elanous 0.2.37 → 0.2.38

package/src/dashboard/input/terminal-modal-router.ts

@@ -1,159 +1,8 @@
-// Dashboard key routing for interactive terminal modals.
-//
-// Holds singleton state for "which interactive terminal modal is
-// currently foregrounded" + the key-intercept policy:
-//
-//   • while a modal is present, ESC / Ctrl-G dispose it
-//   • all other keys forward to modal.surface.onKey(ev) so the PTY
-//     receives them without the chat readKey loop trying to
-//     interpret them
-//
-// Kept as a standalone module so the policy is unit-testable
-// without standing up the full dashboard. dashboard.ts imports and
-// wires it into the top of its stdin handler in a follow-up commit.
-//
-// P10 will extend this with Ctrl-B prefix handling (d=detach,
-// s=switch, etc.) once a session registry exists to act on.
-
-import type { InteractiveTerminalModalHandle } from '../../interactive-terminal-modal.js';
-import type { KeyEvent } from '../../display/types.js';
-import { debug } from '../../debug/log.js';
-
-export type KeyRouteResult = 'consumed' | 'passthrough' | 'closed';
-
-export interface TerminalModalRouter {
-  current(): InteractiveTerminalModalHandle | null;
-  /** Install a modal handle. Optional closePolicy controls what
-   *  ESC/Ctrl-G does: 'kill' disposes the modal + PTY (default);
-   *  'detach' calls handle.dispose({keepPreview:true}) so the PTY
-   *  survives for re-attach (session registry flow). An explicit
-   *  onClose hook wins over closePolicy — that's how dashboard
-   *  wires sessionRegistry.detach(session.id) on Esc. */
-  set(
-    handle: InteractiveTerminalModalHandle | null,
-    opts?: { closePolicy?: 'kill' | 'detach'; onClose?: () => void },
-  ): void;
-  close(): void;
-  handleKey(ev: KeyEvent): KeyRouteResult;
-}
-
-// `exit` typed cleanly + Enter closes the popup. claude / codex don't
-// recognize plain `exit` (their command is /exit or /quit), so a user
-// typing `exit\n` would otherwise be stuck — the popup stays open
-// because the child never exits, and the typed text just becomes chat
-// input. elanous intercepts the exact sequence at the router so:
-//   • plain shell: same end result (we close before shell evaluates)
-//   • claude / codex: popup closes as the user expected
-// Sequence is reset on any non-letter key (other than backspace, which
-// rewinds), Ctrl/Alt modifiers, or any character outside `e/x/i/t` —
-// so genuine words containing "exit" (e.g. typing "exit this loop"
-// into a claude prompt without Enter) DON'T trigger the close. The
-// trigger is specifically `e`, `x`, `i`, `t`, Enter with nothing else.
-const EXIT_CHARS = ['e', 'x', 'i', 't'] as const;
-
-export function createTerminalModalRouter(): TerminalModalRouter {
-  let handle: InteractiveTerminalModalHandle | null = null;
-  let closePolicy: 'kill' | 'detach' = 'kill';
-  let onClose: (() => void) | null = null;
-  let exitProgress = 0; // how many of EXIT_CHARS have been typed in order
-
-  const close = (): void => {
-    if (!handle) return;
-    const h = handle;
-    const cb = onClose;
-    if (debug.enabled) debug.log('window.terminalModalRouter.close', h.id, { id: h.id, closePolicy, hasOnClose: !!cb });
-    handle = null;
-    onClose = null;
-    exitProgress = 0;
-    try {
-      if (cb) cb();
-      else if (closePolicy === 'detach') h.dispose({ keepPreview: true });
-      else h.dispose();
-    } catch { /* already disposed */ }
-    closePolicy = 'kill';
-  };
-
-  return {
-    current: () => handle,
-    set: (h, opts) => {
-      if (handle && h && handle.id !== h.id) close();
-      handle = h;
-      closePolicy = opts?.closePolicy ?? 'kill';
-      onClose = opts?.onClose ?? null;
-      exitProgress = 0;
-      if (debug.enabled) {
-        debug.log('window.terminalModalRouter.set', h?.id ?? '(null)', {
-          id: h?.id ?? null,
-          closePolicy,
-          hasOnClose: !!onClose,
-        });
-      }
-    },
-    close,
-    handleKey: (ev) => {
-      if (!handle) return 'passthrough';
-      const name = (ev.name ?? '').toLowerCase();
-      // ESC must NOT close the modal — claude / codex inside the popup
-      // use ESC to cancel an in-progress chat / tool turn. Closing the
-      // wrapper window on ESC made the only-way-to-cancel kill the
-      // whole popup. iTerm / ghostty don't close their own windows on
-      // ESC either; the wrapper should match. Modal close is reserved
-      // for: Ctrl+G (close + focus log), Ctrl+Shift+T (toggle off),
-      // typed `exit\n`, and the child's own `exit`. ESC just forwards.
-      if (ev.ctrl && (name === 'g' || name === 'ㅎ')) {
-        if (debug.enabled) debug.log('window.terminalModalRouter.handleKey.close', 'ctrl-g', { id: handle.id });
-        close();
-        return 'closed';
-      }
-
-      // Track typed `exit` followed by Enter so the user's natural
-      // mental model ("type exit to quit") works inside agent popups
-      // (claude / codex) where the child app doesn't recognize a bare
-      // `exit` command. See EXIT_CHARS comment above for false-positive
-      // avoidance.
-      const noMods = !ev.ctrl && !ev.alt;
-      if (noMods && name === 'enter' && exitProgress === EXIT_CHARS.length) {
-        if (debug.enabled) {
-          debug.log('window.terminalModalRouter.handleKey.close', 'typed-exit', {
-            id: handle.id,
-          });
-        }
-        close();
-        return 'closed';
-      }
-      if (noMods && name === 'backspace') {
-        if (exitProgress > 0) exitProgress--;
-      } else if (noMods && name.length === 1 && exitProgress < EXIT_CHARS.length && name === EXIT_CHARS[exitProgress]) {
-        exitProgress++;
-      } else if (noMods && name === 'enter') {
-        // Enter without a complete `exit` prefix — reset and forward.
-        exitProgress = 0;
-      } else if (name.length === 1 || name === 'space' || ev.ctrl || ev.alt) {
-        // Any other printable key OR a modifier keystroke breaks the
-        // streak. Multi-char named keys (arrow / fn / etc.) leave the
-        // streak alone — the child may consume them without affecting
-        // the user's typed prompt buffer.
-        exitProgress = 0;
-      }
-
-      if (debug.enabled) {
-        debug.log('window.terminalModalRouter.handleKey.forward', name || '(empty)', {
-          id: handle.id,
-          name,
-          ctrl: ev.ctrl ?? false,
-          shift: ev.shift ?? false,
-          alt: ev.alt ?? false,
-          exitProgress,
-        });
-      }
-      try {
-        handle.surface.onKey?.(ev);
-      } catch { /* surface disposed mid-event; treat as no-op */ }
-      return 'consumed';
-    },
-  };
-}
-
-/** Singleton instance used by dashboard.ts. Exported as a separate
- *  factory + singleton so tests can inject a fresh router per case. */
-export const terminalModalRouter = createTerminalModalRouter();
+// Compatibility entry for dashboard-owned consumers. The routing policy is
+// shared with the standalone Next TUI from src/terminal.
+export {
+  createTerminalModalRouter,
+  terminalModalRouter,
+  type KeyRouteResult,
+  type TerminalModalRouter,
+} from '../../terminal/terminal-modal-router.js';

