elanous 0.2.10 → 0.2.11

package/skills/youtube-master/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "."
+  },
+  "include": ["src/**/*.ts", "scripts/**/*.ts"]
+}

package/src/acp/server.ts

@@ -241,6 +241,8 @@ export interface AcpServerOptions {
   /** ACP standalone entry: require session cwd or an explicit boot default. */
   requireSessionToolCwd?: boolean;
   bootToolCwd?: string;
+  /** Optional PTY factory for the web terminal; production uses PreviewTerminal. */
+  createWebTerminal?: (opts: ConstructorParameters<typeof import('../preview/terminal.js').PreviewTerminal>[0]) => import('../preview/terminal.js').PreviewTerminal;
   /** Test seam for exercising stdio EOF with controlled byte streams. */
   stdioInput?: ReadableStream<Uint8Array>;
   stdioOutput?: WritableStream<Uint8Array>;
@@ -2190,7 +2192,8 @@ function wireAcpConnection(
           throw new Error('terminal/spawn: sessionId required');
         }
         const tid = resolveAcpTerminalId(p.terminalId);
-        const cwd = typeof p.cwd === 'string' && p.cwd.length > 0 ? p.cwd : process.cwd();
+        const cwd = typeof p.cwd === 'string' && p.cwd.length > 0 ? p.cwd
+          : (await import('../project/session-context.js')).resolveSessionProjectContext(p.sessionId)?.cwd ?? process.cwd();
         const cols = typeof p.cols === 'number' && p.cols > 0 ? p.cols : 80;
         const rows = typeof p.rows === 'number' && p.rows > 0 ? p.rows : 24;
 
@@ -2234,7 +2237,7 @@ function wireAcpConnection(
         }
 
         const { PreviewTerminal } = await import('../preview/terminal.js');
-        const pt = new PreviewTerminal({
+        const pt = (opts.createWebTerminal ?? ((terminalOpts) => new PreviewTerminal(terminalOpts)))({
           cols, rows, cwd,
           // Web-terminal child shell renders inside the PWA's xterm.js,
           // which implements the xterm-256color terminfo. When the daemon

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/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 });

package/src/autopilot/tool-registry.ts

@@ -266,4 +266,6 @@ export const AUTOPILOT_TOOL_IDS = [
   'memory_recall',
   'ops_status',
   'self_recall',
+  // CTX2 #23185 — 맥락 한 문(READ-ONLY 자기관측 원장에 더해졌다).
+  'context_now',
 ] as const;

package/src/boot/daemon-prompt-turn.ts

@@ -116,6 +116,8 @@ export async function runDaemonPromptTurn(opts: {
    *  `--tool-cwd` / `ELANOUS_TOOL_CWD` to keep `/v1/prompt` and ACP WS
    *  on the same path-guard boundary. */
   toolCwd?: string;
+  /** Per-turn project instructions; unlike the base system preamble these must survive subsequent turns. */
+  projectInstructions?: string;
   /** Phase 4 (WT-A-3b) — external abort signal. When provided and
    *  fired, the internal AbortController fans the abort through to
    *  `runCoreTurn` (LLM stream + tool dispatch). Callers without an
@@ -286,6 +288,9 @@ export async function runDaemonPromptTurn(opts: {
   if (fast && !isFirstTurn) {
     messages.unshift({ role: 'system', content: fastPathGuidance });
   }
+  if (!isFirstTurn && opts.projectInstructions) {
+    messages.unshift({ role: 'system', content: opts.projectInstructions });
+  }
   const result = await runCoreTurn({
     sessionId: request.sessionId,
     userText: request.userText,

package/src/boot/daemon-runtime.ts

@@ -53,6 +53,7 @@ import {
 import type { CoreTurnDispatchTool } from '../core-turn/index.js';
 import { elanousSelfAccessPrompt } from '../agent/self-ambient.js';
 import { createToolCwdResolver, type ToolCwdResolver } from './tool-cwd.js';
+import { resolveSessionProjectContext } from '../project/session-context.js';
 import { debug } from '../debug/log.js';
 
 /** C4 (2026-07-12) — arm the non-detached-PTY kill ONCE per turn signal.
@@ -579,7 +580,9 @@ export function createDaemonRunTurn(
     // moved this out of an inline closure to fix the user-message
     // persistence bug uniformly across all daemon paths.
     getMessages: ({ sessionId, userText, promptBlocks, promptMeta }) => {
-      const baseSystemPrompt = composeDaemonSystemPrompt(opts.systemPrompt, promptMeta, sessionId);
+      const projectInstructions = resolveSessionProjectContext(sessionId)?.instructions;
+      const baseSystemPrompt = [composeDaemonSystemPrompt(opts.systemPrompt, promptMeta, sessionId), projectInstructions]
+        .filter(Boolean).join('\n\n');
       // Image-pipeline followup #4 (2026-05-05) — append daemon webterm
       // context (current ACP sessionId + active terminal summary) to
       // the system prompt when the webterm surface is active. Helper
@@ -720,8 +723,11 @@ export function createDaemonRunTurn(
         });
         debugBridge.activate();
       }
-      if (opts.acpSessionCwd) {
-        const resolver = createToolCwdResolver({ tools: opts.tools ?? 'none', toolCwd: turnCtx.cwd });
+      const projectCwd = resolveSessionProjectContext(turnCtx.sessionId)?.cwd;
+      if (projectCwd || opts.acpSessionCwd) {
+        // An ACP session's explicit cwd wins; the project folder is only the default when none was given (IA3 review).
+        const explicitCwd = opts.acpSessionCwd && turnCtx.cwd ? turnCtx.cwd : undefined;
+        const resolver = createToolCwdResolver({ tools: opts.tools ?? 'none', toolCwd: explicitCwd ?? projectCwd ?? turnCtx.cwd });
         await turnToolCwd.run(resolver, () => inner(turnCtx));
       } else {
         await inner(turnCtx);

package/src/boot/daemon-tools/web-search.ts

@@ -23,6 +23,8 @@ export interface DaemonWebSearchArgs {
 export interface DaemonWebSearchResult {
   query: string;
   providerName: string;
+  /** Absent for ordinary searches; signals whether X sources were actually cited. */
+  xSearch?: 'grok' | 'unavailable';
   hits: Array<{
     url: string;
     title: string;
@@ -90,6 +92,7 @@ export async function dispatchWebSearch(
     return {
       query,
       providerName: result.providerName,
+      ...(result.xSearch ? { xSearch: result.xSearch } : {}),
       hits: result.hits.map((h) => ({
         url: h.url,
         title: h.title,