elanous 0.2.9 → 0.2.11

package/src/agent/monad-agent-turn.ts

@@ -26,6 +26,7 @@ import { buildAutonomousToolSpecs, dispatchAutonomousTool, isAutonomousTool, del
 import { isToolSearchCall, routeToolSearch } from '../skills/tools/tool-search-route.js';
 import { financeEnabled, financeAgentSystemPrompt, marketClock } from '../domains/finance.js';
 import { buildFinanceTools } from '../domains/finance-tools.js';
+import { dispatchReleaseChange } from '../domains/release-tool.js';
 import { surfaceEventsDbPath, openSurfaceEventsDb, recentSentDigest, recordInboundTurn } from '../domains/surface-events.js';
 import { elanousSelfAccessPrompt, elanousSelfAmbientParts } from './self-ambient.js';
 import { localRefGroundingAmbient } from './ref-grounding.js';
@@ -188,6 +189,13 @@ export function makeElanousAgentRunTurn(cfg: UserConfig, surface: SessionSource,
           },
         });
       }
+      if (name === 'release_change') {
+        return dispatchReleaseChange(args, {
+          surface: 'chat', sessionId: opts.sessionId,
+          ...(opts.verifiedOwner ? { verifiedOwner: opts.verifiedOwner } : {}),
+          ...(surfaceChannels ? { confirmChannels: surfaceChannels } : {}),
+        });
+      }
       // Thread the turn's abort signal so a long in-flight Bash is killed by
       // `/cancel` (dispatchBash SIGTERMs its child on abort).
       return baseDispatch(name, args, opts.signal);

package/src/agent-mission/driver.ts

@@ -20,6 +20,8 @@ import { configuredWorktreeRoot } from '../user-config.js';
 import { worktreeHasChanges, commitWorktree, changedFiles } from '../self-implement/seams.js';
 import { streamLLM, type LLMMessage } from '../llm.js';
 import { debug } from '../debug/log.js';
+import { emitPtyDecision, type DecisionInput } from './pty-decision.js';
+import { observeExternalEvent } from '../context-bus/external-events.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { resolvePtyWebAddress } from '../cli/pty-web-address.js';
 import { reemitPtyUsage } from '../budget/pty-usage-reemit.js';
