Release v202611-00018

Context window
- Requests asked for the model's full max_output, but providers count
  input + output against the window: long chats with large-output models
  (DeepSeek V4.1 Flash, 384k) failed with "input too long" before automatic
  compaction (85 %) kicked in. max_tokens is now what the window leaves
  (estimated input = last usage + messages since), the chat is compacted when
  less than 32k would remain for an answer, and a context-overflow error
  compacts and retries once.
- ModelConfig.max_input (catalogue limit.input, editable in the provider
  settings) lowers the compaction threshold for models with an input limit.

Enforced reviews (modes with refine.rounds > 0, refine.after_todos default on)
- Every todo marked completed is reviewed against the work since the last
  review; with findings it is reopened and the feedback goes to the agent
  (max. rounds per todo). Passed reviews leave a visible note.
- Ending the turn with open todos sends the agent back to work while it makes
  progress (max. 10 reminders in a row without progress); such modes may take
  up to 2,000 steps per turn. Reaching the step limit is reported.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

CHANGELOG.md

@@ -3,6 +3,88 @@
 All notable changes to CodeCraft. Versions follow [Semantic Versioning](https://semver.org/);
 until 1.0, minor versions may contain breaking changes.
 
+## [v202611-00018] – 2026-11-10
+
+### Added
+
+- **Enforced reviews:** when a review is configured for a mode, every todo the agent marks
+  completed is reviewed; with findings the todo is reopened and the agent has to fix them and
+  complete it again (up to the configured rounds per todo). Ending the turn with open todos sends
+  the agent back to work as long as it makes progress – for unattended runs, e.g. overnight
+  (such modes may take up to 2,000 steps per turn). The chat shows passed reviews and these
+  reminders; *Settings → Modes* can switch it off per mode (then only one review at the end of a
+  turn, as before).
+- **Max input per model:** providers that limit the input below the context window (e.g. 272k of
+  400k) are taken into account; fetched from the model catalogue, editable in the provider settings.
+
+### Fixed
+
+- **Context overflow instead of compaction** (e.g. DeepSeek V4.1 Flash with 384k max output):
+  requests asked for the model's full max output, and providers count input + output against the
+  window, so long chats failed before automatic compaction kicked in. The output budget is now what
+  the window leaves, the chat is compacted when no reasonable room for an answer is left, and a
+  "context too long" error compacts and retries once instead of stopping. A turn that hits the
+  step limit now says so.
+
+## [v202611-00017] – 2026-11-10
+
+### Added
+
+- **Markdown in your messages:** your messages are shown formatted like the model's answers
+  (headings, lists, tables, code blocks, quotes, bold/italic); single line breaks stay as typed.
+  The eye button next to the text field shows a preview of the formatted message before sending.
+
+## [v202611-00016] – 2026-11-10
+
+### Fixed
+
+- **Phone: page stayed shifted after the keyboard closed** – the top bar (menu) was out of
+  reach. On Android the keyboard now shrinks the page instead of shifting it
+  (`interactive-widget=resizes-content`; the chat stays at its latest message); browsers that
+  still shift the page (iOS Safari) get it scrolled back once the keyboard closes.
+
+## [v202611-00015] – 2026-11-10
+
+### Fixed
+
+- **Generated images missing on other devices:** when an agent moved or renamed a generated
+  image afterwards (e.g. sorted it into subfolders), the gallery pointed to the old file – only
+  the device that had it in its browser cache still showed it. Now:
+  - generated images are also kept in the image store and shown from there when the file is gone
+    (existing images get their copy on the first start);
+  - their entries follow moves and renames: after an agent's `mv`/`rename`, when moved with the
+    file manager, and on the next view (found by file name, or by content when renamed);
+  - in the chat, an image that cannot be found falls back to the preview the model saw.
+
+## [v202611-00014] – 2026-11-10
+
+### Added
+
+- **New folder in the folder picker:** creating an automation or a chat, *New folder* creates a
+  subfolder of the shown folder and selects it.
+
+## [v202611-00013] – 2026-11-10
+
+### Added
+
+- **Automation editor:** *New automation* asks for name, project and a starting point (blank
+  example structure or a template), creates `.codecraft/jobs/<name>.md` and opens an editor:
+  the instructions in a Markdown editor, schedule and settings next to them, and an assistant
+  chat in which a model works out the instructions with you and edits the file (reloaded after
+  each answer). New automations start switched off.
+- **Graphical schedule:** every few minutes, hourly, daily, on weekdays, monthly or a cron
+  expression, with the next runs in server time.
+- **Chat list:** folders and projects can be dragged into any order or moved and pinned to the
+  top via their menu; the order is kept per user on all devices. A new message moves the chat
+  to the top of its folder or project, no longer the whole project.
+
+### Changed
+
+- **Automation files hold only the instructions;** name, schedule, mode, model, approval mode
+  and time limit are settings of the automation. Existing job files are taken over on the first
+  start (settings into the database, the frontmatter removed from the file). Registering a
+  plain Markdown file creates a switched-off automation to be scheduled in the editor.
+
 ## [v202611-00012] – 2026-11-10
 
 ### Added

README.md

@@ -11,7 +11,7 @@
 </p>
 
 <p align="center">
-  <img alt="Version v202611-00012" src="https://img.shields.io/badge/version-v202611--00012-d69e2e?style=flat-square">
+  <img alt="Version v202611-00018" src="https://img.shields.io/badge/version-v202611--00018-d69e2e?style=flat-square">
   <img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-689d6a?style=flat-square">
   <img alt="Rust backend" src="https://img.shields.io/badge/backend-Rust-b7410e?style=flat-square&logo=rust">
   <img alt="React PWA" src="https://img.shields.io/badge/frontend-React%20PWA-2d81ff?style=flat-square&logo=react">
@@ -202,11 +202,15 @@ platforms: `cargo install --locked --git https://git.familie-zink.org/zink/codec
   <img src="docs/images/automations.png" alt="Creating an automation from a template: schedule chips, cron expression, mode, permission mode, model and the task for the agent" width="100%">
 </p>
 
-An automation is a Markdown file with a cron schedule in its front matter
-(`.codecraft/jobs/<name>.md`). Each run is a normal chat session, so you can read and continue
-it; if it needs a permission, you get a push notification. Ask an agent in any chat to set one
-up, start from a template (dependency check, security review of recent commits, test suite
-health, daily summary, TODO report, documentation freshness) or write the file yourself.
+An automation is an agent that starts on a schedule. Its instructions are a Markdown file
+(`.codecraft/jobs/<name>.md`, only the prompt); name, schedule, mode, model and limits are set
+in the UI, with a graphical schedule editor (every few minutes, hourly, daily, on weekdays,
+monthly or a cron expression). *New automation* creates the file – blank with an example
+structure or from a template (dependency check, security review of recent commits, test suite
+health, daily summary, TODO report, documentation freshness) – and opens an editor with an
+assistant chat in which a model works out the instructions with you and writes the file. You
+can also ask an agent in any chat to set one up. Each run is a normal chat session, so you can
+read and continue it.
 
 **Webhooks** start an automation from outside, e.g. on every push: the request is checked with a
 shared secret or a Gitea/GitHub HMAC signature, and its JSON payload is handed to the agent.

core/src/config.rs

@@ -64,6 +64,9 @@ pub struct ModelConfig {
     pub context: Option<u64>,
     #[serde(default)]
     pub max_output: Option<u64>,
+    /// Input limit when the provider sets one below the context window (e.g. 272k of 400k).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub max_input: Option<u64>,
     #[serde(default)]
     pub reasoning: bool,
     #[serde(default)]

server/src/api.rs

@@ -137,6 +137,7 @@ pub fn router(app: AppState) -> Router {
         .route("/images/{id}/file", get(image_file))
         .route("/account/git", get(get_git_settings).put(put_git_settings))
         .route("/account/prefs", get(crate::cli_api::get_prefs).put(crate::cli_api::put_prefs))
+        .route("/account/sidebar", get(crate::cli_api::get_sidebar).put(crate::cli_api::put_sidebar))
         .route("/account/memory", get(crate::cli_api::get_memory).put(crate::cli_api::put_memory))
         .route("/account/modes", get(get_personal_modes).put(put_personal_modes))
         .route("/account/telegram", get(get_telegram).put(put_telegram).delete(delete_telegram))
@@ -150,7 +151,9 @@ pub fn router(app: AppState) -> Router {
         .route("/account/tokens/{id}", delete(auth::delete_api_token))
         .route("/jobs", get(list_jobs).post(register_job))
         .route("/jobs/create", post(create_job))
-        .route("/jobs/{id}", axum::routing::patch(update_job).delete(delete_job))
+        .route("/jobs/schedule", get(schedule_preview))
+        .route("/jobs/{id}", get(get_job).patch(update_job).delete(delete_job))
+        .route("/jobs/{id}/assistant", post(job_assistant))
         .route("/jobs/{id}/run", post(run_job))
         .route("/jobs/{id}/webhook", post(job_webhook_settings))
         .route("/terminals", get(list_terminals).post(open_terminal))
@@ -1560,13 +1563,26 @@ fn own_image(app: &App, user: &User, id: &str) -> Result<crate::store::ImageReco
 
 async fn image_file(Extension(user): Extension<User>, State(app): State<AppState>, Path(id): Path<String>) -> Result<Response, ApiError> {
     let img = own_image(&app, &user, &id)?;
-    let bytes = tokio::fs::read(&img.path).await.map_err(|_| not_found("image file"))?;
-    let ctype = match std::path::Path::new(&img.path).extension().and_then(|e| e.to_str()) {
+    let ctype_of = |p: &str| match std::path::Path::new(p).extension().and_then(|e| e.to_str()).map(|e| e.to_ascii_lowercase()).as_deref() {
         Some("jpg") | Some("jpeg") => "image/jpeg",
         Some("webp") => "image/webp",
         _ => "image/png",
     };
-    Ok(([(axum::http::header::CONTENT_TYPE, ctype), (axum::http::header::CACHE_CONTROL, "private, max-age=86400")], bytes).into_response())
+    let respond = |ctype: String, bytes: Vec<u8>| ([(axum::http::header::CONTENT_TYPE, ctype), (axum::http::header::CACHE_CONTROL, "private, max-age=86400".to_string())], bytes).into_response();
+    if let Ok(bytes) = tokio::fs::read(&img.path).await {
+        return Ok(respond(ctype_of(&img.path).into(), bytes));
+    }
+    // The file was moved or renamed (agents tidy up folders): with a copy in the image store,
+    // answer from there and look for the file in the background; otherwise look now.
+    if let Some((mime, bytes)) = img.blob.as_deref().map(|h| app.store.blob(h)).transpose()?.flatten() {
+        let a = app.clone();
+        tokio::task::spawn_blocking(move || crate::images::relocate(&a, &img));
+        return Ok(respond(mime, bytes));
+    }
+    let a = app.clone();
+    let found = tokio::task::spawn_blocking(move || crate::images::relocate(&a, &img)).await.ok().flatten().ok_or_else(|| not_found("image file"))?;
+    let bytes = tokio::fs::read(&found).await.map_err(|_| not_found("image file"))?;
+    Ok(respond(ctype_of(&found.display().to_string()).into(), bytes))
 }
 
 async fn delete_image(Extension(user): Extension<User>, State(app): State<AppState>, Path(id): Path<String>) -> ApiResult {
@@ -1621,15 +1637,24 @@ async fn list_jobs(Extension(user): Extension<User>, State(app): State<AppState>
     Ok(Json(json!(jobs)))
 }
 
+async fn get_job(Extension(user): Extension<User>, State(app): State<AppState>, Path(id): Path<String>) -> ApiResult {
+    let job = own_job(&app, &user, &id)?;
+    Ok(Json(crate::jobs::describe(&job)))
+}
+
 #[derive(Deserialize)]
 struct RegisterJob {
     path: String,
 }
 
+/// Register an existing Markdown file (older files: settings from their frontmatter).
 async fn register_job(Extension(user): Extension<User>, State(app): State<AppState>, Json(b): Json<RegisterJob>) -> ApiResult {
     let p = crate::files::checked_path(&app, &user, &b.path, true)?;
-    crate::jobs::parse(&p).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
+    if !p.is_file() {
+        return Err(ApiError(StatusCode::BAD_REQUEST, format!("{} is not a file", p.display())));
+    }
     let job = app.store.job_register(&user.id, &p.display().to_string())?;
+    let job = crate::jobs::adopt(&app.store, job).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
     app.audit(Some(&user), "job.register", &job.path, "");
     Ok(Json(crate::jobs::describe(&job)))
 }
@@ -1638,22 +1663,38 @@ async fn register_job(Extension(user): Extension<User>, State(app): State<AppSta
 struct CreateJob {
     /// Project folder; the file goes to <cwd>/.codecraft/jobs/<name>.md.
     cwd: String,
-    #[serde(flatten)]
-    job: crate::jobs::NewJob,
+    name: String,
+    /// Initial content of the instructions file (example or template).
+    prompt: String,
+    #[serde(default)]
+    schedule: Option<String>,
+    #[serde(default)]
+    agent: Option<String>,
+    #[serde(default)]
+    permission_mode: Option<String>,
+    /// Default false: the user switches it on once prompt and schedule are ready.
+    #[serde(default)]
+    enabled: bool,
 }
 
 async fn create_job(Extension(user): Extension<User>, State(app): State<AppState>, Json(b): Json<CreateJob>) -> ApiResult {
     let dir = crate::files::checked_path(&app, &user, &b.cwd, true)?;
-    if b.job.name.trim().is_empty() || b.job.prompt.trim().is_empty() {
-        return Err(ApiError(StatusCode::BAD_REQUEST, "name and prompt are required".into()));
+    if b.prompt.trim().is_empty() {
+        return Err(ApiError(StatusCode::BAD_REQUEST, "the instructions are empty".into()));
     }
-    if !crate::permission::MODES.contains(&b.job.permission_mode.as_str()) {
-        return Err(ApiError(StatusCode::BAD_REQUEST, "invalid permission mode".into()));
+    let mut settings = crate::jobs::JobSettings::new(&b.name);
+    if let Some(x) = b.schedule {
+        settings.schedule = x;
+    }
+    if let Some(x) = b.agent {
+        settings.agent = x;
+    }
+    if let Some(x) = b.permission_mode {
+        settings.permission_mode = x;
     }
     // Inside the checked folder: the file name is a slug of the name.
-    let path = crate::jobs::new_job_path(&dir, &b.job.name);
-    crate::jobs::write_file(&path, &b.job).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
-    let job = app.store.job_register(&user.id, &path.display().to_string())?;
+    let path = crate::jobs::new_job_path(&dir, &b.name);
+    let job = crate::jobs::create(&app.store, &user.id, &path, settings, &b.prompt, b.enabled).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
     app.audit(Some(&user), "job.create", &job.path, "");
     Ok(Json(crate::jobs::describe(&job)))
 }
@@ -1661,15 +1702,45 @@ async fn create_job(Extension(user): Extension<User>, State(app): State<AppState
 #[derive(Deserialize)]
 struct UpdateJob {
     enabled: Option<bool>,
-    /// Written into the job file's frontmatter.
+    name: Option<String>,
+    schedule: Option<String>,
+    agent: Option<String>,
+    /// "" = the server's default model.
+    model: Option<String>,
     permission_mode: Option<String>,
+    timeout_minutes: Option<u64>,
 }
 
 async fn update_job(Extension(user): Extension<User>, State(app): State<AppState>, Path(id): Path<String>, Json(b): Json<UpdateJob>) -> ApiResult {
     let job = own_job(&app, &user, &id)?;
-    if let Some(m) = b.permission_mode.as_deref() {
-        crate::jobs::set_permission_mode(std::path::Path::new(&job.path), m).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
-        app.audit(Some(&user), "job.permission_mode", &job.path, m);
+    let job = crate::jobs::adopt(&app.store, job).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
+    let changes = b.name.is_some() || b.schedule.is_some() || b.agent.is_some() || b.model.is_some() || b.permission_mode.is_some() || b.timeout_minutes.is_some();
+    if changes {
+        let mut st = job.settings.clone().unwrap_or_else(|| crate::jobs::JobSettings::new("automation"));
+        if let Some(x) = b.name {
+            st.name = x;
+        }
+        if let Some(x) = b.schedule {
+            st.schedule = x;
+        }
+        if let Some(x) = b.agent {
+            st.agent = x;
+        }
+        if let Some(x) = b.model {
+            if !x.is_empty() {
+                app.registry().resolve(&x)?;
+            }
+            st.model = Some(x);
+        }
+        if let Some(x) = b.permission_mode {
+            st.permission_mode = x;
+        }
+        if let Some(x) = b.timeout_minutes {
+            st.timeout_minutes = x;
+        }
+        st.validate().map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
+        app.store.job_set_settings(&job.id, &st)?;
+        app.audit(Some(&user), "job.settings", &job.path, &st.schedule);
     }
     if let Some(e) = b.enabled {
         app.store.job_set_enabled(&job.id, e)?;
@@ -1678,6 +1749,96 @@ async fn update_job(Extension(user): Extension<User>, State(app): State<AppState
     Ok(Json(crate::jobs::describe(&job)))
 }
 
+/// Chat in which the user works out the instructions with a model (created once, reused
+/// while it exists). The model edits the job file directly.
+async fn job_assistant(Extension(user): Extension<User>, State(app): State<AppState>, Path(id): Path<String>) -> ApiResult {
+    let job = own_job(&app, &user, &id)?;
+    let job = crate::jobs::adopt(&app.store, job).map_err(|e| ApiError(StatusCode::BAD_REQUEST, format!("{e:#}")))?;
+    let mut st = job.settings.clone().ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, "automation without settings".into()))?;
+    if let Some(sid) = st.assistant_session.as_deref() {
+        if app.store.get_session(sid)?.is_some_and(|s| s.owner_id.as_deref() == Some(user.id.as_str())) {
+            return Ok(Json(json!({"session_id": sid})));
+        }
+    }
+    let path = std::path::Path::new(&job.path);
+    let cwd = crate::jobs::cwd_of(&job.path, st.cwd.as_deref());
+    let cfg = app.config();
+    let model = st
+        .model
+        .clone()
+        .or_else(|| Some(cfg.server.default_model.clone()).filter(|m| !m.is_empty()))
+        .or_else(|| app.registry().first_model())
+        .ok_or_else(|| ApiError(StatusCode::BAD_REQUEST, "no model configured – ask an admin to add a provider".into()))?;
+    let now = now_ms();
+    let instructions = format!(
+        "You help the user write the instructions of the automation \"{name}\". They live in the Markdown file {file} \
+         and are executed unattended by an agent (mode {agent}) on a schedule the user sets in the UI. That run starts a \
+         fresh session and sees only this file – no conversation, nobody to ask.\n\
+         - Work on that file directly with your edit tools and keep it up to date after every round; the user sees it next to this chat.\n\
+         - Find out what the automation should achieve, then shape the file into clear, self-contained instructions: \
+         goal, steps, expected result (e.g. a short report), limits (what must not be done).\n\
+         - Write only the instructions: no frontmatter, no schedule or settings in the file.\n\
+         - Do not carry out the automation's task yourself and do not create other files. Use the language the user writes in.",
+        name = st.name,
+        file = path.display(),
+        agent = st.agent,
+    );
+    let s = Session {
+        id: new_id(),
+        title: format!("{} – {}", st.name, if crate::telegram::german(&app, &user.id) { "Anweisungen" } else { "instructions" }),
+        cwd: cwd.display().to_string(),
+        model,
+        agent: "build".into(),
+        permission_mode: "auto".into(),
+        parent_id: None,
+        owner_id: Some(user.id.clone()),
+        created_at: now,
+        updated_at: now,
+        todos: Value::Null,
+        last_usage: None,
+        clean_room: None,
+        phase: None,
+        worktree: None,
+        pinned: false,
+        archived: false,
+        folder: None,
+        instructions,
+        telegram_quiet: true,
+    };
+    let s = app.save_session(s)?;
+    st.assistant_session = Some(s.id.clone());
+    app.store.job_set_settings(&job.id, &st)?;
+    Ok(Json(json!({"session_id": s.id})))
+}
+
+#[derive(Deserialize)]
+struct ScheduleQ {
+    expr: String,
+}
+
+/// Check a cron expression and list its next runs (for the schedule editor).
+async fn schedule_preview(Query(q): Query<ScheduleQ>) -> ApiResult {
+    let expr = q.expr.trim();
+    if let Err(e) = crate::jobs::check_schedule(expr) {
+        return Ok(Json(json!({"ok": false, "error": format!("{e:#}")})));
+    }
+    let mut next = Vec::new();
+    let mut t = now_ms();
+    for _ in 0..5 {
+        match crate::jobs::next_run(expr, t) {
+            Some(n) => {
+                next.push(n);
+                t = n + 1000;
+            }
+            None => break,
+        }
+    }
+    // Wall-clock times of the server: cron works in its time zone, the browser may be elsewhere.
+    let local: Vec<String> = next.iter().filter_map(|n| chrono::DateTime::from_timestamp_millis(*n)).map(|t| t.with_timezone(&chrono::Local).format("%Y-%m-%dT%H:%M").to_string()).collect();
+    let tz = std::env::var("TZ").ok().filter(|z| !z.is_empty()).unwrap_or_else(|| chrono::Local::now().format("UTC%:z").to_string());
+    Ok(Json(json!({"ok": true, "next": next, "next_local": local, "tz": tz})))
+}
+
 async fn delete_job(Extension(user): Extension<User>, State(app): State<AppState>, Path(id): Path<String>) -> ApiResult {
     let job = own_job(&app, &user, &id)?;
     app.store.job_delete(&job.id)?;

server/src/app.rs

@@ -144,6 +144,11 @@ impl App {
                 Ok(n) => tracing::info!("moved {n} images of older chats to the image store"),
                 Err(e) => tracing::warn!("moving images to the image store: {e:#}"),
             }
+            match crate::images::backfill_copies(&self) {
+                Ok(0) => {}
+                Ok(n) => tracing::info!("kept copies of {n} generated images in the image store"),
+                Err(e) => tracing::warn!("copies of generated images: {e:#}"),
+            }
             match self.store.gc_blobs() {
                 Ok(0) => {}
                 Ok(n) => tracing::info!("removed {n} unused images"),

server/src/blobs.rs

@@ -56,7 +56,8 @@ pub fn is_hash(s: &str) -> bool {
     s.len() == 64 && s.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
 }
 
-fn hash(bytes: &[u8]) -> String {
+/// Address of `bytes` in the image store (SHA-256, hex).
+pub fn hash(bytes: &[u8]) -> String {
     Sha256::digest(bytes).iter().map(|b| format!("{b:02x}")).collect()
 }
 

server/src/budget.rs

@@ -409,6 +409,7 @@ fn opencode_model(m: &Value) -> Value {
         "id": m["id"],
         "context": m["limit"]["context"],
         "max_output": m["limit"]["output"],
+        "max_input": m["limit"]["input"],
         "vision": images,
         "reasoning": m["capabilities"]["reasoning"]["supported"].as_bool().unwrap_or(false),
         "input_price": input["price"],

server/src/cli_api.rs

@@ -231,6 +231,23 @@ pub async fn put_prefs(Extension(user): Extension<User>, State(app): State<AppSt
     Ok(Json(b))
 }
 
+/// Order and pinning of the groups (folders, projects) in the chat list – per user, so
+/// every device shows the same order: {"order": [group ids], "pinned": [group ids]}.
+pub async fn get_sidebar(Extension(user): Extension<User>, State(app): State<AppState>) -> ApiResult {
+    let v: Value = app.store.user_setting(&user.id, "sidebar")?;
+    Ok(Json(if v.is_null() { json!({"order": [], "pinned": []}) } else { v }))
+}
+
+pub async fn put_sidebar(Extension(user): Extension<User>, State(app): State<AppState>, Json(b): Json<Value>) -> ApiResult {
+    let ids = |k: &str| b[k].as_array().is_some_and(|a| a.iter().all(|x| x.as_str().is_some_and(|s| s.len() <= 1000)));
+    if !ids("order") || !ids("pinned") || b.to_string().len() > 100_000 {
+        return Err(ApiError(StatusCode::BAD_REQUEST, "invalid chat list layout".into()));
+    }
+    let v = json!({"order": b["order"], "pinned": b["pinned"]});
+    app.store.set_user_setting(&user.id, "sidebar", &v)?;
+    Ok(Json(v))
+}
+
 /// Personal memory (applies to all projects, web and CLI).
 pub async fn get_memory(Extension(user): Extension<User>, State(app): State<AppState>) -> ApiResult {
     let m: String = app.store.user_setting(&user.id, "memory")?;

server/src/config.rs

@@ -413,6 +413,9 @@ pub struct RefineConfig {
     /// Review criteria; empty = the mode's defaults.
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub criteria: Option<String>,
+    /// Also review every todo the agent marks completed (reopened when findings come back).
+    #[serde(default = "yes")]
+    pub after_todos: bool,
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize)]

server/src/files.rs

@@ -353,6 +353,10 @@ pub async fn move_or_copy(Extension(user): Extension<User>, State(app): State<Ap
     }
     let (f, t) = (from.clone(), to.clone());
     tokio::task::spawn_blocking(move || if b.copy { copy_recursive(&f, &t) } else { std::fs::rename(&f, &t) }).await??;
+    if !b.copy {
+        // Generated images in the moved file or folder keep their entries.
+        app.store.move_image_paths(&from.display().to_string(), &to.display().to_string())?;
+    }
     Ok(Json(json!({"ok": true, "path": to})))
 }
 

server/src/images.rs

@@ -213,6 +213,8 @@ pub async fn generate(app: &App, req: GenerateRequest) -> Result<Vec<ImageRecord
         let name = if images.len() > 1 { format!("{stamp}-{base}-{}.{ext}", i + 1) } else { format!("{stamp}-{base}.{ext}") };
         let path = req.dir.join(name);
         tokio::fs::write(&path, &bytes).await?;
+        // A copy in the image store keeps it viewable when the file is moved or deleted.
+        let blob = app.store.put_blob(&ctype, &bytes).map_err(|e| tracing::warn!("image copy: {e:#}")).ok();
         let rec = ImageRecord {
             id: new_id(),
             user_id: req.user_id.clone(),
@@ -223,6 +225,7 @@ pub async fn generate(app: &App, req: GenerateRequest) -> Result<Vec<ImageRecord
             width: img["width"].as_i64().unwrap_or(0),
             height: img["height"].as_i64().unwrap_or(0),
             created_at: now_ms(),
+            blob,
         };
         app.store.add_image(&rec)?;
         records.push(rec);
@@ -252,6 +255,98 @@ pub async fn generate(app: &App, req: GenerateRequest) -> Result<Vec<ImageRecord
     Ok(records)
 }
 
+/// A generated image whose file is gone: the same file name below its original folder
+/// (or the folder above it), e.g. after an agent sorted the images into subfolders.
+/// Only inside `roots`; looks at a few thousand entries at most.
+pub fn find_moved(path: &Path, roots: &[PathBuf]) -> Option<PathBuf> {
+    let name = path.file_name()?;
+    search_near(path, roots, |p, _| p.file_name() == Some(name))
+}
+
+/// Like `find_moved`, but by content: an image file with the same bytes (renamed).
+pub fn find_by_content(path: &Path, roots: &[PathBuf], hash: &str, size: u64) -> Option<PathBuf> {
+    search_near(path, roots, |p, len| {
+        let ext = p.extension().and_then(|e| e.to_str()).map(|e| e.to_ascii_lowercase());
+        len == size && matches!(ext.as_deref(), Some("png" | "jpg" | "jpeg" | "webp")) && std::fs::read(p).is_ok_and(|b| crate::blobs::hash(&b) == hash)
+    })
+}
+
+/// Files below the folder of `path` and the folder above it (3 levels, hidden folders
+/// skipped, inside `roots`) for which `matches(path, size)` holds.
+fn search_near(path: &Path, roots: &[PathBuf], matches: impl Fn(&Path, u64) -> bool) -> Option<PathBuf> {
+    let dir = path.parent()?;
+    let mut budget = 5000usize;
+    for base in [Some(dir), dir.parent()].into_iter().flatten() {
+        if !roots.iter().any(|r| base.starts_with(r)) {
+            continue;
+        }
+        let mut stack = vec![(base.to_path_buf(), 0usize)];
+        while let Some((d, depth)) = stack.pop() {
+            let Ok(entries) = std::fs::read_dir(&d) else { continue };
+            for e in entries.flatten() {
+                if budget == 0 {
+                    return None;
+                }
+                budget -= 1;
+                let p = e.path();
+                let Ok(ft) = e.file_type() else { continue };
+                if ft.is_file() && p != path && matches(&p, e.metadata().map(|m| m.len()).unwrap_or(0)) {
+                    return Some(p);
+                }
+                let hidden = p.file_name().and_then(|n| n.to_str()).is_some_and(|n| n.starts_with('.') || n == "node_modules");
+                if ft.is_dir() && depth < 3 && !hidden {
+                    stack.push((p, depth + 1));
+                }
+            }
+        }
+    }
+    None
+}
+
+/// Where the file of a generated image is now: by name, then (with a copy in the image
+/// store) by content. Corrects the stored path when found.
+pub fn relocate(app: &App, rec: &ImageRecord) -> Option<PathBuf> {
+    let path = Path::new(&rec.path);
+    let roots = app.user_roots(rec.user_id.as_deref());
+    let found = find_moved(path, &roots).or_else(|| {
+        let hash = rec.blob.as_deref()?;
+        let (_, bytes) = app.store.blob(hash).ok()??;
+        find_by_content(path, &roots, hash, bytes.len() as u64)
+    })?;
+    let _ = app.store.set_image_path(&rec.id, &found.display().to_string());
+    Some(found)
+}
+
+/// After an agent moved or renamed files: find the generated images of `owner` from the
+/// last two weeks whose files are gone and correct their paths. Returns how many.
+pub fn relocate_missing(app: &App, owner: Option<&str>) -> usize {
+    let since = now_ms() - 14 * 86_400_000;
+    let Ok(list) = app.store.images(owner, 500) else { return 0 };
+    list.iter().filter(|r| r.created_at >= since && !Path::new(&r.path).exists()).filter(|r| relocate(app, r).is_some()).count()
+}
+
+/// Copies in the image store for generated images from before they were kept (once per
+/// image, files up to 25 MB): later moves and renames are then found by content.
+pub fn backfill_copies(app: &App) -> Result<usize> {
+    let mut n = 0;
+    for (id, path) in app.store.images_without_copy()? {
+        let Ok(meta) = std::fs::metadata(&path) else { continue };
+        if !meta.is_file() || meta.len() > 25 * 1024 * 1024 {
+            continue;
+        }
+        let Ok(bytes) = std::fs::read(&path) else { continue };
+        let mime = match Path::new(&path).extension().and_then(|e| e.to_str()).map(|e| e.to_ascii_lowercase()).as_deref() {
+            Some("jpg" | "jpeg") => "image/jpeg",
+            Some("webp") => "image/webp",
+            _ => "image/png",
+        };
+        let hash = app.store.put_blob(mime, &bytes)?;
+        app.store.set_image_blob(&id, &hash)?;
+        n += 1;
+    }
+    Ok(n)
+}
+
 /// Downscaled copy for the model's context.
 fn preview_for_model(path: &Path) -> Option<ImageData> {
     let img = image::open(path).ok()?;
@@ -363,6 +458,37 @@ impl Tool for GenerateImage {
 mod tests {
     use super::*;
 
+    #[test]
+    fn finds_moved_files_and_keeps_their_copies() {
+        let dir = std::env::temp_dir().join(format!("cc-img-moved-{}", std::process::id()));
+        let art = dir.join("art");
+        std::fs::create_dir_all(art.join("older")).unwrap();
+        std::fs::write(art.join("older/20261110-a.png"), b"x").unwrap();
+        // Moved into a subfolder: found; renamed or outside the roots: not.
+        assert_eq!(find_moved(&art.join("20261110-a.png"), std::slice::from_ref(&dir)), Some(art.join("older/20261110-a.png")));
+        assert_eq!(find_moved(&art.join("20261110-b.png"), std::slice::from_ref(&dir)), None);
+        assert_eq!(find_moved(&art.join("20261110-a.png"), &[dir.join("elsewhere")]), None);
+        // Renamed: found by content.
+        std::fs::write(art.join("older/level-5.png"), b"renamed bytes").unwrap();
+        let h = crate::blobs::hash(b"renamed bytes");
+        assert_eq!(find_by_content(&art.join("20261110-c.png"), std::slice::from_ref(&dir), &h, 13), Some(art.join("older/level-5.png")));
+        assert_eq!(find_by_content(&art.join("20261110-c.png"), std::slice::from_ref(&dir), &crate::blobs::hash(b"other"), 13), None);
+        // The image store keeps the copy of a generated image.
+        let store = crate::store::Store::open(&dir.join("t.db")).unwrap();
+        let hash = store.put_blob("image/png", b"png bytes").unwrap();
+        store
+            .add_image(&ImageRecord { id: "i".into(), user_id: None, session_id: None, prompt: "p".into(), model: "m".into(), path: "/gone.png".into(), width: 1, height: 1, created_at: 0, blob: Some(hash.clone()) })
+            .unwrap();
+        assert_eq!(store.gc_blobs().unwrap(), 0);
+        // Moved with the file manager: the entry follows (file or folder, not look-alikes).
+        assert_eq!(store.move_image_paths("/gone.png", "/art/new.png").unwrap(), 1);
+        assert_eq!(store.move_image_paths("/art", "/bilder/").unwrap(), 1);
+        assert_eq!(store.move_image_paths("/bild", "/x").unwrap(), 0);
+        assert_eq!(store.image("i").unwrap().unwrap().path, "/bilder/new.png");
+        assert_eq!(store.blob(&hash).unwrap().unwrap().1, b"png bytes");
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
     fn m(id: &str) -> ImageModel {
         with_defaults(ImageModel { id: id.into(), ..Default::default() })
     }

server/src/jobs.rs

@@ -1,20 +1,23 @@
-//! Scheduled agents ("automations"): a Markdown file with a cron schedule in
-//! its frontmatter starts an agent session at the given times.
+//! Scheduled agents ("automations"). The instructions are a Markdown file (only the
+//! prompt, e.g. `<project>/.codecraft/jobs/<name>.md`); name, schedule, mode, model and
+//! limits are settings of the automation in the database, edited in the UI.
+//!
+//! Older job files carried the settings as frontmatter:
 //!
 //! ```markdown
 //! ---
 //! name: Nightly dependency check
 //! schedule: "0 3 * * *"        # cron (minute hour day month weekday), server time zone
-//! agent: build                  # mode (default build)
-//! model: provider/model         # optional, default: server default model
-//! permission_mode: auto         # default auto; "bypass" runs without asking
-//! timeout_minutes: 60           # optional, default 60
+//! agent: build
+//! permission_mode: auto
+//! timeout_minutes: 60
 //! ---
 //! Check for outdated dependencies and open a summary …
 //! ```
 //!
-//! The file is re-read on every run, so edits apply to the next run. Each run
-//! is a normal chat session owned by the job's owner.
+//! They are adopted once (settings into the database, the frontmatter removed from the
+//! file). The file is re-read on every run, so edits apply to the next run. Each run is
+//! a normal chat session owned by the job's owner.
 
 use crate::app::App;
 use crate::tools::{Tool, ToolCtx, ToolOutput, arg_str};
@@ -40,6 +43,70 @@ pub struct Job {
     pub created_at: i64,
     /// Webhook enabled (the secret – also the HMAC key – is only shown once when created).
     pub webhook: bool,
+    /// None: not adopted yet (settings still in the file's frontmatter).
+    #[serde(skip)]
+    pub settings: Option<JobSettings>,
+}
+
+/// Settings of an automation (database; the file holds only the prompt).
+#[derive(Debug, Clone, Serialize, serde::Deserialize, PartialEq)]
+pub struct JobSettings {
+    pub name: String,
+    /// 5-field cron in the server's time zone.
+    pub schedule: String,
+    #[serde(default = "default_agent")]
+    pub agent: String,
+    #[serde(default)]
+    pub model: Option<String>,
+    #[serde(default = "default_mode")]
+    pub permission_mode: String,
+    #[serde(default = "default_timeout")]
+    pub timeout_minutes: u64,
+    /// Working directory (absolute or relative to the file); default: the project of the file.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub cwd: Option<String>,
+    /// Chat in which the user works out the prompt with a model.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub assistant_session: Option<String>,
+}
+
+impl JobSettings {
+    pub fn new(name: &str) -> Self {
+        Self {
+            name: name.trim().to_string(),
+            schedule: "0 3 * * *".into(),
+            agent: default_agent(),
+            model: None,
+            permission_mode: default_mode(),
+            timeout_minutes: default_timeout(),
+            cwd: None,
+            assistant_session: None,
+        }
+    }
+
+    pub fn validate(&mut self) -> Result<()> {
+        self.name = self.name.trim().chars().take(120).collect();
+        if self.name.is_empty() {
+            bail!("the automation needs a name");
+        }
+        self.schedule = self.schedule.trim().to_string();
+        check_schedule(&self.schedule)?;
+        if !crate::permission::MODES.contains(&self.permission_mode.as_str()) {
+            bail!("invalid permission_mode '{}'", self.permission_mode);
+        }
+        self.model = self.model.take().map(|m| m.trim().to_string()).filter(|m| !m.is_empty());
+        self.timeout_minutes = self.timeout_minutes.clamp(1, 24 * 60);
+        Ok(())
+    }
+}
+
+/// Valid 5-field cron expression?
+pub fn check_schedule(schedule: &str) -> Result<()> {
+    if schedule.split_whitespace().count() != 5 {
+        bail!("invalid schedule '{schedule}': expected 5 fields (minute hour day month weekday)");
+    }
+    croner::Cron::from_str(schedule).map_err(|e| anyhow!("invalid schedule '{schedule}': {e}"))?;
+    Ok(())
 }
 
 /// Parsed job file.
@@ -52,15 +119,89 @@ pub struct JobSpec {
     pub permission_mode: String,
     pub timeout_minutes: u64,
     pub cwd: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub assistant_session: Option<String>,
     pub prompt: String,
 }
 
+impl JobSpec {
+    fn from_settings(s: &JobSettings, prompt: String) -> Self {
+        Self {
+            name: s.name.clone(),
+            schedule: s.schedule.clone(),
+            agent: s.agent.clone(),
+            model: s.model.clone(),
+            permission_mode: s.permission_mode.clone(),
+            timeout_minutes: s.timeout_minutes,
+            cwd: s.cwd.clone(),
+            assistant_session: s.assistant_session.clone(),
+            prompt,
+        }
+    }
+
+    fn settings(&self) -> JobSettings {
+        JobSettings {
+            name: self.name.clone(),
+            schedule: self.schedule.clone(),
+            agent: self.agent.clone(),
+            model: self.model.clone(),
+            permission_mode: self.permission_mode.clone(),
+            timeout_minutes: self.timeout_minutes,
+            cwd: self.cwd.clone(),
+            assistant_session: self.assistant_session.clone(),
+        }
+    }
+}
+
+/// Settings and prompt of a job: settings from the database, the prompt from its file
+/// (a leftover frontmatter is ignored); not yet adopted jobs from the frontmatter.
+pub fn spec(job: &Job) -> Result<JobSpec> {
+    let path = Path::new(&job.path);
+    let Some(settings) = &job.settings else { return parse(path) };
+    let text = std::fs::read_to_string(path).with_context(|| format!("cannot read {}", path.display()))?;
+    let (_, body) = crate::prompts::frontmatter(&text);
+    if body.trim().is_empty() {
+        bail!("{}: the instructions are empty", path.display());
+    }
+    Ok(JobSpec::from_settings(settings, body.trim().to_string()))
+}
+
+/// Move the frontmatter of an older job file into the database and remove it from the
+/// file. Files without frontmatter get default settings (named after the file) and are
+/// switched off until the user sets a schedule. Returns the updated job.
+pub fn adopt(store: &crate::store::Store, job: Job) -> Result<Job> {
+    if job.settings.is_some() {
+        return Ok(job);
+    }
+    let path = Path::new(&job.path);
+    let text = std::fs::read_to_string(path).with_context(|| format!("cannot read {}", path.display()))?;
+    let (meta, body) = crate::prompts::frontmatter(&text);
+    let settings = if meta.is_empty() {
+        let stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("automation").replace(['-', '_'], " ");
+        store.job_set_enabled(&job.id, false)?;
+        JobSettings::new(&stem)
+    } else {
+        let spec = parse(path)?;
+        // Prompt only from now on.
+        std::fs::write(path, format!("{}\n", body.trim()))?;
+        spec.settings()
+    };
+    store.job_set_settings(&job.id, &settings)?;
+    store.job(&job.id)?.ok_or_else(|| anyhow!("automation {} vanished", job.id))
+}
+
+/// Settings from the frontmatter of an older job file.
 pub fn parse(path: &Path) -> Result<JobSpec> {
     let text = std::fs::read_to_string(path).with_context(|| format!("cannot read {}", path.display()))?;
     let (meta, body) = crate::prompts::frontmatter(&text);
-    let unquote = |s: &String| s.trim().trim_matches('"').trim_matches('\'').to_string();
+    // Values may carry a trailing comment (`auto   # default`).
+    let unquote = |s: &String| {
+        let v = s.trim();
+        let v = if v.starts_with('"') || v.starts_with('\'') { v } else { v.split(" #").next().unwrap_or(v).trim() };
+        v.trim_matches('"').trim_matches('\'').to_string()
+    };
     let schedule = meta.get("schedule").map(unquote).ok_or_else(|| anyhow!("{}: frontmatter needs `schedule: \"<cron>\"`", path.display()))?;
-    croner::Cron::from_str(&schedule).map_err(|e| anyhow!("invalid schedule '{schedule}': {e}"))?;
+    check_schedule(&schedule)?;
     let permission_mode = meta.get("permission_mode").map(unquote).unwrap_or_else(|| "auto".into());
     if !crate::permission::MODES.contains(&permission_mode.as_str()) {
         bail!("invalid permission_mode '{permission_mode}'");
@@ -76,6 +217,7 @@ pub fn parse(path: &Path) -> Result<JobSpec> {
         permission_mode,
         timeout_minutes: meta.get("timeout_minutes").and_then(|v| unquote(v).parse().ok()).unwrap_or(60).clamp(1, 24 * 60),
         cwd: meta.get("cwd").map(unquote).filter(|c| !c.is_empty()),
+        assistant_session: None,
         prompt: body.trim().to_string(),
     })
 }
@@ -89,7 +231,13 @@ pub fn next_run(schedule: &str, after_ms: i64) -> Option<i64> {
 
 /// Working directory of a job: `cwd` from the file, else the project containing `.codecraft/jobs/`.
 fn job_cwd(path: &Path, spec: &JobSpec) -> PathBuf {
-    if let Some(c) = &spec.cwd {
+    cwd_of(&path.display().to_string(), spec.cwd.as_deref())
+}
+
+/// Working directory for a job file and its optional `cwd` setting.
+pub fn cwd_of(file: &str, cwd: Option<&str>) -> PathBuf {
+    let path = Path::new(file);
+    if let Some(c) = cwd {
         let p = PathBuf::from(c);
         return if p.is_absolute() { p } else { path.parent().unwrap_or(Path::new("/")).join(p) };
     }
@@ -106,13 +254,19 @@ fn job_cwd(path: &Path, spec: &JobSpec) -> PathBuf {
 /// Job with its parsed file and next run, for the UI and the tool.
 pub fn describe(job: &Job) -> Value {
     let mut v = json!(job);
-    match parse(Path::new(&job.path)) {
+    match spec(job) {
         Ok(spec) => {
             v["spec"] = json!(spec);
             let base = job.last_run.unwrap_or(job.created_at).max(now_ms() - 60_000);
             v["next_run"] = json!(if job.enabled { next_run(&spec.schedule, base) } else { None });
         }
-        Err(e) => v["error"] = json!(format!("{e:#}")),
+        Err(e) => {
+            v["error"] = json!(format!("{e:#}"));
+            // The settings stay editable when the file is missing or empty.
+            if let Some(st) = &job.settings {
+                v["spec"] = json!(JobSpec::from_settings(st, String::new()));
+            }
+        }
     }
     v
 }
@@ -125,7 +279,7 @@ pub async fn run(app: &Arc<App>, job: &Job, trigger: &str) -> Result<String> {
 /// Start a run; `payload` (webhook body) is appended to the instructions.
 pub async fn run_with(app: &Arc<App>, job: &Job, trigger: &str, payload: Option<String>) -> Result<String> {
     let path = PathBuf::from(&job.path);
-    let spec = match parse(&path) {
+    let spec = match spec(job) {
         Ok(s) => s,
         Err(e) => {
             app.store.job_finished(&job.id, None, &format!("error: {e:#}"))?;
@@ -204,12 +358,20 @@ pub async fn run_with(app: &Arc<App>, job: &Job, trigger: &str, payload: Option<
 /// Background scheduler: checks every 30 s which jobs are due.
 pub fn spawn_scheduler(app: Arc<App>) {
     tokio::spawn(async move {
+        // Older job files: settings from the frontmatter into the database.
+        for job in app.store.jobs(None).unwrap_or_default().into_iter().filter(|j| j.settings.is_none()) {
+            let path = job.path.clone();
+            match adopt(&app.store, job) {
+                Ok(_) => tracing::info!("automation {path}: settings moved from the file into the database"),
+                Err(e) => tracing::warn!("automation {path}: {e:#}"),
+            }
+        }
         loop {
             tokio::time::sleep(Duration::from_secs(30)).await;
             let Ok(jobs) = app.store.jobs(None) else { continue };
             let now = now_ms();
             for job in jobs.into_iter().filter(|j| j.enabled) {
-                let Ok(spec) = parse(Path::new(&job.path)) else { continue };
+                let Ok(spec) = spec(&job) else { continue };
                 // Due if a scheduled time passed since the last run (or since creation).
                 let base = job.last_run.unwrap_or(job.created_at);
                 let Some(next) = next_run(&spec.schedule, base) else { continue };
@@ -236,22 +398,6 @@ pub fn spawn_scheduler(app: Arc<App>) {
 /// Tool: create, list, run and delete automations.
 pub struct Schedule;
 
-/// Fields of a job file written by the agent tool or the "from template" dialog.
-#[derive(Debug, serde::Deserialize)]
-pub struct NewJob {
-    pub name: String,
-    pub schedule: String,
-    #[serde(default = "default_agent")]
-    pub agent: String,
-    #[serde(default)]
-    pub model: Option<String>,
-    #[serde(default = "default_mode")]
-    pub permission_mode: String,
-    #[serde(default = "default_timeout")]
-    pub timeout_minutes: u64,
-    pub prompt: String,
-}
-
 fn default_agent() -> String {
     "build".into()
 }
@@ -262,71 +408,20 @@ fn default_timeout() -> u64 {
     60
 }
 
-/// Write (and validate) a job file.
-pub fn write_file(path: &Path, j: &NewJob) -> Result<JobSpec> {
-    croner::Cron::from_str(&j.schedule).map_err(|e| anyhow!("invalid schedule '{}': {e}", j.schedule))?;
-    let q = |s: &str| format!("\"{}\"", s.replace('"', "'").replace('\n', " "));
-    let plain = |s: &str| s.chars().filter(|c| c.is_alphanumeric() || "-_/.:".contains(*c)).collect::<String>();
-    let mut fm = format!("---\nname: {}\nschedule: {}\nagent: {}\n", q(&j.name), q(&j.schedule), plain(&j.agent));
-    if let Some(m) = j.model.as_deref().filter(|m| !m.is_empty()) {
-        fm.push_str(&format!("model: {}\n", plain(m)));
+/// Write the instructions file, register it and store the settings.
+pub fn create(store: &crate::store::Store, owner: &str, path: &Path, mut settings: JobSettings, prompt: &str, enabled: bool) -> Result<Job> {
+    settings.validate()?;
+    if path.exists() {
+        bail!("{} already exists", path.display());
     }
-    fm.push_str(&format!("permission_mode: {}\n", plain(&j.permission_mode)));
-    fm.push_str(&format!("timeout_minutes: {}\n---\n", j.timeout_minutes.clamp(1, 24 * 60)));
     if let Some(dir) = path.parent() {
         std::fs::create_dir_all(dir)?;
     }
-    std::fs::write(path, format!("{fm}{}\n", j.prompt.trim()))?;
-    match parse(path) {
-        Ok(spec) => Ok(spec),
-        Err(e) => {
-            let _ = std::fs::remove_file(path);
-            Err(e)
-        }
-    }
-}
-
-/// Set `permission_mode` in the frontmatter of a job file (replaces the line or adds it
-/// before the closing `---`); the rest of the file stays as it is.
-pub fn set_permission_mode(path: &Path, mode: &str) -> Result<JobSpec> {
-    if !crate::permission::MODES.contains(&mode) {
-        bail!("invalid permission_mode '{mode}'");
-    }
-    let text = std::fs::read_to_string(path).with_context(|| format!("cannot read {}", path.display()))?;
-    let updated = set_frontmatter_key(&text, "permission_mode", mode).ok_or_else(|| anyhow!("{} has no frontmatter", path.display()))?;
-    std::fs::write(path, &updated)?;
-    match parse(path) {
-        Ok(spec) => Ok(spec),
-        Err(e) => {
-            let _ = std::fs::write(path, &text);
-            Err(e)
-        }
-    }
-}
-
-fn set_frontmatter_key(text: &str, key: &str, value: &str) -> Option<String> {
-    let bom = if text.starts_with('\u{feff}') { "\u{feff}" } else { "" };
-    let t = &text[bom.len()..];
-    let rest = t.strip_prefix("---")?;
-    let end = rest.find("\n---")?;
-    let (head, tail) = (&rest[..end], &rest[end..]);
-    let prefix = format!("{key}:");
-    let mut found = false;
-    let mut lines: Vec<String> = head
-        .split('\n')
-        .map(|l| {
-            if !found && l.trim_start().starts_with(&prefix) {
-                found = true;
-                format!("{key}: {value}")
-            } else {
-                l.to_string()
-            }
-        })
-        .collect();
-    if !found {
-        lines.push(format!("{key}: {value}"));
-    }
-    Some(format!("{bom}---{}{tail}", lines.join("\n")))
+    std::fs::write(path, format!("{}\n", prompt.trim()))?;
+    let job = store.job_register(owner, &path.display().to_string())?;
+    store.job_set_settings(&job.id, &settings)?;
+    store.job_set_enabled(&job.id, enabled)?;
+    store.job(&job.id)?.ok_or_else(|| anyhow!("automation {} vanished", job.id))
 }
 
 /// Free file name for a new job in `<project>/.codecraft/jobs/`.
@@ -348,10 +443,11 @@ impl Tool for Schedule {
         "schedule"
     }
     fn description(&self) -> String {
-        "Manage automations: agents that run on a cron schedule from a Markdown job file \
-         (.codecraft/jobs/<name>.md in the working directory). Actions: \
-         `create` (name, schedule, prompt, optional agent/model/permission_mode/timeout_minutes) writes the job file and registers it; \
-         `register` (path) registers an existing job file; `list`; `run` (id) starts a run now; \
+        "Manage automations: agents that run on a cron schedule. The instructions are a Markdown file \
+         (.codecraft/jobs/<name>.md in the working directory, only the prompt); name, schedule, mode, model and \
+         limits are settings of the automation. Actions: \
+         `create` (name, schedule, prompt, optional agent/model/permission_mode/timeout_minutes) writes the file and registers it; \
+         `register` (path) registers an existing Markdown file (switched off until a schedule is set in the UI); `list`; `run` (id) starts a run now; \
          `enable`/`disable` (id); `delete` (id, delete_file). Schedules are 5-field cron expressions \
          in the server's time zone, e.g. \"0 7 * * 1-5\" = weekdays 07:00, \"*/30 * * * *\" = every 30 minutes. \
          The prompt must be self-contained: the run starts a fresh session without this conversation."
@@ -394,19 +490,15 @@ impl Tool for Schedule {
                 let prompt = arg_str(&input, "prompt")?;
                 let rel = format!(".codecraft/jobs/{}.md", slug(name));
                 let path = ctx.resolve(&rel)?;
-                write_file(
-                    &path,
-                    &NewJob {
-                        name: name.into(),
-                        schedule: schedule.into(),
-                        agent: input["agent"].as_str().unwrap_or("build").into(),
-                        model: input["model"].as_str().map(String::from),
-                        permission_mode: input["permission_mode"].as_str().unwrap_or("auto").into(),
-                        timeout_minutes: input["timeout_minutes"].as_u64().unwrap_or(60),
-                        prompt: prompt.into(),
-                    },
-                )?;
-                let job = ctx.app.store.job_register(&owner, &path.display().to_string())?;
+                let settings = JobSettings {
+                    schedule: schedule.into(),
+                    agent: input["agent"].as_str().unwrap_or("build").into(),
+                    model: input["model"].as_str().map(String::from),
+                    permission_mode: input["permission_mode"].as_str().unwrap_or("auto").into(),
+                    timeout_minutes: input["timeout_minutes"].as_u64().unwrap_or(60),
+                    ..JobSettings::new(name)
+                };
+                let job = create(&ctx.app.store, &owner, &path, settings, prompt, true)?;
                 let d = describe(&job);
                 Ok(ToolOutput::text(format!(
                     "Automation '{name}' created: {} (id {}). Schedule {schedule}, next run {}. The user can manage it on the Automations page.",
@@ -418,8 +510,10 @@ impl Tool for Schedule {
             }
             "register" => {
                 let path = ctx.resolve(arg_str(&input, "path")?)?;
-                parse(&path)?;
-                let job = ctx.app.store.job_register(&owner, &path.display().to_string())?;
+                if !path.is_file() {
+                    bail!("{} is not a file", path.display());
+                }
+                let job = adopt(&ctx.app.store, ctx.app.store.job_register(&owner, &path.display().to_string())?)?;
                 Ok(ToolOutput::text(format!("Registered {} as automation {}.", path.display(), job.id)).with_meta(describe(&job)))
             }
             "list" => {
@@ -491,12 +585,35 @@ mod tests {
         let s = parse(&p).unwrap();
         assert_eq!((s.name.as_str(), s.schedule.as_str(), s.agent.as_str(), s.permission_mode.as_str()), ("Nightly", "0 3 * * *", "build", "auto"));
         assert_eq!(job_cwd(&p, &s), dir);
-        // Added when missing, replaced when present; comments and the prompt stay.
-        assert_eq!(set_permission_mode(&p, "bypass").unwrap().permission_mode, "bypass");
-        std::fs::write(&p, "---\nname: N\npermission_mode: auto   # comment\nschedule: \"0 3 * * *\"\n---\nPrompt\n---\nmore\n").unwrap();
-        assert_eq!(set_permission_mode(&p, "accept_edits").unwrap().permission_mode, "accept_edits");
-        assert_eq!(std::fs::read_to_string(&p).unwrap(), "---\nname: N\npermission_mode: accept_edits\nschedule: \"0 3 * * *\"\n---\nPrompt\n---\nmore\n");
-        assert!(set_permission_mode(&p, "yolo").is_err());
+        std::fs::remove_dir_all(&dir).unwrap();
+    }
+
+    #[test]
+    fn adopts_frontmatter_and_creates_prompt_only_files() {
+        let dir = std::env::temp_dir().join(format!("cc-job-adopt-{}", std::process::id()));
+        std::fs::create_dir_all(dir.join(".codecraft/jobs")).unwrap();
+        let store = crate::store::Store::open(&dir.join("t.db")).unwrap();
+        // Older file: settings move into the database, the file keeps only the prompt.
+        let p = dir.join(".codecraft/jobs/old.md");
+        std::fs::write(&p, "---\nname: \"Old\"\nschedule: \"0 4 * * *\"\npermission_mode: bypass   # comment\n---\nDo old things.\n").unwrap();
+        let job = adopt(&store, store.job_register("u", &p.display().to_string()).unwrap()).unwrap();
+        let st = job.settings.clone().unwrap();
+        assert_eq!((st.name.as_str(), st.schedule.as_str(), st.permission_mode.as_str()), ("Old", "0 4 * * *", "bypass"));
+        assert_eq!(std::fs::read_to_string(&p).unwrap(), "Do old things.\n");
+        assert_eq!(spec(&job).unwrap().prompt, "Do old things.");
+        assert!(job.enabled);
+        // Plain Markdown: default settings, switched off.
+        let q = dir.join(".codecraft/jobs/weekly-report.md");
+        std::fs::write(&q, "Write a report.\n").unwrap();
+        let job = adopt(&store, store.job_register("u", &q.display().to_string()).unwrap()).unwrap();
+        assert_eq!(job.settings.as_ref().unwrap().name, "weekly report");
+        assert!(!job.enabled);
+        // New automation.
+        let r = dir.join(".codecraft/jobs/new.md");
+        assert!(create(&store, "u", &r, JobSettings { schedule: "nope".into(), ..JobSettings::new("N") }, "x", false).is_err());
+        let job = create(&store, "u", &r, JobSettings::new("New"), "# New\n\nGoal", false).unwrap();
+        assert_eq!(spec(&job).unwrap().prompt, "# New\n\nGoal");
+        assert!(check_schedule("0 3 * *").is_err() && check_schedule("*/15 8-18 * * 1-5").is_ok());
         std::fs::remove_dir_all(&dir).unwrap();
     }
 }

server/src/prompts.rs

@@ -121,7 +121,7 @@ pub fn agents(app: &App, root: &Path, cwd: &Path) -> Vec<Agent> {
                 model: meta.get("model").filter(|m| m.contains('/')).cloned(),
                 source: "file".into(),
                 max_parallel: meta.get("max_parallel").and_then(|v| v.parse().ok()),
-                refine: meta.get("refine_rounds").and_then(|v| v.parse().ok()).map(|rounds| crate::config::RefineConfig { rounds, model: meta.get("refine_model").cloned(), criteria: None }),
+                refine: meta.get("refine_rounds").and_then(|v| v.parse().ok()).map(|rounds| crate::config::RefineConfig { rounds, model: meta.get("refine_model").cloned(), criteria: None, after_todos: meta.get("refine_after_todos").is_none_or(|v| v != "false") }),
                 path: Some(p.display().to_string()),
             });
         }

server/src/runner.rs

@@ -18,6 +18,8 @@ use tokio::sync::mpsc;
 use tokio_util::sync::CancellationToken;
 
 const MAX_STEPS: usize = 250;
+/// Modes with enforced reviews work through their todo list (e.g. overnight).
+const MAX_STEPS_ENFORCED: usize = 2_000;
 const MAX_SUBAGENT_DEPTH: usize = 3;
 
 /// What happened to a prompt.
@@ -260,7 +262,15 @@ pub async fn run_session(app: Arc<App>, session_id: &str, cancel: CancellationTo
     let mut stop_hooks = 0;
     let mut refine_done = 0u32;
     let turn_start = now_ms();
-    for _ in 0..MAX_STEPS {
+    // Compacted for the current step (no second compaction before a request went through).
+    let mut compacted_now = false;
+    // Mandatory reviews of completed todos: rounds per todo, and where the last one ended.
+    let mut todo_reviews: std::collections::HashMap<String, u32> = std::collections::HashMap::new();
+    let mut review_since = turn_start;
+    // Reminders about open todos at the end of a turn (see MAX_IDLE_CONTINUES).
+    let mut last_reminder: Option<Value> = None;
+    let mut idle_continues = 0u32;
+    for step_no in 0..=MAX_STEPS_ENFORCED {
         if cancel.is_cancelled() {
             break;
         }
@@ -275,40 +285,65 @@ pub async fn run_session(app: Arc<App>, session_id: &str, cancel: CancellationTo
             agent.prompt = prompts::craft_prompt(clean_room);
         }
         let model_spec = agent.model.clone().unwrap_or_else(|| session.model.clone());
+        let step_limit = if enforced_review(&agent) > 0 { MAX_STEPS_ENFORCED } else { MAX_STEPS };
+        if step_no >= step_limit {
+            app.emit(Event::Error { session_id: session_id.into(), message: format!("Stopped after {step_limit} steps (limit of a turn) – send a message to continue.") });
+            break;
+        }
         let (provider, mut model) = app.registry().resolve(&model_spec)?;
         if let Some(effort) = app.with_runtime(session_id, |r| r.effort.clone()) {
             model.effort = Some(effort);
         }
 
-        // Auto-compaction when the last request used most of the context window.
-        if let (Some(u), Some(ctx_len)) = (&session.last_usage, model.context) {
+        let history = active_history(app.store.messages_for_model(session_id)?);
+        // Providers count input + max_tokens against the context window: the answer needs
+        // room too. Estimated input = last request (input + its answer) + what came since.
+        let est_input = estimate_input(session.last_usage.as_ref(), &history);
+        let want_output = model.max_output.unwrap_or(16_000);
+        if let Some(ctx_len) = model.context {
             let threshold = app.config().server.auto_compact_threshold;
-            if threshold > 0.0 && u.context_tokens() as f64 > ctx_len as f64 * threshold {
-                compact(app.clone(), session_id, cancel.clone(), Some((u.context_tokens(), ctx_len))).await?;
+            // Input limit: the context window, or the provider's lower input limit.
+            let input_limit = model.max_input.map_or(ctx_len, |m| m.min(ctx_len));
+            let room = ctx_len.saturating_sub(est_input);
+            // Most of the input limit used, or no room left for a reasonable answer.
+            if threshold > 0.0 && (est_input as f64 > input_limit as f64 * threshold || room < want_output.min(MIN_ANSWER_ROOM)) && !compacted_now {
+                compacted_now = true;
+                compact(app.clone(), session_id, cancel.clone(), Some((est_input, input_limit))).await?;
                 continue;
             }
         }
+        let max_tokens = answer_budget(want_output, model.context, est_input);
 
         let owner = session.owner_id.as_deref().and_then(|id| app.store.user(id).ok().flatten());
         let tools = available_tools(&app, &agent, owner.as_ref());
-        let history = active_history(app.store.messages_for_model(session_id)?);
         let req = ChatRequest {
             system: prompts::with_chat_instructions(prompts::system_prompt(&app, &agent, &root, &cwd, &model_spec, &session.permission_mode, owner.as_ref()), &session.instructions),
             messages: history,
             tools: tools.iter().map(|t| t.def()).collect(),
-            max_tokens: model.max_output.unwrap_or(16_000),
+            max_tokens,
             reasoning: true,
             session_id: Some(session_id.to_string()),
             model: model.clone(),
         };
         let step = match stream_step(&app, &session, &agent.name, &model_spec, provider, req.clone(), &cancel).await {
-            Ok(step) => step,
+            Ok(step) => {
+                compacted_now = false;
+                step
+            }
+            // The estimate was off and the provider says the input is too long: compact
+            // once and try again instead of stopping.
+            Err(e) if is_context_overflow(&e) && !compacted_now && !cancel.is_cancelled() => {
+                compacted_now = true;
+                app.emit(Event::Error { session_id: session_id.into(), message: format!("context window full ({}) – compacting the conversation and continuing", short_error(&e)) });
+                compact(app.clone(), session_id, cancel.clone(), Some((est_input, model.context.unwrap_or(0)))).await?;
+                continue;
+            }
             // Host down or budget used up: switch to the model's fallback for this step.
             Err(e) if model.fallback.is_some() && !cancel.is_cancelled() && needs_fallback(&e) => {
                 let fb = model.fallback.clone().unwrap_or_default();
                 let (fb_provider, fb_model) = app.registry().resolve(&fb)?;
                 app.emit(Event::Error { session_id: session_id.into(), message: format!("{model_spec} is not available ({}) – using the fallback model {fb}", short_error(&e)) });
-                let req = ChatRequest { model: fb_model.clone(), max_tokens: fb_model.max_output.unwrap_or(16_000), ..req };
+                let req = ChatRequest { model: fb_model.clone(), max_tokens: answer_budget(fb_model.max_output.unwrap_or(16_000), fb_model.context, est_input), ..req };
                 stream_step(&app, &session, &agent.name, &fb, fb_provider, req, &cancel).await?
             }
             Err(e) => return Err(e),
@@ -353,12 +388,37 @@ pub async fn run_session(app: Arc<App>, session_id: &str, cancel: CancellationTo
             }
         }
         let normal_end = matches!(step.stop_reason.as_str(), "stop" | "end_turn" | "");
+        // Enforced reviews also mean: work until the todo list is done. Ending the turn with
+        // open todos sends the agent back (as long as it makes progress).
+        if calls.is_empty() && depth == 0 && normal_end && !cancel.is_cancelled() && enforced_review(&agent) > 0 {
+            let todos_now = app.session(session_id)?.todos;
+            let open = open_todos(&todos_now);
+            if !open.is_empty() {
+                let progressed = last_reminder.as_ref() != Some(&todos_now);
+                idle_continues = if progressed { 0 } else { idle_continues + 1 };
+                if idle_continues < MAX_IDLE_CONTINUES {
+                    last_reminder = Some(todos_now);
+                    save_user_parts(
+                        &app,
+                        session_id,
+                        vec![Part::Text {
+                            text: format!(
+                                "<todo-reminder open=\"{}\">\n{}\n</todo-reminder>\nThese todos are still open. Continue working until all of them are completed (each completed todo is reviewed). Only if you are truly blocked and need the user, say clearly what you need and stop.",
+                                open.len(),
+                                open.iter().map(|t| format!("- {t}")).collect::<Vec<_>>().join("\n")
+                            ),
+                        }],
+                    )?;
+                    continue;
+                }
+            }
+        }
         if calls.is_empty() && depth == 0 && normal_end && !cancel.is_cancelled() {
             // Refinement loop: a reviewer checks the turn; findings send the agent back to work.
             let rounds = agent.refine.as_ref().map(|r| r.rounds).unwrap_or(0);
             if refine_done < rounds {
                 refine_done += 1;
-                match review_turn(&app, &session, &agent, &model_spec, turn_start, refine_done, rounds, &cancel).await {
+                match review_turn(&app, &session, &agent, &model_spec, turn_start, None, refine_done, rounds, &cancel).await {
                     Ok(Some(feedback)) => {
                         save_user_parts(&app, session_id, vec![Part::Text { text: feedback }])?;
                         continue;
@@ -412,6 +472,40 @@ pub async fn run_session(app: Arc<App>, session_id: &str, cancel: CancellationTo
                 results.push(execute_call(&app, &session, &base, by_name(name), id, name, input.clone(), depth).await);
             }
         }
+        // Mode with a review: every todo marked completed is reviewed; with findings it is
+        // reopened and the agent has to fix them and complete it again (max. `rounds` per todo).
+        // The verdict goes into the same message as the tool results.
+        let rounds = enforced_review(&agent);
+        if rounds > 0 && depth == 0 && !cancel.is_cancelled() && calls.iter().any(|(_, n, _)| n == "todo_write") {
+            let todos_now = app.session(session_id)?.todos;
+            let due: Vec<String> = newly_completed(&session.todos, &todos_now)
+                .into_iter()
+                .filter(|t| todo_reviews.get(t).copied().unwrap_or(0) < rounds)
+                .collect();
+            if !due.is_empty() {
+                for t in &due {
+                    *todo_reviews.entry(t.clone()).or_default() += 1;
+                }
+                let round = due.iter().filter_map(|t| todo_reviews.get(t)).copied().max().unwrap_or(1);
+                let fresh = app.session(session_id)?;
+                let reviewed = review_turn(&app, &fresh, &agent, &model_spec, review_since, Some(&due), round, rounds, &cancel).await;
+                review_since = now_ms();
+                match reviewed {
+                    Ok(Some(feedback)) => {
+                        app.set_todos(session_id, reopen_todos(&todos_now, &due))?;
+                        results.push(Part::Text { text: feedback });
+                    }
+                    Ok(None) => {
+                        let open = open_todos(&todos_now);
+                        let next = if open.is_empty() { "All todos are done – check the whole request once more, then finish." } else { "Continue with the next open todo." };
+                        results.push(Part::Text {
+                            text: format!("<refine-approved reviewer=\"{}\">\n{}\n</refine-approved>\nReview passed. {next}", review_model(&agent, &model_spec), due.iter().map(|t| format!("- {t}")).collect::<Vec<_>>().join("\n")),
+                        });
+                    }
+                    Err(e) => tracing::warn!("todo review of {session_id} failed: {e:#}"),
+                }
+            }
+        }
         // Deliver messages the user queued while we were working (with attachments).
         results.extend(take_queue(&app, session_id));
         save_user_parts(&app, session_id, results)?;
@@ -419,6 +513,55 @@ pub async fn run_session(app: Arc<App>, session_id: &str, cancel: CancellationTo
     Ok(final_text)
 }
 
+/// Review rounds when the mode enforces reviews of completed todos (0 = not enforced).
+fn enforced_review(agent: &prompts::Agent) -> u32 {
+    agent.refine.as_ref().filter(|r| r.after_todos).map(|r| r.rounds).unwrap_or(0)
+}
+
+/// The model that reviews for this mode.
+fn review_model(agent: &prompts::Agent, model_spec: &str) -> String {
+    agent.refine.as_ref().and_then(|r| r.model.clone()).filter(|m| !m.is_empty()).unwrap_or_else(|| model_spec.to_string())
+}
+
+/// Contents of the todos that are not completed yet.
+fn open_todos(todos: &Value) -> Vec<String> {
+    todos.as_array().into_iter().flatten().filter(|t| t["status"] != "completed").filter_map(|t| t["content"].as_str()).map(String::from).collect()
+}
+
+/// Times in a row the agent may end its turn with open todos without making progress.
+const MAX_IDLE_CONTINUES: u32 = 10;
+
+/// Contents of the todos that are completed in `after` but were not in `before`.
+fn newly_completed(before: &Value, after: &Value) -> Vec<String> {
+    let done_before: std::collections::HashSet<&str> = before
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter(|t| t["status"] == "completed")
+        .filter_map(|t| t["content"].as_str())
+        .collect();
+    after
+        .as_array()
+        .into_iter()
+        .flatten()
+        .filter(|t| t["status"] == "completed")
+        .filter_map(|t| t["content"].as_str())
+        .filter(|c| !done_before.contains(c))
+        .map(String::from)
+        .collect()
+}
+
+/// The todo list with the given items open again (in progress).
+fn reopen_todos(todos: &Value, items: &[String]) -> Value {
+    let mut out = todos.clone();
+    for t in out.as_array_mut().into_iter().flatten() {
+        if t["content"].as_str().is_some_and(|c| items.iter().any(|i| i == c)) {
+            t["status"] = Value::from("in_progress");
+        }
+    }
+    out
+}
+
 fn tool_result(call_id: &str, name: &str, content: String, is_error: bool, meta: Option<Value>) -> Part {
     Part::ToolResult { call_id: call_id.into(), name: name.into(), content, images: vec![], is_error, meta }
 }
@@ -563,7 +706,15 @@ async fn execute_call(
         // Pass depth through the agent name channel: subagents run with depth+1.
         run_task(app, &ctx, input, depth).await
     } else {
-        tool.run(input, &ctx).await
+        let moves = name == "bash" && input["command"].as_str().is_some_and(moves_files);
+        let out = tool.run(input, &ctx).await;
+        if moves {
+            // Generated images the command moved or renamed keep their entries.
+            let a = app.clone();
+            let owner = session.owner_id.clone();
+            tokio::task::spawn_blocking(move || crate::images::relocate_missing(&a, owner.as_deref()));
+        }
+        out
     };
     // Diagnostics: report new errors of the changed file right away.
     let res = match res {
@@ -609,6 +760,11 @@ async fn execute_call(
     }
 }
 
+/// A shell command that may move or rename files (`mv`, `git mv`, `rename`).
+fn moves_files(cmd: &str) -> bool {
+    cmd.split(|c: char| c.is_whitespace() || ";&|()`$".contains(c)).any(|w| w == "mv" || w == "rename")
+}
+
 async fn run_task(app: &Arc<App>, ctx: &ToolCtx, input: Value, depth: usize) -> Result<tools::ToolOutput> {
     let prompt = tools::arg_str(&input, "prompt")?.to_string();
     let description = input["description"].as_str().unwrap_or("subagent").to_string();
@@ -766,6 +922,47 @@ fn estimate_prompt_tokens(req: &ChatRequest) -> u64 {
 
 /// Errors after which the fallback model takes over: the host is unreachable
 /// (connection, timeout, gateway errors) or the provider's budget is used up.
+/// Room an answer gets at least before the conversation is compacted.
+const MIN_ANSWER_ROOM: u64 = 32_000;
+
+/// Estimated input tokens of the next request: the last request (its input and answer)
+/// plus the messages that came after that answer (tool results, user messages), at about
+/// 3 characters per token; without usage (fresh or just compacted) the whole history.
+fn estimate_input(last: Option<&crate::types::Usage>, history: &[Message]) -> u64 {
+    let chars_of = |m: &Message| -> u64 {
+        m.parts
+            .iter()
+            .map(|p| match p {
+                Part::Text { text } | Part::Reasoning { text, .. } | Part::Summary { text, .. } => text.len() as u64,
+                Part::ToolCall { input, .. } => input.to_string().len() as u64,
+                Part::ToolResult { content, images, .. } => content.len() as u64 + images.len() as u64 * 4_500,
+                Part::Image { .. } => 4_500,
+            })
+            .sum()
+    };
+    match last {
+        Some(u) => {
+            let after = history.iter().rposition(|m| m.role == Role::Assistant).map(|i| &history[i + 1..]).unwrap_or(&[]);
+            u.context_tokens() + after.iter().map(chars_of).sum::<u64>() / 3
+        }
+        None => history.iter().map(chars_of).sum::<u64>() / 3 + 8_000,
+    }
+}
+
+/// max_tokens for a request: the model's maximum, but no more than the window leaves
+/// (with a margin for the estimate), and never below a small floor.
+fn answer_budget(max_output: u64, context: Option<u64>, est_input: u64) -> u64 {
+    let Some(ctx) = context else { return max_output };
+    let room = ctx.saturating_sub(est_input + est_input / 50 + 2_000);
+    max_output.min(room).max(4_096.min(max_output))
+}
+
+/// The provider rejected the request because input + output exceed the context window.
+fn is_context_overflow(e: &anyhow::Error) -> bool {
+    let s = format!("{e:#}").to_lowercase();
+    ["input too long", "context length", "context_length", "maximum context", "context window", "prompt is too long", "too many tokens", "reduce the length"].iter().any(|k| s.contains(k))
+}
+
 fn needs_fallback(e: &anyhow::Error) -> bool {
     let s = format!("{e:#}").to_lowercase();
     ["connect", "timed out", "timeout", "http 502", "http 503", "http 504", "dns", "budget"].iter().any(|k| s.contains(k))
@@ -1120,7 +1317,7 @@ fn advance_phase(app: &App, session_id: &str, phase: &str, only_from: Option<&st
 /// Review the last turn against the user's request. Returns feedback for the
 /// agent, or None when the reviewer approves.
 #[allow(clippy::too_many_arguments)]
-async fn review_turn(app: &Arc<App>, session: &Session, agent: &prompts::Agent, model_spec: &str, turn_start: i64, round: u32, rounds: u32, cancel: &CancellationToken) -> Result<Option<String>> {
+async fn review_turn(app: &Arc<App>, session: &Session, agent: &prompts::Agent, model_spec: &str, since: i64, todos: Option<&[String]>, round: u32, rounds: u32, cancel: &CancellationToken) -> Result<Option<String>> {
     let refine = agent.refine.clone().unwrap_or_default();
     let spec = refine.model.clone().filter(|m| !m.is_empty()).unwrap_or_else(|| model_spec.to_string());
     let (provider, mut model) = app.registry().resolve(&spec)?;
@@ -1134,7 +1331,12 @@ async fn review_turn(app: &Arc<App>, session: &Session, agent: &prompts::Agent,
             .rposition(|m| matches!(m.role, Role::User) && m.parts.iter().any(|p| matches!(p, Part::Text { text } if !text.starts_with("<refine-feedback") && !text.starts_with("<hook-"))))
             .unwrap_or(0);
         let request: String = history.get(req_idx).map(|m| m.parts.iter().filter_map(|p| if let Part::Text { text } = p { Some(text.as_str()) } else { None }).collect::<Vec<_>>().join("\n")).unwrap_or_default();
-        let mut work = transcript_of(&history[(req_idx + 1).min(history.len())..]);
+        // A todo review looks at the work since the last review, the end-of-turn review at the whole turn.
+        let from = match todos {
+            Some(_) => history.iter().position(|m| m.created_at >= since).unwrap_or(history.len()).max(req_idx + 1),
+            None => req_idx + 1,
+        };
+        let mut work = transcript_of(&history[from.min(history.len())..]);
         if work.len() > 30_000 {
             let mut start = work.len() - 30_000;
             while !work.is_char_boundary(start) {
@@ -1145,7 +1347,7 @@ async fn review_turn(app: &Arc<App>, session: &Session, agent: &prompts::Agent,
         // Actual file changes of this turn (checkpoint vs. current content).
         let mut changes = String::new();
         let mut seen = std::collections::HashSet::new();
-        for (path, before) in app.store.checkpoints_since(&session.id, turn_start)? {
+        for (path, before) in app.store.checkpoints_since(&session.id, since)? {
             if !seen.insert(path.clone()) || changes.len() > 30_000 {
                 continue;
             }
@@ -1159,10 +1361,17 @@ async fn review_turn(app: &Arc<App>, session: &Session, agent: &prompts::Agent,
         let system = "You review the work of an AI coding agent for the user. Be strict about what matters for the user's request and ignore style nitpicks. \
             Reply in exactly this format: the first line is APPROVED or CHANGES_NEEDED. For CHANGES_NEEDED, follow with at most 8 concrete, actionable findings as a bullet list \
             (with file:line where possible). If the important work is done and correct, reply APPROVED.";
+        let focus = match todos {
+            Some(items) => format!(
+                "<completed-todos>\n{}\n</completed-todos>\nThe agent just marked these todo items as completed. Review only whether they are really done and correct; other parts of the request may still be in progress.\n\n",
+                items.iter().map(|t| format!("- {t}")).collect::<Vec<_>>().join("\n")
+            ),
+            None => String::new(),
+        };
         let body = format!(
-            "<request>\n{request}\n</request>\n\n<criteria>\n{criteria}\n</criteria>\n\n<agent-work mode=\"{}\">\n{work}\n</agent-work>\n\n<file-changes>\n{}\n</file-changes>",
+            "<request>\n{request}\n</request>\n\n{focus}<criteria>\n{criteria}\n</criteria>\n\n<agent-work mode=\"{}\">\n{work}\n</agent-work>\n\n<file-changes>\n{}\n</file-changes>",
             agent.name,
-            if changes.is_empty() { "(no files changed in this turn)" } else { changes.as_str() }
+            if changes.is_empty() { "(no files changed since the last review)" } else { changes.as_str() }
         );
         let req = ChatRequest { system: system.into(), messages: vec![Message::new(Role::User, vec![Part::Text { text: body }])], tools: vec![], max_tokens: 4000, reasoning: false, model: model.clone(), session_id: Some(session.id.clone()) };
         let (text, usage) = complete_text(app, &spec, provider, req, cancel.clone()).await?;
@@ -1175,10 +1384,17 @@ async fn review_turn(app: &Arc<App>, session: &Session, agent: &prompts::Agent,
         }
         let findings: String = lines.collect::<Vec<_>>().join("\n");
         let findings = if findings.trim().is_empty() { text.clone() } else { findings };
-        Ok(Some(format!(
-            "<refine-feedback round=\"{round}/{rounds}\" reviewer=\"{spec}\">\n{}\n</refine-feedback>\nAddress these review findings (or explain briefly why one does not apply), verify, then finish.",
-            findings.trim()
-        )))
+        Ok(Some(match todos {
+            Some(items) => format!(
+                "<refine-feedback round=\"{round}/{rounds}\" reviewer=\"{spec}\" todos=\"{}\">\n{}\n</refine-feedback>\nThe review of the todo(s) you just completed found problems, so they are open again. Fix these findings (or explain briefly why one does not apply), verify, then mark the todo(s) completed again – that triggers the next review.",
+                items.len(),
+                findings.trim()
+            ),
+            None => format!(
+                "<refine-feedback round=\"{round}/{rounds}\" reviewer=\"{spec}\">\n{}\n</refine-feedback>\nAddress these review findings (or explain briefly why one does not apply), verify, then finish.",
+                findings.trim()
+            ),
+        }))
     }
     .await;
     app.emit(Event::Waiting { session_id: session.id.clone(), reason: None });
@@ -1301,6 +1517,47 @@ async fn compact_inner(app: Arc<App>, session_id: &str, cancel: CancellationToke
 mod tests {
     use super::*;
 
+    #[test]
+    fn todo_completion_and_reopening() {
+        let before = serde_json::json!([{"content": "A", "status": "in_progress"}, {"content": "B", "status": "completed"}, {"content": "C", "status": "pending"}]);
+        let after = serde_json::json!([{"content": "A", "status": "completed"}, {"content": "B", "status": "completed"}, {"content": "C", "status": "pending"}]);
+        assert_eq!(newly_completed(&before, &after), vec!["A".to_string()]);
+        assert_eq!(newly_completed(&Value::Null, &after), vec!["A".to_string(), "B".to_string()]);
+        assert_eq!(open_todos(&after), vec!["C".to_string()]);
+        let reopened = reopen_todos(&after, &["A".to_string()]);
+        assert_eq!(reopened[0]["status"], "in_progress");
+        assert_eq!(reopened[1]["status"], "completed");
+    }
+
+    #[test]
+    fn answer_room_and_overflow() {
+        // The case from production: DeepSeek V4.1 Flash, 1M window, 384K output, 720K input.
+        let (ctx, out) = (1_048_576u64, 393_216u64);
+        let b = answer_budget(out, Some(ctx), 720_000);
+        assert!(720_000 + b <= ctx && b > 300_000, "{b}");
+        assert_eq!(answer_budget(out, Some(ctx), 100_000), out);
+        assert_eq!(answer_budget(16_000, None, 5_000_000), 16_000);
+        assert_eq!(answer_budget(out, Some(ctx), 1_040_000), 4_096);
+        assert!(is_context_overflow(&anyhow!("HTTP 400: [invalid_request_error] Input too long: model limit 1048576 tokens, requested 1108739 tokens")));
+        assert!(is_context_overflow(&anyhow!("This model's maximum context length is 128000 tokens")));
+        assert!(!is_context_overflow(&anyhow!("HTTP 429 rate limited")));
+        // Estimate: last request + what came after its answer (about 3 chars per token).
+        let u = crate::types::Usage { input_tokens: 1_000, cache_read_tokens: 9_000, output_tokens: 500, ..Default::default() };
+        let mut call = Message::new(Role::Assistant, vec![call("c1")]);
+        call.id = "a".into();
+        let result = Message::new(Role::User, vec![Part::ToolResult { call_id: "c1".into(), name: "bash".into(), content: "x".repeat(3_000), images: vec![], is_error: false, meta: None }]);
+        assert_eq!(estimate_input(Some(&u), &[call.clone(), result.clone()]), 10_500 + 1_000);
+        assert!(estimate_input(None, &[call, result]) >= 1_000 + 8_000);
+    }
+
+    #[test]
+    fn detects_commands_that_move_files() {
+        assert!(moves_files("mkdir -p art/old && mv art/*.png art/old/"));
+        assert!(moves_files("git mv a.png b.png"));
+        assert!(moves_files("cd art;mv x y"));
+        assert!(!moves_files("ls -la movies && cat remove.txt"));
+    }
+
     fn call(id: &str) -> Part {
         Part::ToolCall { id: id.into(), name: "bash".into(), input: serde_json::json!({}), extra: None }
     }

server/src/store.rs

@@ -169,6 +169,8 @@ impl Store {
             ("usage", "user_id", "ALTER TABLE usage ADD COLUMN user_id TEXT"),
             ("users", "monthly_quota", "ALTER TABLE users ADD COLUMN monthly_quota REAL"),
             ("jobs", "webhook_secret", "ALTER TABLE jobs ADD COLUMN webhook_secret TEXT"),
+            ("jobs", "settings", "ALTER TABLE jobs ADD COLUMN settings TEXT"),
+            ("images", "blob", "ALTER TABLE images ADD COLUMN blob TEXT"),
             ("usage", "allowance", "ALTER TABLE usage ADD COLUMN allowance REAL"),
         ] {
             let exists: bool = conn
@@ -393,6 +395,10 @@ impl Store {
         }
         drop(rows);
         drop(stmt);
+        // Copies of generated images (see ImageRecord::blob).
+        for h in conn.prepare("SELECT blob FROM images WHERE blob IS NOT NULL")?.query_map([], |r| r.get::<_, String>(0))? {
+            used.insert(h?);
+        }
         let all: Vec<String> = conn.prepare("SELECT hash FROM blobs")?.query_map([], |r| r.get(0))?.collect::<rusqlite::Result<_>>()?;
         let mut removed = 0;
         for h in all.iter().filter(|h| !used.contains(*h)) {
@@ -965,6 +971,10 @@ pub struct ImageRecord {
     pub width: i64,
     pub height: i64,
     pub created_at: i64,
+    /// Copy of the bytes in the image store: the file may be moved or deleted later
+    /// (agents tidy up folders), the image stays viewable.
+    #[serde(skip)]
+    pub blob: Option<String>,
 }
 
 fn image_row(r: &rusqlite::Row) -> rusqlite::Result<ImageRecord> {
@@ -978,21 +988,62 @@ fn image_row(r: &rusqlite::Row) -> rusqlite::Result<ImageRecord> {
         width: r.get(6)?,
         height: r.get(7)?,
         created_at: r.get(8)?,
+        blob: r.get(9)?,
     })
 }
 
-const IMAGE_COLS: &str = "id, user_id, session_id, prompt, model, path, width, height, created_at";
+const IMAGE_COLS: &str = "id, user_id, session_id, prompt, model, path, width, height, created_at, blob";
 
 impl Store {
     pub fn add_image(&self, img: &ImageRecord) -> Result<()> {
         let conn = self.conn.lock().unwrap();
         conn.execute(
-            &format!("INSERT INTO images ({IMAGE_COLS}) VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9)"),
-            params![img.id, img.user_id, img.session_id, img.prompt, img.model, img.path, img.width, img.height, img.created_at],
+            &format!("INSERT INTO images ({IMAGE_COLS}) VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10)"),
+            params![img.id, img.user_id, img.session_id, img.prompt, img.model, img.path, img.width, img.height, img.created_at, img.blob],
         )?;
         Ok(())
     }
 
+    /// Store bytes in the image store; returns their hash.
+    pub fn put_blob(&self, media_type: &str, bytes: &[u8]) -> Result<String> {
+        let hash = crate::blobs::hash(bytes);
+        self.conn.lock().unwrap().execute(
+            "INSERT OR IGNORE INTO blobs (hash, media_type, data, created_at) VALUES (?1, ?2, ?3, ?4)",
+            params![hash, media_type, bytes, now_ms()],
+        )?;
+        Ok(hash)
+    }
+
+    /// Generated images from before the copies in the image store (id, path).
+    pub fn images_without_copy(&self) -> Result<Vec<(String, String)>> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn.prepare("SELECT id, path FROM images WHERE blob IS NULL")?;
+        let rows = stmt.query_map([], |r| Ok((r.get(0)?, r.get(1)?)))?.collect::<rusqlite::Result<Vec<_>>>()?;
+        Ok(rows)
+    }
+
+    pub fn set_image_blob(&self, id: &str, hash: &str) -> Result<()> {
+        self.conn.lock().unwrap().execute("UPDATE images SET blob = ?2 WHERE id = ?1", params![id, hash])?;
+        Ok(())
+    }
+
+    /// A file or folder was moved: generated images in it follow.
+    pub fn move_image_paths(&self, from: &str, to: &str) -> Result<usize> {
+        let from = from.trim_end_matches('/');
+        let to = to.trim_end_matches('/');
+        Ok(self.conn.lock().unwrap().execute(
+            "UPDATE images SET path = ?2 || substr(path, length(?1) + 1)
+             WHERE path = ?1 OR substr(path, 1, length(?1) + 1) = ?1 || '/'",
+            params![from, to],
+        )?)
+    }
+
+    /// The file of a generated image was found somewhere else.
+    pub fn set_image_path(&self, id: &str, path: &str) -> Result<()> {
+        self.conn.lock().unwrap().execute("UPDATE images SET path = ?2 WHERE id = ?1", params![id, path])?;
+        Ok(())
+    }
+
     /// Latest images; `user = None` lists everybody's (admins).
     pub fn images(&self, user: Option<&str>, limit: i64) -> Result<Vec<ImageRecord>> {
         let conn = self.conn.lock().unwrap();
@@ -1135,13 +1186,14 @@ impl Store {
             last_status: r.get(6)?,
             created_at: r.get(7)?,
             webhook: r.get::<_, Option<String>>(8)?.is_some(),
+            settings: r.get::<_, Option<String>>(9)?.and_then(|j| serde_json::from_str(&j).ok()),
         })
     }
 
     pub fn jobs(&self, owner: Option<&str>) -> Result<Vec<crate::jobs::Job>> {
         let conn = self.conn.lock().unwrap();
         let mut stmt = conn.prepare(
-            "SELECT id, owner_id, path, enabled, last_run, last_session_id, last_status, created_at, webhook_secret FROM jobs
+            "SELECT id, owner_id, path, enabled, last_run, last_session_id, last_status, created_at, webhook_secret, settings FROM jobs
              WHERE ?1 IS NULL OR owner_id = ?1 ORDER BY created_at",
         )?;
         let rows = stmt.query_map([owner], Self::job_row)?;
@@ -1151,7 +1203,7 @@ impl Store {
     pub fn job(&self, id: &str) -> Result<Option<crate::jobs::Job>> {
         let conn = self.conn.lock().unwrap();
         Ok(conn
-            .query_row("SELECT id, owner_id, path, enabled, last_run, last_session_id, last_status, created_at, webhook_secret FROM jobs WHERE id = ?1", [id], Self::job_row)
+            .query_row("SELECT id, owner_id, path, enabled, last_run, last_session_id, last_status, created_at, webhook_secret, settings FROM jobs WHERE id = ?1", [id], Self::job_row)
             .optional()?)
     }
 
@@ -1167,7 +1219,7 @@ impl Store {
         }
         let conn = self.conn.lock().unwrap();
         Ok(conn.query_row(
-            "SELECT id, owner_id, path, enabled, last_run, last_session_id, last_status, created_at, webhook_secret FROM jobs WHERE path = ?1",
+            "SELECT id, owner_id, path, enabled, last_run, last_session_id, last_status, created_at, webhook_secret, settings FROM jobs WHERE path = ?1",
             [path],
             Self::job_row,
         )?)
@@ -1200,6 +1252,11 @@ impl Store {
     }
 
     /// Set (Some) or remove (None) the webhook secret of a job.
+    pub fn job_set_settings(&self, id: &str, settings: &crate::jobs::JobSettings) -> Result<()> {
+        self.conn.lock().unwrap().execute("UPDATE jobs SET settings = ?2 WHERE id = ?1", rusqlite::params![id, serde_json::to_string(settings)?])?;
+        Ok(())
+    }
+
     pub fn job_set_webhook(&self, id: &str, secret: Option<&str>) -> Result<()> {
         self.conn.lock().unwrap().execute("UPDATE jobs SET webhook_secret = ?2 WHERE id = ?1", rusqlite::params![id, secret])?;
         Ok(())

server/src/telegram.rs

@@ -260,7 +260,8 @@ fn user(app: &App, user_id: &str) -> Result<User> {
     app.store.user(user_id)?.filter(|u| !u.disabled).ok_or_else(|| anyhow!("account disabled"))
 }
 
-fn german(app: &App, user_id: &str) -> bool {
+/// The user reads German (language preference of the web UI).
+pub fn german(app: &App, user_id: &str) -> bool {
     let prefs: Value = app.store.user_setting(user_id, "prefs").unwrap_or_default();
     prefs["lang"].as_str().unwrap_or("en").starts_with("de")
 }

web/index.html

@@ -2,7 +2,9 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+    <!-- interactive-widget: the on-screen keyboard shrinks the page (Android) instead of
+         shifting it up – the top bar stays in place. -->
+    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-content" />
     <meta name="theme-color" content="#282828" />
     <link rel="icon" href="/icon.svg" type="image/svg+xml" />
     <link rel="apple-touch-icon" href="/apple-touch-icon.png" />

web/src/App.tsx

@@ -12,6 +12,7 @@ import { Settings } from "./components/Settings";
 import { Stats } from "./components/Stats";
 import { Images } from "./components/Images";
 import { Jobs } from "./components/Jobs";
+import { JobEditor } from "./components/JobEditor";
 import { Spinner, useTitleActivity } from "./components/Activity";
 import { DialogHost } from "./dialogs";
 import { startPrefsSync } from "./prefsSync";
@@ -95,6 +96,7 @@ export function App() {
   else if (section === "settings") content = <Settings tab={arg} onMenu={() => setMenuOpen(true)} />;
   else if (section === "stats") content = <Stats onMenu={() => setMenuOpen(true)} />;
   else if (section === "images") content = <Images onMenu={() => setMenuOpen(true)} />;
+  else if (section === "jobs" && arg) content = <JobEditor key={arg} id={arg} onMenu={() => setMenuOpen(true)} />;
   else if (section === "jobs") content = <Jobs onMenu={() => setMenuOpen(true)} />;
   else if (section === "terminal")
     content = (

web/src/components/ChatView.tsx

@@ -115,7 +115,36 @@ function BackgroundResult({ text }: { text: string }) {
   );
 }
 
-const REFINE_RE = /^<refine-feedback round="([^"]*)" reviewer="([^"]*)">\n?([\s\S]*?)\n?<\/refine-feedback>/;
+const REFINE_RE = /^<refine-feedback round="([^"]*)" reviewer="([^"]*)"(?: todos="\d+")?>\n?([\s\S]*?)\n?<\/refine-feedback>/;
+/** Enforced reviews: a completed todo passed, or a reminder about open todos. */
+const NOTE_RE = /^<(refine-approved|todo-reminder)(?: reviewer="([^"]*)")?(?: open="\d+")?>\n?([\s\S]*?)\n?<\/(?:refine-approved|todo-reminder)>/;
+/** Messages from the harness shown as cards instead of user bubbles. */
+const isHarnessNote = (text: string) => BG_RE.test(text) || REFINE_RE.test(text) || NOTE_RE.test(text);
+
+/** A todo passed its review, or the agent was sent back to its open todos. */
+function HarnessNote({ text }: { text: string }) {
+  const t = useT();
+  const m = text.match(NOTE_RE);
+  if (!m) return null;
+  const [, kind, reviewer, body] = m;
+  const items = body.split("\n").map((l) => l.replace(/^- /, "").trim()).filter(Boolean);
+  const approved = kind === "refine-approved";
+  return (
+    <div className={`harness-note ${approved ? "ok" : ""}`}>
+      <Icon name={approved ? "check" : "refresh"} />
+      <span className="grow">
+        <b>{t(approved ? "chat.reviewPassed" : "chat.todoReminder", { n: items.length })}</b> {items.join(" · ")}
+      </span>
+      {reviewer && <span className="chip">{reviewer}</span>}
+    </div>
+  );
+}
+
+function HarnessMessage({ text }: { text: string }) {
+  if (REFINE_RE.test(text)) return <RefineFeedback text={text} />;
+  if (NOTE_RE.test(text)) return <HarnessNote text={text} />;
+  return <BackgroundResult text={text} />;
+}
 
 /** Findings of the review loop, sent back to the agent. */
 function RefineFeedback({ text }: { text: string }) {
@@ -202,6 +231,17 @@ export function ChatView({ sessionId, onMenu, onClosePane }: { sessionId: string
     const el = scrollRef.current;
     if (el && stick.current) el.scrollTop = el.scrollHeight;
   });
+  // … also when the pane gets smaller (on-screen keyboard opens) without a render.
+  const hasSession = !!session;
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (!el || typeof ResizeObserver === "undefined") return;
+    const ro = new ResizeObserver(() => {
+      if (stick.current) el.scrollTop = el.scrollHeight;
+    });
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [hasSession, sessionId]);
 
   if (loadError) return <div className="empty">{loadError}</div>;
   if (!session) return <div className="empty">{t("common.loading")}</div>;
@@ -458,14 +498,14 @@ export function ChatView({ sessionId, onMenu, onClosePane }: { sessionId: string
               );
             }
             const allTexts = m.parts.filter((p) => p.type === "text") as { text: string }[];
-            const background = allTexts.filter((p) => BG_RE.test(p.text) || REFINE_RE.test(p.text));
-            const texts = allTexts.filter((p) => !BG_RE.test(p.text) && !REFINE_RE.test(p.text));
+            const background = allTexts.filter((p) => isHarnessNote(p.text));
+            const texts = allTexts.filter((p) => !isHarnessNote(p.text));
             const imgs = m.parts.filter((p) => p.type === "image") as { image: ImageData }[];
             if (texts.length === 0 && imgs.length === 0) {
               return background.length ? (
                 <div key={m.id} className="msg">
                   {background.map((p, i) => (
-                    REFINE_RE.test(p.text) ? <RefineFeedback key={i} text={p.text} /> : <BackgroundResult key={i} text={p.text} />
+                    <HarnessMessage key={i} text={p.text} />
                   ))}
                 </div>
               ) : null;
@@ -473,7 +513,7 @@ export function ChatView({ sessionId, onMenu, onClosePane }: { sessionId: string
             return (
               <div key={m.id} className="msg">
                 {background.map((p, i) => (
-                  REFINE_RE.test(p.text) ? <RefineFeedback key={i} text={p.text} /> : <BackgroundResult key={i} text={p.text} />
+                  <HarnessMessage key={i} text={p.text} />
                 ))}
                 <div className="msg-user">
                   {!busy && !readOnly && (
@@ -597,9 +637,10 @@ function UserText({ text }: { text: string }) {
     const last = rest.pop()!;
     if (last.trim().endsWith(":")) break;
   }
+  const body = rest.join("\n").trim();
   return (
     <>
-      {rest.join("\n").trimEnd()}
+      {body && <Markdown text={body} breaks />}
       {files.length > 0 && (
         <div className="user-files">
           {files.map((f) => (

web/src/components/Composer.tsx

@@ -9,6 +9,7 @@ import type { ImageData, Session } from "../types";
 import { ModelSelect } from "./ModelSelect";
 import { EffortSelect } from "./Regenerate";
 import { VoiceButton } from "./Voice";
+import { Markdown } from "./Markdown";
 import { confirmDialog, promptDialog, toast } from "../dialogs";
 
 interface Suggestion {
@@ -67,6 +68,8 @@ export function Composer({
   const [effort, setEffort] = useState("");
   const [interim, setInterim] = useState("");
   const [picker, setPicker] = useState(false);
+  // Rendered Markdown instead of the text field (to check formatting before sending).
+  const [preview, setPreview] = useState(false);
   const models = useModels();
   const [prov, ...mid] = session.model.split("/");
   const reasoning = !!models.find((p) => p.provider === prov)?.models.find((m) => m.id === mid.join("/"))?.reasoning;
@@ -265,7 +268,20 @@ export function Composer({
             ))}
           </div>
         )}
+        {preview && (
+          <div
+            className="composer-preview"
+            role="button"
+            tabIndex={0}
+            title={t("composer.previewEdit")}
+            onClick={() => (setPreview(false), setTimeout(() => ref.current?.focus(), 0))}
+            onKeyDown={(e) => e.key === "Enter" && (setPreview(false), setTimeout(() => ref.current?.focus(), 0))}
+          >
+            {text.trim() ? <Markdown text={text} breaks /> : <span className="hint">{t("composer.previewEmpty")}</span>}
+          </div>
+        )}
         <textarea
+          style={preview ? { display: "none" } : undefined}
           ref={ref}
           rows={1}
           value={text}
@@ -337,6 +353,15 @@ export function Composer({
               }}
             />
           )}
+          <button
+            className={`ghost ${preview ? "active" : ""}`}
+            style={{ padding: "3px 6px" }}
+            onClick={() => setPreview(!preview)}
+            aria-pressed={preview}
+            title={t(preview ? "composer.previewEdit" : "composer.preview")}
+          >
+            <Icon name={preview ? "edit" : "eye"} />
+          </button>
           <VoiceButton onText={(d) => setText(text ? `${text.replace(/\s+$/, "")} ${d}` : d)} onInterim={setInterim} />
           <label className="ghost" style={{ cursor: "pointer", padding: "3px 6px" }} title={t("composer.attach")}>
             <Icon name="clip" />

web/src/components/CronBuilder.tsx

@@ -0,0 +1,217 @@
+import { useEffect, useState } from "react";
+import { get } from "../api";
+import { getLang, useT } from "../i18n";
+
+/**
+ * Graphical editor for a 5-field cron expression (minute hour day month weekday,
+ * server time zone): every N minutes, hourly, daily, on weekdays, monthly – or a
+ * custom expression. Shows the next runs as computed by the server.
+ */
+type Mode = "minutes" | "hourly" | "daily" | "weekly" | "monthly" | "custom";
+
+interface State {
+  mode: Mode;
+  every: number;
+  minute: number;
+  time: string; // HH:MM
+  days: number[]; // cron weekdays, 0 = Sunday
+  dom: number;
+  custom: string;
+}
+
+const MINUTE_STEPS = [5, 10, 15, 20, 30];
+/** Monday first; cron numbers (0 = Sunday). */
+const WEEK = [1, 2, 3, 4, 5, 6, 0];
+
+const pad = (n: number) => String(n).padStart(2, "0");
+const hhmm = (h: string, m: string) => `${pad(Number(h))}:${pad(Number(m))}`;
+
+function expandDays(field: string): number[] | null {
+  const out = new Set<number>();
+  for (const part of field.split(",")) {
+    const m = part.match(/^(\d)(?:-(\d))?$/);
+    if (!m) return null;
+    const a = Number(m[1]);
+    const b = m[2] ? Number(m[2]) : a;
+    if (a > 7 || b > 7 || b < a) return null;
+    for (let d = a; d <= b; d++) out.add(d % 7);
+  }
+  return [...out];
+}
+
+export function parseCron(expr: string): State {
+  const base: State = { mode: "custom", every: 15, minute: 0, time: "03:00", days: [1, 2, 3, 4, 5], dom: 1, custom: expr.trim() };
+  const f = expr.trim().split(/\s+/);
+  if (f.length !== 5) return base;
+  const [mi, h, dom, mon, dow] = f;
+  const num = (s: string, max: number) => /^\d+$/.test(s) && Number(s) <= max;
+  if (mon !== "*") return base;
+  let m;
+  if ((m = mi.match(/^\*\/(\d+)$/)) && h === "*" && dom === "*" && dow === "*" && MINUTE_STEPS.includes(Number(m[1]))) return { ...base, mode: "minutes", every: Number(m[1]) };
+  if (num(mi, 59) && h === "*" && dom === "*" && dow === "*") return { ...base, mode: "hourly", minute: Number(mi) };
+  if (!num(mi, 59) || !num(h, 23)) return base;
+  const time = hhmm(h, mi);
+  if (dom === "*" && dow === "*") return { ...base, mode: "daily", time };
+  if (dom === "*") {
+    const days = expandDays(dow);
+    return days?.length ? { ...base, mode: "weekly", time, days } : base;
+  }
+  if (num(dom, 31) && Number(dom) >= 1 && dow === "*") return { ...base, mode: "monthly", time, dom: Number(dom) };
+  return base;
+}
+
+export function buildCron(s: State): string {
+  const [h, m] = s.time.split(":").map(Number);
+  switch (s.mode) {
+    case "minutes":
+      return `*/${s.every} * * * *`;
+    case "hourly":
+      return `${s.minute} * * * *`;
+    case "daily":
+      return `${m} ${h} * * *`;
+    case "weekly": {
+      const days = [...s.days].sort((a, b) => a - b);
+      return `${m} ${h} * * ${days.length ? days.join(",") : "*"}`;
+    }
+    case "monthly":
+      return `${m} ${h} ${s.dom} * *`;
+    default:
+      return s.custom.trim();
+  }
+}
+
+const dayName = (d: number, style: "short" | "long") => {
+  // 2023-01-01 was a Sunday.
+  return new Date(2023, 0, 1 + d).toLocaleDateString(getLang(), { weekday: style });
+};
+
+/** "2026-11-11T06:30" (server wall time) for display, without time zone conversion. */
+const fmtWall = (s: string) => {
+  const [d, hm] = s.split("T");
+  const [y, mo, da] = d.split("-").map(Number);
+  const date = new Date(y, mo - 1, da).toLocaleDateString(getLang(), { weekday: "short", day: "numeric", month: "short" });
+  return `${date}, ${hm}`;
+};
+
+export function CronBuilder({ value, onChange }: { value: string; onChange: (cron: string) => void }) {
+  const t = useT();
+  const [s, setS] = useState<State>(() => parseCron(value));
+  const [preview, setPreview] = useState<{ ok: boolean; next_local?: string[]; error?: string; tz?: string }>();
+
+  // A value from outside (another automation, reset) that the builder did not produce.
+  useEffect(() => {
+    if (value.trim() !== buildCron(s)) setS(parseCron(value));
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [value]);
+
+  useEffect(() => {
+    const expr = value.trim();
+    if (!expr) return setPreview(undefined);
+    let alive = true;
+    const h = setTimeout(() => {
+      get<typeof preview>(`/jobs/schedule?expr=${encodeURIComponent(expr)}`)
+        .then((p) => alive && setPreview(p))
+        .catch(() => alive && setPreview(undefined));
+    }, 250);
+    return () => {
+      alive = false;
+      clearTimeout(h);
+    };
+  }, [value]);
+
+  const set = (patch: Partial<State>) => {
+    const next = { ...s, ...patch };
+    // Switching to "custom" starts from the current expression.
+    if (patch.mode === "custom" && s.mode !== "custom") next.custom = buildCron(s);
+    setS(next);
+    onChange(buildCron(next));
+  };
+
+  const modes: Mode[] = ["minutes", "hourly", "daily", "weekly", "monthly", "custom"];
+  return (
+    <div className="cron-builder">
+      <div className="cron-modes" role="radiogroup" aria-label={t("cron.label")}>
+        {modes.map((m) => (
+          <button key={m} type="button" role="radio" aria-checked={s.mode === m} className={`chip-btn ${s.mode === m ? "active" : ""}`} onClick={() => set({ mode: m })}>
+            {t(`cron.mode.${m}` as const)}
+          </button>
+        ))}
+      </div>
+      <div className="cron-fields">
+        {s.mode === "minutes" && (
+          <label>
+            {t("cron.every")}
+            <select value={s.every} onChange={(e) => set({ every: Number(e.target.value) })}>
+              {MINUTE_STEPS.map((n) => (
+                <option key={n} value={n}>
+                  {n}
+                </option>
+              ))}
+            </select>
+            {t("cron.minutes")}
+          </label>
+        )}
+        {s.mode === "hourly" && (
+          <label>
+            {t("cron.atMinute")}
+            <input type="number" min={0} max={59} value={s.minute} onChange={(e) => set({ minute: Math.min(59, Math.max(0, Number(e.target.value) || 0)) })} />
+          </label>
+        )}
+        {s.mode === "weekly" && (
+          <div className="cron-days" role="group" aria-label={t("cron.days")}>
+            {WEEK.map((d) => (
+              <button
+                key={d}
+                type="button"
+                aria-pressed={s.days.includes(d)}
+                className={`chip-btn ${s.days.includes(d) ? "active" : ""}`}
+                title={dayName(d, "long")}
+                onClick={() => set({ days: s.days.includes(d) ? s.days.filter((x) => x !== d) : [...s.days, d] })}
+              >
+                {dayName(d, "short")}
+              </button>
+            ))}
+            <button type="button" className="link-btn" onClick={() => set({ days: [1, 2, 3, 4, 5] })}>
+              {t("cron.workdays")}
+            </button>
+          </div>
+        )}
+        {s.mode === "monthly" && (
+          <label>
+            {t("cron.onDay")}
+            <select value={s.dom} onChange={(e) => set({ dom: Number(e.target.value) })}>
+              {Array.from({ length: 31 }, (_, i) => i + 1).map((d) => (
+                <option key={d} value={d}>
+                  {d}.
+                </option>
+              ))}
+            </select>
+          </label>
+        )}
+        {(s.mode === "daily" || s.mode === "weekly" || s.mode === "monthly") && (
+          <label>
+            {t("cron.at")}
+            <input type="time" value={s.time} onChange={(e) => e.target.value && set({ time: e.target.value })} />
+          </label>
+        )}
+        {s.mode === "custom" && (
+          <label className="cron-custom">
+            <input className="mono" value={s.custom} placeholder="0 3 * * *" spellCheck={false} onChange={(e) => set({ custom: e.target.value })} />
+            <small className="hint">{t("cron.customHint")}</small>
+          </label>
+        )}
+      </div>
+      <div className="cron-preview">
+        <code>{value || "–"}</code>
+        {preview?.ok === false && <span className="err">{preview.error}</span>}
+        {preview?.ok && preview.next_local && preview.next_local.length > 0 && (
+          <span>
+            {t("cron.nextRuns")} {preview.next_local.slice(0, 3).map(fmtWall).join(" · ")}
+          </span>
+        )}
+        {preview?.tz && s.mode !== "minutes" && <span className="hint">{t("cron.serverTz", { tz: preview.tz })}</span>}
+        {s.mode === "monthly" && s.dom > 28 && <span className="hint">{t("cron.shortMonths")}</span>}
+      </div>
+    </div>
+  );
+}

web/src/components/JobEditor.tsx

@@ -0,0 +1,298 @@
+import { lazy, Suspense, useCallback, useEffect, useRef, useState } from "react";
+import { ApiError, get, patch, post, put } from "../api";
+import { confirmDialog, toast } from "../dialogs";
+import { fmtRelative, useT } from "../i18n";
+import { navigate } from "../router";
+import { useStore } from "../store";
+import { Spinner } from "./Activity";
+import { ChatView } from "./ChatView";
+import { CronBuilder } from "./CronBuilder";
+import { Icon } from "./Icon";
+import type { JobInfo } from "./Jobs";
+import { ModelSelect } from "./ModelSelect";
+
+const CodeEditor = lazy(() => import("./CodeEditor").then((m) => ({ default: m.CodeEditor })));
+
+interface Settings {
+  name: string;
+  schedule: string;
+  agent: string;
+  model: string;
+  permission_mode: string;
+  timeout_minutes: number;
+}
+
+const settingsOf = (j: JobInfo): Settings => ({
+  name: j.spec?.name ?? "",
+  schedule: j.spec?.schedule ?? "0 3 * * *",
+  agent: j.spec?.agent ?? "build",
+  model: j.spec?.model ?? "",
+  permission_mode: j.spec?.permission_mode ?? "auto",
+  timeout_minutes: j.spec?.timeout_minutes ?? 60,
+});
+
+type Tab = "prompt" | "settings" | "assistant";
+
+/**
+ * One automation: its instructions (Markdown file) in an editor, schedule and settings,
+ * and a chat with a model that helps to write the instructions (it edits the file).
+ */
+export function JobEditor({ id, onMenu }: { id: string; onMenu: () => void }) {
+  const t = useT();
+  const [job, setJob] = useState<JobInfo>();
+  const [settings, setSettings] = useState<Settings>();
+  const [saved, setSaved] = useState<Settings>();
+  const [text, setText] = useState<string>();
+  const [savedText, setSavedText] = useState<string>();
+  const [mtime, setMtime] = useState<number>();
+  const [changedOnDisk, setChangedOnDisk] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [assistant, setAssistant] = useState<string>();
+  const [tab, setTab] = useState<Tab>("prompt");
+
+  const loadJob = useCallback(async () => {
+    const j = await get<JobInfo>(`/jobs/${id}`);
+    setJob(j);
+    const s = settingsOf(j);
+    setSettings((cur) => (cur && saved && JSON.stringify(cur) !== JSON.stringify(saved) ? cur : s));
+    setSaved(s);
+    setAssistant(j.spec?.assistant_session ?? undefined);
+    return j;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [id]);
+
+  const loadFile = useCallback(async (path: string) => {
+    const f = await get<{ content?: string; mtime?: number }>(`/files/read?path=${encodeURIComponent(path)}`);
+    setText(f.content ?? "");
+    setSavedText(f.content ?? "");
+    setMtime(f.mtime);
+    setChangedOnDisk(false);
+  }, []);
+
+  useEffect(() => {
+    loadJob()
+      .then((j) => loadFile(j.path))
+      .catch((e) => toast(e.message));
+  }, [loadJob, loadFile]);
+
+  const fileDirty = text !== undefined && text !== savedText;
+  const settingsDirty = !!settings && !!saved && JSON.stringify(settings) !== JSON.stringify(saved);
+  const dirty = fileDirty || settingsDirty;
+
+  // The assistant edits the file: reload it when a turn ends (unless there are unsaved edits).
+  const busy = useStore((s) => (assistant ? !!s.busy[assistant] : false));
+  const wasBusy = useRef(false);
+  const dirtyRef = useRef(fileDirty);
+  dirtyRef.current = fileDirty;
+  useEffect(() => {
+    if (wasBusy.current && !busy && job) {
+      get<{ mtime?: number }>(`/files/stat?path=${encodeURIComponent(job.path)}`)
+        .then((st) => {
+          if (st.mtime && mtime && st.mtime <= mtime) return;
+          if (dirtyRef.current) setChangedOnDisk(true);
+          else void loadFile(job.path);
+        })
+        .catch(() => undefined);
+    }
+    wasBusy.current = busy;
+  }, [busy, job, mtime, loadFile]);
+
+  // Unsaved changes: ask before leaving the page.
+  useEffect(() => {
+    if (!dirty) return;
+    const warn = (e: BeforeUnloadEvent) => e.preventDefault();
+    window.addEventListener("beforeunload", warn);
+    return () => window.removeEventListener("beforeunload", warn);
+  }, [dirty]);
+
+  const save = async (force = false) => {
+    if (!job || !settings) return;
+    setSaving(true);
+    try {
+      if (settingsDirty) {
+        const j = await patch<JobInfo>(`/jobs/${id}`, settings);
+        setJob(j);
+        const s = settingsOf(j);
+        setSettings(s);
+        setSaved(s);
+      }
+      if (fileDirty) {
+        const r = await put<{ mtime?: number }>("/files/write", { path: job.path, content: text, expected_mtime: mtime, force });
+        setSavedText(text);
+        setMtime(r.mtime);
+        setChangedOnDisk(false);
+        void loadJob();
+      }
+      toast(t("jobEditor.saved"), "success");
+    } catch (e: any) {
+      if (e instanceof ApiError && e.status === 409) {
+        if (await confirmDialog({ message: t("jobEditor.conflict"), confirmLabel: t("jobEditor.overwrite"), danger: true })) return save(true);
+      } else toast(e.message);
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const setEnabled = async (enabled: boolean) => {
+    try {
+      setJob(await patch<JobInfo>(`/jobs/${id}`, { enabled }));
+    } catch (e: any) {
+      toast(e.message);
+    }
+  };
+
+  const runNow = async () => {
+    if (dirty && !(await confirmDialog({ message: t("jobEditor.runUnsaved") }))) return;
+    try {
+      const r = await post<{ session_id: string }>(`/jobs/${id}/run`, {});
+      navigate(`/s/${r.session_id}`);
+    } catch (e: any) {
+      toast(e.message);
+    }
+  };
+
+  const startAssistant = async () => {
+    try {
+      const r = await post<{ session_id: string }>(`/jobs/${id}/assistant`, {});
+      setAssistant(r.session_id);
+      setTab("assistant");
+    } catch (e: any) {
+      toast(e.message);
+    }
+  };
+
+  const back = async () => {
+    if (dirty && !(await confirmDialog({ message: t("jobEditor.discard"), danger: true }))) return;
+    navigate("/jobs");
+  };
+
+  if (!job || !settings) return <div className="empty"><Spinner /></div>;
+  const up = (p: Partial<Settings>) => setSettings({ ...settings, ...p });
+
+  return (
+    <>
+      <div className="topbar">
+        <button className="ghost menu-btn" onClick={onMenu} aria-label={t("nav.menu")}>
+          <Icon name="menu" />
+        </button>
+        <button className="small ghost" onClick={back} title={t("jobEditor.back")} aria-label={t("jobEditor.back")}>
+          <Icon name="arrow-left" />
+        </button>
+        <div className="grow">
+          <h1>{settings.name || t("nav.jobs")}</h1>
+          <div className="path mono">{job.path}</div>
+        </div>
+        <label className="switch" title={t(job.enabled ? "jobs.disable" : "jobs.enable")}>
+          <input type="checkbox" checked={job.enabled} onChange={(e) => void setEnabled(e.target.checked)} />
+          <span>{t(job.enabled ? "jobs.on" : "jobs.off")}</span>
+        </label>
+        <button className="small ghost" onClick={runNow} title={t("jobs.runNow")}>
+          <Icon name="play" /> <span className="hide-mobile">{t("jobs.runNow")}</span>
+        </button>
+        <button className="small primary" disabled={!dirty || saving} onClick={() => void save()}>
+          {saving ? <Spinner small /> : <Icon name="check" />} {t("common.save")}
+        </button>
+      </div>
+      <div className="job-tabs" role="tablist">
+        {(["prompt", "settings", "assistant"] as Tab[]).map((x) => (
+          <button key={x} role="tab" aria-selected={tab === x} className={tab === x ? "active" : ""} onClick={() => setTab(x)}>
+            {t(`jobEditor.tab.${x}` as const)}
+            {x === "prompt" && fileDirty && " •"}
+            {x === "settings" && settingsDirty && " •"}
+          </button>
+        ))}
+      </div>
+      <div className={`job-editor tab-${tab}`}>
+        <div className="job-editor-main">
+          <section className="job-editor-settings panel">
+            <div className="job-editor-row">
+              <label className="field" style={{ flex: 2 }}>
+                <span>{t("jobs.tplName")}</span>
+                <input value={settings.name} onChange={(e) => up({ name: e.target.value })} />
+              </label>
+              <div className="job-editor-status">
+                <span>
+                  {t("jobs.next")}: {job.enabled && job.next_run ? new Date(job.next_run).toLocaleString(undefined, { dateStyle: "medium", timeStyle: "short" }) : "–"}
+                </span>
+                <span>
+                  {t("jobs.last")}: {job.last_run ? fmtRelative(job.last_run) : "–"}
+                  {job.last_session_id && (
+                    <button className="link-btn" style={{ marginLeft: 6 }} onClick={() => navigate(`/s/${job.last_session_id}`)}>
+                      {t("jobs.openRun")}
+                    </button>
+                  )}
+                </span>
+              </div>
+            </div>
+            <div className="field">
+              <span>{t("jobs.schedule")}</span>
+              <CronBuilder value={settings.schedule} onChange={(schedule) => up({ schedule })} />
+            </div>
+            <div className="job-editor-row">
+              <label className="field">
+                <span>{t("jobs.tplMode")}</span>
+                <select value={settings.agent} onChange={(e) => up({ agent: e.target.value })}>
+                  <option value="build">build</option>
+                  <option value="plan">plan</option>
+                </select>
+              </label>
+              <label className="field">
+                <span>{t("jobs.permissionMode")}</span>
+                <select value={settings.permission_mode} title={t("jobs.permissionModeHint")} onChange={(e) => up({ permission_mode: e.target.value })}>
+                  <option value="default">{t("permissionMode.default")}</option>
+                  <option value="auto">{t("permissionMode.auto")}</option>
+                  <option value="accept_edits">{t("permissionMode.accept_edits")}</option>
+                  <option value="bypass">{t("permissionMode.bypass")}</option>
+                </select>
+              </label>
+              <label className="field">
+                <span>{t("composer.model")}</span>
+                <ModelSelect value={settings.model} onChange={(model) => up({ model })} emptyLabel={t("jobEditor.defaultModel")} />
+              </label>
+              <label className="field" style={{ maxWidth: 140 }}>
+                <span>{t("jobEditor.timeout")}</span>
+                <input type="number" min={1} max={1440} value={settings.timeout_minutes} onChange={(e) => up({ timeout_minutes: Math.max(1, Number(e.target.value) || 60) })} />
+              </label>
+            </div>
+            {settings.permission_mode !== "bypass" && <div className="hint">{t("jobEditor.bypassHint")}</div>}
+          </section>
+          <section className="job-editor-prompt">
+            <div className="job-editor-prompt-head">
+              <b>{t("jobEditor.instructions")}</b>
+              <span className="hint">{t("jobEditor.instructionsHint")}</span>
+            </div>
+            {changedOnDisk && (
+              <div className="notice">
+                {t("jobEditor.changedOnDisk")}{" "}
+                <button className="small" onClick={() => void loadFile(job.path)}>
+                  {t("jobEditor.reload")}
+                </button>
+              </div>
+            )}
+            {job.error && !job.error.includes("empty") && <div className="notice err">{job.error}</div>}
+            {text === undefined ? (
+              <div className="empty"><Spinner /></div>
+            ) : (
+              <Suspense fallback={<div className="empty"><Spinner /></div>}>
+                <CodeEditor value={text} filename={job.path} onChange={setText} onSave={() => void save()} />
+              </Suspense>
+            )}
+          </section>
+        </div>
+        <aside className="job-editor-chat">
+          {assistant ? (
+            <ChatView key={assistant} sessionId={assistant} onMenu={onMenu} />
+          ) : (
+            <div className="job-assistant-start">
+              <Icon name="sparkle" />
+              <p>{t("jobEditor.assistantIntro")}</p>
+              <button className="primary" onClick={startAssistant}>
+                {t("jobEditor.assistantStart")}
+              </button>
+            </div>
+          )}
+        </aside>
+      </div>
+    </>
+  );
+}

web/src/components/JobTemplateDialog.tsx

@@ -1,134 +0,0 @@
-import { useEffect, useState } from "react";
-import { useFetch } from "../hooks";
-import { post } from "../api";
-import { getLang, useT } from "../i18n";
-import { JOB_TEMPLATES, SCHEDULES, type JobTemplate } from "../jobTemplates";
-import { Icon } from "./Icon";
-import { ModelSelect } from "./ModelSelect";
-import { FolderPicker } from "./NewSession";
-
-/** Create an automation from a template: pick it, choose the project, adjust, create. */
-export function JobTemplateDialog({ onClose, onCreated }: { onClose: () => void; onCreated: () => void }) {
-  const t = useT();
-  const de = getLang() === "de";
-  const [tpl, setTpl] = useState<JobTemplate>();
-  const [name, setName] = useState("");
-  const [schedule, setSchedule] = useState("");
-  const [agent, setAgent] = useState("build");
-  const [mode, setMode] = useState("auto");
-  const [model, setModel] = useState("");
-  const [prompt, setPrompt] = useState("");
-  const [cwd, setCwd] = useState(localStorage.getItem("codecraft.lastDir") ?? "");
-  const [error, setError] = useState<string>();
-  const [busy, setBusy] = useState(false);
-  const config = useFetch<{ default_model?: string }>("/config").data;
-  useEffect(() => {
-    if (!model && config?.default_model) setModel(config.default_model);
-  }, [config, model]);
-
-  const choose = (x: JobTemplate) => {
-    setTpl(x);
-    setName(de ? x.name.de : x.name.en);
-    setSchedule(x.schedule);
-    setAgent(x.agent);
-    setPrompt(x.prompt);
-  };
-
-  const create = async () => {
-    setBusy(true);
-    setError(undefined);
-    try {
-      await post("/jobs/create", { cwd, name: name.trim(), schedule: schedule.trim(), agent, permission_mode: mode, model: model || undefined, prompt });
-      onCreated();
-      onClose();
-    } catch (e: any) {
-      setError(e.message);
-    } finally {
-      setBusy(false);
-    }
-  };
-
-  return (
-    <div className="modal-backdrop" onClick={onClose}>
-      <div className="modal job-tpl" role="dialog" aria-label={t("jobs.fromTemplate")} onClick={(e) => e.stopPropagation()}>
-        {!tpl ? (
-          <>
-            <h3>{t("jobs.fromTemplate")}</h3>
-            <div className="job-tpl-grid">
-              {JOB_TEMPLATES.map((x) => (
-                <button key={x.id} className="job-tpl-card" onClick={() => choose(x)}>
-                  <Icon name={x.icon} />
-                  <span>
-                    <b>{de ? x.name.de : x.name.en}</b>
-                    <small>{de ? x.desc.de : x.desc.en}</small>
-                  </span>
-                </button>
-              ))}
-            </div>
-            <div className="row" style={{ marginTop: 12, justifyContent: "flex-end" }}>
-              <button onClick={onClose}>{t("common.cancel")}</button>
-            </div>
-          </>
-        ) : (
-          <>
-            <h3>
-              <Icon name={tpl.icon} /> {de ? tpl.name.de : tpl.name.en}
-            </h3>
-            <label className="field">
-              <span>{t("jobs.tplName")}</span>
-              <input value={name} onChange={(e) => setName(e.target.value)} />
-            </label>
-            <div className="field">
-              <span>{t("jobs.tplProject")}</span>
-              <FolderPicker path={cwd} onPick={setCwd} />
-            </div>
-            <div className="field">
-              <span>{t("jobs.tplSchedule")}</span>
-              <div className="row" style={{ gap: 6, flexWrap: "wrap" }}>
-                {SCHEDULES.map((s) => (
-                  <button key={s.cron} type="button" className={`chip-btn ${schedule === s.cron ? "active" : ""}`} onClick={() => setSchedule(s.cron)}>
-                    {de ? s.de : s.en}
-                  </button>
-                ))}
-              </div>
-              <input className="mono" value={schedule} onChange={(e) => setSchedule(e.target.value)} placeholder="0 3 * * *" />
-              <small className="hint">{t("jobs.tplCronHint")}</small>
-            </div>
-            <div className="row" style={{ gap: 10, flexWrap: "wrap" }}>
-              <label className="field">
-                <span>{t("jobs.tplMode")}</span>
-                <select value={agent} onChange={(e) => setAgent(e.target.value)}>
-                  <option value="build">build</option>
-                  <option value="plan">plan</option>
-                </select>
-              </label>
-              <label className="field">
-                <span>{t("composer.permissionMode")}</span>
-                <select value={mode} onChange={(e) => setMode(e.target.value)}>
-                  <option value="auto">{t("permissionMode.auto")}</option>
-                  <option value="accept_edits">{t("permissionMode.accept_edits")}</option>
-                  <option value="bypass">{t("permissionMode.bypass")}</option>
-                </select>
-              </label>
-              <label className="field">
-                <span>{t("composer.model")}</span>
-                <ModelSelect value={model} onChange={setModel} />
-              </label>
-            </div>
-            <label className="field">
-              <span>{t("jobs.tplPrompt")}</span>
-              <textarea rows={6} value={prompt} onChange={(e) => setPrompt(e.target.value)} />
-            </label>
-            {error && <div className="notice err">{error}</div>}
-            <div className="row" style={{ marginTop: 12, justifyContent: "flex-end" }}>
-              <button onClick={() => setTpl(undefined)}>{t("common.back")}</button>
-              <button className="primary" disabled={busy || !cwd || !name.trim() || !schedule.trim() || !prompt.trim()} onClick={create}>
-                {t("jobs.tplCreate")}
-              </button>
-            </div>
-          </>
-        )}
-      </div>
-    </div>
-  );
-}

web/src/components/Jobs.tsx

@@ -5,9 +5,9 @@ import { navigate } from "../router";
 import { confirmDialog, toast } from "../dialogs";
 import { Icon } from "./Icon";
 import { Spinner } from "./Activity";
-import { JobTemplateDialog } from "./JobTemplateDialog";
+import { NewJobDialog } from "./NewJobDialog";
 
-interface JobInfo {
+export interface JobInfo {
   id: string;
   path: string;
   enabled: boolean;
@@ -17,12 +17,12 @@ interface JobInfo {
   next_run?: number | null;
   error?: string;
   webhook?: boolean;
-  spec?: { name: string; schedule: string; agent: string; model?: string | null; permission_mode: string; timeout_minutes: number; prompt: string };
+  spec?: { name: string; schedule: string; agent: string; model?: string | null; permission_mode: string; timeout_minutes: number; prompt: string; assistant_session?: string | null };
 }
 
 const fmtDate = (ms?: number | null) => (ms ? new Date(ms).toLocaleString(undefined, { dateStyle: "medium", timeStyle: "short" }) : "–");
 
-/** Automations: agents started on a schedule from a Markdown job file. */
+/** Automations: agents started on a schedule with the instructions from a Markdown file. */
 export function Jobs({ onMenu }: { onMenu: () => void }) {
   const t = useT();
   const [jobs, setJobs] = useState<JobInfo[]>();
@@ -68,10 +68,10 @@ export function Jobs({ onMenu }: { onMenu: () => void }) {
           <div className="notice">{t("jobs.intro")}</div>
           <div className="row" style={{ margin: "12px 0" }}>
             <button className="primary" onClick={() => setTemplates(true)}>
-              <Icon name="plus" /> {t("jobs.fromTemplate")}
+              <Icon name="plus" /> {t("jobs.new")}
             </button>
           </div>
-          {templates && <JobTemplateDialog onClose={() => setTemplates(false)} onCreated={() => void reload()} />}
+          {templates && <NewJobDialog onClose={() => setTemplates(false)} />}
           {!jobs && <div className="empty"><Spinner /></div>}
           {jobs?.length === 0 && <div className="empty">{t("jobs.none")}</div>}
           {jobs?.map((j) => (
@@ -79,7 +79,11 @@ export function Jobs({ onMenu }: { onMenu: () => void }) {
               <div className="job-head">
                 <Icon name="clock" className="job-icon" />
                 <div style={{ flex: 1, minWidth: 0 }}>
-                  <h3>{j.spec?.name ?? j.path.split("/").pop()}</h3>
+                  <h3>
+                    <button className="link-btn job-title" onClick={() => navigate(`/jobs/${j.id}`)}>
+                      {j.spec?.name ?? j.path.split("/").pop()}
+                    </button>
+                  </h3>
                   <div className="hint mono">{j.path}</div>
                 </div>
                 <label className="switch" title={t(j.enabled ? "jobs.disable" : "jobs.enable")}>
@@ -107,22 +111,7 @@ export function Jobs({ onMenu }: { onMenu: () => void }) {
                   </span>
                   <span>{t("jobs.mode")}</span>
                   <span>
-                    {j.spec?.agent} · {j.spec?.model || t("agents.sessionModel")} · max {j.spec?.timeout_minutes} min
-                  </span>
-                  <span>{t("jobs.permissionMode")}</span>
-                  <span>
-                    <select
-                      value={j.spec?.permission_mode ?? "auto"}
-                      disabled={busy === j.id}
-                      title={t("jobs.permissionModeHint")}
-                      aria-label={t("jobs.permissionMode")}
-                      onChange={(e) => act(j.id, () => patch(`/jobs/${j.id}`, { permission_mode: e.target.value }))}
-                    >
-                      <option value="default">{t("permissionMode.default")}</option>
-                      <option value="auto">{t("permissionMode.auto")}</option>
-                      <option value="accept_edits">{t("permissionMode.accept_edits")}</option>
-                      <option value="bypass">{t("permissionMode.bypass")}</option>
-                    </select>
+                    {j.spec?.agent} · {j.spec?.model || t("agents.sessionModel")} · {t(`permissionMode.${j.spec?.permission_mode ?? "auto"}` as any)} · max {j.spec?.timeout_minutes} min
                   </span>
                 </div>
               )}
@@ -178,14 +167,8 @@ export function Jobs({ onMenu }: { onMenu: () => void }) {
                 })}>
                   {busy === j.id ? <Spinner small /> : <Icon name="play" />} {t("jobs.runNow")}
                 </button>
-                <button
-                  className="small ghost"
-                  onClick={() => {
-                    sessionStorage.setItem("codecraft.openFile", j.path);
-                    navigate("/files");
-                  }}
-                >
-                  <Icon name="edit" /> {t("jobs.editFile")}
+                <button className="small" onClick={() => navigate(`/jobs/${j.id}`)}>
+                  <Icon name="edit" /> {t("jobs.edit")}
                 </button>
                 <span className="grow" />
                 <button
@@ -205,20 +188,13 @@ export function Jobs({ onMenu }: { onMenu: () => void }) {
             <div className="row" style={{ gap: 8 }}>
               <input className="mono" style={{ flex: 1, minWidth: 0 }} value={path} placeholder="/workspace/project/.codecraft/jobs/nightly.md" onChange={(e) => setPath(e.target.value)} />
               <button disabled={!path.trim()} onClick={() => act("new", async () => {
-                await post("/jobs", { path: path.trim() });
+                const j = await post<JobInfo>("/jobs", { path: path.trim() });
                 setPath("");
+                navigate(`/jobs/${j.id}`);
               })}>
                 {t("jobs.registerBtn")}
               </button>
             </div>
-            <pre className="job-example">{`---
-name: "Nightly dependency check"
-schedule: "0 3 * * *"
-agent: build
-permission_mode: auto
-timeout_minutes: 60
----
-Check the project for outdated dependencies …`}</pre>
           </div>
         </div>
       </div>

web/src/components/Markdown.tsx

@@ -44,7 +44,30 @@ export function SvgBlock({ code, children }: { code: string; children?: ReactNod
   );
 }
 
-export const Markdown = memo(function Markdown({ text, baseDir }: { text: string; baseDir?: string }) {
+/**
+ * Keep single line breaks as typed (Markdown would join the lines into one paragraph):
+ * a hard break at the end of every line that continues a paragraph. Code blocks stay as
+ * they are.
+ */
+export function keepLineBreaks(text: string) {
+  let fence: string | null = null;
+  const lines = text.split("\n");
+  return lines
+    .map((line, i) => {
+      const f = line.match(/^\s*(`{3,}|~{3,})/);
+      if (f) {
+        if (!fence) fence = f[1][0];
+        else if (f[1][0] === fence) fence = null;
+        return line;
+      }
+      const next = lines[i + 1];
+      if (fence || next === undefined || !line.trim() || !next.trim() || / {2}$|\\$/.test(line)) return line;
+      return `${line}  `;
+    })
+    .join("\n");
+}
+
+export const Markdown = memo(function Markdown({ text, baseDir, breaks }: { text: string; baseDir?: string; breaks?: boolean }) {
   return (
     <div className="markdown">
       <ReactMarkdown
@@ -81,7 +104,7 @@ export const Markdown = memo(function Markdown({ text, baseDir }: { text: string
           },
         }}
       >
-        {text}
+        {breaks ? keepLineBreaks(text) : text}
       </ReactMarkdown>
     </div>
   );

web/src/components/NewJobDialog.tsx

@@ -0,0 +1,128 @@
+import { useState } from "react";
+import { post } from "../api";
+import { getLang, useT } from "../i18n";
+import { JOB_TEMPLATES, type JobTemplate } from "../jobTemplates";
+import { navigate } from "../router";
+import { Icon } from "./Icon";
+import { FolderPicker } from "./NewSession";
+
+/** Starting point of a new instructions file: headings to fill in (with the assistant). */
+function example(name: string, de: boolean) {
+  return de
+    ? `# ${name}
+
+## Ziel
+Was soll diese Automatisierung erreichen? (ein, zwei Sätze)
+
+## Vorgehen
+1. …
+2. …
+
+## Ergebnis
+Was am Ende vorliegen soll – z. B. ein kurzer Bericht, geänderte Dateien, ein Commit.
+
+## Grenzen
+- Was der Agent nicht tun darf (z. B. nichts pushen, nichts löschen).
+`
+    : `# ${name}
+
+## Goal
+What should this automation achieve? (one or two sentences)
+
+## Steps
+1. …
+2. …
+
+## Result
+What should exist at the end – e.g. a short report, changed files, a commit.
+
+## Limits
+- What the agent must not do (e.g. no pushing, no deleting).
+`;
+}
+
+/**
+ * New automation: name, project and a starting point (example or template). Creates the
+ * instructions file (<project>/.codecraft/jobs/<name>.md, switched off) and opens the
+ * editor, where the schedule is set and the instructions are worked out.
+ */
+export function NewJobDialog({ onClose }: { onClose: () => void }) {
+  const t = useT();
+  const de = getLang() === "de";
+  const [tpl, setTpl] = useState<JobTemplate>();
+  const [name, setName] = useState("");
+  const [cwd, setCwd] = useState(localStorage.getItem("codecraft.lastDir") ?? "");
+  const [error, setError] = useState<string>();
+  const [busy, setBusy] = useState(false);
+
+  const choose = (x?: JobTemplate) => {
+    setTpl(x);
+    if (x && (!name.trim() || JOB_TEMPLATES.some((y) => name === y.name.de || name === y.name.en))) setName(de ? x.name.de : x.name.en);
+  };
+
+  const create = async () => {
+    setBusy(true);
+    setError(undefined);
+    try {
+      const n = name.trim();
+      const job = await post<{ id: string }>("/jobs/create", {
+        cwd,
+        name: n,
+        prompt: tpl ? `# ${n}\n\n${tpl.prompt}\n` : example(n, de),
+        schedule: tpl?.schedule,
+        agent: tpl?.agent,
+      });
+      onClose();
+      navigate(`/jobs/${job.id}`);
+    } catch (e: any) {
+      setError(e.message);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <div className="modal-backdrop" onClick={onClose}>
+      <div className="modal job-tpl" role="dialog" aria-label={t("jobs.new")} onClick={(e) => e.stopPropagation()}>
+        <h3>{t("jobs.new")}</h3>
+        <label className="field">
+          <span>{t("jobs.tplName")}</span>
+          <input autoFocus value={name} placeholder={t("jobs.namePlaceholder")} onChange={(e) => setName(e.target.value)} />
+        </label>
+        <div className="field">
+          <span>{t("jobs.tplProject")}</span>
+          <FolderPicker path={cwd} onPick={setCwd} />
+          <small className="hint">{t("jobs.fileHint")}</small>
+        </div>
+        <div className="field">
+          <span>{t("jobs.startWith")}</span>
+          <div className="job-tpl-grid">
+            <button className={`job-tpl-card ${!tpl ? "active" : ""}`} onClick={() => choose(undefined)}>
+              <Icon name="file-text" />
+              <span>
+                <b>{t("jobs.blank")}</b>
+                <small>{t("jobs.blankDesc")}</small>
+              </span>
+            </button>
+            {JOB_TEMPLATES.map((x) => (
+              <button key={x.id} className={`job-tpl-card ${tpl?.id === x.id ? "active" : ""}`} onClick={() => choose(x)}>
+                <Icon name={x.icon} />
+                <span>
+                  <b>{de ? x.name.de : x.name.en}</b>
+                  <small>{de ? x.desc.de : x.desc.en}</small>
+                </span>
+              </button>
+            ))}
+          </div>
+        </div>
+        {error && <div className="notice err">{error}</div>}
+        <div className="row" style={{ marginTop: 12, justifyContent: "flex-end" }}>
+          <button onClick={onClose}>{t("common.cancel")}</button>
+          <button className="primary" disabled={busy || !cwd || !name.trim()} onClick={create}>
+            {t("jobs.createAndEdit")}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

web/src/components/NewSession.tsx

@@ -1,6 +1,7 @@
 import { Icon } from "./Icon";
 import { useEffect, useMemo, useRef, useState, type ReactNode } from "react";
 import { post, uploadFile } from "../api";
+import { promptDialog, toast } from "../dialogs";
 import { useAgents, useFetch } from "../hooks";
 import { useT, type Key } from "../i18n";
 import type { ImageData } from "../types";
@@ -602,6 +603,20 @@ export function FolderPicker({ path, onPick }: { path: string; onPick: (p: strin
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [listing?.path]);
   const rel = listing ? listing.path.slice(listing.workspace.length) || "/" : "";
+  /** Create a subfolder of the shown folder and select it. */
+  const newFolder = async () => {
+    if (!listing) return;
+    const name = (await promptDialog({ title: t("files.newFolder"), message: t("files.newFolderName") }))?.trim();
+    if (!name) return;
+    if (name.includes("/") || name === "." || name === "..") return toast(t("new.invalidFolderName"));
+    const target = `${listing.path.replace(/\/$/, "")}/${name}`;
+    try {
+      await post("/files/create", { path: target, dir: true });
+      setBrowse(target);
+    } catch (e: any) {
+      toast(e.message);
+    }
+  };
   return (
     <div className="wiz-picker">
       {roots.length > 1 && (
@@ -622,6 +637,11 @@ export function FolderPicker({ path, onPick }: { path: string; onPick: (p: strin
             <Icon name="arrow-up" /> {t("new.up")}
           </button>
         )}
+        {listing && (
+          <button className="small" onClick={() => void newFolder()}>
+            <Icon name="plus" /> {t("files.newFolder")}
+          </button>
+        )}
       </div>
       <div className="dir-list">
         {listing?.dirs.length === 0 && <div className="empty" style={{ padding: 16 }}>{t("new.noSubdirs")}</div>}

web/src/components/Settings.tsx

@@ -376,6 +376,7 @@ interface ModelRow {
   name?: string;
   context?: number;
   max_output?: number;
+  max_input?: number;
   reasoning?: boolean;
   vision?: boolean;
   effort?: string;
@@ -454,6 +455,7 @@ function ProviderEditor({ name, p, reload, status }: { name: string; p: Json; re
             price_multipliers: f.price_multipliers ?? m.price_multipliers,
             context: m.context ?? f.context,
             max_output: m.max_output ?? f.max_output,
+            max_input: m.max_input ?? f.max_input ?? undefined,
             vision: m.vision || !!f.vision,
             reasoning: m.reasoning || !!f.reasoning,
           };
@@ -616,6 +618,7 @@ function ProviderEditor({ name, p, reload, status }: { name: string; p: Json; re
                   <th>ID</th>
                   <th>{t("settings.context")}</th>
                   <th>{t("settings.maxOutput")}</th>
+                  <th title={t("settings.maxInputHint")}>{t("settings.maxInput")}</th>
                   <th title={t("settings.reasoning")}><Icon name="brain" /></th>
                   <th title={t("settings.vision")}><Icon name="eye" /></th>
                   <th>{t("settings.effort")}</th>
@@ -640,6 +643,9 @@ function ProviderEditor({ name, p, reload, status }: { name: string; p: Json; re
                     <td>
                       <input type="number" value={m.max_output ?? ""} onChange={(e) => setModel(i, { max_output: num(e.target.value) })} />
                     </td>
+                    <td>
+                      <input type="number" value={m.max_input ?? ""} placeholder="–" onChange={(e) => setModel(i, { max_input: num(e.target.value) })} />
+                    </td>
                     <td>
                       <input type="checkbox" checked={!!m.reasoning} onChange={(e) => setModel(i, { reasoning: e.target.checked })} />
                     </td>

web/src/components/Sidebar.tsx

@@ -2,7 +2,7 @@ import { Icon } from "./Icon";
 import { StatusLeds } from "./StatusLeds";
 import { cycleThemeMode, getThemeMode, onThemeChange } from "../theme";
 import { useEffect, useMemo, useState, useSyncExternalStore } from "react";
-import { get, patch, post } from "../api";
+import { get, patch, post, put } from "../api";
 import { promptDialog, toast } from "../dialogs";
 import { fmtRelative, useT, type Key } from "../i18n";
 import { navigate, openBeside } from "../router";
@@ -102,6 +102,113 @@ function SessionRow({ s, active, attention, busy, folders }: { s: Session; activ
   );
 }
 
+/** Order and pinning of folders and projects in the list (per user, all devices). */
+interface Layout {
+  order: string[];
+  pinned: string[];
+}
+
+/** Folders and projects can be moved and pinned; time groups and the archive cannot. */
+const movable = (id: string) => id.startsWith("folder:") || id.startsWith("project:");
+
+const DRAG_TYPE = "application/x-codecraft-group";
+
+/** Header of a group: collapses it; folders and projects also have a menu and can be dragged. */
+function GroupHeader({
+  g,
+  collapsed,
+  pinned,
+  onToggle,
+  onPin,
+  onMove,
+  onDrop,
+}: {
+  g: { id: string; label: string; icon?: string; items: Session[] };
+  collapsed: boolean;
+  pinned: boolean;
+  onToggle: () => void;
+  onPin?: () => void;
+  onMove?: (dir: -1 | 1) => void;
+  onDrop?: (dragged: string, after: boolean) => void;
+}) {
+  const t = useT();
+  const [menu, setMenu] = useState(false);
+  const [over, setOver] = useState<"before" | "after">();
+  useEffect(() => {
+    if (!menu) return;
+    const close = () => setMenu(false);
+    window.addEventListener("click", close);
+    window.addEventListener("keydown", close);
+    return () => {
+      window.removeEventListener("click", close);
+      window.removeEventListener("keydown", close);
+    };
+  }, [menu]);
+  const canMove = !!onMove;
+  return (
+    <div
+      className={`session-row group-row ${menu ? "menu-open" : ""} ${over ? `drop-${over}` : ""}`}
+      draggable={canMove}
+      onDragStart={(e) => {
+        if (!canMove) return;
+        e.dataTransfer.setData(DRAG_TYPE, g.id);
+        e.dataTransfer.effectAllowed = "move";
+      }}
+      onDragOver={(e) => {
+        if (!onDrop || !e.dataTransfer.types.includes(DRAG_TYPE)) return;
+        e.preventDefault();
+        const r = e.currentTarget.getBoundingClientRect();
+        setOver(e.clientY > r.top + r.height / 2 ? "after" : "before");
+      }}
+      onDragLeave={() => setOver(undefined)}
+      onDrop={(e) => {
+        const id = e.dataTransfer.getData(DRAG_TYPE);
+        const after = over === "after";
+        setOver(undefined);
+        if (id && id !== g.id && onDrop) {
+          e.preventDefault();
+          onDrop(id, after);
+        }
+      }}
+    >
+      <button className="session-group" onClick={onToggle} aria-expanded={!collapsed}>
+        <Icon name={collapsed ? "chevron-right" : "chevron-down"} className="tiny" />
+        {g.icon && <Icon name={g.icon} className="tiny" />}
+        <span className="grow">{g.label}</span>
+        {pinned && <Icon name="pin" className="tiny group-pin" />}
+        {collapsed && <span className="count">{g.items.length}</span>}
+      </button>
+      {canMove && (
+        <button
+          className="session-more ghost"
+          aria-label={t("sidebar.groupMenu")}
+          aria-haspopup="menu"
+          aria-expanded={menu}
+          onClick={(e) => {
+            e.stopPropagation();
+            setMenu(!menu);
+          }}
+        >
+          <Icon name="more" />
+        </button>
+      )}
+      {menu && (
+        <div className="session-menu" role="menu" onClick={(e) => e.stopPropagation()}>
+          <button role="menuitem" onClick={() => (setMenu(false), onPin?.())}>
+            <Icon name="pin" /> {t(pinned ? "sidebar.groupUnpin" : "sidebar.groupPin")}
+          </button>
+          <button role="menuitem" onClick={() => (setMenu(false), onMove?.(-1))}>
+            <Icon name="arrow-up" /> {t("sidebar.groupUp")}
+          </button>
+          <button role="menuitem" onClick={() => (setMenu(false), onMove?.(1))}>
+            <Icon name="arrow-down" /> {t("sidebar.groupDown")}
+          </button>
+        </div>
+      )}
+    </div>
+  );
+}
+
 export function Sidebar({ open, activeIds, section }: { open: boolean; activeIds: string[]; section: string }) {
   const t = useT();
   const sessions = useStore((s) => s.sessions);
@@ -164,14 +271,15 @@ export function Sidebar({ open, activeIds, section }: { open: boolean; activeIds
     const live = sessions.filter((s) => !s.archived);
     for (const s of live.filter((s) => s.pinned)) add("pinned", t("sidebar.pinned"), s, "pin");
     const rest = live.filter((s) => !s.pinned);
-    const folders = [...new Set(rest.map((s) => s.folder).filter(Boolean) as string[])].sort((a, b) => a.localeCompare(b));
+    const folders = [...new Set(rest.map((s) => s.folder).filter(Boolean) as string[])];
     for (const f of folders) for (const s of rest.filter((s) => s.folder === f)) add(`folder:${f}`, f, s, "folder");
     const loose = rest.filter((s) => !s.folder);
     if (groupBy === "project") {
       const byProject = new Map<string, Session[]>();
       for (const s of loose) byProject.set(s.cwd, [...(byProject.get(s.cwd) ?? []), s]);
-      // Projects with the most recent activity first.
-      for (const [cwd, items] of [...byProject].sort((a, b) => b[1][0].updated_at - a[1][0].updated_at)) for (const s of items) add(`project:${cwd}`, basename(cwd) || "/", s, "folders");
+      // Order of the projects: see `ordered` below (not by activity – a new message
+      // moves the chat to the top of its project, not the project).
+      for (const [cwd, items] of byProject) for (const s of items) add(`project:${cwd}`, basename(cwd) || "/", s, "folders");
     } else {
       for (const s of loose) {
         const key = groupKey(s.updated_at);
@@ -181,6 +289,81 @@ export function Sidebar({ open, activeIds, section }: { open: boolean; activeIds
     for (const s of sessions.filter((s) => s.archived)) add("archive", t("sidebar.archive"), s, "archive");
     return out;
   }, [sessions, groupBy, t]);
+  // Folders and projects: pinned first, then in the user's order. Groups not ordered yet
+  // (new folder or project) start at the top and are then kept where they are.
+  const [layout, setLayout] = useState<Layout>();
+  useEffect(() => {
+    get<Layout>("/account/sidebar")
+      .then((l) => setLayout({ order: l.order ?? [], pinned: l.pinned ?? [] }))
+      .catch(() => setLayout({ order: [], pinned: [] }));
+  }, []);
+  const ordered = useMemo(() => {
+    const l = layout ?? { order: [], pinned: [] };
+    const head = groups.filter((g) => g.id === "pinned");
+    const tail = groups.filter((g) => g.id !== "pinned" && !movable(g.id));
+    const rank = (id: string) => l.order.indexOf(id);
+    const mid = groups
+      .filter((g) => movable(g.id))
+      .sort((a, b) => {
+        const pa = l.pinned.includes(a.id);
+        const pb = l.pinned.includes(b.id);
+        if (pa !== pb) return pa ? -1 : 1;
+        const ra = rank(a.id);
+        const rb = rank(b.id);
+        if (ra < 0 && rb < 0) return b.items[0].updated_at - a.items[0].updated_at;
+        if (ra < 0 || rb < 0) return ra < 0 ? -1 : 1;
+        return ra - rb;
+      });
+    return { head, mid, tail };
+  }, [groups, layout]);
+  const saveLayout = (next: Layout) => {
+    // Forget groups that no longer exist (no chat in that folder or project).
+    const known = new Set(sessions.flatMap((s) => [`project:${s.cwd}`, ...(s.folder ? [`folder:${s.folder}`] : [])]));
+    const clean = { order: next.order.filter((id) => known.has(id)), pinned: next.pinned.filter((id) => known.has(id)) };
+    setLayout(clean);
+    void put("/account/sidebar", clean).catch((e) => toast(e.message));
+  };
+  // Freeze the position of groups that appeared since the last visit.
+  useEffect(() => {
+    if (!layout) return;
+    const fresh = ordered.mid.map((g) => g.id).filter((id) => !layout.order.includes(id));
+    if (fresh.length) saveLayout({ ...layout, order: [...fresh, ...layout.order] });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [ordered, layout]);
+  /** Order of the shown groups with `id` moved: by a step, or next to another group. */
+  const reorder = (ids: string[]) => {
+    if (!layout) return;
+    const shown = new Set(ids);
+    saveLayout({ ...layout, order: [...ids, ...layout.order.filter((id) => !shown.has(id))] });
+  };
+  const moveGroup = (id: string, dir: -1 | 1) => {
+    if (!layout) return;
+    const ids = ordered.mid.map((g) => g.id);
+    const i = ids.indexOf(id);
+    const j = i + dir;
+    // Only within the pinned or the unpinned part.
+    if (j < 0 || j >= ids.length || layout.pinned.includes(ids[j]) !== layout.pinned.includes(id)) return;
+    [ids[i], ids[j]] = [ids[j], ids[i]];
+    reorder(ids);
+  };
+  const dropGroup = (dragged: string, target: string, after: boolean) => {
+    if (!layout || !movable(dragged)) return;
+    const ids = ordered.mid.map((g) => g.id).filter((id) => id !== dragged);
+    const at = ids.indexOf(target);
+    if (at < 0) return;
+    ids.splice(after ? at + 1 : at, 0, dragged);
+    // Dropped among pinned groups: pinned too (and the other way round).
+    const pinTarget = layout.pinned.includes(target);
+    const pinned = pinTarget ? [...new Set([...layout.pinned, dragged])] : layout.pinned.filter((p) => p !== dragged);
+    const shown = new Set(ids);
+    saveLayout({ pinned, order: [...ids, ...layout.order.filter((id) => !shown.has(id))] });
+  };
+  const pinGroup = (id: string) => {
+    if (!layout) return;
+    const pinned = layout.pinned.includes(id) ? layout.pinned.filter((p) => p !== id) : [...layout.pinned, id];
+    saveLayout({ ...layout, pinned });
+  };
+
   const folderNames = useMemo(() => [...new Set(sessions.map((s) => s.folder).filter(Boolean) as string[])].sort(), [sessions]);
 
   return (
@@ -235,14 +418,17 @@ export function Sidebar({ open, activeIds, section }: { open: boolean; activeIds
           </div>
         )}
         {!hits &&
-          groups.map((g) => (
+          [...ordered.head, ...ordered.mid, ...ordered.tail].map((g) => (
             <div key={g.id}>
-              <button className="session-group" onClick={() => toggle(g.id)} aria-expanded={!collapsed.has(g.id)}>
-                <Icon name={collapsed.has(g.id) ? "chevron-right" : "chevron-down"} className="tiny" />
-                {g.icon && <Icon name={g.icon} className="tiny" />}
-                <span className="grow">{g.label}</span>
-                {collapsed.has(g.id) && <span className="count">{g.items.length}</span>}
-              </button>
+              <GroupHeader
+                g={g}
+                collapsed={collapsed.has(g.id)}
+                pinned={!!layout?.pinned.includes(g.id)}
+                onToggle={() => toggle(g.id)}
+                onPin={movable(g.id) ? () => pinGroup(g.id) : undefined}
+                onMove={movable(g.id) ? (dir) => moveGroup(g.id, dir) : undefined}
+                onDrop={movable(g.id) ? (dragged, after) => dropGroup(dragged, g.id, after) : undefined}
+              />
               {!collapsed.has(g.id) &&
                 g.items.map((s) => (
                   <SessionRow key={s.id} s={s} active={activeIds.includes(s.id)} attention={attention.has(s.id)} busy={!!busy[s.id]} folders={folderNames} />

web/src/components/ToolCard.tsx

@@ -158,11 +158,25 @@ export function ToolCard({ call, result, running, baseDir }: { call: ToolCall; r
         )}
         {Array.isArray(meta?.image_ids) ? (
           <div className="gallery small">
-            {meta.image_ids.map((id: string) => (
-              <FileFigure key={id} url={`/api/images/${id}/file`} className="gallery-item">
-                <img src={`/api/images/${id}/file`} alt="" />
-              </FileFigure>
-            ))}
+            {meta.image_ids.map((id: string, i: number) => {
+              // The file may be gone (moved or deleted later): fall back to the preview the model saw.
+              const preview = result?.images?.[i];
+              return (
+                <FileFigure key={id} url={`/api/images/${id}/file`} className="gallery-item">
+                  <img
+                    src={`/api/images/${id}/file`}
+                    alt=""
+                    onError={(e) => {
+                      const img = e.currentTarget;
+                      if (preview && !img.dataset.fallback) {
+                        img.dataset.fallback = "1";
+                        img.src = imageSrc(preview);
+                      }
+                    }}
+                  />
+                </FileFigure>
+              );
+            })}
           </div>
         ) : (
           result?.images?.map((img, i) => (

web/src/components/settings/AgentsEditor.tsx

@@ -61,6 +61,7 @@ function AgentRow({ a, raw, tools, onSaved }: { a: AgentInfo; raw: any; tools: T
     refine_rounds: String(raw?.refine?.rounds ?? a.refine?.rounds ?? 0),
     refine_model: raw?.refine?.model ?? "",
     refine_criteria: raw?.refine?.criteria ?? "",
+    refine_after_todos: (raw?.refine?.after_todos ?? a.refine?.after_todos ?? true) as boolean,
   });
   const builtin = a.source === "builtin" || (a.source === "config" && !raw?.prompt && ["build", "plan", "craft", "chat", "general", "explore"].includes(a.name));
 
@@ -74,7 +75,7 @@ function AgentRow({ a, raw, tools, onSaved }: { a: AgentInfo; raw: any; tools: T
       const rounds = Math.max(0, Math.min(10, Number(form.refine_rounds) || 0));
       patches.push({
         path: [...base, "refine"],
-        value: rounds || form.refine_model || form.refine_criteria ? { rounds, model: form.refine_model || null, criteria: form.refine_criteria || null } : null,
+        value: rounds || form.refine_model || form.refine_criteria ? { rounds, model: form.refine_model || null, criteria: form.refine_criteria || null, after_todos: form.refine_after_todos } : null,
       });
     }
     if (!builtin || form.description) patches.push({ path: [...base, "description"], value: form.description || null });
@@ -158,6 +159,11 @@ function AgentRow({ a, raw, tools, onSaved }: { a: AgentInfo; raw: any; tools: T
                 <label>{t("agents.refineCriteria")}</label>
                 <textarea rows={3} value={form.refine_criteria} onChange={(e) => setForm({ ...form, refine_criteria: e.target.value })} />
                 <div className="hint">{t("agents.refineCriteriaHint")}</div>
+                <label className="check">
+                  <input type="checkbox" checked={form.refine_after_todos} onChange={(e) => setForm({ ...form, refine_after_todos: e.target.checked })} />
+                  {t("agents.refineAfterTodos")}
+                </label>
+                <div className="hint">{t("agents.refineAfterTodosHint")}</div>
               </>
             )}
             <label>{t("agents.description")}</label>

web/src/i18n/de.ts

@@ -334,6 +334,10 @@ export const de: Messages = {
   "wizard.idea.cadBox": "Eine Box mit Schnappdeckel, Innenmaß 80 × 50 × 30 mm",
   "wizard.idea.cadBracket": "Eine Wandhalterung für ein 25-mm-Rohr mit zwei M4-Schraublöchern",
   "activity.reviewing": "Ergebnis wird geprüft (Runde {round})…",
+  "chat.reviewPassed": "Review bestanden:",
+  "chat.todoReminder": "Weiterarbeiten – {n} offene Todos:",
+  "agents.refineAfterTodos": "Jedes erledigte Todo prüfen und bis zum Ende der Liste arbeiten",
+  "agents.refineAfterTodosHint": "Jedes Todo, das der Agent als erledigt markiert, wird geprüft; bei Befunden wird es wieder geöffnet. Beendet er den Turn mit offenen Todos, arbeitet er weiter (für unbeaufsichtigte Läufe, z. B. über Nacht). Aus: nur ein Review am Ende des Turns.",
   "chat.reviewRound": "Review {round}: Änderungen nötig",
   "agents.refine": "Review-Schleife",
   "agents.refineRounds": "Review-Runden pro Aufgabe",
@@ -344,7 +348,7 @@ export const de: Messages = {
   "agents.refineShort": "Review ×{n}",
   "agents.deleteFile": "Agenten-Datei {path} löschen?",
   "nav.jobs": "Automationen",
-  "jobs.intro": "Agenten, die nach Zeitplan starten. Jede Automation ist eine Markdown-Datei (Auftrag + Zeitplan im Frontmatter) – lass sie dir in einem Chat von einem Agenten anlegen (Tool „schedule“) oder registriere unten eine Datei. Jeder Lauf erscheint als normaler Chat; braucht er eine Freigabe, bekommst du eine Push-Benachrichtigung.",
+  "jobs.intro": "Agenten, die nach Zeitplan starten. Die Anweisungen jeder Automatisierung stehen in einer Markdown-Datei; Name, Zeitplan und Einstellungen legst du hier fest. Mit „Neue Automatisierung“ anlegen und die Anweisungen mit dem Assistenten erarbeiten – oder einen Agenten in einem Chat darum bitten (Tool „schedule“). Jeder Lauf erscheint als normaler Chat.",
   "jobs.none": "Noch keine Automationen.",
   "jobs.schedule": "Zeitplan",
   "jobs.next": "Nächster Lauf",
@@ -355,13 +359,12 @@ export const de: Messages = {
   "jobs.enable": "Aktivieren",
   "jobs.disable": "Deaktivieren",
   "jobs.runNow": "Jetzt starten",
-  "jobs.editFile": "Datei bearbeiten",
   "jobs.remove": "Entfernen",
   "jobs.deleteConfirm": "Automation „{name}“ entfernen? Die Job-Datei bleibt erhalten.",
   "jobs.openRun": "Lauf öffnen",
   "jobs.prompt": "Auftrag",
-  "jobs.register": "Job-Datei registrieren",
-  "jobs.registerHint": "Pfad zu einer Markdown-Datei mit Zeitplan im Frontmatter:",
+  "jobs.register": "Vorhandene Datei registrieren",
+  "jobs.registerHint": "Pfad zu einer Markdown-Datei mit Anweisungen (ältere Dateien mit Zeitplan im Frontmatter werden übernommen):",
   "jobs.registerBtn": "Registrieren",
   "jobs.status.running": "läuft",
   "jobs.status.done": "fertig",
@@ -509,6 +512,11 @@ export const de: Messages = {
   "sidebar.unpin": "Nicht mehr anpinnen",
   "sidebar.openBeside": "Daneben öffnen",
   "chat.closePane": "Spalte schließen",
+  "sidebar.groupMenu": "Ordner-Optionen",
+  "sidebar.groupPin": "Oben fixieren",
+  "sidebar.groupUnpin": "Nicht mehr fixieren",
+  "sidebar.groupUp": "Nach oben",
+  "sidebar.groupDown": "Nach unten",
   "sidebar.moveTo": "In Ordner verschieben…",
   "sidebar.removeFromFolder": "Aus Ordner entfernen",
   "sidebar.archiveOne": "Archivieren",
@@ -545,16 +553,12 @@ export const de: Messages = {
   "backup.s3Keep": "Im Bucket behalten (0 = alle)",
   "backup.last": "Letztes Backup",
   "backup.s3Ok": "hochgeladen",
-  "jobs.fromTemplate": "Neue Automation aus Vorlage",
   "jobs.tplName": "Name",
   "jobs.tplProject": "Projektordner",
-  "jobs.tplSchedule": "Wann",
-  "jobs.tplCronHint": "Cron: Minute Stunde Tag Monat Wochentag (Zeitzone des Servers).",
   "jobs.tplMode": "Modus",
-  "jobs.tplPrompt": "Aufgabe für den Agenten",
-  "jobs.tplCreate": "Automation anlegen",
   "new.title": "Neue Session",
   "new.directory": "Projektverzeichnis",
+  "new.invalidFolderName": "Ordnernamen dürfen kein „/“ enthalten.",
   "new.up": "Hoch",
   "new.noSubdirs": "Keine Unterverzeichnisse",
   "new.model": "Modell",
@@ -595,8 +599,52 @@ export const de: Messages = {
   "chat.compactingDetail": "{tokens} von {limit} Tokens ({pct}) – danach arbeitet der Agent mit einer Zusammenfassung weiter",
   "chat.telegram": "Fragen an Telegram senden",
   "chat.telegramHint": "Freigaben und Rückfragen dieses Chats auch per Telegram schicken (der gerade in Telegram geöffnete Chat meldet sich immer)",
+  "cron.label": "Zeitplan",
+  "cron.mode.minutes": "Alle paar Minuten",
+  "cron.mode.hourly": "Stündlich",
+  "cron.mode.daily": "Täglich",
+  "cron.mode.weekly": "An Wochentagen",
+  "cron.mode.monthly": "Monatlich",
+  "cron.mode.custom": "Cron-Ausdruck",
+  "cron.every": "Alle",
+  "cron.minutes": "Minuten",
+  "cron.atMinute": "Zur Minute",
+  "cron.days": "Wochentage",
+  "cron.workdays": "Mo–Fr",
+  "cron.onDay": "Am",
+  "cron.at": "um",
+  "cron.customHint": "Minute Stunde Tag Monat Wochentag, z. B. „30 6 * * 1-5“ = Mo–Fr 06:30.",
+  "cron.nextRuns": "Nächste Läufe:",
+  "cron.shortMonths": "Monate ohne diesen Tag werden übersprungen.",
+  "cron.serverTz": "Uhrzeiten in Serverzeit ({tz})",
+  "jobEditor.saved": "Gespeichert",
+  "jobEditor.conflict": "Die Anweisungen wurden inzwischen geändert (z. B. vom Assistenten). Mit deiner Fassung überschreiben?",
+  "jobEditor.overwrite": "Überschreiben",
+  "jobEditor.runUnsaved": "Es gibt ungespeicherte Änderungen – der Lauf verwendet die gespeicherte Fassung. Trotzdem starten?",
+  "jobEditor.discard": "Ungespeicherte Änderungen verwerfen?",
+  "jobEditor.back": "Zurück zu den Automatisierungen",
+  "jobEditor.tab.prompt": "Anweisungen",
+  "jobEditor.tab.settings": "Zeitplan",
+  "jobEditor.tab.assistant": "Assistent",
+  "jobEditor.timeout": "Zeitlimit (Min.)",
+  "jobEditor.bypassHint": "Läuft nachts: Mit „Alles erlauben“ wartet der Lauf nie auf eine Freigabe.",
+  "jobEditor.instructions": "Anweisungen",
+  "jobEditor.instructionsHint": "Der Agent sieht nur diesen Text – keinen Chat, niemanden zum Nachfragen.",
+  "jobEditor.changedOnDisk": "Der Assistent hat die Datei geändert, während du bearbeitet hast.",
+  "jobEditor.reload": "Seine Fassung laden",
+  "jobEditor.assistantIntro": "Erarbeite die Anweisungen zusammen mit einem Modell: Beschreib, was die Automatisierung tun soll – es fragt nach und schreibt die Datei nebenan mit.",
+  "jobEditor.assistantStart": "Assistent starten",
+  "jobEditor.defaultModel": "Server-Standard",
+  "jobs.new": "Neue Automatisierung",
+  "jobs.namePlaceholder": "z. B. Nächtlicher Abhängigkeits-Check",
+  "jobs.fileHint": "Die Anweisungen landen in .codecraft/jobs/<name>.md in diesem Ordner.",
+  "jobs.startWith": "Beginnen mit",
+  "jobs.blank": "Leer",
+  "jobs.blankDesc": "Beispielgliederung zum Ausfüllen mit dem Assistenten",
+  "jobs.createAndEdit": "Anlegen und bearbeiten",
+  "jobs.edit": "Bearbeiten",
   "jobs.permissionMode": "Freigabemodus",
-  "jobs.permissionModeHint": "Gilt ab dem nächsten Lauf (wird in die Datei geschrieben). „Alles erlauben“: der Lauf fragt nie nach und wartet nicht auf Freigaben.",
+  "jobs.permissionModeHint": "Gilt ab dem nächsten Lauf. „Alles erlauben“: der Lauf fragt nie nach und wartet nicht auf Freigaben.",
   "instructions.title": "Anweisungen für diesen Chat",
   "instructions.hint": "Gelten für jede Nachricht in diesem Chat, zusätzlich zum Modus – z. B. Sprache, Ton, Regeln oder der Teil des Projekts, um den es geht.",
   "instructions.placeholder": "z. B. Antworte immer auf Englisch. Ändere nur Dateien unter api/. Frag, bevor du Abhängigkeiten hinzufügst.",
@@ -619,6 +667,9 @@ export const de: Messages = {
   "composer.mode": "Modus",
   "composer.model": "Modell",
   "composer.permissionMode": "Berechtigungsmodus",
+  "composer.preview": "Vorschau (Markdown)",
+  "composer.previewEdit": "Zurück zum Bearbeiten",
+  "composer.previewEmpty": "Noch nichts zum Anzeigen.",
   "composer.attach": "Dateien anhängen",
 
   "command.compact": "Unterhaltung zusammenfassen, um Kontext freizugeben",
@@ -710,6 +761,8 @@ export const de: Messages = {
   "settings.pricesHint": "Preise pro 1 Mio. Tokens in der eingestellten Währung. Cache-Preise fallen auf den Input-Preis zurück.",
   "settings.modelsEmptyHint": "Keine Modelle eingetragen: Sie werden automatisch beim Provider abgefragt.",
   "settings.context": "Kontext",
+  "settings.maxInput": "Max. Eingabe",
+  "settings.maxInputHint": "Eingabe-Limit, falls der Anbieter eines unterhalb des Kontextfensters setzt (leer: das Kontextfenster). Der Chat wird zusammengefasst, bevor die Eingabe es erreicht.",
   "settings.maxOutput": "Max. Ausgabe",
   "settings.reasoning": "Reasoning",
   "settings.vision": "Bilder",

web/src/i18n/en.ts

@@ -333,6 +333,10 @@ export const en = {
   "wizard.idea.cadBox": "A box with a snap-on lid, inner size 80 × 50 × 30 mm",
   "wizard.idea.cadBracket": "A wall bracket for a 25 mm pipe with two M4 screw holes",
   "activity.reviewing": "Reviewing the result (round {round})…",
+  "chat.reviewPassed": "Review passed:",
+  "chat.todoReminder": "Back to work – {n} open todos:",
+  "agents.refineAfterTodos": "Review every completed todo and work until the list is done",
+  "agents.refineAfterTodosHint": "Each todo the agent marks completed is reviewed; with findings it is reopened. Ending the turn with open todos sends the agent back to work (for unattended runs, e.g. overnight). Off: only one review at the end of the turn.",
   "chat.reviewRound": "Review {round}: changes requested",
   "agents.refine": "Review loop",
   "agents.refineRounds": "Review rounds per task",
@@ -343,7 +347,7 @@ export const en = {
   "agents.refineShort": "Review ×{n}",
   "agents.deleteFile": "Delete agent file {path}?",
   "nav.jobs": "Automations",
-  "jobs.intro": "Agents that start on a schedule. Each automation is a Markdown file (prompt + schedule in the frontmatter) – ask an agent in any chat to create one (tool “schedule”) or register a file below. Every run appears as a normal chat; if it needs permission you get a push notification.",
+  "jobs.intro": "Agents that start on a schedule. Each automation has its instructions in a Markdown file; name, schedule and settings are set here. Create one with “New automation” and work out the instructions with the assistant – or ask an agent in any chat (tool “schedule”). Every run appears as a normal chat.",
   "jobs.none": "No automations yet.",
   "jobs.schedule": "Schedule",
   "jobs.next": "Next run",
@@ -354,13 +358,12 @@ export const en = {
   "jobs.enable": "Enable",
   "jobs.disable": "Disable",
   "jobs.runNow": "Run now",
-  "jobs.editFile": "Edit file",
   "jobs.remove": "Remove",
   "jobs.deleteConfirm": "Remove the automation “{name}”? The job file stays.",
   "jobs.openRun": "Open run",
   "jobs.prompt": "Instructions",
-  "jobs.register": "Register a job file",
-  "jobs.registerHint": "Path to a Markdown file with a schedule in its frontmatter:",
+  "jobs.register": "Register an existing file",
+  "jobs.registerHint": "Path to a Markdown file with instructions (older files with a schedule in the frontmatter are taken over):",
   "jobs.registerBtn": "Register",
   "jobs.status.running": "running",
   "jobs.status.done": "done",
@@ -508,6 +511,11 @@ export const en = {
   "sidebar.unpin": "Unpin",
   "sidebar.openBeside": "Open beside",
   "chat.closePane": "Close this column",
+  "sidebar.groupMenu": "Folder options",
+  "sidebar.groupPin": "Pin to the top",
+  "sidebar.groupUnpin": "Unpin",
+  "sidebar.groupUp": "Move up",
+  "sidebar.groupDown": "Move down",
   "sidebar.moveTo": "Move to folder…",
   "sidebar.removeFromFolder": "Remove from folder",
   "sidebar.archiveOne": "Archive",
@@ -544,16 +552,12 @@ export const en = {
   "backup.s3Keep": "Keep in bucket (0 = all)",
   "backup.last": "Last backup",
   "backup.s3Ok": "uploaded",
-  "jobs.fromTemplate": "New automation from a template",
   "jobs.tplName": "Name",
   "jobs.tplProject": "Project folder",
-  "jobs.tplSchedule": "When",
-  "jobs.tplCronHint": "Cron: minute hour day month weekday (server time zone).",
   "jobs.tplMode": "Mode",
-  "jobs.tplPrompt": "Task for the agent",
-  "jobs.tplCreate": "Create automation",
   "new.title": "New session",
   "new.directory": "Project directory",
+  "new.invalidFolderName": "Folder names cannot contain “/”.",
   "new.up": "Up",
   "new.noSubdirs": "No subdirectories",
   "new.model": "Model",
@@ -594,8 +598,52 @@ export const en = {
   "chat.compactingDetail": "{tokens} of {limit} tokens ({pct}) – the agent continues with a summary afterwards",
   "chat.telegram": "Send questions to Telegram",
   "chat.telegramHint": "Also send approvals and questions of this chat via Telegram (the chat currently open in Telegram always reports)",
+  "cron.label": "Schedule",
+  "cron.mode.minutes": "Every few minutes",
+  "cron.mode.hourly": "Hourly",
+  "cron.mode.daily": "Daily",
+  "cron.mode.weekly": "On weekdays",
+  "cron.mode.monthly": "Monthly",
+  "cron.mode.custom": "Cron expression",
+  "cron.every": "Every",
+  "cron.minutes": "minutes",
+  "cron.atMinute": "At minute",
+  "cron.days": "Days of the week",
+  "cron.workdays": "Mon–Fri",
+  "cron.onDay": "On day",
+  "cron.at": "at",
+  "cron.customHint": "Minute hour day month weekday, e.g. “30 6 * * 1-5” = Mon–Fri 06:30.",
+  "cron.nextRuns": "Next runs:",
+  "cron.shortMonths": "Months without this day are skipped.",
+  "cron.serverTz": "Times in server time ({tz})",
+  "jobEditor.saved": "Saved",
+  "jobEditor.conflict": "The instructions were changed on disk meanwhile (e.g. by the assistant). Overwrite them with your version?",
+  "jobEditor.overwrite": "Overwrite",
+  "jobEditor.runUnsaved": "There are unsaved changes – the run uses the saved version. Start anyway?",
+  "jobEditor.discard": "Discard the unsaved changes?",
+  "jobEditor.back": "Back to automations",
+  "jobEditor.tab.prompt": "Instructions",
+  "jobEditor.tab.settings": "Schedule",
+  "jobEditor.tab.assistant": "Assistant",
+  "jobEditor.timeout": "Time limit (min)",
+  "jobEditor.bypassHint": "Runs at night: with “Allow everything” the run never waits for approval.",
+  "jobEditor.instructions": "Instructions",
+  "jobEditor.instructionsHint": "The agent sees only this text – no chat, nobody to ask.",
+  "jobEditor.changedOnDisk": "The assistant changed the file while you were editing.",
+  "jobEditor.reload": "Load its version",
+  "jobEditor.assistantIntro": "Work out the instructions together with a model: describe what the automation should do – it asks back and writes the file next to you.",
+  "jobEditor.assistantStart": "Start assistant",
+  "jobEditor.defaultModel": "Server default",
+  "jobs.new": "New automation",
+  "jobs.namePlaceholder": "e.g. Nightly dependency check",
+  "jobs.fileHint": "The instructions go to .codecraft/jobs/<name>.md in this folder.",
+  "jobs.startWith": "Start with",
+  "jobs.blank": "Blank",
+  "jobs.blankDesc": "Example structure to fill in with the assistant",
+  "jobs.createAndEdit": "Create and edit",
+  "jobs.edit": "Edit",
   "jobs.permissionMode": "Approval mode",
-  "jobs.permissionModeHint": "Applies from the next run (written to the file). “Allow everything”: the run never asks and never waits for approval.",
+  "jobs.permissionModeHint": "Applies from the next run. “Allow everything”: the run never asks and never waits for approval.",
   "instructions.title": "Instructions for this chat",
   "instructions.hint": "Apply to every message in this chat, in addition to the mode – e.g. language, tone, rules, the part of the project to work on.",
   "instructions.placeholder": "e.g. Always answer in English. Only change files under api/. Ask before adding dependencies.",
@@ -618,6 +666,9 @@ export const en = {
   "composer.mode": "Mode",
   "composer.model": "Model",
   "composer.permissionMode": "Permission mode",
+  "composer.preview": "Preview (Markdown)",
+  "composer.previewEdit": "Back to editing",
+  "composer.previewEmpty": "Nothing to preview yet.",
   "composer.attach": "Attach files",
 
   "command.compact": "Summarize the conversation to free up context",
@@ -709,6 +760,8 @@ export const en = {
   "settings.pricesHint": "Prices per 1M tokens in the configured currency. Cache prices default to the input price.",
   "settings.modelsEmptyHint": "No models listed: they are discovered automatically from the provider.",
   "settings.context": "Context",
+  "settings.maxInput": "Max input",
+  "settings.maxInputHint": "Input limit, if the provider sets one below the context window (empty: the context window). The chat is compacted before the input reaches it.",
   "settings.maxOutput": "Max output",
   "settings.reasoning": "Reasoning",
   "settings.vision": "Vision",

web/src/jobTemplates.ts

@@ -71,13 +71,3 @@ export const JOB_TEMPLATES: JobTemplate[] = [
       "Compare the README and other documentation with the current code: commands, configuration options, APIs and examples that are outdated, missing or wrong. Do not change files. Report concrete corrections.",
   },
 ];
-
-/** Quick schedule choices for the dialog. */
-export const SCHEDULES: { cron: string; en: string; de: string }[] = [
-  { cron: "0 3 * * *", en: "daily 03:00", de: "täglich 03:00" },
-  { cron: "0 8 * * 1-5", en: "weekdays 08:00", de: "werktags 08:00" },
-  { cron: "0 7 * * 1", en: "Mondays 07:00", de: "montags 07:00" },
-  { cron: "0 16 * * 5", en: "Fridays 16:00", de: "freitags 16:00" },
-  { cron: "0 9 1 * *", en: "monthly on the 1st", de: "monatlich am 1." },
-  { cron: "0 * * * *", en: "hourly", de: "stündlich" },
-];

web/src/main.tsx

@@ -10,6 +10,43 @@ import { captureShare } from "./share";
 applyTheme();
 captureShare();
 registerSW({ immediate: true });
+undoKeyboardShift();
+
+/**
+ * Browsers that do not resize the page for the on-screen keyboard (iOS Safari, older
+ * Android) scroll the whole page up to show the input – and do not always scroll it back
+ * when the keyboard closes, leaving the top bar (menu) out of reach. The app never
+ * scrolls the page itself (only its panes), so any page offset is undone once the
+ * visible area grows again.
+ */
+function undoKeyboardShift() {
+  const vv = window.visualViewport;
+  if (!vv) return;
+  let last = vv.height;
+  const reset = () => {
+    const el = document.scrollingElement ?? document.documentElement;
+    if (window.scrollY !== 0 || el.scrollTop !== 0 || document.body.scrollTop !== 0) {
+      window.scrollTo(0, 0);
+      el.scrollTop = 0;
+      document.body.scrollTop = 0;
+    }
+  };
+  vv.addEventListener("resize", () => {
+    // Grown back (keyboard closed or closing): after the browser's own adjustment.
+    if (vv.height > last + 1) {
+      requestAnimationFrame(reset);
+      setTimeout(reset, 350);
+    }
+    last = vv.height;
+  });
+  // Keyboard closed by leaving the input (no resize on some browsers).
+  document.addEventListener("focusout", () =>
+    setTimeout(() => {
+      const a = document.activeElement;
+      if (!a || !(a instanceof HTMLInputElement || a instanceof HTMLTextAreaElement || (a as HTMLElement).isContentEditable)) reset();
+    }, 300),
+  );
+}
 
 createRoot(document.getElementById("root")!).render(
   <StrictMode>

web/src/styles.css

@@ -299,6 +299,25 @@ button.session-group:hover {
 .session-row .session-item {
   padding-right: 30px;
 }
+/* Group headers (folders, projects): menu button, drag and drop. */
+.group-row .session-group {
+  padding-right: 30px;
+}
+.group-row .session-more {
+  top: 4px;
+}
+.group-row[draggable="true"] .session-group {
+  cursor: grab;
+}
+.group-row.drop-before {
+  box-shadow: inset 0 2px 0 var(--accent);
+}
+.group-row.drop-after {
+  box-shadow: inset 0 -2px 0 var(--accent);
+}
+.session-group .group-pin {
+  color: var(--accent);
+}
 .session-more {
   position: absolute;
   top: 6px;
@@ -508,6 +527,20 @@ button.session-group:hover {
   word-break: break-word;
   position: relative;
 }
+/* User messages are Markdown too; the line breaks come from keepLineBreaks. */
+.msg-user .markdown {
+  white-space: normal;
+}
+.composer-preview {
+  min-height: 44px;
+  max-height: 40vh;
+  overflow-y: auto;
+  padding: 10px 12px;
+  border-radius: var(--radius);
+  border: 1px dashed var(--bg3);
+  background: var(--bg1);
+  cursor: text;
+}
 .msg-user .msg-actions {
   position: absolute;
   top: 4px;
@@ -1035,6 +1068,13 @@ button.session-group:hover {
 .form label {
   color: var(--fg2);
 }
+.form label.check {
+  grid-column: 2;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  color: var(--fg1);
+}
 .form .hint {
   grid-column: 2;
   font-size: 12px;
@@ -3131,6 +3171,28 @@ button.danger-solid {
 .refine-card summary .icon {
   color: var(--purple);
 }
+.harness-note {
+  display: flex;
+  align-items: baseline;
+  gap: 8px;
+  margin: 6px 0;
+  padding: 6px 10px;
+  border-left: 3px solid var(--blue);
+  border-radius: 4px;
+  background: var(--bg1);
+  font-size: 12.5px;
+  color: var(--fg2);
+}
+.harness-note .icon {
+  color: var(--blue);
+  flex-shrink: 0;
+}
+.harness-note.ok {
+  border-left-color: var(--green);
+}
+.harness-note.ok .icon {
+  color: var(--green);
+}
 
 /* --- automations ---------------------------------------------------------------- */
 .job.off {
@@ -3607,6 +3669,217 @@ button.danger-solid {
   border-color: var(--accent);
   color: var(--accent);
 }
+.job-tpl-card.active {
+  outline: 2px solid var(--accent);
+  outline-offset: -2px;
+}
+.job-tpl .job-tpl-grid {
+  max-height: 40vh;
+  overflow-y: auto;
+}
+.job-title {
+  font: inherit;
+  color: inherit;
+  text-align: left;
+}
+
+/* --- automation editor ------------------------------------------------------ */
+.job-tabs {
+  display: none;
+  border-bottom: 1px solid var(--bg2);
+}
+.job-tabs button {
+  flex: 1;
+  border: none;
+  border-radius: 0;
+  background: transparent;
+  padding: 8px 6px;
+  color: var(--muted);
+  border-bottom: 2px solid transparent;
+}
+.job-tabs button.active {
+  color: var(--fg0);
+  border-bottom-color: var(--accent);
+}
+.job-editor {
+  flex: 1;
+  min-height: 0;
+  display: grid;
+  grid-template-columns: minmax(0, 1.2fr) minmax(340px, 1fr);
+}
+.job-editor-main {
+  min-height: 0;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+  padding: 12px;
+}
+.job-editor-settings {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  margin: 0;
+}
+.job-editor-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 10px;
+  align-items: flex-end;
+}
+.job-editor-row .field {
+  flex: 1;
+  min-width: 150px;
+  margin: 0;
+}
+.job-editor-row select,
+.job-editor-row input {
+  width: 100%;
+}
+.job-editor-status {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  font-size: 12.5px;
+  color: var(--fg3);
+  padding-bottom: 4px;
+}
+.job-editor-prompt {
+  flex: 1;
+  min-height: 360px;
+  display: flex;
+  flex-direction: column;
+  border: 1px solid var(--bg2);
+  border-radius: var(--radius);
+  overflow: hidden;
+}
+.job-editor-prompt-head {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  gap: 8px;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--bg2);
+  background: var(--bg1);
+}
+.job-editor-prompt .notice {
+  margin: 8px;
+}
+.job-editor-chat {
+  min-height: 0;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  border-left: 1px solid var(--bg3);
+}
+.job-editor-chat .topbar {
+  flex-wrap: nowrap;
+}
+.job-assistant-start {
+  margin: auto;
+  max-width: 340px;
+  padding: 24px;
+  text-align: center;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 10px;
+  color: var(--fg2);
+}
+.job-assistant-start .icon {
+  width: 32px;
+  height: 32px;
+  color: var(--accent);
+}
+@media (max-width: 900px) {
+  .job-tabs {
+    display: flex;
+  }
+  .job-editor {
+    grid-template-columns: minmax(0, 1fr);
+  }
+  .job-editor-chat {
+    border-left: none;
+  }
+  .job-editor.tab-prompt .job-editor-settings,
+  .job-editor.tab-settings .job-editor-prompt,
+  .job-editor.tab-prompt .job-editor-chat,
+  .job-editor.tab-settings .job-editor-chat,
+  .job-editor.tab-assistant .job-editor-main {
+    display: none;
+  }
+  .job-editor.tab-prompt .job-editor-main {
+    padding: 0;
+  }
+  .job-editor.tab-prompt .job-editor-prompt {
+    border: none;
+    border-radius: 0;
+    min-height: 0;
+  }
+}
+
+/* --- schedule builder ---------------------------------------------------------- */
+.cron-builder {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.cron-modes,
+.cron-days {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  align-items: center;
+}
+.cron-modes .chip-btn,
+.cron-days .chip-btn {
+  padding: 4px 10px;
+  font-size: 13px;
+}
+.cron-days .chip-btn {
+  min-width: 44px;
+}
+.cron-fields {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px 16px;
+  align-items: center;
+}
+.cron-fields label {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  font-size: 13.5px;
+}
+.cron-fields input[type="number"] {
+  width: 70px;
+}
+.cron-custom {
+  flex-direction: column;
+  align-items: stretch !important;
+  flex: 1;
+}
+.cron-custom input {
+  width: 100%;
+  max-width: 260px;
+}
+.cron-preview {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px 12px;
+  align-items: baseline;
+  font-size: 12.5px;
+  color: var(--fg3);
+}
+.cron-preview code {
+  background: var(--bg2);
+  padding: 1px 6px;
+  border-radius: 4px;
+  color: var(--fg1);
+}
+.cron-preview .err {
+  color: var(--red);
+}
 
 .chip.price-extra {
   margin-left: 4px;

web/src/types.ts

@@ -141,6 +141,7 @@ export interface ModelInfo {
   name: string;
   context?: number;
   max_output?: number | null;
+  max_input?: number | null;
   reasoning: boolean;
   vision: boolean;
   effort?: string | null;
@@ -166,7 +167,7 @@ export interface AgentInfo {
   tools?: string[] | null;
   source: "builtin" | "config" | "file" | "personal";
   max_parallel?: number | null;
-  refine?: { rounds: number; model?: string | null; criteria?: string | null } | null;
+  refine?: { rounds: number; model?: string | null; criteria?: string | null; after_todos?: boolean } | null;
   /** Source file of Markdown agents. */
   path?: string | null;
 }

web/src/whatsnew.ts

@@ -3,6 +3,34 @@
  * under "unreleased"; scripts/release.sh renames the key to the release version.
  */
 export const WHATS_NEW: Record<string, { en: string[]; de: string[] }> = {
+  "202611-00018": {
+    en: [
+      "Modes with a review: every completed todo is reviewed, and the agent keeps working until the todo list is done – for overnight runs",
+      "Long chats are compacted in time instead of failing with “input too long”",
+    ],
+    de: [
+      "Modi mit Review: jedes erledigte Todo wird geprüft, und der Agent arbeitet weiter, bis die Liste abgehakt ist – für Läufe über Nacht",
+      "Lange Chats werden rechtzeitig zusammengefasst, statt mit „Eingabe zu lang“ abzubrechen",
+    ],
+  },
+  "202611-00017": {
+    en: ["Your messages are shown as Markdown; the eye button next to the text field previews it before sending"],
+    de: ["Deine Nachrichten werden als Markdown dargestellt; das Augen-Symbol neben dem Textfeld zeigt vor dem Senden eine Vorschau"],
+  },
+  "202611-00014": {
+    en: ["Folder picker (new automation, new chat): create a new folder right there"],
+    de: ["Ordnerauswahl (neue Automatisierung, neuer Chat): direkt einen neuen Ordner anlegen"],
+  },
+  "202611-00013": {
+    en: [
+      "New automation editor: instructions, a graphical schedule and an assistant chat that writes the instructions with you",
+      "Chat list: drag folders and projects into order or pin them (⋯ on the folder); new messages no longer move the whole project up",
+    ],
+    de: [
+      "Neuer Editor für Automatisierungen: Anweisungen, grafischer Zeitplan und ein Assistent-Chat, der die Anweisungen mit dir schreibt",
+      "Chatliste: Ordner und Projekte per Drag & Drop sortieren oder fixieren (⋯ am Ordner); neue Nachrichten schieben nicht mehr das ganze Projekt nach oben",
+    ],
+  },
   "202611-00012": {
     en: ["Automations: set the approval mode right in the list – “Allow everything” runs unattended without asking", "⋯ → Send questions to Telegram: per chat, off for new chats"],
     de: ["Automatisierungen: Freigabemodus direkt in der Liste wählen – „Alles erlauben“ läuft nachts ohne Rückfrage", "⋯ → Fragen an Telegram senden: pro Chat, bei neuen Chats aus"],