@dougharness/cli 1.3.0 → 1.5.0

package/node_modules/@dougharness/flow/lib/plan.mjs

@@ -576,6 +576,46 @@ export function validatePlan(plan) {
       }
     });
   }
+  errors.push(...signatureErrors(plan));
+  return errors;
+}
+
+// Card planner-keeps-stated-signatures (2026-10-23, ts-orders swarm-skill): a signature the goal or an acceptance
+// line quotes in backticks (`name(...)...`) must reach every task spec that quotes the same name, character for
+// character after an optional `export `, `async `, `function ` prefix. Two different signatures for one name are
+// rejected, never guessed between. Non-string goal, spec, and acceptance entries are skipped.
+function signatureErrors(plan) {
+  const spans = (s) => (typeof s === "string" ? [...s.matchAll(/`([^`\n]+)`/g)].map((m) => m[1].trim()) : []);
+  const strip = (s) => s.replace(/^export\s+/, "").replace(/^async\s+/, "").replace(/^function\s+/, "").replace(/\s*;\s*$/, "").trim();
+  // A stated signature is a call form that carries a return type (its last `)` is followed by `:`); an untyped call
+  // is an example, never compared.
+  const nameOf = (s) => (/\)\s*:/.test(s.slice(s.lastIndexOf(")"))) ? /^([A-Za-z_$][\w$]*)\(/.exec(s)?.[1] : undefined);
+  const texts = [plan.goal, ...(Array.isArray(plan.acceptance) ? plan.acceptance.map((a) => (a && typeof a === "object" ? a.text : a)) : [])];
+  const stated = new Map(); // name -> signatures (distinct)
+  for (const text of texts) {
+    for (const span of spans(text)) {
+      const sig = strip(span);
+      const name = nameOf(sig);
+      if (!name) continue;
+      if (!stated.has(name)) stated.set(name, []);
+      if (!stated.get(name).includes(sig)) stated.get(name).push(sig);
+    }
+  }
+  const errors = [];
+  for (const [name, sigs] of stated) {
+    if (sigs.length > 1) errors.push(`the goal and acceptance state ${name} two ways, ${sigs.map((s) => `\`${s}\``).join(" and ")}: a stated signature reaches the plan verbatim, so state one`);
+  }
+  if (!Array.isArray(plan.tasks)) return errors;
+  for (const t of plan.tasks) {
+    if (!t || typeof t !== "object") continue;
+    for (const span of spans(t.spec)) {
+      const sig = strip(span);
+      const name = nameOf(sig);
+      const want = name && stated.get(name);
+      if (!want || want.length !== 1 || want[0] === sig) continue;
+      errors.push(`task ${t.id} spec states \`${sig}\` but the plan states \`${want[0]}\`: a stated signature reaches the task spec verbatim`);
+    }
+  }
   return errors;
 }
 

package/node_modules/@dougharness/flow/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougharness/flow",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "private": true,
   "description": "Plan, approve, implement one task per worktree, verify, review: a Workflow-tool template and subagents for Claude Code.",
   "type": "module",

package/node_modules/@dougharness/flow/scripts/autopilot.mjs

@@ -9,25 +9,33 @@
 //   autopilot.mjs stop <id> --reason "<why>"
 //   autopilot.mjs filed <id> --kind <follow-up|user> [--from <card>] --position "<text>"
 //   autopilot.mjs caps [--usd <n>] [--wall <min>] [--context <pct>]
