@warren-dean/code-kit 0.13.0 → 0.14.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
       "name": "code-kit",
       "source": "./",
       "description": "Keeps AI coding agents inside your project's rules, from idea to merged code: spec design, lanes, layer rules, protected paths with an approval log, spec-check and design gates, proof-before-finish checks, dispatch, review, build status and CI verification, configured per project from its docs",
-      "version": "0.13.0",
+      "version": "0.14.0",
       "category": "development",
       "tags": ["guardrails", "architecture", "lanes", "layers", "spec-driven", "ci", "multi-agent"],
       "license": "MIT"

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "code-kit",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Keeps AI coding agents inside your project's rules, from idea to merged code: spec design, lanes, layer rules, protected paths with an approval log, spec-check and design gates, proof-before-finish checks, dispatch, review, build status and CI verification, configured per project from its docs",
   "author": {
     "name": "Warren Langeveldt"

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 What changed in each release of code-kit, newest first. Versions follow the plugin manifest and the npm package `@warren-dean/code-kit`. Each release is also on [GitHub Releases](https://github.com/warrendeanlangeveldt/code-kit/releases).
 
+## 0.14.0 (2026-10-16)
+
+The lead loop stays in one session, listens to the lead before prompting it again, and asks your choices in Claude Code's own question dialog.
+
+- Only one session in a project runs the loop. Opening a second session there, for anything else, used to have code-kit prompt that session's lead too. The first session whose loop acts now holds a lead lease in `.claude/state/loop.json` and renews it while it runs. Any other session leaves its lead alone, and its band says "the loop runs in another session" with Lead from here to move the loop over. A new session also no longer clears a pause the running session made. `code-kit loop lead` and `code-kit loop release` record the lease, and the hooks refuse both to agents.
+- The loop reads the lead's last reply before prompting again, with a side call over the lead's own conversation. When the reply waits on you (a question, a design to look at, an approval), or you stopped the lead's turn, nothing more is prompted until you answer or speak to the lead. The band says what the lead is waiting on, and its question is asked in Claude Code's dialog with the answers it offered. A step the lead didn't take waits in the band with the lead's reason and Ask again. Before, the loop kept re-sending the same step and then asked you whether to ask again, without knowing what the lead had said.
+- A design story is handed to the lead once a session. While you and the lead design it, the loop leaves it to you instead of prompting the design step again each time a screen is approved.
+- Choices are asked in Claude Code's own question dialog while the lead is idle: how hands-off the loop is, a step under `propose`, a repeated or blocked step, a stalled lane, a stale claim, and a question from the lead with answers to pick from. Each is asked once; dismissed, it stays in the band and the Decisions tab. Approvals, send-backs and settings, which need your reason, stay in the pane.
+- The card for a step still next after two prompts now says why it's yours (the lead was asked twice and something stopped it), where it used to say you'd asked to approve each step.
+
 ## 0.13.0 (2026-10-14)
 
 A fix proves its bug, tests can't be weakened without you, and a passing `verify` says exactly what it covered.

package/README.md

@@ -331,8 +331,12 @@ Each button has a digit: type it in an empty prompt to press it. The band keeps
 The loop keeps the build moving between your prompts, under `harness.autonomy`. `/code-kit:init` asks you how hands-off you want it. Until you've chosen, its first step waits in the band ("code-kit can keep the build moving between your prompts") with **Keep going**, **Ask each time** and **Off**, and your answer is recorded as your setting.
 
 - **Each step.** Once the lead has finished a turn, with the lead idle and nothing typed in the prompt, the loop asks `code-kit next` and prompts the lead to dispatch the ready stories, review a finished one, or build its own. It never prompts the same step twice while nothing has changed, and never a story an agent is still on: one its lane agent is building, or a reviewer is reviewing, waits until that agent finishes ("waiting: ST-10 is still with its agent").
-- **A step that doesn't move.** One the lead was prompted with twice in a row that is still next goes to you instead: "Merge lead/st-1: still next after 2 prompts. Ask the lead again?" with **Go**.
-- **Modes.** **Pause** and **Resume** stop and start it. Under `propose`, each step waits in the band for **Go**; under `off`, the loop does nothing. When every story is done, the band says so and the loop stops.
+- **It reads the lead's reply first.** Before prompting again, the loop reads the lead's last reply with a side call over the lead's own conversation. A reply that waits on you (a question, a design to look at, an approval), or a turn you stopped, holds the loop until you answer or speak to the lead: the band says what the lead waits on, and its question is asked in Claude Code's own question dialog. A step the lead didn't take waits in the band with its reason and **Ask again**.
+- **A step that doesn't move.** One the lead was prompted with twice in a row that is still next goes to you instead: "Merge lead/st-1: still next after 2 prompts. Ask the lead again?" with **Ask again**.
+- **Designs.** A design story is handed to the lead once a session; while you and the lead design it, the loop leaves it to you.
+- **One session runs it.** The first session whose loop acts runs it for the project. Another session you open there, for any reason, never prompts its lead: its band reads "the loop runs in another session", with **Lead from here** to move the loop to it.
+- **Modes.** **Pause** and **Resume** stop and start it. Under `propose`, each step waits for **Go**; under `off`, the loop does nothing. When every story is done, the band says so and the loop stops.
+- **Choices in Claude Code's dialog.** A decision you settle by choosing (how hands-off the loop is, a step to take, a stalled lane, a stale claim, a question from the lead with answers offered) is asked in Claude Code's own question dialog while the lead is idle, once; dismissed, it stays in the band and the Decisions tab. Approvals, send-backs and settings, which need your reason, stay in the pane.
 - **Stalled lanes.** A lane agent with no tool call for `harness.stall.nudgeMinutes` (5) is messaged, unless its work is done (it handed back, or its branch is in review or the merge queue). At `stall.restartMinutes` (10) the lead is asked to stop it and dispatch its story again, at most `stall.maxRestarts` (2) times, and then the band flags the lane.
 - **The reviewer agent**, with `harness.agents.reviewer.on`. A finished branch is first reviewed in the background by code-kit's reviewer agent, which the lead starts: it runs `verify` and the review checklist, read-only, and grades each finding blocker, concern or nit. The lead's review prompt then carries the findings, and a blocker means the branch is sent back. The pane shows each review, running with its clock or what it found. If the reviewer hasn't reported within 15 minutes, or the plan's 5-hour use is past `harness.background.pauseAtPercent`, the lead reviews without it.
 - **The merge queue** (`code-kit queue`). A branch the lead's review passes joins the queue. Branches merge one at a time, in the order they passed, each verified against the base as it is then: the lead merges where `approvals.delegate.merge` is on under `autonomous`, otherwise the band shows the head with **Merge** for you. Who may merge is read from the config committed on the base, so a branch can't grant itself merges. The queue records the commit each review passed, and merges exactly that commit: a branch that moves on after its review leaves the queue (`moved`) for the lead to review it again. A head that conflicts or fails verify goes back to its lane. A merged lane's worktree is removed when it holds nothing uncommitted. The pane lists the queue, and lanes whose branch waits in it read `queued`.
@@ -442,6 +446,7 @@ code-kit queue rules                                          # the lead puts th
 code-kit queue merge --delegated|--person                     # merge the head at the commit its review passed, verified against the base as it is now; a conflict or failed verify sends it back to its lane, and a branch that moved since its review leaves the queue to be reviewed again
 code-kit loop [--json]                                        # whether the person paused the lead loop; other tools' background work pauses with it
 code-kit loop pause|resume                                    # the person's act, as Pause and Resume in the band
+code-kit loop lead|release --session <id> [--take]            # which session runs the loop: the mod's, and Lead from here in the band
 code-kit story <id> [--json]                                  # one story's requirements, spec-check report, diff against the base and verify (without checks), for the drill-down
 code-kit timeline [--json]                                    # when each story's work happened: its branch made, last commit, merge, send-backs and approvals
 code-kit journal [--json]                                     # the build's lineage: the request, its decisions, the spec, each story handed out, sent back and merged, each approval and who gave it

package/bin/code-kit.mjs

@@ -79,7 +79,7 @@ import { PROJECT, projectMap, storyMap, trail } from '../hooks/lib/storymap.mjs'
 import { journal } from '../hooks/lib/journal.mjs';
 import { dequeue, enqueue, lastMerged, readQueue, settle, waiting } from '../hooks/lib/queue.mjs';
 import { SETTINGS, parseSetting, settingOf, withSetting } from '../hooks/lib/harness.mjs';
-import { readLoop, writeLoop } from '../hooks/lib/loop-state.mjs';
+import { claimLead, readLoop, releaseLead, writeLoop } from '../hooks/lib/loop-state.mjs';
 import {
   claimChanges,
   storyOfBranch,
@@ -162,6 +162,7 @@ const FLAGS = [
   '--peek',
   '--off',
   '--blocks',
+  '--take',
 ];
 const flag = (name) => args.includes(name);
 const writeBaseline = flag('--write');
@@ -1814,6 +1815,8 @@ function reportCommand() {
 /**
  * The lead loop's pause (LOOP-6): `loop` says whether the person paused it; `loop pause|resume`, the
  * person's act from the code-kit band, records it, so other tools' background work pauses with it.
+ * LOOP-10: `loop lead` takes or renews the lease of the one session that runs the loop, and `loop
+ * release` gives it up; the mod runs both, and the hooks refuse all four to agents.
  */
 function loopCommand() {
   const root = resolve('.');
@@ -1822,14 +1825,31 @@ function loopCommand() {
     writeLoop(root, sub === 'pause');
     return out(sub === 'pause' ? 'The lead loop is paused.' : 'The lead loop is running.');
   }
-  if (sub !== undefined) die('code-kit loop [--json] | loop pause | loop resume');
+  // LOOP-10: one session in the project runs the loop; the mod takes and renews the lease.
+  if (sub === 'lead' || sub === 'release') {
+    if (!sessionId) die(`code-kit loop ${sub} needs the session: --session <id>.`);
+    if (sub === 'release')
+      return out(
+        releaseLead(root, sessionId)
+          ? 'This session no longer runs the lead loop.'
+          : "This session wasn't running the lead loop.",
+      );
+    const r = claimLead(root, sessionId, { take: flag('--take') });
+    if (!r.ok)
+      die(
+        `Another session (${r.lead.session}, renewed ${r.lead.at}) runs the lead loop in this project. Leave it there, or take it over with --take.`,
+      );
+    return out('This session runs the lead loop.');
+  }
+  if (sub !== undefined)
+    die(
+      'code-kit loop [--json] | loop pause | loop resume | loop lead --session <id> [--take] | loop release --session <id>',
+    );
   const state = readLoop(root);
   out(
     flag('--json')
       ? JSON.stringify(state)
-      : state.paused
-        ? `The lead loop is paused (since ${state.at}).`
-        : 'The lead loop is running.',
+      : `${state.paused ? `The lead loop is paused (since ${state.at}).` : 'The lead loop is running.'}${state.lead ? ` Session ${state.lead.session} runs it.` : ''}`,
   );
 }
 
@@ -1881,7 +1901,7 @@ function usage() {
       '              | settings [--json] | settings set <key> <value> --reason "…" [--via pane]\n' +
       '              | hold <id> [--minutes N] | hold <id> --answer approved|refused\n' +
       '              | queue [--json] | queue add|drop <branch> | queue rules | queue merge --delegated|--person\n' +
-      '              | loop [--json] | loop pause|resume\n' +
+      '              | loop [--json] | loop pause|resume | loop lead|release --session id [--take]\n' +
       '              | map <story>|project [--json] | trail [--json] | journal [--json]\n' +
       '              | story <id> [--json] | timeline [--json]\n' +
       '              | team [--json] [--fresh] | team since [--json] [--peek]\n' +

package/hooks/guard-bash.mjs

@@ -186,6 +186,11 @@ if (runs(cmd, new RegExp(String.raw`^${CODE_KIT}\s+loop\s+(pause|resume)\b`)))
   block(
     `Blocked: pausing or resuming the lead loop is the person's own act, from the code-kit band or their terminal. Ask them, and stop.\nCommand: ${cmd}`,
   );
+// LOOP-10: which session runs the loop is the mod's to record, and moving it the person's.
+if (runs(cmd, new RegExp(String.raw`^${CODE_KIT}\s+loop\s+(lead|release)\b`)))
+  block(
+    `Blocked: which session runs the lead loop is recorded by the code-kit band, and moving it is the person's own act (Lead from here, in the band). Carry on with your work.\nCommand: ${cmd}`,
+  );
 // TEAM-9: handing someone's claim to someone else is the tech lead's own decision too.
 if (runs(cmd, new RegExp(String.raw`^${CODE_KIT}\s+team\s+reassign\b`)))
   block(

package/hooks/lib/loop-state.mjs

@@ -1,26 +1,66 @@
-// Whether the person has paused the lead loop (spec 05, LOOP-6), kept beside the merge queue so other
-// tools sharing the project can hold their own background work while it's paused. The mod records it
-// through the CLI; a session that starts begins unpaused.
+// The lead loop's state, kept beside the merge queue (spec 05): whether the person has paused it
+// (LOOP-6), so other tools sharing the project can hold their own background work while it's paused;
+// and which session runs it (LOOP-10), so a second session opened in the project never prompts its
+// lead too. The mod records both through the CLI.
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { projectWorktrees } from './rules.mjs';
 
 export const LOOP_FILE = '.claude/state/loop.json';
+/** LOOP-10: a lead session renews its lease well within this; one not renewed for this long has ended. */
+export const LEAD_LEASE_MS = 90000;
 
 const loopFile = (root) => join(projectWorktrees(root)[0] ?? root, LOOP_FILE);
 
-/** { paused, at }: not paused when nothing was recorded. */
-export function readLoop(root) {
+function readRaw(root) {
   try {
     const state = JSON.parse(readFileSync(loopFile(root), 'utf8'));
-    return { paused: state?.paused === true, at: state?.at ?? null };
+    return state && typeof state === 'object' ? state : {};
   } catch {
-    return { paused: false, at: null };
+    return {};
   }
 }
 
-export function writeLoop(root, paused, now = Date.now()) {
+function writeRaw(root, state) {
   const file = loopFile(root);
   mkdirSync(dirname(file), { recursive: true });
-  writeFileSync(file, `${JSON.stringify({ paused, at: new Date(now).toISOString() })}\n`);
+  writeFileSync(file, `${JSON.stringify(state)}\n`);
+}
+
+/** The session holding the lead lease, while it holds it: { session, at }, or null. */
+const liveLead = (state, now) => {
+  const lead = state.lead;
+  if (!lead?.session || !lead.at) return null;
+  return now - Date.parse(lead.at) < LEAD_LEASE_MS ? { session: lead.session, at: lead.at } : null;
+};
+
+/** { paused, at, lead }: not paused when nothing was recorded; `lead` is the live lead session or null. */
+export function readLoop(root, now = Date.now()) {
+  const state = readRaw(root);
+  return { paused: state.paused === true, at: state.at ?? null, lead: liveLead(state, now) };
+}
+
+export function writeLoop(root, paused, now = Date.now()) {
+  writeRaw(root, { ...readRaw(root), paused, at: new Date(now).toISOString() });
+}
+
+/**
+ * LOOP-10: `session` takes or renews the lead lease. Another live session keeps it unless `take` (the
+ * person moved the loop here): { ok: true } or { ok: false, lead } naming the session that has it.
+ */
+export function claimLead(root, session, { take = false } = {}, now = Date.now()) {
+  const state = readRaw(root);
+  const lead = liveLead(state, now);
+  if (lead && lead.session !== session && !take) return { ok: false, lead };
+  writeRaw(root, { ...state, lead: { session, at: new Date(now).toISOString() } });
+  return { ok: true, lead: null };
+}
+
+/** LOOP-10: the lead session ends: its lease goes, so the next session to act takes the loop at once. */
+export function releaseLead(root, session) {
+  const state = readRaw(root);
+  if (state.lead?.session !== session) return false;
+  const { lead: _lead, ...rest } = state;
+  writeRaw(root, rest);
+  return true;
 }

package/hooks/mod/decisions.mjs

@@ -22,6 +22,7 @@ export const DECISION_KINDS = new Set([
   'brief',
   'denied',
   'report',
+  'waiting',
 ]);
 
 /** What each answer does, in the person's words. */
@@ -54,6 +55,10 @@ const EFFECT = {
     'Puts it in your prompt after !, so you run it yourself; press Enter to run it, then Done it.',
   deniedDone: 'The lead is told you ran it, or allowed it, and carries on.',
   deniedNo: "The lead is told you won't run it now, and carries on with other work.",
+  answerLead: 'The lead is told your answer and carries on.',
+  answerLeadText: 'Type your answer; the lead is told it and carries on.',
+  askAgain: 'The lead is asked to take this step again now.',
+  carryOn: 'The loop goes on with whatever is next.',
   sendReport:
     "Files it on code-kit's GitHub under your account (a comment instead, if it's filed already).",
   discardReport: "It's not sent, and goes.",
@@ -133,6 +138,18 @@ function optionsOf(line) {
       { id: 'sendReport', label: 'Send' },
       { id: 'discardReport', label: 'Discard' },
     ];
+  // LOOP-11: what the lead waits on, read from its reply: its answers, or the person's own words.
+  if (line.kind === 'waiting' && line.waiting.kind === 'person' && line.waiting.question)
+    return [
+      ...line.waiting.options.map((o, i) => ({
+        id: `answerLead-${i}`,
+        act: 'answerLead',
+        label: o.label,
+        effect: o.effect,
+        line: { ...line, choice: o.label },
+      })),
+      { id: 'answerLeadText', label: line.waiting.options.length ? 'Something else…' : 'Answer…' },
+    ];
   return line.actions;
 }
 
@@ -149,6 +166,7 @@ const TAG = {
   brief: 'your brief',
   denied: 'refused',
   report: 'bug report',
+  waiting: 'the lead',
 };
 
 /** At most `n` characters on one line, cut with an ellipsis. */
@@ -200,6 +218,8 @@ function headlineOf(line, story) {
     };
   if (line.kind === 'report')
     return { headline: line.report.title, sub: "drafted by an agent, for code-kit's GitHub" };
+  if (line.kind === 'waiting' && line.waiting.question)
+    return { headline: line.waiting.question, sub: 'from the lead, which waits on it' };
   return { headline: line.text, sub: story ? `${story.id} ${story.title ?? ''}` : '' };
 }
 
@@ -245,6 +265,12 @@ function whyOf(line, check) {
     return `It's an open question in ${line.brief.path}, left for you: what gets built depends on your answer. Not sure what it means? Ask about it when you answer.`;
   if (line.kind === 'denied')
     return `Claude Code's own permission check refused it${line.denial.reason ? ` (${line.denial.reason})` : ''}, which code-kit can't approve past: only you can run it or allow it.`;
+  if (line.kind === 'waiting' && line.waiting.kind === 'person')
+    return "The lead's last reply waits on you, so the loop doesn't prompt it again until you answer, here or in the chat.";
+  if (line.kind === 'waiting' && line.waiting.kind === 'stopped')
+    return 'You stopped the lead mid-turn, so the loop leaves the lead to you until you say.';
+  if (line.kind === 'waiting' && line.waiting.kind === 'blocked')
+    return "The lead was asked to take this step and didn't, so the loop won't ask again until you say.";
   if (line.kind === 'report')
     return "code-kit got in an agent's way. It's sent under your GitHub account to a public repository, so read what it says first.";
   return null;
@@ -363,6 +389,7 @@ export function decisionCards(lines, context = {}) {
             : null) ??
           (line.pull ? `Pull request #${line.pull.number} on ${line.pull.branch}` : null) ??
           (line.question?.blocks ? `${line.question.story} waits on your answer.` : null) ??
+          (line.waiting?.label ? `The loop's last step: ${line.waiting.label}` : null) ??
           (line.denial ? clip(line.denial.command ?? line.denial.what, 400) : null) ??
           (line.report ? line.report.body : null),
         settled,
@@ -381,3 +408,51 @@ export function contextOf(card) {
   const reqs = card.requirements.map((r) => r.id).join(', ');
   return `for ${card.story.id} ${card.story.title}${reqs ? ` (${reqs})` : ''}`;
 }
+
+/** DECIDE-4: the kinds of decision settled with a choice, asked in Claude Code's own question dialog. */
+export const NATIVE_KINDS = new Set(['proposal', 'stalled', 'teamStale', 'question', 'waiting']);
+
+/** One sentence ended as a question asks. */
+const asked = (text, question) => `${String(text).replace(/[.\s]+$/, '')}. ${question}`;
+
+/**
+ * DECIDE-4: a decision card as Claude Code's question dialog asks it: { key, question, header, options:
+ * [{ label, act, line }], typed }, or null for one that needs the pane (a reason to give, an answer to
+ * type with no choices offered). An option without `act` leaves the decision where it is; `typed` names
+ * the act that takes the person's own words, typed under the dialog's Other.
+ */
+export function nativeChoice(card) {
+  if (!NATIVE_KINDS.has(card.kind)) return null;
+  const line = card.line;
+  const w = line.waiting;
+  // What the person stopped, or a reply waiting on them with no question in it, is theirs to pick up
+  // in the chat: no dialog over what they're about to type.
+  if (card.kind === 'waiting' && !(w?.kind === 'person' && w.question) && w?.kind !== 'blocked')
+    return null;
+  const options = card.options
+    .filter((o) => !o.label.endsWith('…'))
+    .slice(0, 4)
+    .map((o) => ({ label: o.label, act: o.act ?? o.id, line: o.line ?? line }));
+  if (!options.length) return null;
+  if (options.length === 1) options.push({ label: 'Not now', act: null, line });
+  const question =
+    card.kind === 'proposal' && line.proposal?.first
+      ? asked(line.text, 'How much should it do on its own?')
+      : card.kind === 'proposal' && line.proposal?.repeated
+        ? `${card.why} ${line.text}`
+        : card.kind === 'stalled'
+          ? asked(`${line.text}. ${card.why}`, 'Restart it?')
+          : card.kind === 'teamStale'
+            ? asked(line.text, 'Keep your claim?')
+            : card.kind === 'waiting' && w.kind === 'blocked'
+              ? asked(line.text, 'Ask the lead again?')
+              : card.headline;
+  return {
+    key: `${card.kind}:${card.headline}:${options.map((o) => o.label).join('|')}`,
+    question: /\?$/.test(question) ? question : `${question}?`,
+    header: card.tag.slice(0, 12),
+    options,
+    typed:
+      card.kind === 'question' ? 'answerTyped' : card.kind === 'waiting' ? 'answerLeadTyped' : null,
+  };
+}

package/hooks/mod/loop.mjs

@@ -148,3 +148,77 @@ export function restartPrompt({ type, id, story, minutes }) {
 /** The message a quiet agent gets (LOOP-3). */
 export const nudgeText = (minutes) =>
   `No tool call for ${minutes} minutes: report where you are, or carry on.`;
+
+/** LOOP-11: what a lead turn left the build at, as the loop reads the lead's reply. */
+export const OUTCOMES = new Set(['done', 'started', 'needs-person', 'blocked']);
+const ANSWER_SHOWN = 4000;
+
+/**
+ * LOOP-11: the side call that reads the lead's last reply before the loop prompts it again: over the
+ * lead's own conversation (so it knows the whole exchange), with the reply itself for a call that
+ * can't fork. `prompt` is the loop's own prompt for that turn, or null when the person started it.
+ */
+export function outcomePrompt({ prompt = null, answer = '' }) {
+  const reply = String(answer ?? '').trim();
+  const shown =
+    reply.length > ANSWER_SHOWN ? `${reply.slice(0, ANSWER_SHOWN)}\n[… cut short]` : reply;
+  return [
+    prompt
+      ? `code-kit's lead loop prompted you: "${prompt}"`
+      : "The person prompted you, and code-kit's lead loop is about to prompt you with the build's next step.",
+    `Your reply ended your turn. It read:\n"""\n${shown}\n"""`,
+    'Say where that reply left things, so the loop knows whether to prompt you again. Answer with one JSON object and nothing else:',
+    '{"outcome": "done" | "started" | "needs-person" | "blocked", "question": "…", "options": [{"label": "…", "effect": "…"}], "reason": "…"}',
+    '- done: you finished what was asked, or there was nothing to do.',
+    '- started: you started work that carries on without you, such as lane agents.',
+    "- needs-person: you asked the person something, or wait on their answer, approval or feedback before you go on. question: what you wait on, as one question; options: 2 to 4 answers they could give (a label of at most five words, and what it does), or [] when it's theirs to put in words.",
+    "- blocked: you didn't take the step, for a reason no answer from the person settles now. reason: why, in a sentence.",
+  ].join('\n');
+}
+
+/**
+ * LOOP-11: the side call's answer: { outcome, question, options: [{ label, effect }], reason }, or
+ * null when it isn't one (the loop then goes on as before).
+ */
+export function readOutcome(text) {
+  const raw = String(text ?? '');
+  const json = raw.slice(raw.indexOf('{'), raw.lastIndexOf('}') + 1);
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    return null;
+  }
+  if (!parsed || !OUTCOMES.has(parsed.outcome)) return null;
+  const words = (s, n) =>
+    typeof s === 'string' && s.trim() ? s.replace(/\s+/g, ' ').trim().slice(0, n) : null;
+  const options = (Array.isArray(parsed.options) ? parsed.options : [])
+    .map((o) => ({ label: words(o?.label, 40), effect: words(o?.effect, 200) }))
+    .filter((o) => o.label)
+    .slice(0, 4);
+  return {
+    outcome: parsed.outcome,
+    question: words(parsed.question, 400),
+    options: options.length >= 2 ? options : [],
+    reason: words(parsed.reason, 300),
+  };
+}
+
+/**
+ * LOOP-12: a design is made with the person, so the loop hands a design story to the lead once; while
+ * the stories `next` names have all been handed over, it leaves them to the person and the lead.
+ */
+export const designHandedOver = (step, handed) =>
+  step?.step === 'design' &&
+  (step.args ?? '')
+    .split(/\s+/)
+    .filter(Boolean)
+    .every((id) => handed.has(id));
+
+/** LOOP-11: the lead's prompt with the person's answer to what it waited on. */
+export const answeredPrompt = (question, answer) => {
+  const said = /[.!?]$/.test(answer) ? answer : `${answer}.`;
+  return question
+    ? `The person answered what you asked ("${question}"): ${said} Carry on with it.`
+    : `The person says: ${said} Carry on with it.`;
+};

package/hooks/mod/mission.mjs

@@ -50,7 +50,7 @@ export function missionLines({
 }) {
   if (state?.kind !== 'ok') return [];
   const working = state.lanes.filter((l) => l.name !== 'lead' && l.active && live[l.name]);
-  const loopOn = Boolean(loop?.started) && !['off', 'stopped'].includes(loop?.state);
+  const loopOn = Boolean(loop?.started) && !['off', 'stopped', 'elsewhere'].includes(loop?.state);
   if (!leadBusy && !working.length && !loopOn) return [];
   const rows = [];
   const goal = goalOf(state.stories);
@@ -64,25 +64,29 @@ export function missionLines({
     ? `lead ${live.lead?.tool ? `at work: ${live.lead.tool}` : 'at work'}`
     : 'lead idle';
   const loopWord =
-    loop?.state === 'paused'
-      ? 'loop paused'
-      : loop?.state === 'off'
-        ? 'loop off'
-        : loop?.state === 'done'
-          ? 'milestone done'
-          : loopOn
-            ? `loop ${loop.autonomy === 'propose' ? 'proposing' : 'on'}${loop.last ? ` · last: ${loop.last}` : ''}`
-            : null;
+    loop?.state === 'elsewhere'
+      ? 'loop in another session'
+      : loop?.state === 'paused'
+        ? 'loop paused'
+        : loop?.state === 'off'
+          ? 'loop off'
+          : loop?.state === 'done'
+            ? 'milestone done'
+            : loopOn
+              ? `loop ${loop.autonomy === 'propose' ? 'proposing' : 'on'}${loop.last ? ` · last: ${loop.last}` : ''}`
+              : null;
   rows.push({
     kind: 'now',
     label: 'now',
     text: [lead, loopWord].filter(Boolean).join(' · '),
     actions:
-      loop?.state === 'paused'
-        ? [{ id: 'resume', label: 'Resume' }]
-        : loopOn && loop?.state === 'running'
-          ? [{ id: 'pause', label: 'Pause' }]
-          : [],
+      loop?.state === 'elsewhere'
+        ? [{ id: 'leadHere', label: 'Lead from here' }]
+        : loop?.state === 'paused'
+          ? [{ id: 'resume', label: 'Resume' }]
+          : loopOn && loop?.state === 'running'
+            ? [{ id: 'pause', label: 'Pause' }]
+            : [],
   });
   const next = nextText(nextStep);
   if (next && loop?.state !== 'done') rows.push({ kind: 'next', label: 'next', text: next });