package/src/dashboard/side-basic-runtime.ts

@@ -0,0 +1,61 @@
+import { loadSidetabRows, type SidetabRow } from '../tui/sidetab/list.js';
+import { stripAnsi, termSize } from '../tui.js';
+import { requestRemotePtyControl } from '../pty-shell/pty-control-ipc.js';
+import type { SlashCommandRegistry } from './slash-runtime/registry.js';
+import type { DashboardSlashContext, DashboardSlashReturn } from './slash-runtime/dashboard-handlers.js';
+
+/** Classic /side: the Next TUI manifest is the sole source of list ordering. */
+export function registerClassicSideSlash(
+  registry: SlashCommandRegistry<DashboardSlashContext, DashboardSlashReturn>,
+  loadRows: (sessionId?: string) => SidetabRow[] = (sessionId) => loadSidetabRows(false, sessionId),
+  snapshot: typeof requestRemotePtyControl = requestRemotePtyControl,
+): void {
+  registry.register(['side'], async (args, ctx) => {
+    const sub = (args[0] ?? 'list').toLowerCase();
+    if (sub === 'new') {
+      if (args.length > 1) ctx.chatLines.push(ctx.warning('  사용법: /side new'));
+      else ctx.termSlash.openNewTerminal();
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    if (sub !== 'list' && sub !== 'attach') {
+      ctx.chatLines.push(ctx.muted('  사용법: /side [list] | new | attach <번호>'));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    // Use the same filtered manifest rows for display and numeric resolution;
+    // never let an exited row shift the number shown to the user.
+    const rows = loadRows(ctx.chatPersona?.sessionId()).filter(row => row.badge !== 'exited');
+    if (sub === 'list') {
+      if (rows.length === 0) ctx.chatLines.push(ctx.muted('  사이드탭 없음'));
+      rows.forEach((row, i) => ctx.chatLines.push(ctx.muted(`  ${i + 1}. ${row.badge} ${row.label}`)));
+      ctx.setChatScrollOffset(-1);
+      return;
+    }
+    const raw = args[1] ?? '';
+    const index = /^\d+$/.test(raw) ? Number(raw) - 1 : -1;
+    const row = rows[index];
+    if (args.length !== 2 || !row) {
+      ctx.chatLines.push(ctx.warning('  사용법: /side attach <목록 번호>'));
+    } else if (row.currentProcess) {
+      ctx.chatLines.push(ctx.muted('  현재 세션입니다'));
+    } else if (row.sessionId && ctx.termSlash.sessionRegistry.get(row.sessionId)) {
+      const { cols, rows: height } = termSize();
+      const session = ctx.termSlash.sessionRegistry.attach(row.sessionId, { termCols: cols, termRows: height });
+      if (session?.modal) ctx.termSlash.openSession(session);
+      else ctx.chatLines.push(ctx.warning('  PTY attach 실패'));
+    } else if (row.ptyId) {
+      try {
+        // A foreign child belongs to another PTY owner: snapshot only, no takeover.
+        const result = await snapshot(row.ptyId, 'snapshot', { ansi: false }, { timeoutMs: 450 });
+        if (result.status === 'success' && result.screen?.trim()) {
+          ctx.chatLines.push(ctx.muted(`  ${row.label} · 읽기 전용 snapshot (입력은 전달되지 않습니다)`));
+          ctx.chatLines.push(...stripAnsi(result.screen).split('\n'));
+        } else ctx.chatLines.push(ctx.warning(`  PTY 화면 읽기 실패 · ${result.status}`));
+      } catch (error) {
+        ctx.chatLines.push(ctx.warning(`  PTY 화면 읽기 오류 · ${error instanceof Error ? error.message : String(error)}`));
+      }
+    } else ctx.chatLines.push(ctx.warning('  attach할 PTY가 없습니다'));
+    ctx.setChatScrollOffset(-1);
+  });
+}

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -387,6 +387,7 @@ import { readDashboardAskClarification } from './ask-clarification.js';
 export { readDashboardAskClarification };
 import { createLoopScheduler, type LoopScheduler } from '../loop-scheduler.js';
 import { registerShellSlash } from './shell-slash.js';
+import { registerClassicSideSlash } from '../side-basic-runtime.js';
 export { registerShellSlash } from './shell-slash.js';
 import { registerMissionSlash } from '../../tui/slash/mission.js';
 // TUI-SLASH-SPLIT-MISSION(D4b) — /mission 은 src/tui/slash/mission.ts 로 이사. 옛 입구 re-export shim 은 slash-runtime/index.ts 한 곳뿐(RFC A5).
@@ -2577,6 +2578,7 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
 
 
   registerShellSlash(registry);
+  registerClassicSideSlash(registry);
 
   // ── B-3.b ─────────────────────────────────────────────────────────
 

package/src/dashboard/term-slash-runtime.ts

@@ -127,6 +127,8 @@ export function createDashboardTermSlashRuntime(
       deps.muted('  /term list                List all alive sessions (fg / bg / exited).'),
       deps.muted('  /term attach <id>         Bring a backgrounded session to foreground.'),
       deps.muted('  /term detach              Send foreground session to background (PTY survives).'),
+      deps.muted('  Ctrl+B (while streaming)  Background running child tasks; turn continues.'),
+      deps.muted('  Ctrl+X c (chat input)     Enter control mode.'),
       deps.muted('  /term switch              Open the session picker modal.'),
       deps.muted('  /term kill <id>           Stop the PTY and remove the session.'),
       deps.muted('  /term snapshot <id> [tail [bytes]]   Capture current grid (snapshot) or last N bytes (tail).'),

package/src/dashboard/turn-preamble.ts

@@ -25,6 +25,7 @@ import { buildConcisenessSystemMessages } from '../prompt-library/chat-concisene
 import {
   buildSessionRuntimeSystemMessages,
   buildSessionRuntimeTurnSystemMessages,
+  buildResearchDateSystemMessage,
   type SessionTurnProfile,
 } from '../session-runtime/index.js';
 import { buildExecutionAskSystemMessages } from '../ask-user-question/index.js';
@@ -208,9 +209,13 @@ function buildDashboardTurnPreambleUnmeasured(
     gitSnapshotStaleMs: DASHBOARD_GIT_SNAPSHOT_STALE_MS,
   }));
   const turnProfile = ctx.turnProfile;
+  const researchTurn = turnProfile?.surface.id === 'research/agent';
   const surfaceSystemMsgs = turnProfile
     ? timed(builderMs, 'surface', () => buildSessionRuntimeTurnSystemMessages(turnProfile, ctx.userText))
     : ([] as LLMMessage[]);
+  if (researchTurn) {
+    surfaceSystemMsgs.push(buildResearchDateSystemMessage());
+  }
   // ⭐⭐ `tools.nativeStructure` 는 «어느 provider 에 켤지»를 목록으로 고를 수 있다(2026-08-18).
   //   ⛔ 목록이 없으면 종전대로 «전 provider» — 기존 설정을 쓰는 사람의 값이 안 바뀐다.
   //   ⛔ `config.llm.provider` 를 그대로 읽지 않는다. 그것은 `'auto'` 일 수 있고,
@@ -240,9 +245,9 @@ function buildDashboardTurnPreambleUnmeasured(
     nativeStructureEnabled,
     ...(nativeTools !== undefined ? { enabledTools: nativeTools } : {}),
   }) as LLMMessage[]);
