kritya 0.8.45-beta → 0.8.47-beta

package/dist/commands/registry.js

@@ -10,15 +10,20 @@ import { scanPluginMcpServers } from "../plugins/mcp.js";
 import { listProviders } from "../config/config.js";
 import { expandCommand } from "./custom.js";
 import { recordCommandUse } from "../ui/recentCommands.js";
-import { artifactPath, clearProjectState, loadProjectState, parseIdea, parsePhase, phaseBlocker, phasePrompt, renameProject, staleArtifacts, PHASE_COMMAND, PHASE_ORDER, PHASE_SUMMARY, saveProjectState, 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";
 const INFO = "Info";
 export const BUILTIN_COMMANDS = [
+    {
+        name: "/flow",
+        description: "run the next workflow phase, or a stretch of them: /flow [--until <phase>|--auto]",
+        category: WORKFLOW,
+    },
     {
         name: "/flow-brainstorm",
-        description: "start a new-project workflow: /flow-brainstorm <idea> (brainstorm→spec→plan→build→review→fix)",
+        description: "start a new-project workflow: /flow-brainstorm <idea> (brainstorm→spec→plan→build→review→fix→ship)",
         category: WORKFLOW,
     },
     {
@@ -33,7 +38,7 @@ export const BUILTIN_COMMANDS = [
     },
     {
         name: "/flow-build",
-        description: "project workflow: implement the plan, with tests",
+        description: "project workflow: implement the plan, then review and fix it",
         category: WORKFLOW,
     },
     {
@@ -46,9 +51,19 @@ export const BUILTIN_COMMANDS = [
         description: "project workflow: fix the review's findings, re-verified",
         category: WORKFLOW,
     },
+    {
+        name: "/flow-ship",
+        description: "project workflow: run the tests and write the handover summary",
+        category: WORKFLOW,
+    },
+    {
+        name: "/flow-back",
+        description: "rewind to a phase and re-run everything after it, when a finding belongs upstream",
+        category: WORKFLOW,
+    },
     {
         name: "/project",
-        description: "workflow status · /project goto <phase> · rename <name> · clear",
+        description: "workflow status · list · resume <name> · goto <phase> · rename <name> · clear",
         category: WORKFLOW,
     },
     {
@@ -162,6 +177,11 @@ Also: @path/to/file attaches a file to your message (with autocomplete).
 @mcp:server/name attaches a document an MCP server offers.
 MCP servers can also contribute their own /server-prompt commands.
 Project memory: put standing instructions in KRITYA.md at your workspace root.
+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 ·
@@ -170,7 +190,7 @@ Ctrl+K is the kill switch (stops everything until /kill off) · Ctrl+C exits`;
  * A phase boundary is the one place compaction is unambiguously safe: the
  * phase that just ended wrote its conclusions to a durable artifact on disk,
  * so the transcript that produced them is redundant. Compacting here is what
- * keeps a five-phase project from dragging every phase's exploration into the
+ * keeps a seven-phase project from dragging every phase's exploration into the
  * next phase's context window.
  */
 async function compactAtPhaseBoundary(ctx, phase) {
@@ -196,10 +216,48 @@ async function compactAtPhaseBoundary(ctx, phase) {
         ctx.setActivity(null);
     }
 }
-/** Strip a trailing/leading `--force` from a command argument. */
-function takeForce(arg) {
-    const force = /(^|\s)--force(\s|$)/.test(arg);
-    return { arg: arg.replace(/(^|\s)--force(\s|$)/, " ").trim(), force };
+/**
+ * Pull the workflow flags out of a command argument, leaving the user's own
+ * text behind. `--force` was the only one of these once, and it is still
+ * stripped before the prompt is built: it is an instruction to the command,
+ * not to the model, and leaving it in reads as part of the idea.
+ */
+function takeFlowFlags(arg) {
+    let rest = arg;
+    const take = (flag) => {
+        const re = new RegExp(`(^|\\s)${flag}(\\s|$)`);
+        if (!re.test(rest))
+            return false;
+        rest = rest.replace(re, " ");
+        return true;
+    };
+    const force = take("--force");
+    const auto = take("--auto");
+    // --fast merges brainstorm and spec into one stretch. They answer nearly the
+    // same question, and for a small project the second round trip buys nothing.
+    const fast = take("--fast");
+    const untilMatch = /(^|\s)--until[= ](\S+)/.exec(rest);
+    if (untilMatch) {
+        rest = rest.replace(/(^|\s)--until[= ]\S+/, " ");
+        const phase = parsePhase(untilMatch[2]);
+        if (!phase) {
+            return {
+                arg: rest.trim(),
+                force,
+                error: `Unknown phase "${untilMatch[2]}" for --until. Use one of: ${PHASE_ORDER.join(", ")}.`,
+            };
+        }
+        return { arg: rest.trim(), force, until: phase };
+    }
+    if (/(^|\s)--until(\s|$)/.test(rest)) {
+        return { arg: rest.trim(), force, error: "Usage: --until <phase>" };
+    }
+    if (auto)
+        return { arg: rest.trim(), force, auto: true };
+    if (fast) {
+        return { arg: rest.trim(), force, gates: DEFAULT_GATES.filter((p) => p !== "brainstorm") };
+    }
+    return { arg: rest.trim(), force };
 }
 /** Strip a trailing/leading `--default` from a command argument. */
 function takeDefault(arg) {
@@ -208,25 +266,29 @@ function takeDefault(arg) {
 }
 /**
  * Run one workflow phase: check its prerequisite artifact exists, set the mode
- * the phase needs, record the phase, compact, then hand the prompt to the agent.
+ * the phase needs, record the phase, compact, then hand the prompt to the
+ * agent.
+ *
+ * The outcome is what stops a chain. A blocked phase has written nothing, and
+ * an incomplete one has written something half-finished — either way everything
+ * after it reads an artifact that isn't there yet.
  */
-async function runPhase(ctx, phase) {
+async function runPhase(ctx, phase, run) {
     const project = loadProjectState(ctx.workspace);
     if (!project) {
         ctx.addItem({
             kind: "info",
             text: "No active project workflow. Start one with /flow-brainstorm <idea>.",
         });
-        return;
+        return "blocked";
     }
-    const { arg, force } = takeForce(ctx.arg);
     const blocker = phaseBlocker(ctx.workspace, project.name, phase);
-    if (blocker && !force) {
+    if (blocker && !run.force) {
         ctx.addItem({
             kind: "info",
             text: `${blocker}\nTo run ${PHASE_COMMAND[phase]} anyway: ${PHASE_COMMAND[phase]} --force`,
         });
-        return;
+        return "blocked";
     }
     // Warn (never block) if an earlier artifact was edited after this phase's
     // input was written from it — e.g. spec.md changed after plan.md already
@@ -256,13 +318,150 @@ async function runPhase(ctx, phase) {
         text: `${phase} phase for "${project.name}" — ${PHASE_SUMMARY[phase]}` +
             (artifact ? ` → ${artifact}` : "") +
             (wantPlanMode ? " (plan mode ON: read-only apart from that doc)" : "") +
-            (blocker && force ? "\n⚠ Forced past a missing prerequisite." : ""),
+            (blocker && run.force ? "\n⚠ Forced past a missing prerequisite." : ""),
     });
-    ctx.addItem({ kind: "user", text: ctx.raw.trim() });
     ctx.setRunningPhase(phase);
     ctx.refreshWorkflow();
     await compactAtPhaseBoundary(ctx, phase);
-    return ctx.runAgent(phasePrompt(project.name, phase, arg));
+    await ctx.runAgent(phasePrompt(project.name, phase, run.arg, { stopAfter: run.stopAfter }));
+    // A turn that runs out of steps just ends, and the message it appends reads
+    // like model output. The agent flags it, so a chain can tell "the phase
+    // finished" from "the phase gave up mid-sentence" — which matters because
+    // the next phase reads whatever it managed to write. Subagents already
+    // report this (`stoppedEarly: "max-steps"`); phases were treating a
+    // truncated run as a finished one.
+    if (ctx.agent.hitStepLimit)
+        return "incomplete";
+    return "ok";
+}
+/**
+ * Run a stretch of phases back to back from one command.
+ *
+ * `planRun` decides how far the stretch goes. Stopping between build, review
+ * and fix would ask "shall I now review what I just built?" — a round trip
+ * that buys no decision, because by then the work is already done. Stopping
+ * after brainstorm, spec and plan does buy one: those are cheap to redo and
+ * 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.
+    ctx.addItem({ kind: "user", text: ctx.raw.trim() });
+    if (chained) {
+        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, {
+                arg: i === 0 ? req.arg : "",
+                force: req.force === true,
+                stopAfter: shouldStopAfter(phase, req),
+            });
+            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({
+                    kind: "info",
+                    text: `${phase} stopped at the ${ctx.agent.maxSteps}-step limit before it finished, so ` +
+                        `whatever it wrote is incomplete — and the phases after it read that.` +
+                        (abandoned.length ? ` ${abandoned.join(", ")} did not run.` : "") +
+                        `\nSend "continue" to finish ${phase}, then /flow to carry on from there.`,
+                });
+            }
+            else if (abandoned.length) {
+                ctx.addItem({
+                    kind: "info",
+                    text: `Chain stopped at ${phase} — ${abandoned.join(", ")} did not run. ` +
+                        `Clear the blocker above, then /flow to carry on from here.`,
+                });
+            }
+            break;
+        }
+    }
+    finally {
+        // Only a chain ever sets this, so only a chain releases it — a single-phase
+        // command has nothing to suppress and should not touch the flag at all.
+        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) {
+    return async (ctx) => {
+        const req = takeFlowFlags(ctx.arg);
+        if (req.error) {
+            ctx.addItem({ kind: "info", text: req.error });
+            return;
+        }
+        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) => {
@@ -623,13 +822,20 @@ const handlers = {
             `the change.${trailerInstruction} Do not push. Show the final commit hash and message.`);
     },
     "/flow-brainstorm": async (ctx) => {
-        const input = ctx.arg.trim();
+        const req = takeFlowFlags(ctx.arg);
+        if (req.error) {
+            ctx.addItem({ kind: "info", text: req.error });
+            return;
+        }
+        const input = req.arg;
         const existing = loadProjectState(ctx.workspace);
         if (!existing && !input) {
             ctx.addItem({
                 kind: "info",
                 text: `Usage: /flow-brainstorm <your project idea>. Starts the ${PHASE_ORDER.join(" → ")} workflow.\n` +
-                    `Name it yourself with a short prefix: /flow-brainstorm reverser: a script that reverses a string`,
+                    `Name it yourself with a short prefix: /flow-brainstorm reverser: a script that reverses a string\n` +
+                    `Flags: --fast (run brainstorm and spec as one stretch) · --auto (no stops) · ` +
+                    `--until <phase> · --force`,
             });
             return;
         }
@@ -643,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");
@@ -653,13 +859,117 @@ const handlers = {
             ctx.agent.planMode = false;
             ctx.setPlanMode(false);
         }
-        ctx.addItem({ kind: "user", text: ctx.raw.trim() });
-        ctx.setRunningPhase("brainstorm");
         ctx.refreshWorkflow();
-        // A no-op at the start of a session; earns its keep when a second project
-        // is started in a session that already ran one.
-        await compactAtPhaseBoundary(ctx, "brainstorm");
-        return ctx.runAgent(phasePrompt(name, "brainstorm", idea));
+        // The idea belongs to the brainstorm phase; later phases in a --fast stretch
+        // read its artifact rather than the raw idea again.
+        return runFlow(ctx, "brainstorm", { ...req, arg: idea });
+    },
+    "/flow": async (ctx) => {
+        const project = loadProjectState(ctx.workspace);
+        if (!project) {
+            ctx.addItem({
+                kind: "info",
+                text: "No active project workflow. Start one with /flow-brainstorm <idea>.",
+            });
+            return;
+        }
+        const req = takeFlowFlags(ctx.arg);
+        if (req.error) {
+            ctx.addItem({ kind: "info", text: req.error });
+            return;
+        }
+        // The stored phase is the one that last ran, so continuing means the next
+        // one — re-running what just finished is never what "continue" means.
+        const from = nextPhase(project.phase);
+        if (!from) {
+            ctx.addItem({
+                kind: "info",
+                text: `"${project.name}" has run every phase (last: ${project.phase}). ` +
+                    `Run /project clear to end the workflow, or ${BACK_COMMAND} <phase> to redo one.`,
+            });
+            return;
+        }
+        // A revisit the fix phase recorded means a finding was never really closed.
+        // Carrying on forward would run the rest of the workflow on top of a
+        // requirement that is known to be wrong, so name it here rather than let
+        // the user discover it by reading /project.
+        const revisit = project.revisit;
+        if (revisit && PHASE_ORDER.indexOf(revisit.to) < PHASE_ORDER.indexOf(from)) {
+            ctx.addItem({
+                kind: "info",
+                text: `↩ ${revisit.to} is still flagged as needing a change — ${revisit.reason}\n` +
+                    `Run ${BACK_COMMAND} to redo it and everything after, or carry on anyway with ` +
+                    `${PHASE_COMMAND[from]}.`,
+            });
+        }
+        return runFlow(ctx, from, req);
+    },
+    "/flow-back": async (ctx) => {
+        const project = loadProjectState(ctx.workspace);
+        if (!project) {
+            ctx.addItem({
+                kind: "info",
+                text: "No active project workflow. Start one with /flow-brainstorm <idea>.",
+            });
+            return;
+        }
+        const req = takeFlowFlags(ctx.arg);
+        if (req.error) {
+            ctx.addItem({ kind: "info", text: req.error });
+            return;
+        }
+        // Bare /flow-back acts on whatever the fix phase recorded; naming a phase
+        // works whether or not anything was recorded.
+        const recorded = project.revisit;
+        const target = parsePhase(req.arg) ?? recorded?.to ?? null;
+        if (!target) {
+            ctx.addItem({
+                kind: "info",
+                text: `Usage: ${BACK_COMMAND} <${PHASE_ORDER.join("|")}> — rewind to a phase and re-run everything after it.\n` +
+                    `Nothing upstream was recorded either, so name the phase you want to redo.`,
+            });
+            return;
+        }
+        if (PHASE_ORDER.indexOf(target) >= PHASE_ORDER.indexOf(project.phase)) {
+            ctx.addItem({
+                kind: "info",
+                text: `${BACK_COMMAND} rewinds, and ${target} is not before the current phase ` +
+                    `(${project.phase}). Use ${PHASE_COMMAND[target]} to move forward.`,
+            });
+            return;
+        }
+        if (revisitsRemaining(ctx.workspace) <= 0) {
+            ctx.addItem({
+                kind: "info",
+                text: `"${project.name}" has already looped back ${MAX_REVISITS} time(s), which is the limit — ` +
+                    `another automatic pass would be guessing at what you want. Fix what you can by hand, ` +
+                    `then /project goto ${target} and ${PHASE_COMMAND[target]} if you still want to redo it.`,
+            });
+            return;
+        }
+        if (!takeRevisit(ctx.workspace, target)) {
+            ctx.addItem({ kind: "info", text: `Could not rewind "${project.name}".` });
+            return;
+        }
+        ctx.addItem({
+            kind: "info",
+            text: `↩ Rewinding to ${target}` +
+                (recorded && recorded.to === target ? ` — ${recorded.reason}` : "") +
+                `. Everything after it re-runs, because it all reads what ${target} writes.`,
+        });
+        ctx.refreshWorkflow();
+        // Rewinding exists to regenerate what the wrong phase produced, and to put
+        // the user back where they were — not to carry on past it. So it stops at
+        // the phase the project had reached, unless the user asked for a longer or
+        // shorter run with --auto / --until.
+        //
+        // `arg` is blanked deliberately: it held the phase name the user typed
+        // (`/flow-back spec`), and passing it on would inject the literal string
+        // "spec" into the phase prompt as if it were user input.
+        const options = { ...req, arg: "" };
+        if (!req.auto && !req.until)
+            options.until = project.phase;
+        return runFlow(ctx, target, options);
     },
     // `/plan` (no `flow-` prefix) is pure plan-mode control — on/off or a bare
     // toggle — and never touches the project workflow. `/flow-plan` runs the
@@ -684,15 +994,45 @@ const handlers = {
                 : "Plan mode OFF — the agent can make changes again.",
         });
     },
-    "/flow-spec": (ctx) => runPhase(ctx, "spec"),
-    "/flow-plan": (ctx) => runPhase(ctx, "plan"),
-    "/flow-build": (ctx) => runPhase(ctx, "build"),
-    "/flow-review": (ctx) => runPhase(ctx, "review"),
-    "/flow-fix": (ctx) => runPhase(ctx, "fix"),
+    "/flow-spec": phaseCommand("spec"),
+    "/flow-plan": phaseCommand("plan"),
+    "/flow-build": phaseCommand("build"),
+    "/flow-review": phaseCommand("review"),
+    "/flow-fix": phaseCommand("fix"),
+    "/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;
@@ -701,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 });
@@ -725,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("|")}>` });
@@ -735,25 +1077,39 @@ const handlers = {
             ctx.refreshWorkflow();
             ctx.addItem({
                 kind: "info",
-                text: `"${project.name}" set to the ${target} phase. Run ${PHASE_COMMAND[target]} to start it.`,
+                text: `"${project.name}" set to the ${target} phase. Run ${PHASE_COMMAND[target]} to start it, or /flow to continue from here.`,
             });
             return;
         }
-        const lines = PHASE_ORDER.map((p) => {
+        const lines = PHASE_ORDER.map((p, i) => {
             const marker = p === project.phase ? "*" : " ";
             const artifact = artifactPath(project.name, p);
-            return `  ${marker} ${p.padEnd(11)}${PHASE_SUMMARY[p]}\n      ${artifact ?? "(application code)"}`;
+            // build has no document of its own, so there is nothing to look for.
+            const written = artifact !== null && artifactExists(ctx.workspace, project.name, 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);
         const staleBlock = stale.length ? `\n\n${stale.join("\n")}` : "";
+        const revisitBlock = project.revisit
+            ? `\n\n↩ ${project.revisit.to} was flagged as needing a change: ${project.revisit.reason}` +
+                `\n   ${BACK_COMMAND} redoes it and everything after it.`
+            : "";
         ctx.addItem({
             kind: "info",
-            text: `Project "${project.name}" — ${project.phase} phase` +
+            text: `Project "${project.name}" — ${project.phase} phase ` +
+                `(${phaseIndex(project.phase)}/${PHASE_ORDER.length})` +
                 (project.updatedAt ? ` (since ${project.updatedAt.slice(0, 10)})` : "") +
                 `\n\n${lines.join("\n")}` +
                 staleBlock +
-                `\n\nRun ${PHASE_COMMAND[project.phase]} to continue · /project goto <phase> to move · ` +
-                `/project rename <name> · /project clear to end the workflow.`,
+                revisitBlock +
+                `\n\n/flow continues · ${PHASE_COMMAND[project.phase]} re-runs this phase · ` +
+                `/project goto <phase> to move · rename <name> · list · resume <name> · clear to end it.`,
         });
     },
     "/diff": (ctx) => {

package/dist/headless.js

@@ -25,6 +25,26 @@ import { gatedContentHash, isTrusted } from "./trust/trust.js";
 import { partitionByTrust, serverFingerprint, trustServer } from "./trust/mcpTrust.js";
 import { installCrashHandlers } from "./crash.js";
 import { defaultSandboxMode } from "./shell/sandbox.js";
+/**
+ * Whether a `--prompt` value looks like a slash command.
+ *
+ * Slash commands are dispatched by the interactive UI, which owns the command
+ * layer; headless mode has none, so a `/flow-brainstorm ...` prompt was handed
+ * to the model as literal text. The model then improvised the workflow from the
+ * system prompt — which looks like it worked and does not: no gate stops, no
+ * 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 /^\/[a-z][a-z0-9-]*(\s|$)/.test(prompt.trimStart());
+}
 function emit(args, r) {
     if (args.output === "json") {
         console.log(JSON.stringify(r));
@@ -65,6 +85,20 @@ function approveHeadlessMcp(servers, trust, source) {
 export async function runHeadless(args) {
     const startedAt = Date.now();
     const workspace = path.resolve(args.dir);
+    // Refuse rather than silently do something else. See isSlashCommandPrompt.
+    if (isSlashCommandPrompt(args.prompt)) {
+        return finish(args, startedAt, {
+            success: false,
+            result: "",
+            error: `--prompt starts with "/", which is a slash command. Headless mode does not run ` +
+                `slash commands — it sends the text to the model, which would improvise the task ` +
+                `instead of following the command. Run the command in the interactive UI, or ` +
+                `describe the task in plain language here.`,
+            toolCalls: [],
+            usage: { promptTokens: 0, completionTokens: 0, cachedPromptTokens: 0, estimated: false },
+            durationMs: 0,
+        });
+    }
     // Only the user's own global .env is unconditionally trusted; see below.
     loadDotEnv([path.join(CONFIG_DIR, ".env")]);
     // There's no terminal to show the interactive trust prompt, so headless