@@ -522,6 +524,8 @@ export interface AgentMissionDeps {
   createWorktree?: typeof createWorktree;
   recordWorktreeProvenance?: typeof recordHarnessWorktreeProvenance;
   runControlLoop?: typeof runPtyControlLoop;
+  /** Capture decisions in tests without replacing the process-wide debug logger. */
+  emitPtyDecision?: typeof emitPtyDecision;
   /** Inject controller responses while keeping the production control loop. */
   controlStream?: StreamLLMFn;
   resolvePtyWebAddress?: typeof resolvePtyWebAddress;
@@ -830,6 +834,7 @@ export interface MissionControlBrainOpts {
   readonly handoffEnabled?: boolean;
   /** Screen-grounded brain summary for the next backend, never the raw PTY screen. */
   readonly onSummary?: (summary: string) => void;
+  readonly onDecision?: (text: string, reply?: { question: string; answer: string }) => void;
 }
 
 /** 기존 5-action mission 판단을 canonical PTY control-loop 결정으로 축소한다. search는 이 경계에서만
@@ -855,7 +860,7 @@ export function createMissionControlBrain(opts: MissionControlBrainOpts): RunSup
  행동(action):
  - "wait": ${backendName} 가 아직 작업 중(도구 실행/생성)이면 대기.
  - "verify": ${backendName} 가 MISSION-COMPLETE/완료를 주장하면 증거 게이트(내가 실행)로 검증. 완료주장 시 이걸 우선.
- - "send": ${backendName} 가 멈추거나 계속 진행이 필요하면 짧고 명확한 지시(text).
+ - "send": ${backendName} 가 멈추거나 계속 진행이 필요하면 짧고 명확한 지시(text). 화면의 질문에 직접 답하는 경우에만 reason 을 Answering question: <화면의 질문 원문> 으로 기록하라. 다른 send 의 reason 은 종전처럼 행동 이유를 적어라.
  - "search": ${backendName} 가 정보/라이브러리/문법/외부자원에 막혔으면 omni-crawl 로 조사(query). ⭐외부 힌트 없이 스스로 판단.
 ${opts.handoffEnabled ? ` - "handoff": 다른 담당자로 넘길 때 to(codex/claude/elanous), mission(다음 지시), carry(diff/summary 선택). carry=summary 면 reason 에 화면에서 확인한 리뷰 지적을 구체적으로 요약하라(다음 backend 에 전달된다). claude 리뷰 뒤 지적은 codex 에 summary 로 되돌려라. elanous 는 증거 게이트와 PR.
  - "ask-human": 화면에 로그인 URL/장치 코드가 보이면 reason, url/code(보이는 것만). 토큰·자격파일을 열지 마라.` : ''}${opts.provision ? `
@@ -873,6 +878,12 @@ ${opts.handoffEnabled ? ` - "handoff": 다른 담당자로 넘길 때 to(codex/c
       history.push(`s${obs.step}:${decision.action}`);
       debug.log('agent-mission', 'brain', { step: obs.step, action: decision.action,
         ...(decision.action === 'ask-human' ? {} : { reason: decision.reason.slice(0, 120) }) });
+      // A '?' on screen alone does not establish that this send answered it. Only an
+      // explicit question citation in the brain's reason can attribute the reply.
+      const citedQuestion = /^Answering question:\s*(.+\?)\s*$/i.exec(decision.reason)?.[1]?.trim();
+      const question = citedQuestion && classifierFrameLines(obs.screen).find((line) => line === citedQuestion);
+      opts.onDecision?.(`step ${obs.step}: ${decision.action}${decision.action === 'ask-human' ? '' : ` — ${decision.reason || decision.text || decision.query || ''}`}`,
+        decision.action === 'send' && decision.text?.trim() && question ? { question, answer: decision.text } : undefined);
       if (decision.reason && decision.action !== 'ask-human') opts.onSummary?.(decision.reason.slice(0, 2000));
       if (decision.action === 'handoff' && decision.to && decision.mission) return { action: 'handoff', to: decision.to, mission: decision.mission, ...(decision.carry ? { carry: decision.carry } : {}) };
       if (decision.action === 'ask-human') return { action: 'ask-human', reason: decision.reason, ...(decision.url ? { url: decision.url } : {}), ...(decision.code ? { code: decision.code } : {}) };
@@ -974,6 +985,7 @@ export function makeMissionObserveStep(deps: {
   bus: ChannelBus;
   ident: { ptyId: string; instance: string; runId?: string };
   now?: () => number;
+  onPublishedFrame?: (obs: ControlObservation) => void;
 }): (obs: ControlObservation, decision: ControlDecision) => Promise<void> {
   const now = deps.now ?? ((): number => Date.now());
   let lastFrameState: FrameState | null = null;
@@ -1008,6 +1020,7 @@ export function makeMissionObserveStep(deps: {
       ...(deps.ident.runId ? { runId: deps.ident.runId } : {}),
       ...(pngRef ? { pngRef } : {}),
     });
+    deps.onPublishedFrame?.(obs);
     // capture 는 원 semantics 유지 — 예외 전파(증거/전사 계약 불변).
     await deps.capture(`s${obs.step}-${decision.action}`);
   };
@@ -1574,9 +1587,19 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   if (deps.isMissionAborted?.()) { offLive(); throw new Error('MISSION_ABORTED'); }
   try { h = spawnPty(ptyOpts); }
   catch (error) { offLive(); throw error; }
-  deps.onPtyStarted?.(h, () => { if (liveTimer) clearInterval(liveTimer); offLive(); });
-  if (deps.isMissionAborted?.()) return { ok: false, reason: 'aborted', worktree: wt.path, branch: wt.branch,
-    rounds: 0, evidencePath: null, committed: false, usedOmniCrawl: false, detail: 'aborted' };
+  if (backend.name === 'codex') observeExternalEvent({ origin: 'codex-agent-mission', kind: 'started',
+    summary: 'Codex agent mission started', source: `elanous://agent-mission/${encodeURIComponent(runId)}/${encodeURIComponent(h.id)}` });
+  let contextFinished = false;
+  const finishContext = (ok: boolean): void => {
+    if (contextFinished || backend.name !== 'codex') return;
+    contextFinished = true;
+    observeExternalEvent({ origin: 'codex-agent-mission', kind: 'finished',
+      summary: `Codex agent mission ${ok ? 'completed' : 'failed'}`,
+      source: `elanous://agent-mission/${encodeURIComponent(runId)}/${encodeURIComponent(h.id)}` });
+  };
+  deps.onPtyStarted?.(h, () => { if (liveTimer) clearInterval(liveTimer); offLive(); finishContext(false); });
+  if (deps.isMissionAborted?.()) { finishContext(false); return { ok: false, reason: 'aborted', worktree: wt.path, branch: wt.branch,
+    rounds: 0, evidencePath: null, committed: false, usedOmniCrawl: false, detail: 'aborted' }; }
   const executorRef = buildExecutorPtyRef({
     ptyId: h.id,
     backend: backend.name,
@@ -1589,6 +1612,12 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   process.stderr.write(`[agent-mission] pty=${h.id} watch=${webAddress.webUrl ?? `(web unavailable: ${webAddress.pwaUnavailableReason ?? 'not-resolved'})`}\n`);
   debug.log('agent-mission', 'pty-link', { id: h.id, webUrl: webAddress.webUrl, webUrlSource: webAddress.webUrlSource });
 
+  const decisionIdentity = { missionId: runId, sessionId: runId, terminalId: h.id, agent: backend.name };
+  const decisionEvent = (event: Omit<DecisionInput, keyof typeof decisionIdentity>): void => {
+    try { (deps.emitPtyDecision ?? emitPtyDecision)({ ...decisionIdentity, ...event } as DecisionInput); }
+    catch { /* Observation must not change mission control or handoff. */ }
+  };
+
   // ⭐P2 arbiter: the child is accessMode='auto' (brain-owned), so the driver —
   // the autonomous brain — must write as 'agent' or the arbiter denies it. This
   // makes "protected autonomy" real: a human attaching mid-mission (read) can't
@@ -1615,6 +1644,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
         : 'AGENT_YIELDED: PTY 제어가 사람에게 이양됨(takeover) — 자율 미션 중단');
     }
     h['write'](s, 'agent');
+    decisionEvent({ step: 'input', text: s === '\r' ? 'Sent Enter' : `Sent ${s.startsWith('\x1b') ? 'key' : 'text'}: ${s.startsWith('\x1b') ? 'navigation' : s}` });
   };
 
   let seq = 0;