-//   autopilot.mjs pick [--max <n>]            JSON { launch, needsPlan, held, alone }; a held line per held card on stderr
-//   autopilot.mjs queen-args <id> --kind <flow|hand> [--with <id,id,...>]   writes .doug/.state/reports/<id>/queen-args.json and the per-card queen.js beside it, prints both paths (args, then queen.js)
+//   autopilot.mjs pick [--max <n>] [--milestone <id>]            JSON { launch, needsPlan, held, alone }; a held line per held card on stderr
+//   autopilot.mjs queen-args <id> --kind <flow|hand> [--with <id,id,...>] [--research on|off]   writes .doug/.state/reports/<id>/queen-args.json and the per-card queen.js beside it, prints both paths (args, then queen.js)
 //   autopilot.mjs agent-types --kind <flow|hand>   prints the agent types that queen spawns, one per line
 //   autopilot.mjs launched <id> --run <wf_id> --kind <flow|hand> --worktree <abs> --args-file <path>
-//   autopilot.mjs report --run <wf_id> --file <result.json>   saves the queen's report, prints land|resume|ask
-//   autopilot.mjs resumed <id> --run <wf_id>
+//   autopilot.mjs report --run <wf_id> --file <result.json>   saves the queen's report (a hand card's inline researchNote is written to .doug/.state/research/<id>.md so record promotes it), prints land|resume|ask
+//   autopilot.mjs answer <id> --answer "<text>"   records the user's answer to any asking stop in queen-args.json options.answers
+//   autopilot.mjs resumed <id> --run <wf_id>   counts every resume, plain or with the answer, against the single plain resume
+//   autopilot.mjs rerun-alone <id>   records a rerun-alone answer for a gate-timeout stop; refuses while another queen is in flight or after the card's one resume
+//   autopilot.mjs leave <id> --reason "<text>"   records the user's choice to leave a card In flow
 //   autopilot.mjs lock-wait <id> --ms <n>
+//   autopilot.mjs clear   drops an ended or inactive run; a running run is kept
 //   autopilot.mjs end
 // --dir <d> names the project (default cwd). Exit 0 done; 1 no run or unknown card; 2 bad usage.
 import { execFileSync } from "node:child_process";