-  const concisenessSystemMsgs = timed(builderMs, 'conciseness', () => buildConcisenessSystemMessages(
-    ctx.userConfig.chat.conciseness,
-  ) as LLMMessage[]);
+  const concisenessSystemMsgs = timed(builderMs, 'conciseness', () => researchTurn
+    ? [] as LLMMessage[]
+    : buildConcisenessSystemMessages(ctx.userConfig.chat.conciseness) as LLMMessage[]);
   // ★ elanous 자기접근 규율 + 자기인지 ambient(P3 · 2026-07-13) — 텔레그램/디스코드
   //   (makeElanousAgentRunTurn)와 단일 출처(agent/self-ambient.ts). TUI 채팅에서도 미션
   //   진단("P2 왜 실패?")·자율 시스템 관측·회상이 규율+ambient+툴(self-ops family) 3박자로
@@ -313,10 +318,29 @@ function buildDashboardTurnPreambleUnmeasured(
   let taskNotificationCount = 0;
   try {
     timed(builderMs, 'taskNotifications', () => {
+      // ACP may ask for a preamble while the session is idle. Keep queued
+      // completion receipts for the next actual user/auto-wake turn.
+      if (!ctx.userText.trim()) return;
+      const notificationOnlyWake = /(?:^|\n)(?:Question: )?\[자동 재개\] 위임 끝: .+ \((?:done|error|aborted)\) — <task-notification> 의 결과를 읽고 이어서 처리$/u
+        .test(ctx.userText);
+      if (notificationOnlyWake) {
+        preamble.push({ role: 'system', content: '[알림 전용 턴] 이것은 완료 알림을 전달한 비요청 status receipt다. 작업 요청으로 취급하지 말고 Agent 또는 SelfImplement 위임을 시작하지 않는다. 포함된 결과를 바탕으로 한 번의 간결한 상태 요약만 답하고 멈춘다. 결과가 전달되지 않았다면 결과가 아직 제공되지 않았다고 알리고 내용을 추측하지 않는다.' });
+      }
       const pendingNotifications = globalTaskNotificationQueue.drain();
       taskNotificationCount = pendingNotifications.length;
-      const taskNotificationsXml = renderTaskNotificationsXml(pendingNotifications);
+      if (pendingNotifications.length === 0) {
+        if (notificationOnlyWake) {
+          debug.log('tui.notify', 'notification-only-turn', { notificationCount: 0, resultAvailable: false });
+        }
+        return;
+      }
+      const taskNotificationsXml = renderTaskNotificationsXml(pendingNotifications, {
+        statusReceipt: notificationOnlyWake,
+      });
       if (taskNotificationsXml) {
+        debug.log('tui.notify', notificationOnlyWake ? 'notification-only-turn' : 'notification-with-user-request', {
+          notificationCount: pendingNotifications.length,
+        });
         preamble.push({ role: 'user', content: taskNotificationsXml });
       }
     });

package/src/domains/guardian-tick.ts

@@ -19,6 +19,8 @@ export interface GuardianDeps {
   execute?: (command: string) => Promise<SpawnOutcome>;
   /** Injected only for deterministic expiry-alert tests. Production reads the local Grok auth file. */
   grokExpiry?: () => string | null;
+  /** Injected in tests; production reevaluates recorded doctor visits without dispatching a prescription. */
+  doctorShadow?: () => void | Promise<void>;
   hostName?: string;
 }
 
@@ -100,6 +102,13 @@ export async function guardianTick(now: Date, plan: GuardianPlan, deps: Guardian
       errorName: error instanceof Error ? error.name : 'unknown',
     });
   }
