kritya 0.8.46-beta → 0.8.48-beta

package/README.md

@@ -44,7 +44,8 @@ autonomously looping until your request is done. Anything that mutates state
   confining writes to the workspace; falls back to unsandboxed (with a
   warning) if the sandbox binary isn't installed
 - **Staged project workflow** — `/flow-brainstorm → spec → plan → build →
-review → fix` for building something new end-to-end
+review → fix → ship` for building something new end-to-end, with parked
+  projects you can pick up again later
 - **MCP + Agent Plugins support** — extend with external tools/servers, each
   individually trust-gated
 - **Undo/redo/checkpoints** — revert or rewind file changes and conversation
@@ -166,8 +167,11 @@ In-session commands (type `/` to see them with autocomplete; letters filter the
 | `/flow-build`             | project workflow: implement the plan, with tests                                                                                    |
 | `/flow-review`            | project workflow: spec-compliance and security review of the build                                                                  |
 | `/flow-fix`               | project workflow: fix the review's findings, each one re-verified                                                                   |
+| `/flow-ship`              | project workflow: hand over the finished project, with the test suite actually run                                                  |
+| `/flow`                   | continue the workflow from wherever the project stands                                                                              |
+| `/flow-back <phase>`      | rewind to a phase and re-run everything after it (bounded — see below)                                                              |
 | `/plan`                   | toggle plan mode: `/plan`, `/plan on`, `/plan off` (unrelated to `/flow-plan`)                                                      |
-| `/project`                | workflow status; `goto <phase>`, `rename <name>`, `clear` to end it                                                                 |
+| `/project`                | workflow status; `list`, `resume <name>`, `goto <phase>`, `rename <name>`, `clear`                                                  |
 | `/diff`                   | show the cumulative git diff of this session's changes                                                                              |
 | `/init`                   | scan the repo and generate a `KRITYA.md` project-memory file                                                                        |
 | `/commit`                 | have the agent review, stage, and commit the current git changes                                                                    |
@@ -202,9 +206,9 @@ checkpoints). `Ctrl+K` is the kill switch (see below). `Ctrl+C` exits.
 
 - **Staged new-project workflow** — ask kritya to build something new (a
   FastAPI backend, a Next.js frontend, a CLI) and it doesn't dive straight into
-  code. It runs six phases — **brainstorm → spec → plan → build → review → fix**
-  — writing a durable artifact for each under `docs/<name>/` and stopping for
-  your approval between phases:
+  code. It runs seven phases — **brainstorm → spec → plan → build → review →
+  fix → ship** — writing a durable artifact for each under `docs/<name>/` and
+  stopping for your approval between phases:
 
   | Phase        | Produces                                                                                                                                                                                        |
   | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -214,35 +218,63 @@ checkpoints). `Ctrl+K` is the kill switch (see below). `Ctrl+C` exits.
   | `build`      | the code, with tests written before the code they test, plus negative/failure-path tests for security/reliability-tagged milestones, and a live milestone checklist                             |
   | `review`     | `review.md` — a one-line scorecard, then spec-compliance, security, and reliability findings                                                                                                    |
   | `fix`        | `fix.md` — the review's findings addressed and re-verified                                                                                                                                      |
+  | `ship`       | `ship.md` — a handover summary, the test suite actually run, and an optional commit                                                                                                             |
 
   Spec comes before plan on purpose: the spec settles _what_ (and pins the
   numbered acceptance criteria everything downstream is held to), the plan
   settles _how_ and sequences milestones against those criteria. Each phase
   reads only the artifact immediately before it, so nothing gets re-derived.
-  The current phase lives in `.kritya/project.json`, so the flow resumes across
-  sessions. While a workflow is active the statusline carries a `⚑ name:phase`
-  flag, and the spinner names the running phase; `/project` shows the full
-  picture — including a warning if an earlier artifact was edited after a
-  later one already depended on it — and `/project clear` ends it. A phase
-  refuses to run if the artifact it reads was never written (`--force`
-  overrides). The agent walks the phases on its own, or you drive them by hand
-  with `/flow-brainstorm <idea>`, `/flow-spec`, `/flow-plan`, `/flow-build`,
-  `/flow-review`, `/flow-fix` — and after each one kritya tells you which
-  command comes next, so the handoff doesn't depend on the model remembering
-  to say it. `/flow-fix` only fixes what review found; if anything is still
-  open afterward it tells you to run `/flow-review` again or `/flow-fix`
-  again once you've decided how to handle what's left.
+  The agent walks the phases on its own, or you drive them by hand with
+  `/flow-brainstorm <idea>`, `/flow-spec`, `/flow-plan`, `/flow-build`,
+  `/flow-review`, `/flow-fix`, `/flow-ship` — and after each one kritya tells
+  you which command comes next, so the handoff doesn't depend on the model
+  remembering to say it.
+
+  **Where it stops is a policy, not a property of the phase list.** It hands
+  back for approval after brainstorm, spec and plan — the phases where changing
+  course is still cheap — then runs build through ship as one stretch, because
+  by then the work is already done and "shall I now review what I just built?"
+  adds a round trip without adding a decision. `/flow` continues from wherever
+  the project stands; `--auto` runs the rest without stopping, `--until <phase>`
+  stops at a named phase, and `--fast` merges brainstorm and spec into one
+  stretch. A phase refuses to run if the artifact it reads was never written
+  (`--force` overrides). `/flow-fix` only fixes what review found; if anything
+  is still open afterward it tells you to run `/flow-review` again, `/flow-fix`
+  again, or `/flow-back <phase>` if the finding is really a problem with the
+  requirement — that rewinds to a phase and re-runs everything after it, bounded
+  at two passes so a disagreement the model can't resolve can't spend forever.
+
+  **Parking a project keeps its phase.** Starting a second project used to
+  overwrite the first's place in the flow, because `.kritya/project.json` only
+  ever holds the active one. A registry at `.kritya/projects.json` now keeps
+  every project the workspace has run, so `/project list` shows them all and
+  `/project resume <name>` picks one up exactly where it stopped — phase,
+  loop-back budget and all. `/project clear` ends the active workflow but parks
+  rather than forgets it, and a new `/flow-brainstorm` names the way back.
+
+  **A gate doesn't cost you a file read.** Each phase records a one-line
+  scorecard, so `/project` shows what every phase concluded ("6 ACs, 2 MUST")
+  instead of just a generic description — you can judge whether to approve
+  without opening anything. When a project is active, launch names its phase,
+  and after a gated phase `/flow` is prefilled into the input line: Enter
+  continues, Esc (or any edit) discards it. The gate still holds — nothing runs
+  until you submit.
+
+  While a workflow is active the statusline carries a `⚑ name N/7 phase` flag
+  and the spinner names the running phase. `/project` shows the full picture,
+  including a warning if an earlier artifact was edited after a later one
+  already depended on it.
 
   The project is named from your idea unless you name it yourself with a short
   prefix — `/flow-brainstorm reverser: a script that reverses a string` gives
   you `docs/reverser/`. `/project rename <name>` moves an existing one.
 
-  Cost matters here — six phases in one session adds up — so kritya compacts
+  Cost matters here — seven phases in one session adds up — so kritya compacts
   the conversation at each phase boundary (the artifact is on disk, so the
   transcript that produced it is redundant), caps artifact length, and in the
   build phase dispatches independent milestones to isolated write subagents
   rather than pulling every file into the main context. The review phase runs
-  its two reviewers as read-only subagents, so only their findings come back;
+  its three reviewers as read-only subagents, so only their findings come back;
   the fix phase does the same to re-verify only what it changed.
 
   In the plan phase, plan mode's read-only guard is relaxed just enough to let

package/dist/agent/systemPrompt.js

@@ -109,7 +109,7 @@ ${PHASE_ORDER.map((p, i) => {
         return `  ${i + 1}. ${p.padEnd(11)}-> ${artifact.padEnd(28)}(${PHASE_SUMMARY[p]})`;
     }).join("\n")}
 Each phase reads the artifact immediately before it and does not redo that phase's work: the spec owns requirements, contracts and numbered acceptance criteria; the plan owns architecture and the milestone order, citing criteria by number rather than restating them. Keep artifacts dense — every later phase pays to read them.
-Track state in .kritya/project.json ({ "name", "phase", "updatedAt" }): read it at the start of a turn to resume at the right phase, and update "phase" (with write_file) when you advance. Stop and ask the user to approve after ${DEFAULT_GATES.join(", ")} — those are the phases where changing course is still cheap. From build onward the run continues without asking, so carry straight on through the phases the command asked for. The user may also drive phases manually with ${PHASE_ORDER.map((p) => PHASE_COMMAND[p]).join(", ")}; when they do, that command sets the phase for you. If a finding cannot be fixed because the requirement or the design is wrong rather than the code, add a "revisit" field ({ "to": "spec" or "plan", "reason": "<one line>" }) instead of working around it, and tell the user to run ${BACK_COMMAND}.
+Track state in .kritya/project.json ({ "name", "phase", "updatedAt", "summaries" }): read it at the start of a turn to resume at the right phase, and update "phase" (with write_file) when you advance. When a phase finishes, add a one-line scorecard for it under "summaries" (keyed by phase name, e.g. "6 ACs, 2 MUST") so /project can show what each phase concluded without the user opening the file — read the file, set the one key, and write it back with every other key unchanged. Stop and ask the user to approve after ${DEFAULT_GATES.join(", ")} — those are the phases where changing course is still cheap. From build onward the run continues without asking, so carry straight on through the phases the command asked for. The user may also drive phases manually with ${PHASE_ORDER.map((p) => PHASE_COMMAND[p]).join(", ")}; when they do, that command sets the phase for you. If a finding cannot be fixed because the requirement or the design is wrong rather than the code, add a "revisit" field ({ "to": "spec" or "plan", "reason": "<one line>" }) instead of working around it, and tell the user to run ${BACK_COMMAND}.
 ${memory}${buildSkillsSection(workspace, defaultExtraSkillRoots(workspace, trustWorkspace), trustWorkspace)}
 # Environment
 - OS: ${os.platform()} (${os.release()})

package/dist/agent/workflow.js

@@ -61,6 +61,32 @@ export const PHASE_COMMAND = {
  * PHASE_ORDER — it is the loop back over it.
  */
 export const BACK_COMMAND = "/flow-back";
+/** Runs whatever phase comes next, wherever the project stands. */
+export const CONTINUE_COMMAND = "/flow";
+/**
+ * The line that ends a phase, and the command that carries on from it.
+ *
+ * Two callers print this, and they must not disagree: the turn's own teardown,
+ * which covers a single-phase command, and `runFlow`, which has to cover the
+ * last phase of a chain — a chain's teardown runs while the chain flag is still
+ * set, so it deliberately stays quiet, and without the second caller the last
+ * phase of every chain went unannounced.
+ */
+export function phaseDoneMessage(phase) {
+    const next = nextPhase(phase);
+    return next
+        ? `✓ ${phase} phase done — next: ${PHASE_COMMAND[next]} or ${CONTINUE_COMMAND} ` +
+            `(or /project to review where you are)`
+        : `✓ ${phase} phase done — the workflow is complete. /project clear ends it.`;
+}
+/**
+ * What to drop into the input line once a phase ends, or null when the workflow
+ * is finished. Prefilling the continuation is what makes a gate one keypress
+ * instead of a retyped command; nothing runs until it is submitted.
+ */
+export function prefillAfter(phase) {
+    return nextPhase(phase) ? CONTINUE_COMMAND : null;
+}
 /** One-line summary of what each phase produces, for help text and the system prompt. */
 export const PHASE_SUMMARY = {
     brainstorm: "problem, users, MVP features, recommended stack",
@@ -93,12 +119,220 @@ const PHASE_WORD_CAP = {
  */
 export const MAX_REVISITS = 2;
 const STATE_REL = path.join(".kritya", "project.json");
+const REGISTRY_REL = path.join(".kritya", "projects.json");
 export function stateFile(workspace) {
     return path.join(workspace, STATE_REL);
 }
+/**
+ * Path of the registry of every project this workspace has run the workflow
+ * for.
+ *
+ * `project.json` holds only the *active* project, which is why starting a
+ * second project used to look like losing the first: the phase pointer was
+ * overwritten and the old project's place in the flow went with it. The
+ * registry is the durable index that fixes that — one entry per slug, written
+ * on every phase change, so a parked project can be picked up again exactly
+ * where it stopped.
+ */
+export function registryFile(workspace) {
+    return path.join(workspace, REGISTRY_REL);
+}
 function isPhase(v) {
     return typeof v === "string" && PHASE_ORDER.includes(v);
 }
+function parseRevisit(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const { to, reason } = raw;
+    return isPhase(to) && typeof reason === "string" ? { to, reason } : undefined;
+}
+/**
+ * Cap on a recorded scorecard, in characters. The prompt asks for ~100; this is
+ * the backstop for a model that ignores it. `/project` lays these out in a
+ * fixed-width column next to the phase name, so one paragraph — or one embedded
+ * newline — would push the rest of the list off the screen.
+ */
+const SUMMARY_MAX = 120;
+/**
+ * Reduce a recorded scorecard to one displayable line. Truncates rather than
+ * drops: a cut-off line still tells the user more than a missing one, and this
+ * is the only thing standing between a chatty model and the `/project` layout.
+ */
+function clampSummary(v) {
+    const oneLine = v.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= SUMMARY_MAX)
+        return oneLine;
+    return oneLine.slice(0, SUMMARY_MAX - 1).trimEnd() + "…";
+}
+/** Keep only the well-formed, non-empty one-liners; drop everything else. */
+function parseSummaries(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+        if (!isPhase(k) || typeof v !== "string")
+            continue;
+        const line = clampSummary(v);
+        if (line)
+            out[k] = line;
+    }
+    return Object.keys(out).length ? out : undefined;
+}
+function parseRegistryEntry(raw) {
+    if (!raw || typeof raw !== "object")
+        return null;
+    const { phase, updatedAt, revisits, revisit, summaries } = raw;
+    if (!isPhase(phase))
+        return null;
+    const entry = {
+        phase,
+        updatedAt: typeof updatedAt === "string" ? updatedAt : "",
+    };
+    if (typeof revisits === "number" && Number.isFinite(revisits)) {
+        entry.revisits = Math.max(0, Math.floor(revisits));
+    }
+    const r = parseRevisit(revisit);
+    if (r)
+        entry.revisit = r;
+    const s = parseSummaries(summaries);
+    if (s)
+        entry.summaries = s;
+    return entry;
+}
+/**
+ * Read the registry, discarding anything malformed.
+ *
+ * Same defensiveness as `loadProjectState`: a hand-edited or half-written file
+ * degrades to "no saved projects" rather than throwing into the UI, and one bad
+ * entry never takes the others down with it.
+ */
+export function loadRegistry(workspace) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(registryFile(workspace), "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const out = {};
+        for (const [slug, raw] of Object.entries(parsed)) {
+            const entry = parseRegistryEntry(raw);
+            if (entry)
+                out[slug] = entry;
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function saveRegistry(workspace, registry) {
+    const file = registryFile(workspace);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(registry, null, 2) + "\n");
+}
+/** The registry entry that mirrors a project's live pointer, exactly. */
+function entryFrom(state) {
+    const entry = { phase: state.phase, updatedAt: state.updatedAt };
+    if (state.revisits)
+        entry.revisits = state.revisits;
+    if (state.revisit)
+        entry.revisit = state.revisit;
+    if (state.summaries && Object.keys(state.summaries).length)
+        entry.summaries = state.summaries;
+    return entry;
+}
+/**
+ * Write the active pointer *and* mirror it into the registry.
+ *
+ * Every writer of `project.json` goes through here so the two can never drift:
+ * the registry is derived state, and a save that updated one but not the other
+ * would leave `/project list` showing a phase the active project had already
+ * left. The entry is replaced wholesale rather than merged — the pointer is the
+ * authority for whichever project is active, and merging would resurrect a
+ * value that was deleted on purpose (a summary cleared by re-entering a phase,
+ * a revisit cleared by acting on it).
+ *
+ * The registry is read *before* the pointer moves, and the project being
+ * displaced is captured on the way past. The agent edits `project.json` itself
+ * when it records a scorecard, so the outgoing project's pointer is routinely
+ * fresher than its registry entry — and this is the only moment that is still
+ * visible, since the pointer is about to be overwritten.
+ */
+function writeProjectState(workspace, state) {
+    const registry = loadRegistry(workspace);
+    const previous = loadProjectState(workspace);
+    if (previous && previous.name !== state.name)
+        registry[previous.name] = entryFrom(previous);
+    fs.mkdirSync(path.dirname(stateFile(workspace)), { recursive: true });
+    fs.writeFileSync(stateFile(workspace), JSON.stringify(state, null, 2) + "\n");
+    registry[state.name] = entryFrom(state);
+    saveRegistry(workspace, registry);
+}
+/**
+ * Every known project, most recently touched first.
+ *
+ * The active project is always included even if the registry has no entry for
+ * it (a workspace whose `project.json` predates the registry), so `/project
+ * list` can never omit the one project the user is actually in.
+ */
+export function listProjects(workspace) {
+    const registry = loadRegistry(workspace);
+    const active = loadProjectState(workspace);
+    const names = new Set(Object.keys(registry));
+    if (active)
+        names.add(active.name);
+    const rows = [];
+    for (const name of names) {
+        const isActive = active?.name === name;
+        const phase = isActive ? active.phase : registry[name]?.phase;
+        if (!phase)
+            continue;
+        rows.push({
+            name,
+            phase,
+            updatedAt: (isActive ? active.updatedAt : registry[name]?.updatedAt) ?? "",
+            revisits: isActive ? active.revisits : registry[name]?.revisits,
+            active: isActive,
+        });
+    }
+    return rows.sort((a, b) => (b.updatedAt || "").localeCompare(a.updatedAt || "") || a.name.localeCompare(b.name));
+}
+/**
+ * Make a saved project active again, restoring its phase, loop-back budget,
+ * pending revisit and per-phase summaries.
+ *
+ * Returns an error message rather than throwing, since the only caller is a
+ * slash command reporting back to the user. Resuming the already-active project
+ * is a no-op success, so a stray `/project resume <current>` does not look like
+ * a failure.
+ */
+export function resumeProject(workspace, name) {
+    const slug = slugify(name);
+    const active = loadProjectState(workspace);
+    if (active?.name === slug)
+        return { ok: true, name: slug };
+    const entry = loadRegistry(workspace)[slug];
+    if (!entry) {
+        const known = Object.keys(loadRegistry(workspace));
+        return {
+            ok: false,
+            error: known.length
+                ? `No project named "${slug}". Known: ${known.join(", ")}.`
+                : `No saved projects yet. Start one with /flow-brainstorm <idea>.`,
+        };
+    }
+    const state = {
+        name: slug,
+        phase: entry.phase,
+        updatedAt: new Date().toISOString(),
+    };
+    if (entry.revisits)
+        state.revisits = entry.revisits;
+    if (entry.revisit)
+        state.revisit = entry.revisit;
+    if (entry.summaries)
+        state.summaries = entry.summaries;
+    writeProjectState(workspace, state);
+    return { ok: true, name: slug };
+}
 /** Parse a phase name from user input (e.g. `/project goto spec`). */
 export function parsePhase(v) {
     const t = v.trim().toLowerCase();
@@ -164,15 +398,15 @@ export function loadProjectState(workspace) {
         };
         // The agent writes this file itself when it runs autonomously, so anything
         // malformed is treated as absent rather than allowed into the UI.
-        const raw = parsed.revisit;
-        if (raw && typeof raw === "object") {
-            const { to, reason } = raw;
-            if (isPhase(to) && typeof reason === "string")
-                state.revisit = { to, reason };
-        }
+        const revisit = parseRevisit(parsed.revisit);
+        if (revisit)
+            state.revisit = revisit;
         if (typeof parsed.revisits === "number" && Number.isFinite(parsed.revisits)) {
             state.revisits = Math.max(0, Math.floor(parsed.revisits));
         }
+        const summaries = parseSummaries(parsed.summaries);
+        if (summaries)
+            state.summaries = summaries;
         return state;
     }
     catch {
@@ -181,21 +415,36 @@ export function loadProjectState(workspace) {
 }
 export function saveProjectState(workspace, name, phase, carry) {
     const previous = loadProjectState(workspace);
+    const slug = slugify(name);
+    // A rename is the same project under a new slug, so it hands its own state in
+    // rather than looking like a fresh project and starting from zero.
+    const same = previous && previous.name === slug ? previous : undefined;
     const state = {
-        name: slugify(name),
+        name: slug,
         phase,
         updatedAt: new Date().toISOString(),
     };
-    // Moving to a phase consumes any recorded revisit: the whole point of looping
-    // back is to act on it, and leaving it set would make the same suggestion
-    // fire again on the next pass. The counter survives, because it is what
-    // bounds the loop. A different project starts fresh — unless the caller is a
-    // rename, which is the same project under a new slug and hands its count in.
-    const revisits = previous && previous.name === state.name ? previous.revisits : carry?.revisits;
+    const revisits = same?.revisits ?? carry?.revisits;
     if (revisits)
         state.revisits = revisits;
-    fs.mkdirSync(path.dirname(stateFile(workspace)), { recursive: true });
-    fs.writeFileSync(stateFile(workspace), JSON.stringify(state, null, 2) + "\n");
+    // A recorded revisit is a standing note until it is acted on — so it survives
+    // a move to any *other* phase. It used to be dropped by every save, which
+    // meant running any phase silently ate a note pointing somewhere else, and
+    // only /flow ever displayed it. Clearing it when the phase being saved is the
+    // one it names is what "acted on" means, whether that came from /flow-back or
+    // from the /project goto + /flow-<phase> escape hatch.
+    const revisit = same?.revisit ?? carry?.revisit;
+    if (revisit && revisit.to !== phase)
+        state.revisit = revisit;
+    // Summaries accumulate, so they are never dropped by a save — but the save
+    // that moves a project *into* a phase must not carry that phase's old
+    // summary forward, or `/project` would show last run's scorecard as if it
+    // described the run about to happen. Everything else is kept.
+    const summaries = { ...(same?.summaries ?? carry?.summaries) };
+    delete summaries[phase];
+    if (Object.keys(summaries).length)
+        state.summaries = summaries;
+    writeProjectState(workspace, state);
     return state;
 }
 /**
@@ -208,12 +457,11 @@ export function markRevisit(workspace, to, reason) {
     const state = loadProjectState(workspace);
     if (!state)
         return false;
-    const next = {
+    writeProjectState(workspace, {
         ...state,
         revisit: { to, reason },
         updatedAt: new Date().toISOString(),
-    };
-    fs.writeFileSync(stateFile(workspace), JSON.stringify(next, null, 2) + "\n");
+    });
     return true;
 }
 /** How many loop-backs this project has left before MAX_REVISITS is reached. */
@@ -240,15 +488,34 @@ export function takeRevisit(workspace, to) {
         updatedAt: new Date().toISOString(),
         revisits: used + 1,
     };
-    fs.writeFileSync(stateFile(workspace), JSON.stringify(next, null, 2) + "\n");
+    // The phase being re-entered loses its summary: it is about to be produced
+    // again, and the old one would be stale by the time the user reads it.
+    const summaries = { ...state.summaries };
+    delete summaries[to];
+    if (Object.keys(summaries).length)
+        next.summaries = summaries;
+    writeProjectState(workspace, next);
     return true;
 }
 /**
  * End the active workflow. The docs/<name>/ artifacts are left alone — only the
  * pointer goes, so the agent stops being told to resume a project the user has
  * moved on from.
+ *
+ * The registry entry is deliberately *kept*: ending the active workflow parks
+ * the project rather than forgetting it, which is what makes `/project resume`
+ * able to bring it back later. Forgetting would need an explicit delete, and
+ * nothing in the UI asks for one. The live pointer is mirrored one last time on
+ * the way out, so a scorecard the agent wrote since the last save is not lost
+ * with the file.
  */
 export function clearProjectState(workspace) {
+    const state = loadProjectState(workspace);
+    if (!state)
+        return false;
+    const registry = loadRegistry(workspace);
+    registry[state.name] = entryFrom(state);
+    saveRegistry(workspace, registry);
     try {
         fs.rmSync(stateFile(workspace));
         return true;
@@ -290,7 +557,17 @@ export function renameProject(workspace, from, to) {
     catch (err) {
         return { ok: false, error: `Could not move docs/${current}/: ${err.message}` };
     }
+    // The registry is keyed by slug, so the rename is a move of the entry rather
+    // than a new one — otherwise the old slug lingers as a project that no longer
+    // exists and `/project list` offers to resume it into an empty folder. The
+    // delete has to come *after* the save: the save re-mirrors the pointer it is
+    // replacing, which still carries the old name.
     saveProjectState(workspace, next, state.phase, state);
+    const registry = loadRegistry(workspace);
+    if (registry[current]) {
+        delete registry[current];
+        saveRegistry(workspace, registry);
+    }
     return { ok: true, name: next };
 }
 /** The phase before `phase` in PHASE_ORDER, or null for the first one. */
@@ -472,10 +749,31 @@ function approvalLine(phase, artifact, stopAfter) {
     return (`${write}Then summarize what you produced in a few lines and ask the user to approve ` +
         `before the ${next} phase (they will run ${PHASE_COMMAND[next]}). Do not advance on your own.`);
 }
+/**
+ * Ask the agent to record a one-line scorecard for the phase it just finished.
+ *
+ * A gate hands back to the user with the artifact on disk and a few lines in
+ * chat, and the chat scrolls away — so `/project` had no way to say what a
+ * phase actually concluded without the user opening seven files. The line is
+ * written into `project.json` (not a file of its own) because that is the one
+ * record already mirrored into the registry, so it survives parking a project.
+ *
+ * The wording is deliberately literal about read-modify-write: the model is
+ * editing a file it does not own, and the keys it must not disturb are the ones
+ * that carry the workflow's own state.
+ */
+function summaryLine(phase) {
+    return (`Last, record a one-line scorecard so /project can show what this phase concluded ` +
+        `without the user opening the file: read .kritya/project.json, set "summaries"."${phase}" ` +
+        `to a single line under ~100 characters (a headline, e.g. "3 MVP features, FastAPI + SQLite" ` +
+        `or "5/6 acceptance criteria met, 1 high finding"), and write the whole file back with ` +
+        `every other key left exactly as it was.\n`);
+}
 /** The instruction sent to the agent to carry out a given phase. */
 export function phasePrompt(name, phase, userInput, opts = {}) {
     const slug = slugify(name);
     const extra = userInput.trim() ? `\n\nUser input for this phase:\n${userInput.trim()}` : "";
+    const summary = summaryLine(phase);
     const cap = capLine(phase);
     const approve = approvalLine(phase, artifactPath(name, phase), opts.stopAfter ?? shouldStopAfter(phase));
     switch (phase) {
@@ -495,6 +793,7 @@ export function phasePrompt(name, phase, userInput, opts = {}) {
                 cap +
                 `Do NOT write application code, do NOT design the architecture, and do NOT specify ` +
                 `interfaces yet — this phase settles direction only.\n` +
+                summary +
                 approve +
                 extra);
         case "spec":
@@ -520,6 +819,7 @@ export function phasePrompt(name, phase, userInput, opts = {}) {
                 cap +
                 `Do NOT design the architecture, choose a folder layout, or sequence the work — that is ` +
                 `the plan phase's job. Do NOT write application code.\n` +