@@ -1638,7 +1668,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       if (liveChunks % 20 === 0) debug.log('agent-mission', 'live', { chunks: liveChunks, tail: s.slice(-80).replace(/\s+/g, ' ') });
     }).catch(() => { /* noop */ });
   }, 800);
-  const stopLive = (): void => { if (liveTimer) clearInterval(liveTimer); offLive(); };
+  const stopLive = (ok = false): void => { if (liveTimer) clearInterval(liveTimer); offLive(); if (ok) finishContext(true); };
+  try {
 
   // ready + trust — backend 별 신뢰/권한 프롬프트 처리(codex=1, 이후 백엔드는 자체 handler).
   await (deps.awaitMission ? deps.awaitMission(waitForQuiet(h, 1500, 20000)) : waitForQuiet(h, 1500, 20000));
@@ -1648,7 +1679,11 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   // A trust menu can need more than one key (claude: ↓ to «Yes», then Enter) — answer until it is gone, at most 3 times.
   //   🩸 09-29: one pass sent only ↓, the mission text went into the menu and its Enter confirmed «Yes» instead of
   //   submitting the mission, which then sat unsent in the input box.
-  for (let pass = 0; pass < 3 && backend.handleTrust?.(screen, (s) => drive(s)); pass++) {
+  for (let pass = 0; pass < 3 && backend.handleTrust?.(screen, (s) => {
+    drive(s);
+    // Moving the selection is only input; the trust question is answered when the choice is confirmed.
+    if (s === '\r') decisionEvent({ step: 'answer', text: 'Answered folder trust prompt', detail: { question: 'Trust this folder?', answer: 'Confirm selected choice' } });
+  }); pass++) {
     debug.log('agent-mission', 'trust', { agent: backend.name, action: 'handled', pass });
     const trusted = (async () => { await waitForQuiet(h, 1500, 15000); return capture('trusted'); })();
     screen = await (deps.awaitMission ? deps.awaitMission(trusted) : trusted);
@@ -1761,6 +1796,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   let controllerSummary = deps.previousSummary ?? '';
   let reviewSummary = '';
   let coverageRetries = enhanceActive && checklist.length ? 2 : 0;
+  let pendingAnswer: { text: string; question: string; answer: string } | undefined;
   const search = createMissionSearch({ worktree: wt.path, omniPath });
   const brain = createMissionControlBrain({
     mission: spec.mission,
@@ -1768,6 +1804,10 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     stream: deps.controlStream,
     handoffEnabled: true,
     onSummary: (summary) => { controllerSummary = summary; },
+    onDecision: (text, reply) => {
+      pendingAnswer = reply ? { text: `${reply.answer || 'continue'}\r`, ...reply } : undefined;
+      decisionEvent({ step: 'judge', text });
+    },
     evidenceReady: () => spec.chain && spec.chain.length > 1 ? true : verifyEvidence(wt.path, spec.evidence).ok,
     search: async (query, step) => {
       usedOmni = true;
@@ -1784,9 +1824,13 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   // before asking the LLM — otherwise the mission text is typed into the prompt and the run stalls.
   const trustAwareBrain: RunSupervisor = {
     decide: (obs, signal) => {
+      pendingAnswer = undefined;
       let answer: string | undefined;
       if (backend.handleTrust?.(obs.screen, (bytes) => { answer = bytes; }) && answer !== undefined) {
         debug.log('agent-mission', 'trust', { agent: backend.name, action: 'handled-in-loop', step: obs.step });
+        decisionEvent({ step: 'judge', text: `step ${obs.step}: trust prompt` });
+        // Only the confirming Enter answers the trust question; a navigation key stays an input event.
+        if (answer === '\r') pendingAnswer = { text: answer, question: 'Trust this folder?', answer: 'Confirm selected choice' };
         emitDecision({ kind: 'ROUTE', what: `${backend.name} 폴더 신뢰 화면 → 계속`, reason: '시작 뒤 늦게 뜬 신뢰 확인', purpose: '미션을 이어 간다', target: backend.name, phase: 'implement' });
         return { action: 'input', text: answer };
       }
@@ -1872,6 +1916,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     renderPng: () => h.renderScreenPng(),
     bus,
     ident: { ptyId: h.id, instance: resolveInstanceName(), runId },
+    onPublishedFrame: (obs) => decisionEvent({ step: 'read', text: `step ${obs.step} (${obs.state}): ${classifierFrameLines(obs.screen).at(-1) ?? 'empty screen'}` }),
   });
   debug.log('agent-mission', 'takeover-wait', { id: h.id, maxWaitMs: AGENT_MISSION_TAKEOVER_WAIT_MS });
   const controlRun = runWithControlObserve(
@@ -1879,9 +1924,24 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     (d) => debug.log('agent-mission.observe', 'progress', { surfaceId: d.surfaceId, state: d.state, summary: d.summary, unknownInput: d.unknownInput, frame: d.frameCount, runId: d.runId }),
     () => {
       const handleDeps = controlDepsForHandle(h);
+      const inject = backend.name === 'claude' ? submitSeparately(handleDeps.inject) : handleDeps.inject;
       const pending = (deps.runControlLoop ?? runPtyControlLoop)(trustAwareBrain, {
         ...handleDeps,
-        ...(backend.name === 'claude' ? { inject: submitSeparately(handleDeps.inject) } : {}),
+        inject: (text) => {
+          const reply = pendingAnswer?.text === text ? pendingAnswer : undefined;
+          pendingAnswer = undefined;
+          const accepted = inject(text);
+          if (accepted) {
+            decisionEvent({ step: 'input', text: `Sent ${text.startsWith('\x1b') ? 'key' : 'text'}: ${text.startsWith('\x1b') ? 'navigation' : text}` });
+            if (reply) decisionEvent({ step: 'answer', text: 'Answered agent question', detail: { question: reply.question, answer: reply.answer } });
+          }
+          return accepted;
+        },
+        injectKey: handleDeps.injectKey && ((name, repeat) => {
+          const accepted = handleDeps.injectKey!(name, repeat);
+          if (accepted) decisionEvent({ step: 'input', text: `Pressed ${name}${repeat ? ` ×${repeat}` : ''}`, detail: { keys: name } });
+          return accepted;
+        }),
         ...(deps.isMissionAborted ? {
           controlStance: () => deps.isMissionAborted!() ? 'unknown' as const : probeControlStance(h, 'agent', (e) =>
             debug.log('agent-mission', 'hascontrol-error', { id: h.id, error: (e as Error)?.message ?? String(e) })),
@@ -1903,7 +1963,11 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
           }
         }
       },
-      verifyDone: spec.chain && spec.chain.length > 1 ? async () => ({ ok: true as const }) : verifyDone,
+      verifyDone: spec.chain && spec.chain.length > 1 ? async () => ({ ok: true as const }) : async (obs) => {
+        const verdict = await verifyDone(obs);
+        if (!verdict.ok) decisionEvent({ step: 'recover', text: 'Evidence check requires another attempt', detail: { blocked: verdict.retry, action: 'Retry after fixing evidence' } });
+        return verdict;
+      },
       handoff: async (decision, obs) => {
         try {
           if (spec.chain && decision.to !== spec.chain[1]) throw new Error(`chain order violation: expected ${spec.chain[1] ?? 'completion'}, got ${decision.to}`);
@@ -1916,6 +1980,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       askHuman: async (decision) => {
         try {
           await waitForHumanLogin(decision, handoffOps);
+          decisionEvent({ step: 'answer', text: 'Human login question resolved', detail: { question: decision.reason, answer: 'Login completed' } });
         } catch (error) {
           transitionFailure = error instanceof Error ? error.message : String(error);
           throw error;
@@ -1954,7 +2019,9 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   }
   // A gate/PR handoff only counts as success when the control loop itself did not end in error.
   if (gatedHandoff && control.termination.kind !== 'error') {
-    stopLive();
+    // The gate hands off a branch, not a file: record what is known instead of mislabeling the worktree directory.
+    decisionEvent({ step: 'done', text: 'Mission handoff gate completed', detail: { result: { kind: 'text', ref: `branch ${wt.branch}` } } });
+    stopLive(true);
     try { h.kill(); } catch { /* noop */ }
     return { ok: true, worktree: wt.path, branch: wt.branch, rounds: control.steps, evidencePath: wt.path, committed: true, usedOmniCrawl: usedOmni,
       ...(handoffPrSkipped ? { pr: 'skipped' as const, reason: 'origin-not-github' as const } : {}),
@@ -1985,6 +2052,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       maxFallbackDescents: runtimeFallback.maxDescents,
     });
     if (nextBackend && !deps.isMissionAborted?.()) {
+      decisionEvent({ step: 'recover', text: `Switching ${backend.name} to ${nextBackend.name}`, detail: { blocked: control.termination.message, action: `Retry with ${nextBackend.name}` } });
       const nextStep: FallbackStep = nextBackend.name === 'grok' ? 'grok' : 'codex-rotate';
       stopLive();
       if (h.pid) await (deps.terminateProcessTree ?? terminateMissionProcessTree)(h.pid);
@@ -2019,7 +2087,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     debug.log('agent-mission', 'commit', { ok: c.ok, out: c.out.slice(0, 120) });
   }
   debug.log('agent-mission', 'result', { ok: finalEv.ok, rounds: round, evidencePath, committed, usedOmni });
-  stopLive();
+  decisionEvent({ step: 'done', text: finalEv.ok ? 'Mission evidence accepted' : 'Mission ended without sufficient evidence', detail: { result: { kind: evidencePath ? 'file' : 'text', ref: evidencePath ?? (control.termination.kind === 'error' ? control.termination.message : 'evidence unavailable') } } });
+  stopLive(finalEv.ok);
   if (h.pid) await terminateMissionProcessTree(h.pid);
   try { h.kill(); } catch { /* noop */ }
 
@@ -2029,6 +2098,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     ptyId: h.id, webUrl: webAddress.webUrl,
     detail: done ? '완료(증거 충족)' : (finalEv.ok ? '증거 충족(루프 종료)' : '미완(증거 부족)'),
   };
+  } finally { stopLive(); finishContext(false); }
 }
 
 /** @deprecated codex 특정 이름 — runAgentMission 을 쓰라(codex 는 기본 backend). */

package/src/agent-mission/pty-decision.ts

@@ -0,0 +1,71 @@
+import { debug } from '../debug/log.js';
+
+type Identity = {
+  ts: string;
+  missionId: string;
+  seq: number;
+  sessionId: string;
+  terminalId: string;
+  agent: string;
+  text: string;
+};
+type Detail = { keys?: string; row?: number };
+
+export type PtyDecision = Identity & (
+  | { step: 'read' | 'judge' | 'input'; detail?: Detail }
+  | { step: 'answer'; detail: Detail & { question: string; answer: string } }
+  | { step: 'recover'; detail: Detail & { blocked: string; action: string } }
+  | { step: 'done'; detail: Detail & { result: { kind: 'pr' | 'file' | 'text'; ref: string } } }
+);
+
+export type DecisionInput = Omit<Identity, 'ts' | 'seq'> & (
+  | { step: 'read' | 'judge' | 'input'; detail?: Detail }
+  | { step: 'answer'; detail: Detail & { question: string; answer: string } }
+  | { step: 'recover'; detail: Detail & { blocked: string; action: string } }
+  | { step: 'done'; detail: Detail & { result: { kind: 'pr' | 'file' | 'text'; ref: string } } }
+);
+
+const missionStreams = new Map<string, { alias: string; seq: number }>();
+export const PTY_DECISION_TEXT_MAX = 240;
+
+function safe(value: string): string {
+  const masked = value
+    .replace(/\bBearer\s+(?:"[^"]*"|'[^']*'|[^\s"'<>]+)/gi, 'Bearer [redacted]')
+    .replace(/\b([a-z0-9_]*(?:token|key(?:[_-]?id)?|secret|password|authorization)\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s"'<>]+)/gi, '$1[redacted]')
+    .replace(/\b(?:sk-[a-z0-9_-]+|gh[pousr]_[a-z0-9_]+|github_pat_[a-z0-9_]+|AIza[a-z0-9_-]+|xox[baprs]-[a-z0-9-]+)\b/gi, '[redacted]')
+    .replace(/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi, '[redacted]')
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, ' ')
+    .trim();
+  const clipped = masked.slice(0, PTY_DECISION_TEXT_MAX);
+  return clipped.replace(/[\uD800-\uDBFF]$/, '') || '[redacted]';
+}
+
+/** The only emission point for the inside-PTY decision stream. Never log unsanitized input. */
+export function emitPtyDecision(input: DecisionInput, log: typeof debug.log = debug.log): PtyDecision {
+  let stream = missionStreams.get(input.missionId);
+  if (!stream) {
+    stream = { alias: `mission-${missionStreams.size + 1}`, seq: -1 };
+    missionStreams.set(input.missionId, stream);
+  }
+  stream.seq += 1;
+  const base = {
+    ts: new Date().toISOString(),
+    missionId: stream.alias,
+    seq: stream.seq,
+    sessionId: safe(input.sessionId),
+    terminalId: safe(input.terminalId),
+    agent: safe(input.agent),
+    text: safe(input.text),
+  };
+  const common = input.detail ? {
+    ...(input.detail.keys !== undefined ? { keys: safe(input.detail.keys) } : {}),
+    ...(input.detail.row !== undefined ? { row: input.detail.row } : {}),
+  } : {};
+  let decision: PtyDecision;
+  if (input.step === 'answer') decision = { ...base, step: input.step, detail: { ...common, question: safe(input.detail.question), answer: safe(input.detail.answer) } };
+  else if (input.step === 'recover') decision = { ...base, step: input.step, detail: { ...common, blocked: safe(input.detail.blocked), action: safe(input.detail.action) } };
+  else if (input.step === 'done') decision = { ...base, step: input.step, detail: { ...common, result: { kind: input.detail.result.kind, ref: safe(input.detail.result.ref) } } };
+  else decision = { ...base, step: input.step, ...(input.detail ? { detail: common } : {}) };
+  log('pty.decision', decision.step, decision);
+  return decision;
+}

package/src/agent-mission/review-loop.ts

@@ -11,6 +11,7 @@ import { runGitCommand } from '../git-fs/runner.js';
 import * as llm from '../llm.js';
 import type { LLMMessage } from '../llm.js';
 import { debug } from '../debug/log.js';
+import { releasePathHold, releasePathHoldShouldPost, releasePathHoldComment, releasePathHoldCommentsArgs, releasePrFilePaths, RELEASE_PATH_LABEL } from '../self-dev/release-path-guard.js';
 import { runAgentMission, resolveBackend, type AgentMissionResult, type EvidenceMode } from './driver.js';
 import { judgeWithAcp, prepareJudgeDiff } from './acp-judge.js';
 import { verifyMergeAndMaybeRevert } from './merge-safety.js';
@@ -114,6 +115,31 @@ function gh(args: string[]): string {
   return execFileSync('gh', args, { encoding: 'utf8', timeout: 60000, maxBuffer: 20 * 1024 * 1024, env: process.env });
 }
 
+/** Check every page of the PR file list immediately before an unattended review-loop merge. */
+function holdReleasePathBeforeReviewMerge(pr: string, runGh: (args: string[]) => string): boolean {
+  let paths: string[];
+  try {
+    paths = releasePrFilePaths(JSON.parse(runGh(['api', '--paginate', '--slurp', '--method', 'GET', '-f', 'per_page=100', `repos/{owner}/{repo}/pulls/${pr}/files`])));
+  } catch (error) {
+    debug.log('self-dev.merge', 'release-path-inspection-failed', { pr, error: String(error) });
+    return true;
+  }
+  const path = releasePathHold(paths);
+  if (!path) return false;
+  debug.log('self-dev.merge', 'release-path-hold', { pr, path, label: RELEASE_PATH_LABEL, surface: 'review-loop' });
+  try {
+    const names: unknown = JSON.parse(runGh(['label', 'list', '--search', RELEASE_PATH_LABEL, '--json', 'name']));
+    if (!Array.isArray(names)) throw new Error('invalid label list');
+    if (!names.some((item: unknown) => !!item && typeof item === 'object' && 'name' in item && item.name === RELEASE_PATH_LABEL)) {
+      runGh(['label', 'create', RELEASE_PATH_LABEL, '--color', 'D93F0B', '--description', 'Release path requires OP approval']);
+    }
+    runGh(['pr', 'edit', pr, '--add-label', RELEASE_PATH_LABEL]);
+  } catch (error) { debug.log('self-dev.merge', 'release-path-annotation-failed', { pr, action: 'label', error: String(error) }); }
+  try { if (releasePathHoldShouldPost(() => JSON.parse(runGh(releasePathHoldCommentsArgs(pr))))) runGh(['pr', 'comment', pr, '--body', releasePathHoldComment(path)]); }
+  catch (error) { debug.log('self-dev.merge', 'release-path-annotation-failed', { pr, action: 'comment', error: String(error) }); }
+  return true;
+}
+
 /** ★ G10 안전봉투 — 자율머지 직후 회귀검증(verifyMerge 시). 회귀면 revert PR 이 이미 생성됨(알림 포함) →
  *  원 PR 에 링크 코멘트만. fail-open(검증 오류는 머지를 막지 않음). */
 async function runMergeSafety(pr: string, opts: ReviewLoopOpts, depth: ReviewDepth): Promise<void> {
@@ -233,6 +259,7 @@ export async function judgeAndFinalize(
 
   if (j.verdict === 'merge') {
     if (opts.autoMerge) {
+      if (holdReleasePathBeforeReviewMerge(pr, runGh)) return { pr, branch, verdict: 'reinforce', asks, action: 'parked', reworkOk: true, pushed: lastPushed, rounds: round, detail: 'OP approval required: release-path hold or PR file inspection unavailable' };
       const approve = opts.approve ?? approvePr;
       const recordReviewOutcome = opts.recordReviewOutcome ?? recordOutcome;
       approve(pr, `2차 ACP 최종심판 MERGE (round ${round})`);
@@ -480,6 +507,9 @@ export async function runReviewLoop(pr: string, opts: ReviewLoopOpts = {}): Prom
   if (cls.verdict === 'ok') {
     // light: 1차 clean 으로 충분 → approve + 머지. heavy: 1차 ok 여도 2차 심판 머스트.
     if (!effectiveFinalJudge) {
+      if ((opts.autoMergeOnOk || opts.autoMerge) && holdReleasePathBeforeReviewMerge(pr, runGh)) {
+        return { pr, branch, verdict: 'ok', asks: [], action: 'parked', detail: 'OP approval required: release-path hold or PR file inspection unavailable' };
+      }
       approve(pr, `소작업(light)·1차 리뷰 clean`);
       let merged = false;
       if (opts.autoMergeOnOk || opts.autoMerge) {

package/src/ask-user-question/pending-questions.ts

@@ -3,16 +3,13 @@ import { join } from 'node:path';
 
 import { elanousStateRoot } from '../autopilot/state-paths.js';
 import { ASK_USER_QUESTION_DELIVERY_VALUES } from './types.js';
-import type { AskUserQuestionRequest, AskUserQuestionResult, HitlDelivery, QuestionOption } from './types.js';
+import type { AskUserQuestionRequest, AskUserQuestionResult, HitlDelivery, Question, QuestionOption } from './types.js';
 
-interface PendingQuestion {
+export interface PendingQuestion {
   id: string;
   sessionId?: string;
-  questions: Array<{
-    id: string;
-    question: string;
-    options: QuestionOption[];
-  }>;
+  runId?: string;
+  questions: Array<Pick<Question, 'id' | 'question' | 'options' | 'impact' | 'recommendedIndex'>>;
   startedAt: string;
   expiresAt?: string;
   surface: 'tui' | 'file';
@@ -86,6 +83,7 @@ function isPendingQuestion(value: unknown): value is PendingQuestion {
   const pending = value as Record<string, unknown>;
   return typeof pending.id === 'string'
     && (pending.sessionId === undefined || typeof pending.sessionId === 'string')
+    && (pending.runId === undefined || typeof pending.runId === 'string')
     && Array.isArray(pending.questions)
     && pending.questions.every((question) => {
       if (question === null || typeof question !== 'object' || Array.isArray(question)) return false;
@@ -93,7 +91,10 @@ function isPendingQuestion(value: unknown): value is PendingQuestion {
       return typeof record.id === 'string'
         && typeof record.question === 'string'
         && Array.isArray(record.options)
-        && record.options.every(isQuestionOption);
+        && record.options.every(isQuestionOption)
+        && (record.impact === undefined || record.impact === 'low' || record.impact === 'medium' || record.impact === 'high' || record.impact === 'critical')
+        && (record.recommendedIndex === undefined || (typeof record.recommendedIndex === 'number'
+          && Number.isInteger(record.recommendedIndex)));
     })
     && isIsoTimestamp(pending.startedAt)
     && (pending.surface === 'tui' || pending.surface === 'file')
@@ -111,7 +112,15 @@ function isPendingQuestion(value: unknown): value is PendingQuestion {
 function parsePendingQuestion(contents: string, file: string): PendingQuestion {
   const value: unknown = JSON.parse(contents);
   if (!isPendingQuestion(value)) throw new Error(`Invalid pending question record: ${file}`);
-  return value;
+  return {
+    ...value,
+    questions: value.questions.map((question) => ({
+      ...question,
+      ...(question.recommendedIndex !== undefined
+        && (question.recommendedIndex < 0 || question.recommendedIndex >= question.options.length)
+        ? { recommendedIndex: undefined } : {}),
+    })),
+  };
 }
 
 export function isAskUserQuestionResult(value: unknown): value is AskUserQuestionResult {
@@ -176,7 +185,13 @@ export function createPendingQuestion(
   return {
     id,
     ...(sessionId === undefined ? {} : { sessionId }),
-    questions: request.questions.map(({ id, question, options }) => ({ id, question, options })),
+    ...(request.runId === undefined ? {} : { runId: request.runId }),
+    questions: request.questions.map(({ id, question, options, impact, recommendedIndex }) => ({
+      id, question, options,
+      ...(impact === undefined ? {} : { impact }),
+      ...(recommendedIndex !== undefined && Number.isInteger(recommendedIndex) && recommendedIndex >= 0 && recommendedIndex < options.length
+        ? { recommendedIndex } : {}),
+    })),
     startedAt: (deps.now ?? (() => new Date()))().toISOString(),
     ...(presentation.expiresAt === undefined ? {} : { expiresAt: presentation.expiresAt }),
     surface: presentation.surface,

package/src/ask-user-question/types.ts

@@ -13,6 +13,7 @@
 // behaviour exactly.
 
 import type { HitlDelivery } from '../hitl/types.js';
+import type { ClarificationImpact } from '../hitl/clarification-policy.js';
 export type { HitlDelivery };
 
 export interface QuestionOption {
@@ -37,6 +38,9 @@ export interface Question {
   question: string;
   /** 2–4 pre-defined choices. */
   options: QuestionOption[];
+  impact?: ClarificationImpact;
+  /** Zero-based position in options; an out-of-range value is ignored. */
+  recommendedIndex?: number;
   /** When true, user can pick more than one option; Space toggles,
    *  Enter submits. Default false. */
   multiSelect?: boolean;
@@ -49,6 +53,7 @@ export interface Question {
 
 export interface AskUserQuestionRequest {
   questions: Question[];   // 1–3
+  runId?: string;
   /** AXON F4 — optional routing hint. When set, callers with HITL
    *  resolvers can fan the prompt out to Telegram/Discord/etc;
    *  omitted (or `'modal'` / `'terminal'`) keeps the existing TUI
@@ -165,6 +170,9 @@ export function parseQuestionRequest(
       header,
       question,
       options,
+      ...(item.impact === 'low' || item.impact === 'medium' || item.impact === 'high' || item.impact === 'critical' ? { impact: item.impact } : {}),
+      ...(typeof item.recommendedIndex === 'number' && Number.isInteger(item.recommendedIndex)
+        && item.recommendedIndex >= 0 && item.recommendedIndex < options.length ? { recommendedIndex: item.recommendedIndex } : {}),
       multiSelect: item.multiSelect === true,
       includeOther: item.includeOther !== false,  // default true
     });
@@ -186,5 +194,6 @@ export function parseQuestionRequest(
 
   const req: AskUserQuestionRequest = { questions: parsed };
   if (delivery !== undefined) req.delivery = delivery;
+  if (typeof raw.runId === 'string') req.runId = raw.runId;
   return { ok: true, req };
 }

package/src/auth/setup-link-tokens.ts

@@ -74,15 +74,26 @@ function writeStore(dir: string, tokens: SetupLinkEntry[]): void {
 
 // A persistent inode and an OS advisory lock avoid stale owner files after an abrupt process exit.
 // Never unlink this file: a replacement inode would let two processes hold different locks.
-const libc = dlopen(process.platform === 'darwin' ? '/usr/lib/libSystem.B.dylib' : 'libc.so.6', {
-  flock: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 },
-});
+// Loaded on first use, not at import: libc.so.6 does not exist on Windows and this module sits on the CLI start path (WIN2 10-02).
+type Flock = (fd: number, op: number) => number;
+let flockFn: Flock | null | undefined;
+function osFlock(): Flock | null {
+  if (flockFn !== undefined) return flockFn;
+  if (process.platform === 'win32') return (flockFn = null);
+  const lib = dlopen(process.platform === 'darwin' ? '/usr/lib/libSystem.B.dylib' : 'libc.so.6', {
+    flock: { args: [FFIType.i32, FFIType.i32], returns: FFIType.i32 },
+  });
+  return (flockFn = lib.symbols.flock as Flock);
+}
 const LOCK_EX = 2;
 const LOCK_NB = 4;
 const LOCK_UN = 8;
 
 function withLock<T>(dir: string, fn: () => T): T {
   mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const flock = osFlock();
+  // Windows: no advisory flock and no POSIX modes — the store still writes by atomic rename.
+  if (!flock) return fn();
   const lock = `${storePath(dir)}.lock`;
   const fd = openSync(lock, constants.O_CREAT | constants.O_RDWR | constants.O_NOFOLLOW, 0o600);
   try {
@@ -92,7 +103,7 @@ function withLock<T>(dir: string, fn: () => T): T {
       throw new Error('setup link lock must be a private regular file (0600)');
     }
     const until = Date.now() + 3000;
-    while (libc.symbols.flock(fd, LOCK_EX | LOCK_NB) !== 0) {
+    while (flock(fd, LOCK_EX | LOCK_NB) !== 0) {
       if (Date.now() > until) throw new Error('setup link store is locked — try again');
       Bun.sleepSync(20);
     }
@@ -101,7 +112,7 @@ function withLock<T>(dir: string, fn: () => T): T {
       if (stat.ino !== locked.ino || stat.dev !== locked.dev) throw new Error('setup link lock changed');
       return fn();
     } finally {
-      libc.symbols.flock(fd, LOCK_UN);
+      flock(fd, LOCK_UN);
     }
   } finally {
     closeSync(fd);

package/src/autopilot/build/integrity-gate.ts

@@ -255,6 +255,7 @@ const STEP_CMDS: Record<GateStepName, { cmd: string; args: string[]; timeoutMs:
   'cli-smoke': { cmd: 'bun', args: ['bin/elanous.mjs', '--help'], timeoutMs: 60_000 },
 };
 
+const DEPENDENCY_INSTALL_TIMEOUT_MS = 300_000;
 const MAX_LOGGED_TEST_FILTERS = 6;
 
 /** Platform runners own Kotlin/Swift execution; Bun must never receive their paths as test filters. */
@@ -289,6 +290,17 @@ export async function runIntegrityGate(
   const runCmd = opts.runCmd ?? createRunCmd();
   const results: GateStep[] = [];
   const logs: string[] = [];
+  // A Pod worktree has no node_modules unless the child happened to install them (the Pod clone has none to link), and Bun
+  // then auto-installs at import time — «Unexpected while resolving package 'commander'» failed cli-smoke as an
+  // «environment deficiency» three times on 10-02 (#22849 · #22919). Install from the lockfile before measuring instead.
+  if (steps.length > 0 && existsSync(join(cwd, 'bin', 'elanous.mjs')) && existsSync(join(cwd, 'bun.lock'))
+      && !existsSync(join(cwd, 'node_modules', 'commander', 'package.json'))) {
+    const install = await runCmd('bun', ['install', '--frozen-lockfile'], cwd, DEPENDENCY_INSTALL_TIMEOUT_MS);
+    const installed = install.code === 0 && !install.timedOut;
+    debug.log('gate.deps', 'install', { installed, code: install.code, timedOut: install.timedOut });
+    const tail = (install.stderr || install.stdout).split('\n').filter(Boolean).slice(-2).join(' | ').slice(0, 200);
+    logs.push(`[deps] ${installed ? 'INSTALLED' : 'FAIL'} bun install --frozen-lockfile — node_modules/commander was missing${installed ? '' : `: ${tail}`}`);
+  }
   let passed = true;
   let testPassCount: number | undefined;
   let sawPassCountRegression = false;

package/src/autopilot/build/llm-conflict-merge.ts

@@ -9,6 +9,17 @@ import { join } from 'node:path';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { runGitCommand } from '../../git-fs/runner.js';
 import { countTestDeclarations } from '../../self-implement/test-declarations.js';
+import { NEXT_MD_PATH, resolveNextMdConflict } from '../../release-loop/next-md-merge.js';
+
+function deterministicNextMd(git: MergeGitSeam, worktreePath: string, file: string): string | null {
+  try {
+    const resolved = resolveNextMdConflict(git.readIndexStage(worktreePath, 1, file), git.readIndexStage(worktreePath, 2, file), git.readIndexStage(worktreePath, 3, file));
+    void import('../../debug/log.js').then(({ debug }) => debug.log('self-dev.merge', 'next-md-deterministic', { resolved: resolved !== null })).catch(() => {});
+    return resolved;
+  } catch {
+    return null; // a stage is missing (added/deleted on one side) — the usual resolver decides
+  }
+}
 
 /** 충돌 마커가 남아있나(LLM 이 해결 못 함 판별). ours/base/theirs 3-way 마커 모두. 순수. */
 export function hasConflictMarkers(s: string): boolean {
@@ -130,8 +141,8 @@ export interface MergeGitSeam {
   merge: (wt: string, mergeTarget: string) => { ok: boolean; conflict: boolean; stdout: string; errorDetail?: string };
   /** 충돌(unmerged) 파일 목록(worktree 상대 경로). */
   conflictedFiles: (wt: string) => string[];
-  /** Reads an unmerged index stage (2=ours, 3=theirs) for a conflicted file. */
-  readIndexStage: (wt: string, stage: 2 | 3, file: string) => string;
+  /** Reads an unmerged index stage (1=base, 2=ours, 3=theirs) for a conflicted file. */
+  readIndexStage: (wt: string, stage: 1 | 2 | 3, file: string) => string;
   readFile: (absPath: string) => string;
   writeFile: (absPath: string, content: string) => void;
   /** 해결된 파일 스테이징. */
@@ -193,7 +204,9 @@ export async function mergeMainWithLlmResolve(
     let merged: string;
     try {
       conflicted = git.readFile(abs);
-      merged = await resolve(f, conflicted);
+      // release/next.md: concurrent landings each append a line — keep both without asking the LLM (REL7c).
+      const deterministic = f === NEXT_MD_PATH ? deterministicNextMd(git, worktreePath, f) : null;
+      merged = deterministic ?? await resolve(f, conflicted);
     } catch {
       git.abort(worktreePath); // LLM 예외 → base 유지
       return measuredOutcome({ status: 'conflict-unresolved', resolvedFiles });