+  try {
+    await deps.doctorShadow?.();
+  } catch (error) {
+    debug.log('guardian.doctor-shadow', 'reevaluation-failed', {
+      errorName: error instanceof Error ? error.name : 'unknown',
+    });
+  }
   const timeZone = plan.timeZone ?? resolveTimeZone().timeZone;
   const wouldRun: string[] = [];
   let executed = 0;

package/src/git-fs/watcher.ts

@@ -1,6 +1,6 @@
 // ── git-fs watcher ──
 //
-// fs.watchFile() on the small set of files whose change indicates
+// fs.watchFile() polls the small set of entries whose replacement indicates
 // the branch or the current commit moved:
 //
 //   <gitDir>/HEAD                    branch switch / detach
@@ -15,7 +15,7 @@
 // watching the whole working tree. The dirty probe is throttled
 // separately.
 
-import { watch, type FSWatcher } from 'node:fs';
+import { unwatchFile, watchFile, type Stats } from 'node:fs';
 import { join } from 'node:path';
 import type { GitHeadInfo } from './types.js';
 import type { LocatedGit } from './locate.js';
@@ -24,9 +24,9 @@ type Listener = () => void;
 
 export class GitFileWatcher {
   private readonly listeners = new Set<Listener>();
-  private headWatcher: FSWatcher | null = null;
-  private refWatcher: FSWatcher | null = null;
-  private packedRefsWatcher: FSWatcher | null = null;
+  private headWatcher: { stop: () => void } | null = null;
+  private refWatcher: { stop: () => void } | null = null;
+  private packedRefsWatcher: { stop: () => void } | null = null;
   private currentBranch: string | null = null;
   private disposed = false;
 
@@ -54,7 +54,7 @@ export class GitFileWatcher {
     const next = head?.branch ?? null;
     if (next === this.currentBranch) return;
     this.currentBranch = next;
-    if (this.refWatcher) { this.refWatcher.close(); this.refWatcher = null; }
+    if (this.refWatcher) { this.refWatcher.stop(); this.refWatcher = null; }
     this.installRefWatcher();
   }
 
@@ -62,9 +62,9 @@ export class GitFileWatcher {
     if (this.disposed) return;
     this.disposed = true;
     this.listeners.clear();
-    if (this.headWatcher) { try { this.headWatcher.close(); } catch {} }
-    if (this.refWatcher) { try { this.refWatcher.close(); } catch {} }
-    if (this.packedRefsWatcher) { try { this.packedRefsWatcher.close(); } catch {} }
+    if (this.headWatcher) { try { this.headWatcher.stop(); } catch {} }
+    if (this.refWatcher) { try { this.refWatcher.stop(); } catch {} }
+    if (this.packedRefsWatcher) { try { this.packedRefsWatcher.stop(); } catch {} }
     this.headWatcher = null;
     this.refWatcher = null;
     this.packedRefsWatcher = null;
@@ -77,10 +77,22 @@ export class GitFileWatcher {
     }
   }
 
+  private watchPath(path: string): { stop: () => void } {
+    const onChange = (current: Stats, previous: Stats) => {
+      if (current.mtimeMs !== previous.mtimeMs || current.ino !== previous.ino || current.size !== previous.size) {
+        this.fire();
+      }
+    };
+    watchFile(path, { interval: 250, persistent: false }, onChange);
+    return { stop: () => unwatchFile(path, onChange) };
+  }
+
   private installHeadWatcher(): void {
-    const path = join(this.located.gitDir, 'HEAD');
     try {
-      this.headWatcher = watch(path, { persistent: false }, () => this.fire());
+      // Git replaces HEAD atomically via HEAD.lock + rename. fs.watch can stay
+      // attached to the old inode or miss the event on loaded hosts; stat
+      // polling follows the path and observes the replacement.
+      this.headWatcher = this.watchPath(join(this.located.gitDir, 'HEAD'));
     } catch {
       // HEAD may not exist during `git init` transient state; swallow.
     }
@@ -89,19 +101,12 @@ export class GitFileWatcher {
   private installRefWatcher(): void {
     if (!this.currentBranch) return;
     const path = join(this.located.commonGitDir, 'refs', 'heads', ...this.currentBranch.split('/'));
-    try {
-      this.refWatcher = watch(path, { persistent: false }, () => this.fire());
-    } catch {
-      // Loose ref may be packed — rely on packed-refs watcher.
-    }
+    // Loose refs are atomically replaced on commit. Polling the path survives
+    // replacement and also detects a ref that is created after subscription.
+    this.refWatcher = this.watchPath(path);
   }
 
   private installPackedRefsWatcher(): void {
-    const path = join(this.located.commonGitDir, 'packed-refs');
-    try {
-      this.packedRefsWatcher = watch(path, { persistent: false }, () => this.fire());
-    } catch {
-      // No packed-refs yet — not an error.
-    }
+    this.packedRefsWatcher = this.watchPath(join(this.located.commonGitDir, 'packed-refs'));
   }
 }

package/src/git-fs/worktree.ts

@@ -61,13 +61,18 @@ function worktreeAddTimeoutForTrackedFileCount(trackedFileCount: number | null):
   return { ms: Math.min(WORKTREE_ADD_TIMEOUT_MAX_MS, Math.max(WORKTREE_ADD_TIMEOUT_MS, scaledMs)), trackedFileCount, source: 'tracked-files' };
 }
 
+export function worktreeAddTimeoutSec(seconds: number | undefined): number | undefined {
+  return typeof seconds === 'number' && Number.isSafeInteger(seconds) && seconds > 0 && seconds <= 2_147_483
+    ? seconds : undefined;
+}
+
 export function worktreeAddTimeoutForRepo(
   repoRoot: string,
   countTrackedFilesForRepo: (repoRoot: string, ref?: string) => number | null = countTrackedFiles,
   trackedFileRef?: string,
 ): WorktreeAddTimeout {
-  const seconds = getUserConfig().harness?.worktreeAddTimeoutSec;
-  if (typeof seconds === 'number' && Number.isSafeInteger(seconds) && seconds > 0 && seconds <= 2_147_483) {
+  const seconds = worktreeAddTimeoutSec(getUserConfig().harness?.worktreeAddTimeoutSec);
+  if (seconds !== undefined) {
     return { ms: seconds * 1000, trackedFileCount: null, source: 'config' };
   }
   return worktreeAddTimeoutForTrackedFileCount(countTrackedFilesForRepo(repoRoot, trackedFileRef));
@@ -347,7 +352,18 @@ function bakedDependenciesMatch(repoTree: string, bakedTree: string): boolean {
   } catch { return false; }
 }
 
-function prepareWorktreeDependencies(repoRoot: string, worktreePath: string, opts: CreateWorktreeOpts, deps: WorktreeAddDeps): void {
+/** Pod source may omit node_modules while the image carries matching baked dependencies. */
+export function worktreeDependenciesAvailable(repoRoot: string, fallbackRoot = GATE_DEPS_DIR): boolean {
+  for (const tree of GATE_DEPS_TREES) {
+    const repoTree = join(repoRoot, tree);
+    if (!existsSync(join(repoTree, 'package.json')) || !existsSync(join(repoTree, 'bun.lock'))) continue;
+    if (existsSync(join(repoTree, 'node_modules'))) continue;
+    if (!bakedDependenciesMatch(repoTree, join(fallbackRoot, tree))) return false;
+  }
+  return true;
+}
+
+export function prepareWorktreeDependencies(repoRoot: string, worktreePath: string, opts: Pick<CreateWorktreeOpts, 'dependencyFallbackRoot' | 'dependencyInstallTimeoutMs'>, deps: WorktreeAddDeps): void {
   const fallbackRoot = opts.dependencyFallbackRoot?.trim() || GATE_DEPS_DIR;
   const timeoutMs = opts.dependencyInstallTimeoutMs ?? WORKTREE_DEPENDENCY_INSTALL_TIMEOUT_MS;
   if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0) throw new Error('dependencyInstallTimeoutMs must be a positive integer');

package/src/graph-runner/graph-grow.ts

@@ -3,13 +3,10 @@ import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { createGraphVariant } from '../self-implement/graph-variant.js';
 import type { GraphEdgeSpec, GraphNodeSpec, GraphTemplateSpec } from '../self-implement/graph-yaml.js';
+import type { ResearchEdgeDecisionRegistry, ResearchEdgeProposal, ResolvedResearchEdgeDecision } from '../research/edge-decision.js';
 import { createLLMGrowthProposer } from './graph-grow-llm.js';
 
-export interface GrowthProposal {
-  node: GraphNodeSpec;
-  returnTo?: string;
-  reason: string;
-}
+export type GrowthProposal = ResearchEdgeProposal;
 
 export type GrowthProposer = (input: { graph: GraphTemplateSpec; nodeId: string; outcome: string; runId: string; output?: unknown }) => GrowthProposal | undefined | Promise<GrowthProposal | undefined>;
 export type GrowthRecipeEffect = 'read-only' | 'external-effect' | 'unknown';
@@ -68,10 +65,41 @@ export function growthDecision(input: Parameters<GrowthProposer>[0], proposal: G
 
 export async function proposeGrowth(input: Parameters<GrowthProposer>[0],
   proposer: GrowthProposer = createLLMGrowthProposer(), classifyRecipe?: (node: GraphNodeSpec) => GrowthRecipeEffect | GrowthRecipeClassification,
-  decisionDeps: GrowthDecisionDeps = {}): Promise<{ ok: true; graph: GraphTemplateSpec; growth: GraphGrowth } | { ok: false; reason: string; park?: boolean; growth?: GraphGrowth; decisionId?: string; decisionRef?: string; command?: GrowthCommand; approval?: string }> {
+  decisionDeps: GrowthDecisionDeps = {}, edgeDecisionRegistry?: ResearchEdgeDecisionRegistry): Promise<
+    | { ok: true; graph: GraphTemplateSpec; growth: GraphGrowth; edgeDecision?: ResolvedResearchEdgeDecision }
+    | { ok: false; reason: string; park?: boolean; growth?: GraphGrowth; decisionId?: string; decisionRef?: string; command?: GrowthCommand; approval?: string; edgeDecision?: ResolvedResearchEdgeDecision }
+  > {
   let proposal: GrowthProposal | undefined;
-  try { proposal = await proposer(input); }
-  catch (error) { return { ok: false, reason: `proposer failed: ${String(error)}` }; }
+  const value = input.output;
+  const assessment = value !== null && typeof value === 'object' && !Array.isArray(value)
+    && Array.isArray((value as Record<string, unknown>).gaps)
+    && Array.isArray((value as Record<string, unknown>).contradictions)
+    && Array.isArray((value as Record<string, unknown>).verdicts)
+    ? { gaps: (value as Record<string, unknown>).gaps as unknown[],
+      contradictions: (value as Record<string, unknown>).contradictions as unknown[],
+      verdicts: (value as Record<string, unknown>).verdicts as unknown[] }
+    : undefined;
+  let edgeDecision: ResolvedResearchEdgeDecision | undefined;
+  if (assessment) {
+    const [{ createResearchEdgeDecisionRegistry }, { debug }] = await Promise.all([
+      import('../research/edge-decision.js'), import('../debug/log.js'),
+    ]);
+    edgeDecision = await (edgeDecisionRegistry ?? createResearchEdgeDecisionRegistry()).decide(assessment);
+    try {
+      debug.log('research.edge', 'decision', {
+        provider: edgeDecision.provider,
+        decision: edgeDecision.action,
+        reason: edgeDecision.reason,
+      });
+    } catch { /* observation must not change graph growth */ }
+    if (edgeDecision.action !== 'add') {
+      return { ok: false, reason: `edge decision ${edgeDecision.action}: ${edgeDecision.reason}`, edgeDecision };
+    }
+    proposal = edgeDecision.proposal;
+  } else {
+    try { proposal = await proposer(input); }
+    catch (error) { return { ok: false, reason: `proposer failed: ${String(error)}` }; }
+  }
   if (!proposal) return { ok: false, reason: 'no proposal' };
   if (!proposal.node || typeof proposal.reason !== 'string' || !proposal.reason.trim()) return { ok: false, reason: 'proposal requires a node and reason' };
   let result: ReturnType<typeof createGraphVariant>;
@@ -99,5 +127,5 @@ export async function proposeGrowth(input: Parameters<GrowthProposer>[0],
         growth: proposalGrowth(input, proposal) };
     }
   }
-  return { ok: true, graph: result.template, growth: proposalGrowth(input, proposal) };
+  return { ok: true, graph: result.template, growth: proposalGrowth(input, proposal), ...(edgeDecision ? { edgeDecision } : {}) };
 }

package/src/graph-runner/runner.ts

@@ -17,6 +17,7 @@ import { recordFailureEvent } from '../self-implement/heal-intake.js';
 import { growthApprovalRef, proposeGrowth, type GraphGrowth, type GrowthProposer, type GrowthRecipeEffect, type GrowthDecisionDeps, type GrowthCommand } from './graph-grow.js';
 import { DecisionLedger, type DecisionEntry } from '../decisions/decision-ledger.js';
 import { createLLMGrowthProposer } from './graph-grow-llm.js';
+import type { ResearchEdgeDecisionRegistry } from '../research/edge-decision.js';
 import { graphVersionHash, parseGraphTemplateYaml, type GraphEdgeSpec, type GraphNodeSpec, type GraphTemplateSpec } from '../self-implement/graph-yaml.js';
 import { createGraphUnitResolver, resolveGraphUnit, UnitNotFoundError, type ResolvedGraphUnit } from '../self-implement/graph-unit-resolver.js';
 import { flattenGraphUnits } from '../self-implement/graph-unit-flatten.js';
@@ -34,6 +35,7 @@ const DEFAULT_BASH_TIMEOUT_MS = 5 * 60 * 1_000;
 // Independent of graph YAML and recipe snapshots: an already-wrong saved binding must fail closed.
 const RELEASE_NODE_COMMANDS: Readonly<Record<string, { recipe: string; command?: string }>> = {
   'version-release': { recipe: 'cmd:version-release', command: 'bun scripts/release-loop/version-node.ts release --json' },
+  'traffic-cut-start': { recipe: 'cmd:traffic-cut-start', command: 'bun scripts/release-loop/traffic-node.ts traffic-cut-start' },
   cutoff: { recipe: 'cmd:cutoff', command: 'bun scripts/release-loop/node-verdict.ts cutoff' },
   'checklist-gate': { recipe: 'cmd:checklist-gate', command: 'bun scripts/release-loop/checklist-gate-node.ts' },
   prefetch: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
@@ -55,9 +57,11 @@ const RELEASE_NODE_COMMANDS: Readonly<Record<string, { recipe: string; command?:
   'approve-publish': { recipe: 'approval:publish' },
   publish: { recipe: 'cmd:publish-command', command: 'bun scripts/release-loop/publish-node.ts' },
   'npm-publish': { recipe: 'cmd:npm-publish', command: 'bun scripts/release-loop/npm-publish-node.ts' },
+  'traffic-npm-published': { recipe: 'cmd:traffic-npm-published', command: 'bun scripts/release-loop/traffic-node.ts traffic-npm-published' },
   'docs-land': { recipe: 'cmd:docs-land', command: 'bun scripts/release-loop/docs-land-node.ts' },
   verify: { recipe: 'cmd:verify', command: 'bun scripts/release-loop/verify-node.ts' },
   'traffic-verify-complete': { recipe: 'cmd:traffic-verify-complete', command: 'bun scripts/release-loop/traffic-node.ts traffic-verify-complete' },
+  'traffic-failed-restore': { recipe: 'cmd:traffic-failed-restore', command: 'bun scripts/release-loop/traffic-node.ts traffic-failed-restore' },
   'vault-note': { recipe: 'cmd:vault-note', command: 'bun scripts/release-loop/vault-note-node.ts' },
   'release-story': { recipe: 'cmd:release-story', command: 'bun scripts/release-story/draft.ts --graph' },
   'ops-upgrade': { recipe: 'cmd:ops-upgrade', command: 'bun scripts/release-loop/ops-upgrade-node.ts' },
@@ -248,6 +252,8 @@ export interface GraphRunOptions {
   pinChildUniverse?: boolean;
   /** Release resume: command checkout and cut tip, checked before every Bash dispatch. */
   releaseCommandSource?: { root: string; cutTip: string; git?: (args: string[]) => string };
+  /** Optional per-run Bloom edge policy hook. */
+  researchEdgeDecisionRegistry?: ResearchEdgeDecisionRegistry;
   deps?: { root?: string; runBash?: BashRun; callLLM?: (prompt: string) => Promise<string>; log?: (event: string, data: Record<string, unknown>) => void; beforeNode?: () => void; processStartMs?: (pid: number) => number | null; growthProposer?: GrowthProposer; growthLLM?: (prompt: string) => Promise<string>; classifyGrowthRecipe?: (node: GraphNodeSpec, resolved: { command?: string; approval?: string }) => GrowthRecipeEffect; growthDecision?: GrowthDecisionDeps & { list?: (filters: { status: 'all' }) => DecisionEntry[] } };
 }
 
@@ -839,7 +845,16 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         const next = nextNode(graph.edges, prior.nodeId, prior.ok ? 'ok' : 'fail', typeof reported === 'string' ? reported : undefined);
         if (next !== recorded.nodeId) throw new Error('saved run path does not follow graph edges');
       } else if (recorded.nodeId !== unitEntryNode) throw new Error('saved run path does not start at entry node');
-      if (i < from && !recorded.ok) throw new Error('cannot preserve a failed predecessor when resuming');
+      if (i < from && !recorded.ok) {
+        // A warning-only node explicitly sends every outcome to the same next
+        // node. Its truthful failed record is safe to preserve when retrying a
+        // later release step; a branching failure is still a hard stop.
+        const edge = graph.edges.find((candidate) => candidate.from === recorded.nodeId);
+        const next = state.path[i + 1];
+        if (edge?.on !== 'outcome' || !next || !(['ok', 'fail', 'error'] as const).every((outcome) => edge.map?.[outcome] === next)) {
+          throw new Error('cannot preserve a failed predecessor when resuming');
+        }
+      }
       const approved = resolveNodeRecipe(spec, recipes, catalogRoles).approval;
       if (approved && i >= from) throw new Error('cannot restart across an approval decision');
       if (approved && i < from) {
@@ -1363,7 +1378,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
             if (!resolved.command && !resolved.approval && candidate.recipe !== 'none') return 'unknown';
             return { effect: resolved.approval ? 'unknown' : options.deps?.classifyGrowthRecipe?.(candidate, { command: resolved.command?.command }) ?? 'unknown',
               command: resolved.command, approval: resolved.approval?.approval };
-          }, { ...options.deps?.growthDecision, root });
+          }, { ...options.deps?.growthDecision, root }, options.researchEdgeDecisionRegistry);
       if (result.ok) {
         graph = result.graph;
         state.growth ??= [];