+                summary +
                 approve +
                 extra);
         case "plan":
@@ -550,6 +850,7 @@ export function phasePrompt(name, phase, userInput, opts = {}) {
                 cap +
                 `Do NOT restate the spec's requirements, contracts, or data schema — reference them by ` +
                 `number instead. Duplicated requirements drift.\n` +
+                summary +
                 approve +
                 extra);
         case "build":
@@ -583,6 +884,7 @@ export function phasePrompt(name, phase, userInput, opts = {}) {
                 `and its own branch, which keeps this conversation from accumulating the full text of ` +
                 `every file you touch. Give each one the milestone's criteria verbatim; never a summary ` +
                 `of them. Build sequentially otherwise.\n` +
+                summary +
                 approve +
                 extra);
         case "review":
@@ -613,6 +915,7 @@ export function phasePrompt(name, phase, userInput, opts = {}) {
                 `build satisfies the spec. Do not fix anything in this phase — reviewing and fixing in one ` +
                 `pass produces neither a trustworthy review nor a reviewed fix.\n` +
                 cap +
+                summary +
                 approve +
                 extra);
         case "fix":
@@ -641,6 +944,7 @@ export function phasePrompt(name, phase, userInput, opts = {}) {
                 `${BACK_COMMAND} to redo the phases that depend on it. Reserve this for findings that ` +
                 `genuinely belong upstream — everything else gets fixed here.\n` +
                 cap +
+                summary +
                 `Write docs/${slug}/fix.md BEFORE you ask for anything. Approval comes after the file ` +
                 `exists — never show the writeup in chat and ask whether to save it. Then summarize the ` +
                 `outcome in a few lines. If anything is still open, say so, and tell the user they can ` +
@@ -663,6 +967,7 @@ export function phasePrompt(name, phase, userInput, opts = {}) {
                 `are not, and every finding review.md raised that fix.md left open. Cite the AC, SEC ` +
                 `and REL labels rather than restating the requirements.\n` +
                 cap +
+                summary +
                 `Then summarize in a few lines and ask whether to commit. Do NOT commit, push or tag ` +
                 `anything until the user says yes — and when they do, use a conventional-commit message ` +
                 `describing the project, not the individual edits.\n` +

package/dist/commands/registry.js

@@ -10,7 +10,7 @@ import { scanPluginMcpServers } from "../plugins/mcp.js";
 import { listProviders } from "../config/config.js";
 import { expandCommand } from "./custom.js";
 import { recordCommandUse } from "../ui/recentCommands.js";
-import { artifactExists, artifactPath, BACK_COMMAND, clearProjectState, DEFAULT_GATES, loadProjectState, MAX_REVISITS, nextPhase, parseIdea, parsePhase, phaseBlocker, phaseIndex, phasePrompt, planRun, renameProject, revisitsRemaining, saveProjectState, shouldStopAfter, staleArtifacts, takeRevisit, PHASE_COMMAND, PHASE_ORDER, PHASE_SUMMARY, slugify, } from "../agent/workflow.js";
+import { artifactExists, artifactPath, BACK_COMMAND, clearProjectState, DEFAULT_GATES, listProjects, loadProjectState, MAX_REVISITS, nextPhase, parseIdea, parsePhase, phaseBlocker, phaseDoneMessage, phaseIndex, phasePrompt, planRun, prefillAfter, renameProject, resumeProject, revisitsRemaining, saveProjectState, shouldStopAfter, staleArtifacts, takeRevisit, PHASE_COMMAND, PHASE_ORDER, PHASE_SUMMARY, slugify, } from "../agent/workflow.js";
 const WORKFLOW = "Workflow";
 const SESSION = "Session";
 const SAFETY = "Safety & limits";
@@ -63,7 +63,7 @@ export const BUILTIN_COMMANDS = [
     },
     {
         name: "/project",
-        description: "workflow status · /project goto <phase> · rename <name> · clear",
+        description: "workflow status · list · resume <name> · goto <phase> · rename <name> · clear",
         category: WORKFLOW,
     },
     {
@@ -181,6 +181,7 @@ Project workflow: /flow-brainstorm <idea> starts one; /flow runs the next phase.
 It stops for your approval after ${DEFAULT_GATES.join(", ")}, then runs the rest
 through to ship. --auto for no stops · --until <phase> to stop early · --fast to
 merge brainstorm and spec · ${BACK_COMMAND} <phase> when a finding belongs upstream.
+Starting another project parks this one: /project list · /project resume <name>.
 Keys: Esc cancels · Tab completes · Shift+Tab cycles normal/accept-edits/dry-run
 mode · ↑/↓ recalls history · Ctrl+R searches history · Ctrl+P opens the command
 palette · Ctrl+B copies the last code block · Ctrl+O toggles full tool output ·
@@ -343,6 +344,20 @@ async function runPhase(ctx, phase, run) {
  * expensive to get wrong.
  */
 async function runFlow(ctx, from, req) {
+    // An `until` behind the start phase can never fire — shouldStopAfter matches
+    // on equality — so the run would quietly do the opposite of what was asked
+    // and execute every remaining phase. A *typo* is caught when the flag is
+    // parsed; a phase that is merely behind is not, and this is the one place
+    // that knows both ends, so it is checked here rather than in the parser.
+    if (req.until && PHASE_ORDER.indexOf(req.until) < PHASE_ORDER.indexOf(from)) {
+        ctx.addItem({
+            kind: "info",
+            text: `--until ${req.until} is behind ${from}, the phase this run starts at, so it would ` +
+                `never stop and every remaining phase would run. Pick ${from} or a later phase, ` +
+                `or use --auto to say that you do want the whole stretch.`,
+        });
+        return;
+    }
     const phases = planRun(from, req);
     const chained = phases.length > 1;
     // One command, so one user line — not one per phase of the stretch.
@@ -351,6 +366,10 @@ async function runFlow(ctx, from, req) {
         ctx.addItem({ kind: "info", text: `Running ${phases.length} phases: ${phases.join(" → ")}` });
         ctx.setChained(true);
     }
+    // The last phase that ran, and whether the chain was cut short. A chain that
+    // reaches its end still has to say so — see the announcement after the loop.
+    let lastRan = null;
+    let stoppedEarly = false;
     try {
         for (const [i, phase] of phases.entries()) {
             const outcome = await runPhase(ctx, phase, {
@@ -358,13 +377,16 @@ async function runFlow(ctx, from, req) {
                 force: req.force === true,
                 stopAfter: shouldStopAfter(phase, req),
             });
-            if (outcome === "ok")
+            if (outcome === "ok") {
+                lastRan = phase;
                 continue;
+            }
             // A phase that did not finish stops the chain, because everything after
             // it reads the artifact it did not (or only half) wrote. Say so: without
             // this the run just goes quiet after the blocker message, and the user
             // has to work out for themselves that phases they were promised never
             // happened.
+            stoppedEarly = true;
             const abandoned = phases.slice(i + 1);
             if (outcome === "incomplete") {
                 ctx.addItem({
@@ -391,6 +413,19 @@ async function runFlow(ctx, from, req) {
         if (chained)
             ctx.setChained(false);
     }
+    // Announce the end of a chain here, because nothing else can. Each phase's
+    // own turn teardown runs *while* the chain flag is still set — it cannot tell
+    // "middle of a chain" from "chain just ended at a gate", so it stays quiet for
+    // both. This is the only place that knows the loop is over, and a chain is
+    // exactly where the handoff matters most: the user has just watched two
+    // phases run, so the next step should be one keypress, not a retyped command.
+    // A chain that stopped early has already explained itself above.
+    if (chained && !stoppedEarly && lastRan) {
+        ctx.addItem({ kind: "info", text: phaseDoneMessage(lastRan) });
+        const prefill = prefillAfter(lastRan);
+        if (prefill)
+            ctx.setPrefill(prefill);
+    }
 }
 /** The standard handler for a single phase command: /flow-spec, /flow-build, … */
 function phaseCommand(phase) {
@@ -403,6 +438,31 @@ function phaseCommand(phase) {
         return runFlow(ctx, phase, req);
     };
 }
+/**
+ * `/project list` — every project this workspace knows, newest first.
+ *
+ * The active one is starred, and its phase is read from the live pointer rather
+ * than the registry so the two can never disagree on screen.
+ */
+function projectListText(workspace) {
+    const rows = listProjects(workspace);
+    if (!rows.length) {
+        return "No projects yet. Start one with /flow-brainstorm <idea>.";
+    }
+    const width = Math.max(...rows.map((r) => r.name.length));
+    const lines = rows.map((r) => {
+        const marker = r.active ? "*" : " ";
+        const date = r.updatedAt ? `  ${r.updatedAt.slice(0, 10)}` : "";
+        const loops = r.revisits ? `  ${r.revisits} loop-back(s)` : "";
+        return (`  ${marker} ${r.name.padEnd(width)}  ${r.phase.padEnd(9)} ` +
+            `(${phaseIndex(r.phase)}/${PHASE_ORDER.length})${date}${loops}`);
+    });
+    const active = rows.find((r) => r.active);
+    return (`Projects (* = active):\n${lines.join("\n")}\n\n` +
+        (active
+            ? `/project resume <name> switches to another one — "${active.name}" keeps its phase.`
+            : `Nothing is active. /project resume <name> picks one up where it stopped.`));
+}
 const handlers = {
     "/help": (ctx) => {
         const customList = ctx.customCommands.length
@@ -789,8 +849,8 @@ const handlers = {
             ctx.addItem({
                 kind: "info",
                 text: `Starting a new project "${name}". The previous project "${existing.name}" was in the ` +
-                    `${existing.phase} phase; its docs/${existing.name}/ artifacts are untouched, and ` +
-                    `/project goto ${existing.phase} after /flow-brainstorm ${existing.name} returns to it.`,
+                    `${existing.phase} phase — its docs/${existing.name}/ artifacts are untouched, and ` +
+                    `/project resume ${existing.name} picks it back up there.`,
             });
         }
         saveProjectState(ctx.workspace, name, "brainstorm");
@@ -942,8 +1002,37 @@ const handlers = {
     "/flow-ship": phaseCommand("ship"),
     "/project": (ctx) => {
         const [sub = "", ...rest] = ctx.arg.trim().split(/\s+/);
+        const verb = sub.toLowerCase();
         const project = loadProjectState(ctx.workspace);
-        if (sub.toLowerCase() === "clear") {
+        // `list` and `resume` are the two subcommands that have to work with no
+        // active project — that is exactly the state they exist for. Everything
+        // below this point assumes a project is active.
+        if (verb === "list") {
+            ctx.addItem({ kind: "info", text: projectListText(ctx.workspace) });
+            return;
+        }
+        if (verb === "resume") {
+            const name = rest.join(" ").trim();
+            if (!name) {
+                ctx.addItem({ kind: "info", text: "Usage: /project resume <name>. See /project list." });
+                return;
+            }
+            const result = resumeProject(ctx.workspace, name);
+            if (!result.ok) {
+                ctx.addItem({ kind: "info", text: result.error });
+                return;
+            }
+            ctx.refreshWorkflow();
+            const resumed = loadProjectState(ctx.workspace);
+            ctx.addItem({
+                kind: "info",
+                text: `Resumed "${result.name}" at the ${resumed?.phase ?? "?"} phase` +
+                    (resumed ? ` (${phaseIndex(resumed.phase)}/${PHASE_ORDER.length})` : "") +
+                    `. /flow continues from here.`,
+            });
+            return;
+        }
+        if (verb === "clear") {
             if (!project) {
                 ctx.addItem({ kind: "info", text: "No active project workflow." });
                 return;
@@ -952,18 +1041,20 @@ const handlers = {
             ctx.refreshWorkflow();
             ctx.addItem({
                 kind: "info",
-                text: `Workflow for "${project.name}" ended. Its docs/${project.name}/ artifacts are kept.`,
+                text: `Workflow for "${project.name}" ended. Its docs/${project.name}/ artifacts are kept, ` +
+                    `and /project resume ${project.name} brings it back at the ${project.phase} phase.`,
             });
             return;
         }
         if (!project) {
             ctx.addItem({
                 kind: "info",
-                text: "No active project workflow. Start one with /flow-brainstorm <idea>.",
+                text: "No active project workflow. Start one with /flow-brainstorm <idea>, " +
+                    "or /project list to resume a saved one.",
             });
             return;
         }
-        if (sub.toLowerCase() === "rename") {
+        if (verb === "rename") {
             const result = renameProject(ctx.workspace, project.name, rest.join(" "));
             if (!result.ok) {
                 ctx.addItem({ kind: "info", text: result.error });
@@ -976,7 +1067,7 @@ const handlers = {
             });
             return;
         }
-        if (sub.toLowerCase() === "goto") {
+        if (verb === "goto") {
             const target = parsePhase(rest.join(" "));
             if (!target) {
                 ctx.addItem({ kind: "info", text: `Usage: /project goto <${PHASE_ORDER.join("|")}>` });
@@ -995,7 +1086,12 @@ const handlers = {
             const artifact = artifactPath(project.name, p);
             // build has no document of its own, so there is nothing to look for.
             const written = artifact !== null && artifactExists(ctx.workspace, project.name, p);
-            return (`  ${marker} ${String(i + 1).padStart(2)}. ${p.padEnd(11)}${PHASE_SUMMARY[p]}` +
+            // A recorded scorecard is what the phase actually concluded; PHASE_SUMMARY
+            // is the generic description of what the phase *does*, so it is only the
+            // fallback — for a phase that hasn't run, or one run before summaries
+            // existed.
+            const recorded = project.summaries?.[p];
+            return (`  ${marker} ${String(i + 1).padStart(2)}. ${p.padEnd(11)}${recorded ?? PHASE_SUMMARY[p]}` +
                 `\n         ${artifact ?? "(application code)"}${written ? "  ✓" : ""}`);
         });
         const stale = staleArtifacts(ctx.workspace, project.name, project.phase);
@@ -1013,7 +1109,7 @@ const handlers = {
                 staleBlock +
                 revisitBlock +
                 `\n\n/flow continues · ${PHASE_COMMAND[project.phase]} re-runs this phase · ` +
-                `/project goto <phase> to move · /project rename <name> · /project clear to end the workflow.`,
+                `/project goto <phase> to move · rename <name> · list · resume <name> · clear to end it.`,
         });
     },
     "/diff": (ctx) => {

package/dist/headless.js

@@ -35,9 +35,15 @@ import { defaultSandboxMode } from "./shell/sandbox.js";
  * per-phase modes, no artifact bookkeeping, and it runs until it hits the step
  * limit. Exported so the check itself is testable without spawning a process
  * (the e2e suite that would otherwise cover it needs a real CLI run).
+ *
+ * Deliberately narrow: `/` + a command word + end-or-whitespace. A plain-language
+ * prompt can legitimately begin with a path — "/home/me notes.txt summarize" —
+ * and refusing that is a false positive against exactly the input this check's
+ * own error message invites. The giveaway is the second `/`: a command name has
+ * no further slash, a path has several.
  */
 export function isSlashCommandPrompt(prompt) {
-    return prompt.trimStart().startsWith("/");
+    return /^\/[a-z][a-z0-9-]*(\s|$)/.test(prompt.trimStart());
 }
 function emit(args, r) {
     if (args.output === "json") {

package/dist/ui/App.js

@@ -148,7 +148,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             .catch(() => { });
     }, [workspace]);
     useEffect(refreshFileList, [refreshFileList]);
-    const { items, addItem, clearItems, phase, setPhase, stream, thinking, activity, setActivity, runningPhase, setRunningPhase, setChained, workflow, refreshWorkflow, permission, elicitation, inFlight, model, provider, servedModel, totalUsage, totalCost, tasks, setTasks, ctxPct, setCtxPct, tokenBudget, budgetPct, budgetUsed, budgetStopped, resetBudget, setBudgetLimit, branch, planMode, setPlanMode, dryRunMode, killed, killReason, engageKill, releaseKill, acceptEdits, setAcceptEdits, bypassMode, setBypassMode, autoApprovedCount, cycleMode, onAcceptEditsConfirm, onBypassModeConfirm, abortRef, setModelEverywhere, setProviderEverywhere, costReport, runAgent, runWebSearch, onPermissionDecision, onElicitationDecision, onResumeSelect, requestPermission, requestElicitation, persistenceWarningCount, } = useAgent({
+    const { items, addItem, clearItems, phase, setPhase, stream, thinking, activity, setActivity, runningPhase, setRunningPhase, setChained, workflow, refreshWorkflow, prefill, setPrefill, permission, elicitation, inFlight, model, provider, servedModel, totalUsage, totalCost, tasks, setTasks, ctxPct, setCtxPct, tokenBudget, budgetPct, budgetUsed, budgetStopped, resetBudget, setBudgetLimit, branch, planMode, setPlanMode, dryRunMode, killed, killReason, engageKill, releaseKill, acceptEdits, setAcceptEdits, bypassMode, setBypassMode, autoApprovedCount, cycleMode, onAcceptEditsConfirm, onBypassModeConfirm, abortRef, setModelEverywhere, setProviderEverywhere, costReport, runAgent, runWebSearch, onPermissionDecision, onElicitationDecision, onResumeSelect, requestPermission, requestElicitation, persistenceWarningCount, } = useAgent({
         agent,
         workspace,
         modelRef,
@@ -168,6 +168,18 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
     useEffect(() => {
         onRequestElicitationReady?.(requestElicitation);
     }, [onRequestElicitationReady, requestElicitation]);
+    // Drop a prefilled command into the input line when a phase ends at a gate,
+    // so Enter continues the workflow instead of the user retyping `/flow`. The
+    // gate still holds: nothing runs until it is submitted, and any edit — or
+    // Esc — discards the suggestion. Applied only from the idle prompt, since a
+    // prefill arriving while a picker was open would clobber what was typed there.
+    useEffect(() => {
+        if (prefill === null || phase !== "input")
+            return;
+        setInput(prefill);
+        setInputKey((k) => k + 1);
+        setPrefill(null);
+    }, [prefill, phase, setPrefill]);
     // Tick an elapsed-seconds counter while the agent is working.
     useEffect(() => {
         if (phase !== "working") {
@@ -374,6 +386,14 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             setActivity("cancelling…");
             abortRef.current?.abort();
         }
+        // Esc clears the idle input line. This is the documented way to decline a
+        // command prefilled at a workflow gate; it also just empties a half-typed
+        // prompt, which is what a bare Esc on an idle prompt is expected to do.
+        if (key.escape && phase === "input" && input) {
+            setInput("");
+            setInputKey((k) => k + 1);
+            return;
+        }
         // Ctrl+O toggles showing full tool output.
         if (key.ctrl && _input === "o") {
             setVerbose((v) => !v);
@@ -537,6 +557,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             setRunningPhase,
             setChained,
             refreshWorkflow,
+            setPrefill,
             setCtxPct,
             setTasks,
             setPlanMode,

package/dist/ui/useAgent.js

@@ -9,7 +9,7 @@ import { SWITCHYARD_ROUTE_ID, resolveEffectiveModel } from "../provider/switchya
 import { KillSwitchError } from "../agent/killSwitch.js";
 import { TAGLINE } from "./Banner.js";
 import { defaultSandboxMode, sandboxAvailable } from "../shell/sandbox.js";
-import { loadProjectState, nextPhase, PHASE_COMMAND, } from "../agent/workflow.js";
+import { loadProjectState, nextPhase, PHASE_ORDER, phaseDoneMessage, phaseIndex, prefillAfter, } from "../agent/workflow.js";
 import { tavilySearch } from "../tools/webSearch.js";
 import { killActiveNotice, useKillSwitch } from "./useKillSwitch.js";
 import { useUsageBudget } from "./useUsageBudget.js";
@@ -69,6 +69,21 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
                     : `Resumed previous session (${resumedCount} messages)${taskNote}.`,
             });
         }
+        // A project parked mid-flow is the single most useful thing to say at
+        // launch: without it the user has to remember which phase they were in,
+        // and `/flow` on its own does not say where it will resume from.
+        const active = loadProjectState(workspace);
+        if (active) {
+            const next = nextPhase(active.phase);
+            initial.push({
+                id: nextId.current++,
+                kind: "info",
+                text: `Project "${active.name}" is at the ${active.phase} phase ` +
+                    `(${phaseIndex(active.phase)}/${PHASE_ORDER.length}). ` +
+                    (next ? `/flow continues with ${next} · ` : `every phase has run · `) +
+                    `/project for status.`,
+            });
+        }
         return initial;
     });
     const [phase, setPhase] = useState(resumeSessions?.length ? "resume" : "input");
@@ -114,6 +129,16 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
     }, []);
     /** The active project workflow, for the statusline. Persists between turns. */
     const [workflow, setWorkflow] = useState(() => loadProjectState(workspace));
+    /**
+     * Text to drop into the input line once the turn ends.
+     *
+     * Stopping at a gate costs two steps — read the result, then type the next
+     * command — and the second one is pure retyping of something the app already
+     * knows. Prefilling it means Enter continues and Esc (or any edit) discards
+     * it, without taking the decision away: nothing runs until the user submits.
+     * One-shot; the UI clears it as soon as it is applied.
+     */
+    const [prefill, setPrefill] = useState(null);
     const [permission, setPermission] = useState(null);
     const [elicitation, setElicitation] = useState(null);
     const [model, setModel] = useState(modelRef.current);
@@ -403,6 +428,12 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
      * paraphrasing its instructions drops it often enough that the handoff can't
      * depend on that — the user is left at a prompt with no idea what comes next.
      * Printing it here makes it deterministic.
+     *
+     * This covers a single-phase command only. The last phase of a *chain* is
+     * announced by `runFlow` instead: this runs at the end of every turn, which
+     * for a chain is while the chain is still going, so it has no way to tell
+     * "middle of a chain" from "chain just ended at a gate" — and staying quiet
+     * for both is the safe half of that. `runFlow` knows which it is.
      */
     const announceNextPhase = useCallback(() => {
         const ran = runningPhaseRef.current;
@@ -416,13 +447,10 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
         // Prefer the phase on disk: an autonomous turn may have advanced it past
         // whatever the command started.
         const current = loadProjectState(workspace)?.phase ?? ran;
-        const next = nextPhase(current);
-        addItem({
-            kind: "info",
-            text: next
-                ? `✓ ${current} phase done — next: ${PHASE_COMMAND[next]} or /flow (or /project to review where you are)`
-                : `✓ ${current} phase done — the workflow is complete. /project clear ends it.`,
-        });
+        addItem({ kind: "info", text: phaseDoneMessage(current) });
+        const prefill = prefillAfter(current);
+        if (prefill)
+            setPrefill(prefill);
     }, [workspace, addItem, setRunningPhase]);
     const runWebSearch = async (query) => {
         if (agent.kill.active) {
@@ -622,6 +650,8 @@ export function useAgent({ agent, workspace, modelRef, providerRef, config, uiBr
         setChained,
         workflow,
         refreshWorkflow,
+        prefill,
+        setPrefill,
         permission,
         elicitation,
         inFlight,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kritya",
-  "version": "0.8.46-beta",
+  "version": "0.8.48-beta",
   "description": "Kritya — Superintelligence at your command line",
   "type": "module",
   "publishConfig": {