hammoc 1.8.4 → 1.9.0

package/scripts/probe-persistent-hooks.mjs

@@ -0,0 +1,795 @@
+// Story 38.1 — live probe (feedback_sdk_verify): does the PERSISTENT stream
+// (AsyncIterable prompt kept open) actually deliver first-class hooks in-process,
+// and does Stop's background_tasks[] track a SUBAGENT-type child (Task 4 GO/NO-GO)?
+//
+// Story 38.2 — `order` mode adds the AC7 GO/NO-GO gate: at the moment the stream
+// consumer dequeues the turn-ending `result`, has THIS turn's main Stop hook
+// (fromSubagent === false) already fired into the ledger? If yes for both a
+// simple turn AND a background turn → GO (processStream reads the snapshot
+// directly at result). If Stop lands after result → NO-GO (bounded micro-grace).
+//
+// Story 38.4 — `runtime` mode: on the persistent stream, does each runtime
+// parameter setter actually take effect on SUBSEQUENT responses?
+//   (a) setModel(<other>)      — do later assistant messages report the new model
+//                                 id (message.model / result.modelUsage keys)? GO.
+//   (b) setMaxThinkingTokens   — is a thinking budget change reflected (thinking
+//                                 blocks appear/disappear with the display param)?
+//   (c) setPermissionMode      — does the 37.5 runtime apply still hold in the
+//                                 persistent stream (no error, follow-up result)?
+//   (d) setEffort              — confirm the Query interface has NO such setter
+//                                 (effort is a query() creation option only → NO-GO).
+//
+// Story 38.5 — `residency` mode: the CORE GO/NO-GO gate for turn-to-turn process
+// residency. On ONE persistent stream, does a single query() process sustain
+// MULTIPLE turns with NO close() and NO restart between them?
+//   - Turn 1 consumed to `result`, then HELD (no close).
+//   - Turn 2..N pushed via the SAME promptQueue onto the SAME iterator; each turn's
+//     result must land on the same process.
+//   - Inter-turn gap is timestamped: a fresh query() spawn costs ~3s of CLI/auth
+//     warmup, so residency shows up as a SECOND+ turn whose time-to-first-token /
+//     total is well under a cold spawn (no restart). GO ⇒ Story 38.5 adopts the
+//     residency registry (turn-end close replaced by an idle-timeout policy).
+//   - Also confirms resume/forkSession have NO live-query runtime setter (they are
+//     query() creation options only) → resume/fork require a NEW query, wired into
+//     the residency registry rather than mutating a live query.
+//
+// Story 38.3 — TWO gates on the persistent control channel:
+//   `interact`  — does the permission/AskUserQuestion gate (canUseTool) still fire
+//                 in the POST-RESULT follow-up generation, and does the injected
+//                 answer round-trip over the still-open control channel back to the
+//                 SDK (no "Stream closed" — the c4ec9acf failure)? GO if a
+//                 post-result AskUserQuestion is answered and a follow-up result
+//                 lands.
+//   `bashkill`  — a background Bash (`sleep 20`) launched then the turn ended: does
+//                 it survive past the ~5s mark (completion notification lands near
+//                 the full sleep) or is it killed at ~5s? GO = survives (no kill).
+//
+// Usage:
+//   node scripts/probe-persistent-hooks.mjs smoke     # auth + hook-firing check (fast)
+//   node scripts/probe-persistent-hooks.mjs subagent  # GO/NO-GO: subagent tracking (~90s)
+//   node scripts/probe-persistent-hooks.mjs order      # 38.2 AC7: Stop-vs-result ordering (~90s)
+//   node scripts/probe-persistent-hooks.mjs interact   # 38.3 AC2/AC6: post-result canUseTool round-trip (~40s)
+//   node scripts/probe-persistent-hooks.mjs bashkill   # 38.3 AC3/AC6: background Bash ~5s kill survival (~40s)
+//   node scripts/probe-persistent-hooks.mjs interrupt  # 38.3 AC1: interrupt() ends the turn but keeps the session (~40s)
+//   node scripts/probe-persistent-hooks.mjs runtime    # 38.4 AC1: setModel/setMaxThinkingTokens/setPermissionMode reflection + setEffort absence (~120s)
+//   node scripts/probe-persistent-hooks.mjs residency  # 38.5 AC1: N-turn process residency (no close, no restart between turns) + resume/fork runtime-setter absence (~120s)
+//   node scripts/probe-persistent-hooks.mjs longhold   # 38.6 AC1: vitest-grade (>1min) long child — hold→terminate + reuse turn (~120s)
+//
+// Runs against the real bundled SDK + owner subscription (standing-approved).
+
+import { query } from '@anthropic-ai/claude-agent-sdk';
+
+const ARG = process.argv[2];
+const KNOWN_MODES = ['smoke', 'subagent', 'order', 'hold', 'interact', 'bashkill', 'interrupt', 'runtime', 'residency', 'longhold'];
+const MODE = KNOWN_MODES.includes(ARG) ? ARG : 'smoke';
+
+// --- Persistent prompt queue (mirrors packages/server/src/services/promptQueue.ts) ---
+class PromptQueue {
+  #queued = [];
+  #waiter = null;
+  #closed = false;
+  push(m) {
+    if (this.#closed) return;
+    if (this.#waiter) { const r = this.#waiter; this.#waiter = null; r({ value: m, done: false }); }
+    else this.#queued.push(m);
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    if (this.#waiter) { const r = this.#waiter; this.#waiter = null; r({ value: undefined, done: true }); }
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.#queued.length) return Promise.resolve({ value: this.#queued.shift(), done: false });
+        if (this.#closed) return Promise.resolve({ value: undefined, done: true });
+        return new Promise((resolve) => { this.#waiter = resolve; });
+      },
+      return: () => { this.close(); return Promise.resolve({ value: undefined, done: true }); },
+    };
+  }
+}
+
+const userMsg = (text) => ({ type: 'user', session_id: '', message: { role: 'user', content: text }, parent_tool_use_id: null });
+
+// --- Hook capture ---
+const stopSnapshots = [];   // { at, tasks: [{id,type,status,agent_type}] }
+const subagentStops = [];   // { at, agent_type, tasks }
+const taskEvents = [];       // ['created'|'completed'|'subagent-start', ...]
+
+const pass = async () => ({});
+const mk = (fn) => ({ hooks: [async (input) => { try { fn(input); } catch (e) { console.error('hook err', e); } return pass(); }] });
+const hooks = {
+  TaskCreated: [mk((i) => taskEvents.push(['created', i.task_id, i.task_subject]))],
+  TaskCompleted: [mk((i) => taskEvents.push(['completed', i.task_id, i.task_subject]))],
+  SubagentStart: [mk((i) => taskEvents.push(['subagent-start', i.agent_id, i.agent_type]))],
+  Stop: [mk((i) => {
+    const tasks = (i.background_tasks ?? []).map((t) => ({ id: t.id, type: t.type, status: t.status, agent_type: t.agent_type }));
+    stopSnapshots.push({ at: Date.now(), tasks });
+    console.log(`[Stop] background_tasks=${tasks.length} ${JSON.stringify(tasks)}`);
+  })],
+  SubagentStop: [mk((i) => {
+    const tasks = (i.background_tasks ?? []).map((t) => ({ id: t.id, type: t.type, status: t.status, agent_type: t.agent_type }));
+    subagentStops.push({ at: Date.now(), agent_type: i.agent_type, tasks });
+    console.log(`[SubagentStop] agent_type=${i.agent_type} background_tasks=${tasks.length} ${JSON.stringify(tasks)}`);
+  })],
+};
+
+// --- canUseTool (interact mode, Story 38.3) -----------------------------------
+// Records whether the gate is invoked AFTER the first turn-ending result (i.e. in
+// the post-result follow-up generation) and, for AskUserQuestion, injects an answer
+// whose return value must round-trip over the still-open control channel.
+const PROBE_T0 = Date.now();
+let firstResultAt = null;      // set when the first result is dequeued (interact)
+const canUseToolEvents = [];   // { at, tool, postResult }
+const canUseTool = async (toolName, input) => {
+  const postResult = firstResultAt !== null;
+  canUseToolEvents.push({ at: Date.now(), tool: toolName, postResult });
+  console.log(`[canUseTool] tool=${toolName} @t+${Date.now() - PROBE_T0}ms postResult=${postResult}`);
+  if (toolName === 'AskUserQuestion') {
+    const questions = Array.isArray(input?.questions) ? input.questions : [];
+    const answers = {};
+    for (const question of questions) {
+      const opts = Array.isArray(question?.options) ? question.options : [];
+      const firstOpt = opts.length ? (opts[0]?.label ?? String(opts[0])) : 'yes';
+      answers[question?.question ?? 'q'] = firstOpt;
+    }
+    await new Promise((r) => setTimeout(r, 300)); // simulate human think-time
+    console.log(`[canUseTool] injecting AskUserQuestion answer (postResult=${postResult}) → return over control channel`);
+    return { behavior: 'allow', updatedInput: { questions, answers } };
+  }
+  return { behavior: 'allow', updatedInput: input };
+};
+
+// interact needs canUseTool exercised, so run it under the production-faithful
+// `default` permission mode (bypass+skip may short-circuit the gate). All other
+// modes keep the fast bypass path.
+const NEEDS_CANUSE = MODE === 'interact';
+
+const pq = new PromptQueue();
+const controller = new AbortController();
+const q = query({
+  prompt: pq,
+  options: {
+    cwd: process.cwd(),
+    permissionMode: NEEDS_CANUSE ? 'default' : 'bypassPermissions',
+    allowDangerouslySkipPermissions: !NEEDS_CANUSE,
+    includePartialMessages: false,
+    settingSources: ['user', 'project', 'local'],
+    hooks,
+    ...(NEEDS_CANUSE ? { canUseTool } : {}),
+    abortController: controller,
+    stderr: (d) => process.stderr.write(`[cli] ${d}`),
+  },
+});
+
+// ========================= interrupt mode (38.3 AC1) ==========================
+// The Stop-button primitive: does q.interrupt() (a) END the current turn's
+// generation (a `result` arrives shortly after), and (b) KEEP the session alive so
+// a SUBSEQUENT prompt on the SAME persistent stream produces a fresh result? GO for
+// both ⇒ mapping the Stop button to interrupt() (turn-only) is safe; the generator
+// is NOT torn down (that is close()/abort).
+if (MODE === 'interrupt') {
+  const iterator = q[Symbol.asyncIterator]();
+  let firstTurnEndedAfterInterrupt = false;
+  let secondTurnResult = false;
+  let interruptAt = null;
+  let firstResultAfterInterruptAt = null;
+  const t0 = Date.now();
+
+  // Turn 1: a long, slow generation we can interrupt mid-flight.
+  pq.push(userMsg(
+    'Count slowly from 1 to 60. Output ONE number per line, and think briefly before each so it takes a while. Do not stop early.'));
+
+  (async () => {
+    try {
+      // Fire the interrupt ~4s into the first turn's streaming.
+      const interruptTimer = setTimeout(async () => {
+        interruptAt = Date.now() - t0;
+        console.log(`[interrupt] calling q.interrupt() @t+${interruptAt}ms`);
+        try { await q.interrupt(); } catch (e) { console.error('[interrupt] interrupt() threw', e?.message || e); }
+      }, 4000);
+
+      let pushedSecond = false;
+      for (;;) {
+        const step = await iterator.next();
+        if (step.done) { console.log('[interrupt] stream ended (generator done)'); break; }
+        const m = step.value;
+        if (m.type !== 'result') continue;
+        const at = Date.now() - t0;
+        if (interruptAt !== null && !firstTurnEndedAfterInterrupt) {
+          firstTurnEndedAfterInterrupt = true;
+          firstResultAfterInterruptAt = at;
+          console.log(`[interrupt] turn-1 result arrived @t+${at}ms (${at - interruptAt}ms after interrupt) subtype=${m.subtype}`);
+          // Session-survival check: push a SECOND prompt on the SAME stream.
+          if (!pushedSecond) {
+            pushedSecond = true;
+            clearTimeout(interruptTimer);
+            console.log('[interrupt] pushing turn-2 prompt on the SAME persistent stream…');
+            pq.push(userMsg('Reply with the single word: RESUMED'));
+          }
+          continue;
+        }
+        if (firstTurnEndedAfterInterrupt) {
+          secondTurnResult = true;
+          console.log(`[interrupt] turn-2 result arrived @t+${at}ms subtype=${m.subtype} — session survived the interrupt`);
+          break;
+        }
+      }
+    } catch (e) { console.error('[interrupt error]', e?.message || e); }
+
+    console.log(`\n=== verdict (mode=interrupt, AC1 gate) ===`);
+    console.log(`interrupt fired: ${interruptAt !== null ? `@t+${interruptAt}ms` : 'NO'}`);
+    console.log(`turn-1 ended after interrupt: ${firstTurnEndedAfterInterrupt}${firstResultAfterInterruptAt !== null ? ` (@t+${firstResultAfterInterruptAt}ms)` : ''}`);
+    console.log(`turn-2 (same stream) produced a result: ${secondTurnResult}`);
+    const GO = firstTurnEndedAfterInterrupt && secondTurnResult;
+    console.log(`GO/NO-GO: ${GO
+      ? 'GO — interrupt() ended the current turn AND the session survived for a follow-up turn (turn-only stop, generator preserved)'
+      : firstTurnEndedAfterInterrupt
+        ? 'PARTIAL — interrupt ended the turn but the follow-up turn did not complete (session-survival unproven)'
+        : 'NO-GO — interrupt did not end the turn (Stop would hang)'}`);
+    pq.close();
+    controller.abort();
+    setTimeout(() => process.exit(0), 500);
+  })();
+
+  setTimeout(() => { if (!secondTurnResult) { console.log('[interrupt] TIMEOUT — did not observe both turns within 45s'); pq.close(); controller.abort(); setTimeout(() => process.exit(0), 500); } }, 45_000);
+}
+// =========================== runtime mode (38.4 AC1) ==========================
+// Drives sequential turns on ONE persistent stream, calling each runtime setter
+// BETWEEN turns, and checks the NEXT turn's response for the effect. The authority
+// for "which model answered" is the response meta (assistant message.model /
+// result.modelUsage keys) — NOT supportedModels() (a static catalog).
+else if (MODE === 'runtime') {
+  const iterator = q[Symbol.asyncIterator]();
+  const t0 = Date.now();
+
+  // Run one turn to its result, collecting the model ids that answered and
+  // whether any thinking content block was emitted.
+  const runTurn = async (text) => {
+    const models = new Set();
+    let thinking = false;
+    pq.push(userMsg(text));
+    for (;;) {
+      const step = await iterator.next();
+      if (step.done) return { done: true, models: [], modelUsage: null, thinking };
+      const m = step.value;
+      if (m.type === 'assistant') {
+        if (m.message?.model) models.add(m.message.model);
+        const content = m.message?.content;
+        if (Array.isArray(content) && content.some((b) => b?.type === 'thinking' || b?.type === 'redacted_thinking')) thinking = true;
+      }
+      if (m.type === 'result') {
+        const usage = m.modelUsage && typeof m.modelUsage === 'object' ? Object.keys(m.modelUsage) : null;
+        return { done: false, subtype: m.subtype, models: [...models], modelUsage: usage, thinking };
+      }
+    }
+  };
+
+  (async () => {
+    const presence = {
+      setModel: typeof q.setModel === 'function',
+      setMaxThinkingTokens: typeof q.setMaxThinkingTokens === 'function',
+      setPermissionMode: typeof q.setPermissionMode === 'function',
+      setEffort: typeof q.setEffort === 'function',
+    };
+    console.log(`[runtime] setter presence ${JSON.stringify(presence)}`);
+
+    // (a) setModel — baseline model, then switch to a clearly-different model.
+    const r1 = await runTurn('Reply with exactly one word: ONE');
+    const ids1 = [...new Set([...(r1.models || []), ...(r1.modelUsage || [])])];
+    console.log(`[runtime] turn1 (baseline) @t+${Date.now() - t0}ms modelIds=${JSON.stringify(ids1)}`);
+
+    const TARGET = 'haiku';
+    let setModelErr = null;
+    if (presence.setModel) {
+      try { console.log(`[runtime] q.setModel('${TARGET}') @t+${Date.now() - t0}ms`); await q.setModel(TARGET); }
+      catch (e) { setModelErr = e?.message || String(e); console.error('[runtime] setModel threw', setModelErr); }
+    }
+    const r2 = await runTurn('Reply with exactly one word: TWO');
+    const ids2 = [...new Set([...(r2.models || []), ...(r2.modelUsage || [])])];
+    console.log(`[runtime] turn2 (after setModel) @t+${Date.now() - t0}ms modelIds=${JSON.stringify(ids2)}`);
+    const modelChanged = ids2.some((id) => id.includes('haiku')) && !ids1.some((id) => id.includes('haiku'));
+    const modelGo = presence.setModel && !setModelErr && modelChanged;
+
+    // (b) setMaxThinkingTokens — reset model to default, budget OFF then ON (with
+    // an explicit summarized display so thinking blocks are observable when on).
+    if (presence.setModel) { try { await q.setModel(undefined); } catch (e) { console.error('[runtime] setModel(undefined) threw', e?.message || e); } }
+    let thinkErr = null;
+    if (presence.setMaxThinkingTokens) { try { await q.setMaxThinkingTokens(0); } catch (e) { thinkErr = e?.message || String(e); } }
+    const rOff = await runTurn('Think step by step, then give the answer: what is 17 * 23?');
+    console.log(`[runtime] thinking-off turn @t+${Date.now() - t0}ms thinkingBlocks=${rOff.thinking}`);
+    if (presence.setMaxThinkingTokens) { try { await q.setMaxThinkingTokens(8000, 'summarized'); } catch (e) { thinkErr = thinkErr || (e?.message || String(e)); } }
+    const rOn = await runTurn('Think step by step, then give the answer: what is 29 * 31?');
+    console.log(`[runtime] thinking-on turn @t+${Date.now() - t0}ms thinkingBlocks=${rOn.thinking}`);
+    const thinkingCallable = presence.setMaxThinkingTokens && !thinkErr;
+    const thinkingObservable = thinkingCallable && rOff.thinking === false && rOn.thinking === true;
+
+    // (c) setPermissionMode — runtime apply must still hold on the persistent
+    // stream (37.5 regression): no error, and a follow-up turn still produces a result.
+    let pmErr = null;
+    if (presence.setPermissionMode) {
+      try { await q.setPermissionMode('plan'); await q.setPermissionMode('default'); }
+      catch (e) { pmErr = e?.message || String(e); }
+    }
+    const rPm = await runTurn('Reply with exactly one word: THREE');
+    const pmGo = presence.setPermissionMode && !pmErr && !rPm.done;
+    console.log(`[runtime] setPermissionMode runtime @t+${Date.now() - t0}ms err=${pmErr} followUpResult=${!rPm.done}`);
+
+    // (d) setEffort — expected ABSENT on the Query interface.
+    const effortRuntimePresent = presence.setEffort;
+
+    console.log(`\n=== verdict (mode=runtime, 38.4 AC1 gate) ===`);
+    console.log(`(a) setModel: ${modelGo ? 'GO' : 'NO-GO'} — before=${JSON.stringify(ids1)} after=${JSON.stringify(ids2)}${setModelErr ? ` err=${setModelErr}` : ''}`);
+    console.log(`(b) setMaxThinkingTokens: ${thinkingObservable ? 'GO (callable + observable thinking diff)' : thinkingCallable ? 'GO-callable (no error; thinking-block diff inconclusive — display may be omitted)' : 'NO-GO'} off=${rOff.thinking} on=${rOn.thinking}${thinkErr ? ` err=${thinkErr}` : ''}`);
+    console.log(`(c) setPermissionMode (persistent-stream 37.5 regression): ${pmGo ? 'GO' : 'NO-GO'}${pmErr ? ` err=${pmErr}` : ''}`);
+    console.log(`(d) setEffort runtime API: ${effortRuntimePresent ? 'PRESENT (unexpected — re-evaluate)' : 'ABSENT → NO-GO by design (fallback: generator restart)'}`);
+    pq.close();
+    controller.abort();
+    setTimeout(() => process.exit(0), 500);
+  })();
+
+  setTimeout(() => { console.log('[runtime] TIMEOUT — did not finish within 120s'); pq.close(); controller.abort(); setTimeout(() => process.exit(0), 500); }, 120_000);
+}
+// ========================= residency mode (38.5 AC1) ==========================
+// The CORE Story 38.5 gate. One persistent stream, N sequential turns, NO close()
+// and NO restart between turns. We time each turn end-to-end; a cold query() spawn
+// pays ~3s CLI/auth warmup, so turns 2..N landing on the SAME iterator with the
+// gap between "prompt pushed" and "result" free of that warmup = residency holds.
+else if (MODE === 'residency') {
+  const iterator = q[Symbol.asyncIterator]();
+  const t0 = Date.now();
+  const N = 4;                 // ≥3 turns to prove repeated reuse
+  const turns = [];            // { i, elapsedMs, gapMs, subtype }
+  let lastResultAt = null;     // wall-clock of the previous turn's result
+
+  // Drive one turn on the shared iterator; measure prompt→result AND the idle gap
+  // between the previous result and this turn's first observed message.
+  const runTurn = async (i, text) => {
+    const pushedAt = Date.now();
+    pq.push(userMsg(text));
+    let firstMsgAt = null;
+    for (;;) {
+      const step = await iterator.next();
+      if (step.done) { console.log(`[residency] turn ${i}: stream ended UNEXPECTEDLY (process died)`); return { i, done: true }; }
+      const m = step.value;
+      if (firstMsgAt === null) firstMsgAt = Date.now();
+      if (m.type !== 'result') continue;
+      const resultAt = Date.now();
+      const rec = {
+        i,
+        subtype: m.subtype,
+        elapsedMs: resultAt - pushedAt,          // prompt → result for this turn
+        ttfmMs: firstMsgAt - pushedAt,           // prompt → first message (warmup proxy)
+        gapMs: lastResultAt !== null ? pushedAt - lastResultAt : null,
+      };
+      lastResultAt = resultAt;
+      turns.push(rec);
+      console.log(`[residency] turn ${i} result subtype=${m.subtype} elapsed=${rec.elapsedMs}ms ttfm=${rec.ttfmMs}ms @t+${resultAt - t0}ms`);
+      return rec;
+    }
+  };
+
+  (async () => {
+    // Live-query runtime setter presence: resume/fork must be ABSENT (creation
+    // options only), model/permission present (38.4 baseline) for contrast.
+    const setterPresence = {
+      setModel: typeof q.setModel === 'function',
+      setPermissionMode: typeof q.setPermissionMode === 'function',
+      setResume: typeof q.setResume === 'function',           // expected ABSENT
+      setForkSession: typeof q.setForkSession === 'function', // expected ABSENT
+      resume: typeof q.resume === 'function',                 // expected ABSENT
+      fork: typeof q.fork === 'function',                     // expected ABSENT
+    };
+    console.log(`[residency] live-query setter presence ${JSON.stringify(setterPresence)}`);
+
+    let processDied = false;
+    for (let i = 1; i <= N && !processDied; i++) {
+      const r = await runTurn(i, `Reply with exactly one word: TURN${i}`);
+      if (r.done) { processDied = true; break; }
+    }
+
+    console.log(`\n=== verdict (mode=residency, 38.5 AC1 gate) ===`);
+    console.log(`turns completed: ${turns.length}/${N}`);
+    for (const t of turns) {
+      console.log(`  turn ${t.i}: elapsed=${t.elapsedMs}ms ttfm=${t.ttfmMs}ms${t.gapMs !== null ? ` idleGapBeforePush=${t.gapMs}ms` : ''} subtype=${t.subtype}`);
+    }
+    // Warmup asymmetry: turn 1 pays the cold spawn; turns 2..N should be markedly
+    // faster to first message (no ~3s restart). Report the ratio for the record.
+    const t1 = turns.find((t) => t.i === 1);
+    const later = turns.filter((t) => t.i > 1);
+    const laterMaxTtfm = later.reduce((mx, t) => Math.max(mx, t.ttfmMs), 0);
+    const allTurnsLanded = turns.length === N && !processDied;
+    // No-restart signal: every turn 2..N reached first message without paying a
+    // fresh cold-spawn warmup (well under turn 1's ttfm, and under a 3s restart).
+    const noRestart = allTurnsLanded && later.every((t) => t.ttfmMs < 3000 && (t1 ? t.ttfmMs <= t1.ttfmMs + 500 : true));
+    const resumeForkRuntimeAbsent = !setterPresence.setResume && !setterPresence.setForkSession && !setterPresence.resume && !setterPresence.fork;
+    console.log(`turn1 ttfm=${t1 ? t1.ttfmMs : 'n/a'}ms; later turns max ttfm=${laterMaxTtfm}ms`);
+    console.log(`resume/fork live-query runtime setters absent: ${resumeForkRuntimeAbsent} (creation-option-only confirmed) ${JSON.stringify({ setResume: setterPresence.setResume, setForkSession: setterPresence.setForkSession, resume: setterPresence.resume, fork: setterPresence.fork })}`);
+    console.log(`GO/NO-GO: ${allTurnsLanded && noRestart
+      ? `GO — one process sustained ${N} turns with no close and no ~3s restart between them (later ttfm max ${laterMaxTtfm}ms) → adopt residency registry`
+      : allTurnsLanded
+        ? `PARTIAL — all ${N} turns landed on one process but a later turn showed restart-scale warmup (max ttfm ${laterMaxTtfm}ms); inspect gaps before adopting residency`
+        : `NO-GO — process did not sustain ${N} turns (completed ${turns.length}); residency not viable, keep turn-boundary recreation`}`);
+    pq.close();
+    controller.abort();
+    setTimeout(() => process.exit(0), 500);
+  })();
+
+  setTimeout(() => { console.log('[residency] TIMEOUT — did not finish within 120s'); pq.close(); controller.abort(); setTimeout(() => process.exit(0), 500); }, 120_000);
+}
+// ========================== interact mode (38.3 AC2) ==========================
+// Post-result control-channel round-trip. Turn 1 launches a background bash and
+// ends; the engine holds, gets the completion notification, auto-resumes, and in
+// THAT follow-up generation calls AskUserQuestion. We verify the gate (canUseTool)
+// fires post-result AND the injected answer round-trips (a follow-up result lands,
+// no "Stream closed"). GO ⇒ wire the production canUseTool path onto the follow-up.
+else if (MODE === 'interact') {
+  const iterator = q[Symbol.asyncIterator]();
+  const results = [];
+  let sawFollowupResult = false;
+  let streamError = null;
+  pq.push(userMsg(
+    'Do these steps strictly in order:\n' +
+    '1. Run a Bash command in the BACKGROUND (set run_in_background: true): `sleep 6; echo probe-done`.\n' +
+    "2. As soon as it is launched, reply with the single word 'launched' and END YOUR TURN — do NOT wait for it.\n" +
+    '3. Later, when you receive the background-task completion notification, use the AskUserQuestion tool to ask exactly one question: "Proceed?" with two options "yes" and "no".\n' +
+    "4. After I answer, reply with the single word 'FOLLOWUP_OK' and end."));
+  (async () => {
+    try {
+      for (;;) {
+        const step = await iterator.next();
+        if (step.done) { console.log('[interact] stream ended'); break; }
+        const m = step.value;
+        if (m.type !== 'result') continue;
+        if (firstResultAt === null) firstResultAt = Date.now();
+        const latest = stopSnapshots[stopSnapshots.length - 1];
+        const tasks = latest ? latest.tasks.length : -1;
+        results.push({ at: Date.now() - PROBE_T0, subtype: m.subtype, bg: tasks });
+        console.log(`[interact] result #${results.length} subtype=${m.subtype} @t+${Date.now() - PROBE_T0}ms bg=${tasks}`);
+        // Turn ends only once the follow-up (which carried the AskUserQuestion)
+        // has produced its own result with no background task still in flight.
+        const answeredPostResult = canUseToolEvents.some((e) => e.tool === 'AskUserQuestion' && e.postResult);
+        if (answeredPostResult && tasks === 0) { sawFollowupResult = true; break; }
+      }
+    } catch (e) { streamError = e?.message || String(e); console.error('[interact error]', streamError); }
+
+    const askPost = canUseToolEvents.filter((e) => e.tool === 'AskUserQuestion' && e.postResult);
+    const askPre = canUseToolEvents.filter((e) => e.tool === 'AskUserQuestion' && !e.postResult);
+    console.log(`\n=== verdict (mode=interact, AC2 gate) ===`);
+    console.log(`results: ${results.map((r) => `#${results.indexOf(r) + 1}:${r.subtype}/bg=${r.bg}@t+${r.at}ms`).join(' → ') || '(none)'}`);
+    console.log(`canUseTool calls: ${JSON.stringify(canUseToolEvents.map((e) => ({ tool: e.tool, postResult: e.postResult, at: e.at - PROBE_T0 })))}`);
+    console.log(`AskUserQuestion post-result: ${askPost.length}, pre-result: ${askPre.length}`);
+    console.log(`stream error: ${streamError ?? 'none'}`);
+    const GO = askPost.length > 0 && sawFollowupResult && !streamError;
+    console.log(`GO/NO-GO: ${GO
+      ? 'GO — post-result AskUserQuestion answered, injection round-tripped, follow-up result landed (control channel survives result)'
+      : askPost.length === 0
+        ? 'INCONCLUSIVE — no post-result AskUserQuestion observed (model may not have deferred it to the follow-up)'
+        : `NO-GO — ${streamError ? `control channel error on injection: ${streamError}` : 'no follow-up result after injection'}`}`);
+    pq.close();
+    controller.abort();
+    setTimeout(() => process.exit(0), 500);
+  })();
+
+  setTimeout(() => { if (!sawFollowupResult) { console.log('[interact] TIMEOUT — no follow-up result within 60s'); pq.close(); controller.abort(); setTimeout(() => process.exit(0), 500); } }, 60_000);
+}
+// ========================== bashkill mode (38.3 AC3) ==========================
+// A background Bash launched with the input channel kept OPEN (persistent stream):
+// does it survive past the historical ~5s kill point? We watch for the completion
+// notification landing near the full sleep (survived) vs an early stop/vanish (~5s).
+else if (MODE === 'bashkill') {
+  const iterator = q[Symbol.asyncIterator]();
+  const SLEEP_S = 20;
+  const t0 = Date.now();
+  let launchedAt = null;
+  let notif = null;       // { at, status }
+  let survivedResult = false;
+  const snapshotPolls = []; // { at, bg } — Stop snapshot bg count sampled over time
+  const poll = setInterval(() => {
+    const latest = stopSnapshots[stopSnapshots.length - 1];
+    snapshotPolls.push({ at: Math.round((Date.now() - t0) / 1000), bg: latest ? latest.tasks.length : -1 });
+  }, 1000);
+  pq.push(userMsg(
+    `Run a Bash command in the BACKGROUND (set run_in_background: true): \`sleep ${SLEEP_S}; echo probe-done\`. ` +
+    "As soon as it is launched, reply with the single word 'launched' and END YOUR TURN — do NOT wait for it. " +
+    "Later, when you receive the completion notification, reply with the single word 'SURVIVED' and end."));
+  (async () => {
+    try {
+      for (;;) {
+        const step = await iterator.next();
+        if (step.done) { console.log('[bashkill] stream ended'); break; }
+        const m = step.value;
+        if (m.type === 'system' && m.subtype === 'task_notification') {
+          notif = { at: Math.round((Date.now() - t0) / 1000), status: m.status };
+          console.log(`[bashkill] task_notification @t+${notif.at}s status=${notif.status}`);
+        }
+        if (m.type !== 'result') continue;
+        const latest = stopSnapshots[stopSnapshots.length - 1];
+        const tasks = latest ? latest.tasks.length : -1;
+        const at = Math.round((Date.now() - t0) / 1000);
+        console.log(`[bashkill] result @t+${at}s subtype=${m.subtype} bg=${tasks}`);
+        if (launchedAt === null) launchedAt = at;
+        // The follow-up result (after the completion notification) closes the turn.
+        if (launchedAt !== null && at > 6 && tasks === 0) { survivedResult = true; break; }
+      }
+    } catch (e) { console.error('[bashkill error]', e?.message || e); }
+    clearInterval(poll);
+
+    console.log(`\n=== verdict (mode=bashkill, AC3 gate) ===`);
+    console.log(`launched result @t+${launchedAt}s; Stop-snapshot bg over time: ${snapshotPolls.map((p) => `${p.at}s:${p.bg}`).join(' ')}`);
+    console.log(`completion notification: ${notif ? `@t+${notif.at}s status=${notif.status}` : 'NONE'}`);
+    // Survival = the sleep 20 ran to completion (notification near the full sleep,
+    // status completed) → no ~5s kill. A stop/failed near 5s = kill reproduced.
+    const survivedByNotif = !!notif && notif.status === 'completed' && notif.at >= 15;
+    const killedEarly = !!notif && notif.status !== 'completed' && notif.at <= 8;
+    const GO = (survivedByNotif || survivedResult) && !killedEarly;
+    console.log(`GO/NO-GO: ${GO
+      ? `GO — background Bash survived past 5s (${survivedByNotif ? `completion @t+${notif.at}s` : 'follow-up result reached'}); no ~5s kill with the input channel open`
+      : killedEarly
+        ? `NO-GO — background task terminated early (@t+${notif.at}s status=${notif.status}) → ~5s kill reproduced, needs root-cause`
+        : 'INCONCLUSIVE — no completion notification nor follow-up result within the window'}`);
+    pq.close();
+    controller.abort();
+    setTimeout(() => process.exit(0), 500);
+  })();
+
+  setTimeout(() => { if (!survivedResult) { console.log(`[bashkill] TIMEOUT — no closing follow-up result within ${SLEEP_S + 20}s`); clearInterval(poll); pq.close(); controller.abort(); setTimeout(() => process.exit(0), 500); } }, (SLEEP_S + 20) * 1000);
+}
+// ========================= longhold mode (38.6 AC1) ============================
+// Vitest-grade verification: a >1 minute background child must be tracked correctly
+// AND the same process must sustain a follow-up reuse turn after the hold→terminate.
+// Combines the hold (background hold→terminate) and residency (reuse) patterns.
+else if (MODE === 'longhold') {
+  const iterator = q[Symbol.asyncIterator]();
+  const SLEEP_S = 65;
+  const results = [];
+  const t0 = Date.now();
+  let holdDone = false;
+  let reuseDone = false;
+  pq.push(userMsg(
+    `Run a Bash command in the BACKGROUND (set run_in_background: true): \`sleep ${SLEEP_S}; echo probe-done\`. ` +
+    "As soon as it is launched, reply 'launched' and END YOUR TURN — do NOT wait."));
+  (async () => {
+    try {
+      // Phase 1: hold→terminate (>1 min child)
+      for (;;) {
+        const step = await iterator.next();
+        if (step.done) { console.log('[longhold] stream ended during phase 1'); break; }
+        const m = step.value;
+        if (m.type !== 'result') continue;
+        const latest = stopSnapshots[stopSnapshots.length - 1];
+        const tasks = latest ? latest.tasks.length : -1;
+        const at = Date.now() - t0;
+        results.push({ phase: 1, at, tasks });
+        console.log(`[longhold] phase1 result #${results.length} @t+${at}ms — bg=${tasks}`);
+        if (tasks === 0) { holdDone = true; console.log('[longhold] hold→terminate complete'); break; }
+        console.log('[longhold] holding (bg in flight)...');
+      }
+      // Phase 2: reuse turn on the same process (residency survival after hold)
+      if (holdDone) {
+        const pushedAt = Date.now();
+        pq.push(userMsg('Reply with exactly one word: REUSED'));
+        for (;;) {
+          const step = await iterator.next();
+          if (step.done) { console.log('[longhold] stream ended during phase 2'); break; }
+          if (step.value.type !== 'result') continue;
+          const at = Date.now() - t0;
+          const ttfm = Date.now() - pushedAt;
+          results.push({ phase: 2, at, ttfm });
+          console.log(`[longhold] phase2 result @t+${at}ms ttfm=${ttfm}ms — reuse turn confirmed`);
+          reuseDone = true;
+          break;
+        }
+      }
+    } catch (e) { console.error('[longhold error]', e?.message || e); }
+
+    const holdResults = results.filter((r) => r.phase === 1);
+    const firstHold = holdResults[0];
+    const lastHold = holdResults[holdResults.length - 1];
+    const holdDurationMs = firstHold && lastHold ? lastHold.at - firstHold.at : 0;
+    const reuseResult = results.find((r) => r.phase === 2);
+    console.log(`\n=== verdict (mode=longhold, 38.6 AC1 gate) ===`);
+    console.log(`hold phase: ${holdResults.length} result(s), duration=${holdDurationMs}ms (${Math.round(holdDurationMs / 1000)}s)`);
+    for (const r of holdResults) console.log(`  phase1 @t+${r.at}ms bg=${r.tasks}`);
+    if (reuseResult) console.log(`reuse phase: @t+${reuseResult.at}ms ttfm=${reuseResult.ttfm}ms`);
+    const childExceeded60s = holdDurationMs > 55_000;
+    console.log(`(a) running period ≥1 task captured: ${firstHold && firstHold.tasks > 0}`);
+    console.log(`(b) completion bg=0: ${holdDone && lastHold?.tasks === 0}`);
+    console.log(`(c) hold→terminate correct: ${holdDone}`);
+    console.log(`(d) reuse turn same process: ${reuseDone}${reuseResult ? ` (ttfm=${reuseResult.ttfm}ms — no cold-spawn warmup)` : ''}`);
+    console.log(`child exceeded 60s: ${childExceeded60s} (hold duration=${Math.round(holdDurationMs / 1000)}s)`);
+    const GO = holdDone && reuseDone && firstHold?.tasks > 0 && childExceeded60s;
+    console.log(`GO/NO-GO: ${GO
+      ? `GO — vitest-grade (${Math.round(holdDurationMs / 1000)}s) background child tracked, hold→terminate correct, reuse turn confirmed`
+      : !holdDone ? 'NO-GO — hold did not terminate'
+      : !childExceeded60s ? `PARTIAL — mechanism correct but child only ran ${Math.round(holdDurationMs / 1000)}s (<60s threshold)`
+      : 'PARTIAL — hold OK but reuse turn did not complete'}`);
+    pq.close();
+    controller.abort();
+    setTimeout(() => process.exit(0), 500);
+  })();
+
+  setTimeout(() => {
+    if (!holdDone || !reuseDone) {
+      console.log(`[longhold] TIMEOUT — holdDone=${holdDone} reuseDone=${reuseDone}`);
+      pq.close(); controller.abort(); setTimeout(() => process.exit(0), 500);
+    }
+  }, (SLEEP_S + 30) * 1000);
+}
+// ============================ hold mode (38.2 AC5) =============================
+// Validates that with the 45s follow-up grace REMOVED, a turn that holds on an
+// in-flight background task still terminates on its own: launch a background bash,
+// keep consuming, and confirm a follow-up result eventually arrives whose main Stop
+// reports background_tasks EMPTY (hadInFlight=false) — the turn's true end. No hang.
+else if (MODE === 'hold') {
+  const iterator = q[Symbol.asyncIterator]();
+  const results = []; // { at, mainStopTasks }
+  pq.push(userMsg(
+    "Run a Bash command in the BACKGROUND (set run_in_background: true): `sleep 6; echo probe-done`. " +
+    "As soon as it is launched, reply 'launched' and END YOUR TURN — do NOT wait. " +
+    "Later, when you get the completion notification, reply 'FOLLOWUP_OK'."));
+  const startedAt = Date.now();
+  let done = false;
+  (async () => {
+    try {
+      for (;;) {
+        const step = await iterator.next();
+        if (step.done) { console.log('[hold] stream ended'); break; }
+        const m = step.value;
+        if (m.type !== 'result') { continue; }
+        // Latest main Stop snapshot at this result (mirrors processStream consume).
+        const latest = stopSnapshots[stopSnapshots.length - 1];
+        const tasks = latest ? latest.tasks.length : -1;
+        results.push({ at: Date.now() - startedAt, tasks });
+        console.log(`[hold] result #${results.length} @t+${Date.now() - startedAt}ms — main Stop background_tasks=${tasks}`);
+        // Turn boundary per 38.2: end when the main Stop reports nothing in flight.
+        if (tasks === 0) { done = true; console.log('[hold] hadInFlight=false → turn ends (no grace needed)'); break; }
+        console.log('[hold] hadInFlight=true → HOLD (keep consuming for the live follow-up)');
+      }
+    } catch (e) { console.error('[hold error]', e?.message || e); }
+
+    console.log(`\n=== verdict (mode=hold, AC5 gate) ===`);
+    console.log(`results seen: ${results.map((r) => `t+${r.at}ms/tasks=${r.tasks}`).join(' → ')}`);
+    console.log(`GO/NO-GO: ${done
+      ? 'GO — hold terminated at an empty-Stop follow-up result WITHOUT any 45s grace (no hang)'
+      : 'NO-GO — turn did not reach an empty-Stop result within the window (would hang without grace)'}`);
+    pq.close();
+    controller.abort();
+    setTimeout(() => process.exit(0), 500);
+  })();
+
+  // Safety: hard stop if it hangs (proves NO-GO rather than blocking forever).
+  setTimeout(() => { if (!done) { console.log('[hold] TIMEOUT — no empty-Stop result within 40s'); pq.close(); controller.abort(); setTimeout(() => process.exit(0), 500); } }, 40_000);
+}
+// ============================ order mode (38.2 AC7) ============================
+// Drives TWO sequential turns on ONE persistent stream and measures, at the moment
+// each turn-ending `result` is dequeued, whether that turn's main Stop already fired.
+else if (MODE === 'order') {
+  const iterator = q[Symbol.asyncIterator]();
+  const turns = [];
+
+  // Await the next turn-ending `result`, recording the ordering vs main Stop.
+  const runTurn = async (label, text) => {
+    const mainStopsBefore = stopSnapshots.length;
+    const pushedAt = Date.now();
+    pq.push(userMsg(text));
+    for (;;) {
+      const step = await iterator.next();
+      if (step.done) { console.log(`[${label}] stream ended unexpectedly`); break; }
+      const m = step.value;
+      if (m.type !== 'result') continue;
+      const resultAt = Date.now();
+      // Main Stop snapshots that arrived DURING this turn (after the push).
+      const turnStops = stopSnapshots.slice(mainStopsBefore);
+      const stopBeforeResult = turnStops.length > 0;
+      const stopAt = turnStops.length ? turnStops[turnStops.length - 1].at : null;
+      const rec = {
+        label,
+        subtype: m.subtype,
+        deltaMs: stopAt !== null ? resultAt - stopAt : null, // >0 = Stop before result
+        stopBeforeResult,
+        hadInFlight: turnStops.length ? turnStops[turnStops.length - 1].tasks.length > 0 : null,
+        elapsedMs: resultAt - pushedAt,
+      };
+      turns.push(rec);
+      console.log(`[${label}] result subtype=${m.subtype} @t+${rec.elapsedMs}ms — mainStopBeforeResult=${stopBeforeResult}` +
+        (stopAt !== null ? ` (Stop ${rec.deltaMs >= 0 ? 'led result by' : 'trailed result by'} ${Math.abs(rec.deltaMs)}ms)` : ' (Stop NOT yet fired at result)'));
+      // If Stop had not fired at result, poll briefly to see how late it lands.
+      if (!stopBeforeResult) {
+        const waitStart = Date.now();
+        while (stopSnapshots.length === mainStopsBefore && Date.now() - waitStart < 2000) {
+          await new Promise((r) => setTimeout(r, 5));
+        }
+        if (stopSnapshots.length > mainStopsBefore) {
+          rec.stopLagMs = Date.now() - resultAt;
+          console.log(`[${label}] main Stop landed ${rec.stopLagMs}ms AFTER result (NO-GO signal)`);
+        } else {
+          console.log(`[${label}] main Stop still not fired 2s after result`);
+        }
+      }
+      break;
+    }
+  };
+
+  (async () => {
+    try {
+      await runTurn('simple', 'Reply with the single word: OK');
+      await runTurn('background',
+        "Run a Bash command in the BACKGROUND (set run_in_background: true): `sleep 30; echo probe-done`. " +
+        "As soon as it is launched in the background, reply with the single word 'launched' and END YOUR TURN — do NOT wait for it to finish.");
+    } catch (e) {
+      console.error('[order driver error]', e?.message || e);
+    }
+
+    console.log(`\n=== verdict (mode=order, AC7 gate) ===`);
+    for (const t of turns) {
+      console.log(`  ${t.label}: stopBeforeResult=${t.stopBeforeResult}` +
+        (t.deltaMs !== null ? `, Stop→result delta=${t.deltaMs}ms` : '') +
+        (t.stopLagMs !== undefined ? `, stopLagAfterResult=${t.stopLagMs}ms` : '') +
+        `, hadInFlight=${t.hadInFlight}`);
+    }
+    const allBefore = turns.length > 0 && turns.every((t) => t.stopBeforeResult);
+    const maxLag = turns.reduce((mx, t) => Math.max(mx, t.stopLagMs ?? 0), 0);
+    console.log(`GO/NO-GO: ${allBefore
+      ? 'GO — main Stop present in ledger at every result (read snapshot directly at result)'
+      : `NO-GO — Stop trailed result (max observed lag ${maxLag}ms) → bounded micro-grace needed`}`);
+
+    pq.close();
+    controller.abort();
+    setTimeout(() => process.exit(0), 500);
+  })();
+} else {
+// ========================== smoke / subagent modes ============================
+const prompt = MODE === 'subagent'
+  ? "Use the Agent tool to launch a subagent in the BACKGROUND (set run_in_background: true) with subagent_type 'general-purpose'. Its task prompt: run a Bash command `sleep 45; echo probe-done`. As soon as you have launched it in the background, reply with the single word 'launched' and END YOUR TURN — do NOT wait for the subagent to finish."
+  : "Reply with the single word: OK";
+
+console.log(`=== probe mode=${MODE} — pushing prompt, streaming... ===`);
+pq.push(userMsg(prompt));
+
+let idleProbeDone = false;
+const startedAt = Date.now();
+
+// Consume the persistent message stream.
+(async () => {
+  try {
+    for await (const m of q) {
+      if (m.type === 'result') {
+        console.log(`[result] subtype=${m.subtype} (t+${Date.now() - startedAt}ms)`);
+        // Idle-next() blocking probe: after the first result the stream should NOT
+        // end; the next iteration blocks awaiting either a follow-up or close().
+        if (!idleProbeDone) { idleProbeDone = true; console.log('[idle] stream held open past result (next() awaiting follow-up/close)'); }
+      } else {
+        console.log(`[msg] ${m.type}`);
+      }
+    }
+    console.log('[stream] generator ended (query closed)');
+  } catch (e) {
+    console.error('[stream error]', e?.message || e);
+  }
+})();
+
+const DURATION = MODE === 'subagent' ? 95_000 : 25_000;
+setTimeout(() => {
+  console.log(`\n=== verdict (mode=${MODE}) ===`);
+  console.log(`Stop snapshots: ${stopSnapshots.length}`);
+  console.log(`SubagentStop hooks: ${subagentStops.length}`);
+  console.log(`Task events: ${JSON.stringify(taskEvents)}`);
+
+  const anyStopFired = stopSnapshots.length > 0;
+  console.log(`HOOKS-IN-PERSISTENT-STREAM: ${anyStopFired ? 'CONFIRMED (Stop fired in-process)' : 'NOT OBSERVED'}`);
+
+  if (MODE === 'subagent') {
+    const subagentInStop = stopSnapshots.some((s) => s.tasks.some((t) => t.type === 'subagent' || t.agent_type));
+    const subagentInSubagentStop = subagentStops.some((s) => s.tasks.length > 0 || s.agent_type);
+    console.log(`Subagent seen in Stop.background_tasks[]: ${subagentInStop}`);
+    console.log(`Subagent seen via SubagentStop: ${subagentInSubagentStop}`);
+    console.log(`GO/NO-GO: ${subagentInStop ? 'GO (Stop tracks subagent)' : subagentInSubagentStop ? 'NO-GO for Stop / SubagentStop is a viable fallback' : 'INCONCLUSIVE (subagent never observed — model may not have backgrounded it)'}`);
+  }
+
+  pq.close();
+  controller.abort();
+  setTimeout(() => process.exit(0), 500);
+}, DURATION);
+}