-import { copyFileSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import { loadModels } from "../lib/models.mjs";
-import { AUTOPILOT_FILE, STEPS, readAutopilot } from "../lib/autopilot-view.mjs";
+import { AUTOPILOT_FILE, STEPS, clearable, readAutopilot } from "../lib/autopilot-view.mjs";
 import { contextThreshold } from "../lib/context.mjs";
 import { classifyNotification, pickCards, queenLabel, renameQueenMeta, workersMax } from "../lib/coordinator.mjs";
 import { nextReadyCards } from "../lib/board.mjs";
+import { SEATS } from "../lib/card-loop.mjs";
 import { planFor, reportPathFor } from "../lib/plan.mjs";
+import { readMemoryConfig, readMemoryStaleDays } from "../lib/embeddings.mjs";
 
 const argv = process.argv.slice(2);
 const opts = {};
@@ -82,10 +90,43 @@ function cardOf(s, cardId) {
   if (!c) fail(`unknown card ${cardId}`);
   return c;
 }
+const IN_FLIGHT = ["running", "done", "landing"];
+const RERUN_ALONE = "Rerun alone: no other queen is in flight now.";
+const othersInFlight = (s, id) => s.cards.filter((x) => x.id !== id && IN_FLIGHT.includes(x.state));
+// The saved stop report and queen-args of a card, for the commands that answer an asking stop.
+function savedStop(id, c) {
+  const reportDir = join(dir, ".doug/.state/reports", id);
+  let rep;
+  try {
+    rep = JSON.parse(readFileSync(join(reportDir, "card-report.json"), "utf8"));
+  } catch (e) {
+    fail(`cannot read the saved report for ${id}: ${e.code || e.message}`);
+  }
+  if (!rep || rep.outcome !== "stopped" || rep.reason === "agent-null" || !SEATS.includes(rep.stoppedAt)) fail(`${id} did not stop on an answerable ask stop`);
+  const argsPath = join(reportDir, "queen-args.json");
+  let qa;
+  try {
+    qa = JSON.parse(readFileSync(argsPath, "utf8"));
+  } catch (e) {
+    fail(`cannot read ${argsPath}: ${e.code || e.message}`);
+  }
+  const stopped = (Array.isArray(rep.history) ? rep.history : []).filter((h) => h && h.result === "stopped").pop();
+  const entry = { seat: rep.stoppedAt, question: rep.detail, answer: "" };
+  if (stopped && Number.isInteger(stopped.round) && stopped.round > 0) entry.round = stopped.round;
+  entry.run = c.runId;
+  return { rep, argsPath, qa, entry };
+}
 const clearStep = (c) => {
   delete c.step;
   delete c.stepStartedAt;
+  delete c.seats;
 };
+// Where the queen run's journal lives: the main session's run dir under the user's Claude dir; "" without a session id.
+function journalPath(run) {
+  const sid = process.env.CLAUDE_CODE_SESSION_ID;
+  if (!sid) return "";
+  return join(homedir(), ".claude", "projects", dir.replace(/[^A-Za-z0-9]/g, "-"), sid, "subagents", "workflows", run, "journal.jsonl");
+}
 
 function boardCard(cardId) {
   try {
@@ -169,6 +210,7 @@ switch (cmd) {
     const c = cardOf(s, id);
     c.step = arg2;
     c.stepStartedAt = new Date().toISOString();
+    c.seats = [...(Array.isArray(c.seats) ? c.seats : []), { step: arg2, startedAt: c.stepStartedAt }];
     save(s);
     say(`${id} ${arg2}`);
     break;
@@ -256,9 +298,14 @@ switch (cmd) {
       const b = boardCard(c.id);
       return b ? shape(b) : { id: c.id, goal: "", track: c.kind === "flow" ? "flow" : "hand" };
     });
-    const ready = nextReadyCards(board, { track: "any", batch: Math.max(1, board.cards.length) })
-      .cards.filter((c) => !flyingIds.has(c.id))
-      .map(shape);
+    if (opts.milestone === "") usage("--milestone needs an id");
+    let picked;
+    try {
+      picked = nextReadyCards(board, { track: "any", batch: Math.max(1, board.cards.length), milestone: opts.milestone });
+    } catch (e) {
+      fail(e instanceof Error ? e.message : String(e));
+    }
+    const ready = picked.cards.filter((c) => !flyingIds.has(c.id)).map(shape);
     const plans = {};
     for (const c of [...ready, ...inFlight]) {
       if (c.track !== "flow") continue;
@@ -280,6 +327,10 @@ switch (cmd) {
     if (!id) usage("queen-args needs a card id");
     const kind = need("kind");
     if (kind !== "flow" && kind !== "hand") usage("--kind must be flow or hand");
+    if (opts.research !== undefined) {
+      if (kind === "flow") usage("--research is for a hand card; research for a flow card runs before its plan (doug-next section 1)");
+      if (opts.research !== "on" && opts.research !== "off") usage("--research must be on or off");
+    }
     let args;
     if (kind === "flow") {
       try {
@@ -296,15 +347,21 @@ switch (cmd) {
       } catch {
         // absent or unreadable: no install command
       }
+      let base = "main";
+      try {
+        base = execFileSync("git", ["-C", dir, "symbolic-ref", "--short", "-q", "HEAD"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || "main";
+      } catch {
+        // not a git repo or a detached HEAD: main
+      }
       args = {
         card: { id: b.id, title: b.title ?? null, size: b.size ?? null, class: b.class ?? null, goal: b.goal ?? "" },
         options: {
           testerAgent: true,
-          research: false,
+          research: opts.research === "on",
           install: (config.commands && config.commands.install) || null,
           gateCommand: "node .doug/hooks/scripts/verify.mjs",
           branch: `card/${id}`,
-          base: "main",
+          base,
         },
         models: loadModels(dir),
         repoRoot: dir,
@@ -370,6 +427,9 @@ switch (cmd) {
     c.kind = kind;
     c.worktree = worktree;
     clearStep(c);
+    delete c.journals;
+    const journal = journalPath(run);
+    if (journal) c.journals = [journal];
     save(s);
     say(`${id} launched as ${run}`);
     break;
@@ -393,6 +453,11 @@ switch (cmd) {
       // unreadable: classify says resume
     }
     const kind = c.kind === "flow" ? "flow" : "hand";
+    // The queen's task-output file wraps the result: {summary, agentCount, logs, result}.
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && parsed.result !== null && typeof parsed.result === "object") {
+      const bare = kind === "flow" ? !("ok" in parsed) && !("paused" in parsed) : !("card" in parsed) && !("outcome" in parsed);
+      if (bare) parsed = parsed.result;
+    }
     if (parsed !== null) {
       const dest = kind === "flow" ? join(dir, reportPathFor(c.id)) : join(dir, ".doug/.state/reports", c.id, "card-report.json");
       try {
@@ -401,11 +466,253 @@ switch (cmd) {
       } catch (e) {
         process.stderr.write(`autopilot: warning: cannot write ${dest}: ${e.code || e.message}\n`);
       }
+      if (kind === "hand") {
+        const rep = parsed.report ?? parsed;
+        const note = rep && typeof rep.researchNote === "string" ? rep.researchNote : "";
+        if (note.trim() !== "") {
+          const noteDest = join(dir, ".doug/.state/research", `${c.id}.md`);
+          try {
+            const oneLine = note.trim();
+            let src = null;
+            if (!oneLine.includes("\n") && oneLine.startsWith("/") && resolve(oneLine) !== resolve(noteDest) && existsSync(oneLine)) src = oneLine;
+            if (resolve(oneLine) !== resolve(noteDest)) {
+              mkdirSync(dirname(noteDest), { recursive: true });
+              if (src) copyFileSync(src, noteDest);
+              else writeFileSync(noteDest, note);
+            }
+          } catch (e) {
+            process.stderr.write(`autopilot: warning: cannot write ${noteDest}: ${e.code || e.message}\n`);
+          }
+        }
+      }
+    }
+    if (kind === "hand" && parsed !== null) {
+      const rep = parsed.report ?? parsed;
+      if (rep && typeof rep === "object" && rep.outcome === "stopped") {
+        try {
+          const mem = await import("../lib/memory.mjs");
+          const written = JSON.stringify(rep, null, 2) + "\n";
+          const readOr = (p) => {
+            try {
+              return readFileSync(p, "utf8");
+            } catch {
+              return "";
+            }
+          };
+          const ids = mem.runAgentIds((Array.isArray(c.journals) ? c.journals : []).map(readOr));
+          const blocks = mem.attributeBlocks(readOr(join(dir, ".doug/.state/blocks.jsonl")), ids);
+          let condition = null;
+          try {
+            const parsedCondition = JSON.parse(readFileSync(join(dir, ".doug/.state/reports", c.id, "condition.json"), "utf8"));
+            if (parsedCondition && typeof parsedCondition === "object" && !Array.isArray(parsedCondition)) condition = parsedCondition;
+          } catch {
+            condition = null;
+          }
+          const row = mem.stopOutcomeRow({
+            card: c.id,
+            report: rep,
+            reportHash: createHash("sha256").update(written).digest("hex"),
+            reportPath: join(dir, ".doug/.state/reports", c.id, "card-report.json"),
+            run,
+            blocks,
+            condition,
+          });
+          const m = mem.openMemory(dir);
+          try {
+            mem.recordOutcomes(m, [row]);
+          } finally {
+            m.close();
+          }
+        } catch (e) {
+          process.stderr.write(`autopilot: warning: cannot record the stop row for ${c.id}: ${e.message || e}\n`);
+        }
+      }
+    }
+    if (kind === "hand" && parsed !== null) {
+      try {
+        const mem = await import("../lib/memory.mjs");
+        const rep = parsed.report ?? parsed;
+        const readOr = (p) => {
+          try {
+            return readFileSync(p, "utf8");
+          } catch {
+            return "";
+          }
+        };
+        const sid = process.env.CLAUDE_CODE_SESSION_ID;
+        const jp = journalPath(run);
+        const journalText = jp ? readOr(jp) : "";
+        let queenArgs = null;
+        try {
+          queenArgs = JSON.parse(readFileSync(join(dir, ".doug/.state/reports", c.id, "queen-args.json"), "utf8"));
+        } catch {
+          // no saved args: no briefs
+        }
+        const seatRuns = mem.journalSeatRuns(journalText);
+        const briefs = mem.replayBriefs(queenArgs, seatRuns);
+        const ids = mem.runAgentIds([journalText]);
+        const blocks = mem.attributeBlocks(readOr(join(dir, ".doug/.state/blocks.jsonl")), ids);
+        const denials = mem.attributeDenials(sid ? readOr(join(dir, ".doug/.state/trace", `${sid.replace(/[^A-Za-z0-9_.-]/g, "_")}.jsonl`)) : "", ids);
+        const scan = await mem.historyScanner(dir);
+        const entries = [{ kind: "report", source: "card-report.json", value: rep }];
+        for (const b of blocks) entries.push({ kind: "block", source: "blocks.jsonl", value: b });
+        for (const d of denials) entries.push({ kind: "denial", source: "trace", value: d });
+        seatRuns.forEach((r, i) => {
+          if (briefs[i] !== null) entries.push({ kind: "brief", seat: r.seat, round: r.round, source: "replay:card-loop.mjs", value: briefs[i] });
+          entries.push({ kind: "hand-back", seat: r.seat, round: r.round, source: "journal.jsonl", value: r.result });
+        });
+        mem.writeRunHistory(dir, { card: c.id, run, entries, scan });
+      } catch (e) {
+        process.stderr.write(`autopilot: warning: cannot write the run history for ${c.id}: ${e.message || e}\n`);
+      }
+    }
+    if (kind === "flow" && parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && parsed.ok === false && !parsed.paused) {
+      try {
+        const mem = await import("../lib/memory.mjs");
+        const readOr = (p) => {
+          try {
+            return readFileSync(p, "utf8");
+          } catch {
+            return "";
+          }
+        };
+        const written = JSON.stringify(parsed, null, 2) + "\n";
+        const ids = mem.runAgentIds((Array.isArray(c.journals) ? c.journals : []).map(readOr));
+        const blocks = mem.attributeBlocks(readOr(join(dir, ".doug/.state/blocks.jsonl")), ids);
+        const levels = Array.isArray(parsed.levels) ? parsed.levels : [];
+        let stopClass = null;
+        let stopReason = null;
+        for (const lv of levels) {
+          const t = (Array.isArray(lv?.tasks) ? lv.tasks : []).find((x) => x && typeof x.stopReason === "string" && x.stopReason.trim() !== "");
+          if (t) {
+            stopClass = t.stopClass ?? null;
+            stopReason = t.stopReason;
+            break;
+          }
+        }
+        if (stopReason === null) {
+          stopReason = "the run stopped";
+          if (parsed.stoppedAtLevel !== undefined && parsed.stoppedAtLevel !== null) {
+            stopReason += ` at level ${parsed.stoppedAtLevel}`;
+            const lv = levels.find((x) => x && x.index === parsed.stoppedAtLevel) ?? levels[parsed.stoppedAtLevel];
+            const why = lv?.integration?.reason;
+            if (typeof why === "string" && why.trim() !== "") stopReason += `: ${why}`;
+          }
+        }
+        const row = {
+          ...mem.stopOutcomeRow({
+            card: c.id,
+            report: { outcome: "stopped", reason: stopClass, detail: stopReason },
+            reportHash: createHash("sha256").update(written).digest("hex"),
+            reportPath: join(dir, reportPathFor(c.id)),
+            run,
+            blocks,
+            memoryConfig: mem.memoryConfig({ embeddings: readMemoryConfig(dir).embeddings, staleDays: readMemoryStaleDays(dir), track: "flow" }),
+          }),
+          track: "flow",
+        };
+        const m = mem.openMemory(dir);
+        try {
+          mem.recordOutcomes(m, [row]);
+        } finally {
+          m.close();
+        }
+      } catch (e) {
+        process.stderr.write(`autopilot: warning: cannot record the stop row for ${c.id}: ${e.message || e}\n`);
+      }
+    }
+    if (kind === "flow" && parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) && (parsed.ok === true || parsed.ok === false) && !parsed.paused) {
+      try {
+        const mem = await import("../lib/memory.mjs");
+        const readOr = (p) => {
+          try {
+            return readFileSync(p, "utf8");
+          } catch {
+            return "";
+          }
+        };
+        const sid = process.env.CLAUDE_CODE_SESSION_ID;
+        const jp = journalPath(run);
+        const ids = mem.runAgentIds([jp ? readOr(jp) : ""]);
+        const blocks = mem.attributeBlocks(readOr(join(dir, ".doug/.state/blocks.jsonl")), ids);
+        const denials = mem.attributeDenials(sid ? readOr(join(dir, ".doug/.state/trace", `${sid.replace(/[^A-Za-z0-9_.-]/g, "_")}.jsonl`)) : "", ids);
+        const scan = await mem.historyScanner(dir);
+        const entries = [{ kind: "report", source: "last-report.json", value: parsed }];
+        for (const b of blocks) entries.push({ kind: "block", source: "blocks.jsonl", value: b });
+        for (const d of denials) entries.push({ kind: "denial", source: "trace", value: d });
+        mem.writeRunHistory(dir, { card: c.id, run, entries, scan });
+      } catch (e) {
+        process.stderr.write(`autopilot: warning: cannot write the run history for ${c.id}: ${e.message || e}\n`);
+      }
     }
     const v = classifyNotification(kind, { status: "completed", result: parsed === null ? text : parsed });
+    if (v.action === "ask") {
+      let answered = false;
+      try {
+        const saved = JSON.parse(readFileSync(join(dir, ".doug/.state/reports", c.id, "queen-args.json"), "utf8"));
+        const rep = parsed?.report ?? parsed;
+        const stop = (Array.isArray(rep?.history) ? rep.history : []).filter((h) => h && h.result === "stopped").pop();
+        answered =
+          Array.isArray(saved?.options?.answers) &&
+          saved.options.answers.some(
+            (a) => a && a.run === run && a.seat === rep?.stoppedAt && stop && a.round === stop.round && a.question === rep?.detail,
+          );
+      } catch {
+        // no readable args: not answered
+      }
+      if (answered) {
+        say(`${c.id} resume with the answer`);
+        break;
+      }
+    }
+    if (v.action === "ask" && v.reason === "gate-timeout" && !c.resumes && othersInFlight(s, c.id).length > 0) {
+      c.state = "stopped";
+      c.reason = "gate-timeout: rerun alone pending";
+      save(s);
+      say(`${c.id} rerun alone gate-timeout`);
+      break;
+    }
     say(`${c.id} ${v.action}${v.reason ? ` ${v.reason}` : ""}`);
     break;
   }
+  case "answer": {
+    if (!id) usage("answer needs a card id");
+    const answer = need("answer");
+    if (answer.trim() === "") usage("--answer needs a non-blank answer");
+    const s = load();
+    const c = cardOf(s, id);
+    const { rep, argsPath, qa, entry } = savedStop(id, c);
+    entry.answer = answer;
+    qa.options = { ...(qa.options || {}), answers: [...(Array.isArray(qa.options?.answers) ? qa.options.answers : []), entry] };
+    writeFileSync(argsPath, JSON.stringify(qa, null, 2) + "\n");
+    say(`${id} answer recorded for ${entry.seat}`);
+    break;
+  }
+  case "rerun-alone": {
+    if (!id) usage("rerun-alone needs a card id");
+    const s = load();
+    const c = cardOf(s, id);
+    const others = othersInFlight(s, id);
+    if (others.length > 0) fail(`${others.map((x) => x.id).join(", ")} still in flight; rerun ${id} alone after it lands`);
+    if (c.resumes >= 1) fail(`${id} was already resumed once`);
+    const { rep, argsPath, qa, entry } = savedStop(id, c);
+    entry.answer = RERUN_ALONE;
+    qa.options = { ...(qa.options || {}), answers: [...(Array.isArray(qa.options?.answers) ? qa.options.answers : []), entry] };
+    writeFileSync(argsPath, JSON.stringify(qa, null, 2) + "\n");
+    say(`${id} rerun alone recorded for ${rep.stoppedAt}`);
+    break;
+  }
+  case "leave": {
+    if (!id) usage("leave needs a card id");
+    const reason = need("reason");
+    if (reason.trim() === "") usage("--reason needs a non-blank reason");
+    const s = load();
+    const c = cardOf(s, id);
+    c.left = reason;
+    save(s);
+    say(`${id} left In flow: ${reason}`);
+    break;
+  }
   case "resumed": {
     if (!id) usage("resumed needs a card id");
     const run = need("run");
@@ -413,6 +720,9 @@ switch (cmd) {
     const c = cardOf(s, id);
     c.resumes = (c.resumes || 0) + 1;
     c.runId = run;
+    c.state = "running";
+    const journal = journalPath(run);
+    if (journal) c.journals = [...(Array.isArray(c.journals) ? c.journals : []), journal];
     save(s);
     say(`${id} resumed as ${run}`);
     break;
@@ -427,8 +737,40 @@ switch (cmd) {
     say(`${id} lock wait ${c.lockWaitMs}ms`);
     break;
   }
+  case "clear": {
+    if (!existsSync(file)) say("nothing to clear");
+    else {
+      const s = readAutopilot(dir);
+      if (!s) say("kept the unreadable file");
+      else if (clearable(s, new Date())) {
+        rmSync(file);
+        say("cleared");
+      } else say("kept the running run");
+    }
+    break;
+  }
   case "end": {
     const s = load();
+    if (s.cards.length > 0) {
+      let board;
+      try {
+        board = JSON.parse(readFileSync(join(dir, ".doug/board.json"), "utf8"));
+      } catch (e) {
+        fail(`cannot read the board to check cards In flow: ${e.code || e.message}`);
+      }
+      const stuck = s.cards.filter((c) => {
+        if ((board.cards || []).find((b) => b.id === c.id)?.column !== "flow") return false;
+        if (c.resumes >= 1 || (typeof c.left === "string" && c.left.trim() !== "")) return false;
+        let answers = [];
+        try {
+          answers = JSON.parse(readFileSync(join(dir, ".doug/.state/reports", c.id, "queen-args.json"), "utf8")).options.answers;
+        } catch {
+          // no readable args: not answered
+        }
+        return !(Array.isArray(answers) && answers.some((a) => a && a.run === c.runId && a.answer !== RERUN_ALONE));
+      });
+      if (stuck.length > 0) fail(`cannot end: ${stuck.map((c) => c.id).join(", ")} still In flow, neither resumed nor answered`);
+    }
     s.status = "ended";
     s.endedAt = new Date().toISOString();
     save(s);
@@ -436,5 +778,5 @@ switch (cmd) {
     break;
   }
   default:
-    usage(`unknown subcommand${cmd ? ` ${cmd}` : ""}; use start, add, card, step, land, stop, filed, caps, pick, launched, report, resumed, lock-wait, or end`);
+    usage(`unknown subcommand${cmd ? ` ${cmd}` : ""}; use start, add, card, step, land, stop, filed, caps, pick, launched, report, answer, rerun-alone, leave, resumed, lock-wait, clear, or end`);
 }