@warren-dean/code-kit 0.15.1 → 0.16.1

package/hooks/mod/loop.mjs

@@ -4,6 +4,7 @@
 
 /** The steps the loop hands the lead; the rest (spec-design, init, check) wait for the person. */
 const LEAD_STEPS = new Set([
+  'decide',
   'dispatch',
   'review',
   'lead',
@@ -39,8 +40,8 @@ export function storiesInFlight(agents) {
  * gives way to the next one `next` listed; with nothing left, the loop waits, saying for what, until an
  * agent finishes (which moves the project on).
  */
-export function withoutInFlight(step, inFlight) {
-  if (!step || !inFlight?.size) return step;
+export function withoutInFlight(step, inFlight, parked = new Map()) {
+  if (!step || (!inFlight?.size && !parked?.size)) return step;
   const chain = [step, ...(step.then ?? [])].map(({ then: _then, ...s }) => s);
   const kept = [];
   const busy = [];
@@ -50,19 +51,72 @@ export function withoutInFlight(step, inFlight) {
       continue;
     }
     const ids = (s.args ?? '').split(/\s+/).filter(Boolean);
-    const free = ids.filter((id) => !inFlight.has(id.toUpperCase()));
-    busy.push(...ids.filter((id) => inFlight.has(id.toUpperCase())));
+    const held = (id) => inFlight?.has(id.toUpperCase()) || parked?.has(id.toUpperCase());
+    const free = ids.filter((id) => !held(id));
+    busy.push(...ids.filter(held));
     if (free.length) kept.push({ ...s, args: free.join(' ') });
   }
   if (kept.length) return { ...kept[0], ...(kept.length > 1 ? { then: kept.slice(1) } : {}) };
-  const names = [...new Set(busy)];
+  const names = [...new Set(busy.map((id) => id.toUpperCase()))];
+  const working = names.filter((id) => inFlight?.has(id));
+  // LOOP-13: what each parked story waits on, as the lead said.
+  const waits = names
+    .filter((id) => !inFlight?.has(id))
+    .map(
+      (id) =>
+        `${id} waits${parked.get(id)?.on?.length ? ` on ${parked.get(id).on.join(', ')}` : ''}`,
+    );
   return {
     step: 'wait',
-    why: `${names.join(', ')} ${names.length === 1 ? 'is' : 'are'} still with ${names.length === 1 ? 'its agent' : 'their agents'}; the loop goes on when one finishes`,
+    why: [
+      working.length
+        ? `${working.join(', ')} ${working.length === 1 ? 'is' : 'are'} still with ${working.length === 1 ? 'its agent' : 'their agents'}`
+        : null,
+      ...waits,
+    ]
+      .filter(Boolean)
+      .join('; ')
+      .concat('; the loop goes on when one moves'),
     inFlight: names,
   };
 }
 
+/** LOOP-13: how long a parked story waits with nothing it waits on moving, before the lead is asked again. */
+export const PARK_MS = 30 * 60_000;
+
+/**
+ * LOOP-13: the stories to watch while `id` is parked: itself, the stories the lead said it waits on,
+ * and the stories that depend on it and aren't done (a pair the lead merges together).
+ */
+export function parkWatch(id, on = [], stories = []) {
+  const dependents = stories
+    .filter((s) => (s.dependsOn ?? []).includes(id) && s.state !== 'done')
+    .map((s) => s.id);
+  return [...new Set([id, ...on, ...dependents])];
+}
+
+/**
+ * LOOP-13: where the watched stories stand, as one string: each one's state, its branch's commit and
+ * whether an agent is at work on it. A parked story wakes when this changes.
+ */
+export function storiesSignature(ids, stories = [], heads = new Map(), inFlight = new Set()) {
+  return ids
+    .map((id) => {
+      const s = stories.find((x) => x.id === id);
+      return `${id}:${s?.state ?? '?'}:${s?.branch ? (heads.get(s.branch) ?? '') : ''}:${inFlight.has(id) ? 'busy' : ''}`;
+    })
+    .join('|');
+}
+
+/** The story ids a step names, upper-cased: `review ST-158 ST-172` gives ST-158 and ST-172. */
+export const stepStories = (step) =>
+  STORY_STEPS.has(step?.stepKind ?? step?.kind ?? step?.step)
+    ? String(step?.target ?? step?.args ?? '')
+        .split(/\s+/)
+        .filter((id) => /^ST-\d+$/i.test(id))
+        .map((id) => id.toUpperCase())
+    : [];
+
 /**
  * The prompt for a step from `code-kit next --json` (LOOP-1), or null when it isn't the lead's to
  * take. Every ready story is named: the dispatch skill decides how many lanes go (LOOP-2). A prompt
@@ -80,6 +134,11 @@ export function leadPrompt(step, { cli = 'code-kit' } = {}) {
   // SETUP-2: the base has no rules yet; the lead puts the approved ones there, then merges as usual.
   if (step.step === 'rules')
     return `Put code-kit's approved rules onto ${ids[0] ?? 'the base'}: run node "${cli}" queue rules. It commits the rules as committed on this branch, without switching branches; after it, merge the queue as usual.`;
+  // HELM-4: a lane waits on the lead's decision; the decide skill takes each request on its merits.
+  if (step.step === 'decide')
+    return ids.length
+      ? `${step.why ?? 'A lane waits on your decision.'} Run /code-kit:decide ${ids.join(' ')}.`
+      : null;
   // ONB-3: a companion set up before any coding.
   if (step.step === 'setup')
     return ids.length
@@ -115,6 +174,7 @@ export function stepLabel(step) {
   const ids = (step.args ?? '').split(/\s+/).filter(Boolean).join(', ');
   const verb =
     {
+      decide: 'Decide requests',
       dispatch: 'Dispatch',
       review: 'Review',
       lead: 'Build',
@@ -150,7 +210,7 @@ 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']);
+export const OUTCOMES = new Set(['done', 'started', 'needs-person', 'blocked', 'waiting']);
 const ANSWER_SHOWN = 4000;
 
 /**
@@ -168,11 +228,12 @@ export function outcomePrompt({ prompt = null, answer = '' }) {
       : "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": "…"}',
+    '{"outcome": "done" | "started" | "needs-person" | "blocked" | "waiting", "question": "…", "options": [{"label": "…", "effect": "…"}], "reason": "…", "waits": [{"story": "ST-n", "on": ["ST-n"], "why": "…"}]}',
     '- 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.",
+    "- waiting: the step isn't due yet for some or all of its stories: they wait on other work still going (a lane building a story they merge with, a rebuild, a check running). waits: one entry per story that waits, with the stories it waits on (their ST ids, [] when it's other work) and why, in a few words. Use this, not done, when you said a story can't be taken yet.",
+    "- blocked: you didn't take the step, for a reason no answer from the person settles now and no work in flight will change. reason: why, in a sentence.",
   ].join('\n');
 }
 
@@ -196,11 +257,21 @@ export function readOutcome(text) {
     .map((o) => ({ label: words(o?.label, 40), effect: words(o?.effect, 200) }))
     .filter((o) => o.label)
     .slice(0, 4);
+  const story = (v) =>
+    typeof v === 'string' && /^ST-\d+$/i.test(v.trim()) ? v.trim().toUpperCase() : null;
+  const waits = (Array.isArray(parsed.waits) ? parsed.waits : [])
+    .map((w) => ({
+      story: story(w?.story),
+      on: (Array.isArray(w?.on) ? w.on : []).map(story).filter(Boolean),
+      why: words(w?.why, 200),
+    }))
+    .filter((w) => w.story);
   return {
     outcome: parsed.outcome,
     question: words(parsed.question, 400),
     options: options.length >= 2 ? options : [],
     reason: words(parsed.reason, 300),
+    waits,
   };
 }
 

package/hooks/mod/register.mjs

@@ -58,16 +58,20 @@ import {
   leadPrompt,
   nudgeText,
   outcomePrompt,
+  PARK_MS,
+  parkWatch,
   readOutcome,
   restartPrompt,
   stallDue,
   stepKey,
   stepLabel,
+  stepStories,
   storiesInFlight,
+  storiesSignature,
   withoutInFlight,
 } from './loop.mjs';
 import { goalOf, nextText } from './mission.mjs';
-import { contextOf, decisionCards, limitsWhy, nativeChoice } from './decisions.mjs';
+import { contextOf, decisionCards, nativeChoice } from './decisions.mjs';
 import { DEFAULT_TEAM_UI, TEAM_ID, teamFrame } from './teamview.mjs';
 import { glowOf, mapStoryOf, touchOf } from './codemap.mjs';
 import { harnessSettings } from '../lib/harness.mjs';
@@ -122,6 +126,8 @@ const loop = {
   // LOOP-11, LOOP-12: what holds the loop: { kind: 'person' | 'stopped' | 'blocked' | 'design', key, label, prompt, question, options, reason }
   waiting: null,
   handedDesign: new Set(), // LOOP-12: design stories handed to the lead this session
+  // LOOP-13: stories the lead said wait on other work: id → { on, why, watch, sig, at }
+  parked: new Map(),
 };
 // LOOP-10: whether this session runs the loop, the session that does when another does, and when this
 // one last renewed its lease.
@@ -268,7 +274,11 @@ export function register(on) {
         const valid = Boolean(check?.valid);
         const status = valid ? await json('status') : null;
         const nextStep = valid ? await json('next') : null;
-        const requests = valid ? await json('requests') : null;
+        const all = valid ? await json('requests') : null;
+        // HELM-6: the person sees only their own decisions; the lead decides the rest.
+        const requests = all
+          ? { ...all, open: (all.open ?? []).filter((r) => r.by !== 'lead') }
+          : null;
         const stops = valid ? ((await json('stops', '--session', session)) ?? []) : [];
         const queue = valid ? ((await json('queue')) ?? []) : [];
         // VIEW-2: when each story's work happened, for the lanes' timelines.
@@ -532,7 +542,6 @@ export function register(on) {
           reason: prefilledReason(line.request),
           error: null,
           heldId: line.heldId ?? null,
-          outside: line.outside ?? null,
           aside: { thread: [], draft: '' },
         };
         await $.ui.open({ id: APPROVE_ID, title: 'Approve', focus: true, closeOnEscape: true });
@@ -581,7 +590,7 @@ export function register(on) {
         const same = (r) =>
           [...r.names].sort().join() === [...line.request.names].sort().join() &&
           (r.lane ?? r.actor) === (line.request.lane ?? line.request.actor);
-        const numbers = open.flatMap((r, i) => (same(r) ? [i + 1] : []));
+        const numbers = open.flatMap((r, i) => (same(r) ? [r.n ?? i + 1] : []));
         if (!numbers.length) return;
         const ran = await $.process.run(
           ['node', cli, 'requests', 'drop', numbers.join(','), '--via', 'pane'],
@@ -734,7 +743,6 @@ export function register(on) {
             why: line.held.refusal ?? null,
           },
           heldId: line.held.id,
-          outside: line.held.outside ?? null,
         }),
       // ACT-5: a side call over the lead's own conversation (it shares the prompt cache, and nothing is
       // added to the conversation); before the lead's first reply, from the prompt's facts alone.
@@ -785,7 +793,6 @@ export function register(on) {
         const prompt = approvalAsidePrompt({
           request: asked.request,
           story: row?.story ?? null,
-          outside: limitsWhy(asked.outside) ?? null,
           thread,
           question: q,
         });
@@ -1098,6 +1105,45 @@ export function register(on) {
         $.ui.invalidate('ui.render');
         await act.step('resume');
       },
+      // LOOP-13: where the watched stories stand now: their states, branch commits, and agents at work.
+      storiesNow: async () => {
+        const refs = await $.process
+          .run(['git', 'for-each-ref', '--format=%(objectname) %(refname)', 'refs/heads'], { cwd })
+          .catch(() => ({ stdout: '' }));
+        const heads = new Map(
+          String(refs.stdout ?? '')
+            .split('\n')
+            .map((l) => /^\s*(\S+)\s+(?:refs\/heads\/)?(\S+)/.exec(l))
+            .filter(Boolean)
+            .map((m) => [m[2], m[1]]),
+        );
+        const inFlight = storiesInFlight(await $.agent.list().catch(() => []));
+        const stories = model.state?.stories ?? [];
+        return {
+          heads,
+          inFlight,
+          stories,
+          sig: (ids) => storiesSignature(ids, stories, heads, inFlight),
+        };
+      },
+      park: async (waits) => {
+        if (!waits.length) return;
+        const now = await $.clock.now();
+        const seen = await act.storiesNow();
+        for (const w of waits) {
+          const watch = parkWatch(w.id, w.on, seen.stories);
+          loop.parked.set(w.id, { on: w.on, why: w.why, watch, sig: seen.sig(watch), at: now });
+        }
+        $.ui.invalidate('ui.render');
+      },
+      // LOOP-13: a parked story wakes when anything it watches moves, or after PARK_MS with nothing moving.
+      unpark: async () => {
+        if (!loop.parked.size) return;
+        const now = await $.clock.now();
+        const seen = await act.storiesNow();
+        for (const [id, p] of loop.parked)
+          if (now - p.at >= PARK_MS || seen.sig(p.watch) !== p.sig) loop.parked.delete(id);
+      },
       // LOOP-11: the lead's last reply, read once before the loop prompts it again. A reply that waits on
       // the person, or a turn they stopped, holds the loop until they speak; a step the lead didn't take
       // holds that step while it's still next.
@@ -1144,6 +1190,21 @@ export function register(on) {
         // Spec 05's data: what came of the step, once known.
         const record = sent ? loop.steps.findLast((x) => x.prompt === sent.prompt) : null;
         if (record) record.outcome = heard?.outcome ?? 'unread';
+        // LOOP-13: stories the lead said wait on other work are parked, each until what it waits on moves.
+        const ids = stepStories(sent);
+        if (['waiting', 'blocked'].includes(heard?.outcome) && ids.length) {
+          const named = new Map((heard.waits ?? []).map((w) => [w.story, w]));
+          // A blocked step, or a reply that names none, parks all its stories; otherwise those it names.
+          const waiting =
+            heard.outcome === 'blocked' || !named.size ? ids : ids.filter((id) => named.has(id));
+          await act.park(
+            waiting.map((id) => ({
+              id,
+              on: named.get(id)?.on ?? [],
+              why: named.get(id)?.why ?? heard.reason ?? null,
+            })),
+          );
+        }
         if (heard?.outcome === 'needs-person')
           loop.waiting = {
             kind: 'person',
@@ -1153,7 +1214,7 @@ export function register(on) {
             reason: heard.reason,
           };
         else if (heard?.outcome === 'blocked' && sent)
-          loop.waiting = { kind: 'blocked', ...step, reason: heard.reason };
+          loop.waiting = { kind: 'blocked', ...step, reason: heard.reason, stories: ids };
         if (loop.waiting) $.ui.invalidate('ui.render');
       },
       // LOOP-11: the person's choice from the lead's options, or their own words, told to the lead.
@@ -1180,11 +1241,13 @@ export function register(on) {
         const w = loop.waiting;
         if (!w?.prompt || leadTurn) return;
         loop.waiting = null;
+        for (const id of w.stories ?? []) loop.parked.delete(id);
         loop.asked = { key: w.key, times: 0 };
         await act.submit(w.prompt, w.stepKind, w.target, { key: w.key, label: w.label });
       },
       // LOOP-11: the person lets the loop go on.
       carryOn: async () => {
+        for (const id of loop.waiting?.stories ?? []) loop.parked.delete(id);
         loop.waiting = null;
         loop.lastKey = null;
         $.ui.invalidate('ui.render');
@@ -1252,12 +1315,15 @@ export function register(on) {
           return act.submit(prompt, 'restart', story);
         }
         const ran = await $.process.run(['node', cli, 'next', '--json'], { cwd });
+        // LOOP-13: a parked story stays out of the step until what it waits on moves.
+        await act.unpark();
         // LOOP-9: never a story an agent is already at work on, building or reviewing it.
         const step =
           ran.exitCode === 0
             ? withoutInFlight(
                 parseJson(ran.stdout),
                 storiesInFlight(await $.agent.list().catch(() => [])),
+                loop.parked,
               )
             : null;
         // MISSION-1: the band shows what the loop takes next.
@@ -1293,9 +1359,17 @@ export function register(on) {
         // LOOP-11, LOOP-12: a step the lead didn't take, or designs left to the person and the lead, hold
         // that step while it's still next; any other step goes on.
         if (loop.waiting) {
-          if (loop.waiting.key === key) return;
-          loop.waiting = null;
-          $.ui.invalidate('ui.render');
+          // LOOP-13: a blocked step's stories are parked, so the line stays while any of them is, and
+          // other steps go on; a step without stories holds while it's still next.
+          const stories = loop.waiting.stories ?? [];
+          const held = stories.length
+            ? stories.some((id) => loop.parked.has(id))
+            : loop.waiting.key === key;
+          if (held && !stories.length) return;
+          if (!held) {
+            loop.waiting = null;
+            $.ui.invalidate('ui.render');
+          }
         }
         if (!prompt) return;
         if (designHandedOver(step, loop.handedDesign)) {
@@ -1757,26 +1831,6 @@ export function register(on) {
       // HOLD-6: nobody to ask (claude -p, the SDK), or hold switched off: refused as today.
       if (!ask || !where?.interactive || minutes <= 0 || model.state?.kind !== 'ok') return res;
       const id = e.tool_use_id;
-      let outsideLimits = null;
-      // HOLD-5: under autonomy, the project's delegated rules decide first, without asking.
-      if ((settings?.autonomy ?? 'autonomous') === 'autonomous') {
-        const delegated = await $.process.run(
-          [
-            'node',
-            where.cli,
-            'approve',
-            ...ask.names,
-            ...(ask.lane ? ['--lane', ask.lane] : []),
-            '--delegated',
-            '--reason',
-            `Held call within the delegated rules: ${ask.what}`,
-          ],
-          { cwd: where.cwd, timeoutMs: 60000 },
-        );
-        if (delegated.exitCode === 0) return next(e);
-        // DECIDE-2: why it's outside the limits the person set, for the decision's card.
-        outsideLimits = (delegated.stderr || delegated.stdout || '').trim();
-      }
       const agent = e.agentId ? agentsSeen.get(e.agentId) : null;
       held.set(id, {
         id,
@@ -1788,10 +1842,9 @@ export function register(on) {
         what: ask.what,
         since: await $.clock.now(),
         minutes,
-        // DECIDE-2: the call itself, the rule that refused it, and why the lead couldn't approve it.
+        // DECIDE-2: the call itself, and the rule that refused it.
         command: e.command ?? e.file_path ?? null,
         refusal: text.split('\n')[0],
-        outside: outsideLimits,
       });
       $.ui.invalidate('ui.render');
       // The wait is a process the band's answer ends (`code-kit hold`), so it isn't the hook's own time.

package/hooks/mod/register.test.ts

@@ -97,10 +97,7 @@ function project() {
     setExit: 0,
     allowed: false, // an approval in force: the hooks beneath let the call through
     bashRuns: 0,
-    delegateExit: 1,
-    delegateRefusal:
-      'This project delegates no approvals to the lead ("approvals.delegate" isn\'t set). Ask the person.',
-    delegated: [] as string[][],
+    delegated: [] as string[][], // HELM-6: the mod never approves for the lead, so this stays empty
     holds: [] as string[][],
     draft: '', // what the person has typed in the prompt
     heads: { 'web/st-4': 'abc123def4567890\n' } as Record<string, string>,
@@ -284,8 +281,7 @@ function stub(on: any, w: World) {
     if (sub === 'queue') return ran(0, JSON.stringify(w.queue));
     if (sub === 'approve' && argv.includes('--delegated')) {
       w.delegated.push([...argv.slice(2)]);
-      if (w.delegateExit === 0) w.allowed = true;
-      return ran(w.delegateExit, '', w.delegateExit ? w.delegateRefusal : '');
+      return ran(1, '', 'Nothing was approved.');
     }
     if (sub === 'hold') {
       const id = argv[3];
@@ -653,6 +649,24 @@ test('BAND-2 and BAND-4 one open request reads "1 approval waiting", with Approv
   await ui.unmount();
 });
 
+test("HELM-6 a request the lead decides isn't the person's: only theirs waits in the band", async ($, on) => {
+  const w = project();
+  w.requests = [
+    { ...dayjs, n: 1, by: 'lead' },
+    { ...dayjs, names: ['contract'], what: 'packages/contracts/a.ts', n: 2, by: 'person' },
+  ];
+  await start($, on, w);
+  const ui = await bandUi($);
+  expect(await ui.find({ type: 'Text', text: '1 approval waiting' })).toBeDefined();
+  await press($, 'band-decide');
+  await ui.unmount();
+  // Not needed drops it by the number the CLI gave it, past the lead's request it doesn't show.
+  const decisions = await pane($, PANE);
+  await press($, 'decide-dropRequest', PANE);
+  expect(w.acts).toContainEqual(['requests', 'drop', '2', '--via', 'pane']);
+  await decisions.unmount();
+});
+
 test('ACT-1 and BAND-3 approving with the prefilled reason grants it for the lane, and the line goes', async ($, on) => {
   const w = project();
   w.requests = [dayjs];
@@ -1412,9 +1426,8 @@ test('DECIDE-2 a decision in the band says which story it is for, and d opens it
   expect(card?.text).toMatch(/BOOK-1 Request a booking/);
   expect(card?.text).toMatch(/npm install dayjs/);
   expect(card?.text).toMatch(/ST-4 Booking form \(BOOK-1\) was handed to the web lane/);
-  expect(card?.text).toMatch(
-    /Blocked: a new dependency \(dayjs\) needs a person's approval\. You haven't let the lead approve these itself\./,
-  );
+  expect(card?.text).toMatch(/Blocked: a new dependency \(dayjs\) needs a person's approval\./);
+  expect(card?.text).not.toMatch(/limits you set/);
   expect((await ui.find({ key: 'decision-option-approveHeld' }))?.text).toMatch(
     /The held call runs now, and the agent carries on/,
   );
@@ -1972,10 +1985,12 @@ test('HOLD-4 Refuse, or no answer in the hold time, lets the refusal through and
   await ui.unmount();
 });
 
-test('HOLD-5 within the delegated rules the call is approved as delegated and runs, without asking', async ($, on) => {
+const leadInstall =
+  'Blocked: a new dependency (dayjs) is the lead\'s decision. The lead decides this, not the person. Hand the lead a change request and stop: the package, the story and requirement that need it, what the project already has that you checked, and anything lighter that would do. The lead approves it, or tells you what to use instead.\n  Decided by the lead: node "/x/bin/code-kit.mjs" approve dep-dayjs --lane web --delegated --story <ST-n> --reason "<what the story needs it for, what the project already has, how it fits>"\nCommand: npm install dayjs';
+
+test("HOLD-5 and HELM-6 a lane's call the lead decides isn't held, and the mod doesn't approve it for the lead", async ($, on) => {
   const w = project();
-  w.refusal = webInstall;
-  w.delegateExit = 0;
+  w.refusal = leadInstall;
   await start($, on, w);
   const res: any = await $.tool.call({
     tool: 'Bash',
@@ -1983,18 +1998,17 @@ test('HOLD-5 within the delegated rules the call is approved as delegated and ru
     command: 'npm install dayjs',
     agentId: 'a1',
   } as any);
-  expect(refused(res)).toBe(false);
-  expect(w.delegated[0]).toEqual(
-    expect.arrayContaining(['approve', 'dep-dayjs', '--lane', 'web', '--delegated']),
-  );
+  expect(refused(res)).toBe(true);
   expect(w.holds).toEqual([]);
+  expect(w.delegated).toEqual([]);
+  const band = await bandUi($);
+  expect(await band.find({ type: 'Text', text: /wants to install/ })).toBeUndefined();
+  await band.unmount();
 });
 
-test('HOLD-5 with autonomy propose the delegated rules are not tried; the call is held', async ($, on) => {
+test("HOLD-5 a call the person decides is held for them, without trying the lead's rules", async ($, on) => {
   const w = project();
   w.refusal = webInstall;
-  w.delegateExit = 0;
-  (w.check as any).harness = { autonomy: 'propose', hold: { minutes: 2 } };
   const clock = await start($, on, w);
   const { call } = await heldCall($, w, clock);
   expect(w.delegated).toEqual([]);
@@ -2496,6 +2510,83 @@ test('LOOP-11 dismissed, what the lead waits on stays in the band, and the loop
   expect(w.prompts.at(-1)).toBe('Review ST-4: run /code-kit:review ST-4.');
 });
 
+test('LOOP-13 stories the lead says wait on other work are parked, each until what it waits on moves', async ($, on) => {
+  const w = project();
+  w.stories.push(
+    {
+      id: 'ST-158',
+      title: 'Storage',
+      lane: 'web',
+      state: 'in review',
+      branch: 'web/st-158',
+      waitingOn: [],
+    },
+    {
+      id: 'ST-164',
+      title: 'Callers use the storage',
+      lane: 'api',
+      state: 'in progress',
+      branch: 'api/st-164',
+      dependsOn: ['ST-158'],
+      waitingOn: [],
+    },
+    {
+      id: 'ST-172',
+      title: 'Silent tests',
+      lane: 'core',
+      state: 'in review',
+      branch: 'core/st-172',
+      waitingOn: [],
+    },
+    {
+      id: 'ST-173',
+      title: 'Verdicts',
+      lane: 'lead',
+      state: 'in review',
+      branch: 'lead/st-173',
+      waitingOn: [],
+    },
+  );
+  w.refs += ' s1 refs/heads/web/st-158\n s2 refs/heads/api/st-164\n s3 refs/heads/core/st-172\n';
+  w.next = { step: 'review', args: 'ST-158 ST-172', then: [] };
+  w.sideReply = unread;
+  const clock = await start($, on, w);
+  await leadTurn($);
+  await settle(clock);
+  expect(w.prompts.at(-1)).toBe('Review ST-158, ST-172: run /code-kit:review.');
+  // The lead says neither is due yet; next then names a third story as well.
+  w.sideReply = outcome({
+    outcome: 'waiting',
+    waits: [
+      { story: 'ST-158', on: [], why: 'it merges with its paired branch' },
+      { story: 'ST-172', on: [], why: 'its merge checks are re-running' },
+    ],
+  });
+  w.next = { step: 'review', args: 'ST-158 ST-172 ST-173', then: [] };
+  await leadSays(
+    $,
+    't-2',
+    'None of these is due: ST-158 merges with ST-164; ST-172 re-runs its checks.',
+  );
+  await settle(clock);
+  // Only the story that isn't waiting is asked for.
+  expect(w.prompts.at(-1)).toBe('Review ST-173: run /code-kit:review ST-173.');
+  const asked = w.prompts.length;
+  // Lanes committing elsewhere don't wake them, and nothing is prompted while both still wait.
+  w.sideReply = unread;
+  w.next = { step: 'review', args: 'ST-158 ST-172', then: [] };
+  w.refs += ' x1 refs/heads/core/st-9\n';
+  await leadTurn($, 't-3');
+  await settle(clock);
+  expect(w.prompts).toHaveLength(asked);
+  // The story building on ST-158 commits: ST-158 wakes, and ST-172 still waits.
+  w.refs = w.refs.replace(' s2 refs/heads/api/st-164', ' s9 refs/heads/api/st-164');
+  await leadTurn($, 't-4');
+  await settle(clock);
+  expect(w.prompts.at(-1)).toBe('Review ST-158: run /code-kit:review ST-158.');
+  expect(w.prompts).toHaveLength(asked + 1);
+});
+
 test('LOOP-11 a turn the person stopped holds the loop, with no dialog, until they speak or press Carry on', async ($, on) => {
   const w = project();
   w.sideReply = unread;