elanous 0.2.16 → 0.2.17

package/src/agent-mission/driver.ts

@@ -8,8 +8,8 @@
 //   - 증거 게이트(doc 존재 / tsc 0 / test pass)로 완료 판정 후 commit
 // 재사용: startPty(Bun 네이티브 PTY)·createWorktree·streamLLM·worktreeHasChanges·commitWorktree.
 import { execFileSync, spawnSync, spawn as spawnChild } from 'node:child_process';
-import { homedir } from 'node:os';
-import { existsSync, writeFileSync, mkdirSync, readdirSync, readFileSync, statSync, readlinkSync, realpathSync, lstatSync, unlinkSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { existsSync, writeFileSync, mkdirSync, mkdtempSync, rmSync, readdirSync, readFileSync, statSync, readlinkSync, realpathSync, lstatSync, unlinkSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { join, relative, resolve, isAbsolute, sep } from 'node:path';
 import { startPty, mintPtyId, onPtyEvent, type PtyHandle, type StartOpts } from '../pty-shell/registry.js';
@@ -18,7 +18,7 @@ import { NESTED_AGENT_ENV_BLOCKLIST } from '../agent/nested-agent-env.js';
 import { getNestDepth } from '../agent/nest-depth.js';
 import { gateNestedElanousLaunch, nestedDepthCodexArgs, readNestedElanousDepth } from '../harness/nested-elanous-policy.js';
 import { createWorktree, resolveMainRepoRoot, type CreateWorktreeOpts } from '../git-fs/worktree.js';
-import { configuredWorktreeRoot } from '../user-config.js';
+import { configuredWorktreeRoot, getUserConfig } 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';
@@ -330,6 +330,27 @@ export function resolveBackendSpawn(
   return { cmd: backend.cmd, args, env, unsetEnv, nestedEnvRemovedCount, forcedEnv };
 }
 
+/** Claude's strict MCP override is per-child; never edit the user's Claude settings. */
+export function prepareClaudeChildSpawn(
+  spawn: ReturnType<typeof resolveBackendSpawn>,
+  options: { readonly backendName: string; readonly depth: number; readonly allowNestedElanous: boolean; readonly tempRoot?: string },
+): { readonly args: string[]; readonly cleanup: () => void; readonly configPath?: string } {
+  // Backend identity, not the command string — an absolute-path claude binary is still the Claude backend.
+  if (options.backendName !== 'claude' || (options.depth === 0 && options.allowNestedElanous)) {
+    return { args: [...spawn.args], cleanup: () => {} };
+  }
+  const dir = mkdtempSync(join(options.tempRoot ?? tmpdir(), 'elanous-claude-mcp-'));
+  try {
+    const configPath = join(dir, 'mcp.json');
+    writeFileSync(configPath, JSON.stringify({ mcpServers: {} }), { mode: 0o600 });
+    return { args: [...spawn.args, '--strict-mcp-config', '--mcp-config', configPath], configPath,
+      cleanup: () => rmSync(dir, { recursive: true, force: true }) };
+  } catch (error) {
+    rmSync(dir, { recursive: true, force: true });
+    throw error;
+  }
+}
+
 /**
  * Refuse a requested nested elanous launch when this backend cannot carry the depth marker.
  * Unset depth is 0. A normal mission spawn (`nestedLaunchRequested: false`) is never refused here.
@@ -528,6 +549,8 @@ export interface AgentMissionSpec {
    * Absent means an ordinary mission spawn — never refused for a missing marker.
    */
   nestedElanousLaunch?: boolean;
+  /** Explicit depth-0 allow from the caller (e.g. `--nested-elanous allow`). Ignored at depth >= 1. Config `harness.nestedElanous` also counts at depth 0. */
+  nestedElanousAllow?: boolean;
   /** Concurrent missions may share one decision stream alias without sharing a PTY or worktree. */
   decisionMissionId?: string;
   /** ⭐⭐ 그 브랜치를 이미 쥔 «소유» 워크트리가 있으면 지우지 말고 그대로 재사용하라고 요청한다
@@ -1574,6 +1597,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   const nestedRefusal = refuseNestedElanousOnBackend({
     backendName: backend.name,
     nestedLaunchRequested: spec.nestedElanousLaunch === true,
+    ...(spec.nestedElanousAllow === true ? { allow: true } : {}),
+    ...(getUserConfig().harness?.nestedElanous === 'allow' ? { configAllow: true } : {}),
     env: process.env,
   });
   if (nestedRefusal.refused) {
@@ -1691,12 +1716,16 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       evidencePath: finalEv.path, evidenceSatisfied: true, committed, usedOmniCrawl: false, detail: '완료(증거 충족)' };
   }
   env.TERM = 'xterm-256color';
+  // Claude's per-child MCP override is held until the PTY exits, not until the control loop returns.
+  const claudeChild = backend.name === 'claude'
+    ? prepareClaudeChildSpawn(spawnParams, { backendName: backend.name, depth: readNestedElanousDepth(process.env), allowNestedElanous: spec.nestedElanousAllow === true || getUserConfig().harness?.nestedElanous === 'allow' })
+    : undefined;
   // ⭐run-identity — runId was resolved before either headless or PTY spawn.
-  debug.log('agent-mission', 'spawn', { agent: backend.name, cmd: `${spawnParams.cmd} ${spawnParams.args.join(' ')}`, scrubbed: backend.scrubEnv ?? [], nestedEnvRemovedCount: spawnParams.nestedEnvRemovedCount, runId });
+  debug.log('agent-mission', 'spawn', { agent: backend.name, cmd: `${spawnParams.cmd} ${(claudeChild?.args ?? spawnParams.args).join(' ')}`, scrubbed: backend.scrubEnv ?? [], nestedEnvRemovedCount: spawnParams.nestedEnvRemovedCount, runId });
   // PTY 정체성 — kind(=backend)·nickname(goto 로 나중 접근)·accessMode='auto'(헤드리스 자율·brain 이 write 소유).
   const ptyOpts = buildAgentMissionPtySpawnOptions({
     backend,
-    spawn: { cmd: spawnParams.cmd, args: spawnParams.args, env, unsetEnv: spawnParams.unsetEnv },
+    spawn: { cmd: spawnParams.cmd, args: claudeChild?.args ?? spawnParams.args, env, unsetEnv: spawnParams.unsetEnv },
     workdir: wt.path,
     nickname: spec.nickname ?? spec.branch ?? backend.name,
   });
@@ -1706,6 +1735,11 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
   let usageReemitted = false;
   let childSessionId: string | undefined;
   let sessionOutput = '';
+  let claudeCleanupTimer: ReturnType<typeof setInterval> | undefined;
+  const cleanupClaude = (): void => {
+    if (claudeCleanupTimer) clearInterval(claudeCleanupTimer);
+    claudeChild?.cleanup();
+  };
   const offLive = onPtyEvent((ev) => {
     if (ev.id !== ptyOpts.id) return;
     if (ev.type === 'output') {
@@ -1718,6 +1752,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     if (ev.type === 'exit') {
       offLive();
       if (liveTimer) clearInterval(liveTimer);
+      cleanupClaude();
     }
     if (ev.type === 'exit' && backend.name === 'codex' && !usageReemitted) {
       usageReemitted = true;
@@ -1740,9 +1775,17 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     }
   });
   let h: PtyHandle;
-  if (deps.isMissionAborted?.()) { offLive(); throw new Error('MISSION_ABORTED'); }
+  if (deps.isMissionAborted?.()) { offLive(); cleanupClaude(); throw new Error('MISSION_ABORTED'); }
   try { h = spawnPty(ptyOpts); }
-  catch (error) { offLive(); throw error; }
+  catch (error) { offLive(); cleanupClaude(); throw error; }
+  if (!h.isAlive()) cleanupClaude();
+  else if (claudeChild) {
+    // A test-injected PTY may not emit registry events; keep the config until its handle exits.
+    claudeCleanupTimer = setInterval(() => {
+      if (!h.isAlive()) cleanupClaude();
+    }, 1000);
+    claudeCleanupTimer.unref();
+  }
   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;
@@ -1753,8 +1796,8 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
       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,
+  deps.onPtyStarted?.(h, () => { if (liveTimer) clearInterval(liveTimer); offLive(); finishContext(false); cleanupClaude(); });
+  if (deps.isMissionAborted?.()) { finishContext(false); cleanupClaude(); 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,
@@ -2275,7 +2318,7 @@ async function runAgentMissionBody(spec: AgentMissionSpec, deps: AgentMissionDep
     ptyId: h.id, webUrl: webAddress.webUrl, driveVerdict: driveVerdict.kind,
     detail: recoverExhausted ? control.termination.reason : driveVerdict.kind === 'done-but-failed' ? `미완(DRIVE-OK: ${driveVerdict.reason})` : driveVerdict.kind === 'success-unverified' && finalEv.ok ? '완료(증거)' : done ? '완료(증거 충족)' : (finalEv.ok ? '증거 충족(루프 종료)' : '미완(증거 부족)'),
   };
-  } finally { stopLive(); finishContext(false); }
+  } finally { stopLive(); finishContext(false); if (!h.isAlive() || deps.isMissionAborted?.()) cleanupClaude(); }
 }
 
 /** @deprecated codex 특정 이름 — runAgentMission 을 쓰라(codex 는 기본 backend). */

package/src/autopilot/track-agent.ts

@@ -47,7 +47,9 @@ const runCli = async (args: string[]): Promise<{ stdout: string }> => {
   const { argv, env } = universeLaunch(args);
   return exec('bun', argv, { cwd: repoDir(), env, timeout: 120_000, maxBuffer: 1024 * 1024, encoding: 'utf8' });
 };
-const forbiddenActionRegex = /\b(?:delete|remove|deploy|publish|release|restart|reboot|merge|force|pay|purchase|secret|credential|sudo|rm\s+-rf|config\s+set)\b|(?:^|\s)--prod\b|삭제|배포|게시|릴리스|재시작|재부팅|병합|결제|자격|비밀|강제/i;
+// A work topic containing a verb is not necessarily an instruction; the guard matches executable requests.
+// Security words (secret · credential · force · 자격 · 비밀 · 강제) stay blocked anywhere — topic or request (UX harvest).
+const forbiddenActionRegex = /\b(?:delete|remove|deploy|publish|release|restart|reboot|merge|pay|purchase|sudo)\b(?=\s+(?:the\s+(?:branch|site|app|release|file|record)\b|(?:this\s+)?branch\b|(?:to|into)\s+main\b|main\b|now\b|(?:site|app)\b))|\bcut\s+a\s+release\b|\brm\s+-rf\b|\bconfig\s+set\b|\b(?:secret|credential|force|sudo)\b|자격|비밀|강제|(?:^|\s)--prod\b|(?:삭제|배포|게시|릴리스|재시작|재부팅|병합|결제|강제)(?:해라|하세요|해줘|하라|해\s*주세요|하시오)(?!\S)|(?:^\s*|후\s*)(?:삭제|배포|게시|릴리스|재시작|재부팅|병합|결제)(?=\s*$|\s*후\s*)|(?:^\s*운영\s*(?:배포|재시작)(?=\s*$))|(?:삭제|배포|게시|릴리스|재시작|재부팅|병합|결제)(?=\s*(?:해|실행|진행)(?:\s|$))/iu;
 export const TRACK_AGENT_FORBIDDEN_ACTION_REGEX = new RegExp(forbiddenActionRegex.source, forbiddenActionRegex.flags);
 let running = 0;
 
@@ -101,7 +103,7 @@ async function decideTrackActionOnce(input: TrackAgentInput, deps: RunnerDeps):
     const values = decision as Record<string, unknown>;
     if (!['say', 'hold'].includes(String(values.action)) || (values.reason !== undefined && typeof values.reason !== 'string')
       || Object.keys(values).some((key) => !['action', 'reason'].includes(key))) throw new Error('invalid decision');
-    if (typeof values.reason === 'string' && forbiddenActionRegex.test(values.reason)) throw new Error('forbidden action');
+    if (values.action === 'say' && typeof values.reason === 'string' && forbiddenActionRegex.test(values.reason)) throw new Error('forbidden action');
     return decision as TrackAgentDecision;
   } catch (error) {
     log('decision-failed', { track: input.track, taskId: input.taskId, error: redactSecretText(String(error)) });
@@ -111,7 +113,7 @@ async function decideTrackActionOnce(input: TrackAgentInput, deps: RunnerDeps):
 
 export async function executeTrackAction(decision: TrackAgentDecision, input: TrackAgentInput, deps: RunnerDeps = {}): Promise<TrackAgentResult> {
   if (decision.action !== 'say') return { status: 'held', detail: decision.reason ?? '사람 확인' };
-  if (forbiddenActionRegex.test(`${input.title}\n${input.prompt}`)) return { status: 'held', detail: '금지 작업 — 사람 확인' };
+  if (forbiddenActionRegex.test(input.prompt)) return { status: 'held', detail: '금지 작업 — 사람 확인' };
   if (!findTrack(input.track)) return { status: 'held', detail: '트랙 미정 — 사람 확인' };
   try {
     const checkBudget = deps.checkBudget ?? (async () => {

package/src/cli/autopilot-cli.ts

@@ -7,9 +7,75 @@ import { writeStdoutJson } from './stdout-json.js';
 // AutopilotLoopDriver against the mission, prints agent deltas on
 // stdout + envelope/termination summary on stderr.
 export function registerAutopilotCommands(program: Command): void {
+  // Explicit runtime entry for a selected action; the task chooser can invoke this entry.
   const autopilotCmd = program
     .command('autopilot')
     .description('Mission-driven autopilot — runs an ACP agent against a single mission with safety + budget guards');
+  autopilotCmd.command('task-agent-action <actionJson>')
+    .description('Execute a selected task-agent action; defaults to shadow')
+    .action(async (actionJson: string) => {
+      const { executeNextAction } = await import('../task-agent/actions.js');
+      const { getUserConfig } = await import('../user-config.js');
+      const { spawnSync } = await import('node:child_process');
+      const { readFileSync, writeFileSync, mkdirSync } = await import('node:fs');
+      const { join, dirname } = await import('node:path');
+      const { debug } = await import('../debug/log.js');
+      const { withFileLockSync } = await import('../storage/file-lock.js');
+      const config = getUserConfig() as ReturnType<typeof getUserConfig> & { taskAgent?: { mode?: string } };
+      const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+      const statePath = join(effectiveInstanceRoot(), 'task-agent-actions.json');
+      let state: { landingDay?: string; landingsToday?: number; failureCounts?: Record<string, number> } = {};
+      try { state = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first run */ }
+      const action = JSON.parse(actionJson) as import('../task-agent/actions.js').NextAction;
+      const deps: import('../task-agent/actions.js').ActionDeps = {
+        ...state,
+        failureCounts: state.failureCounts ?? {},
+        saveState: () => {
+          mkdirSync(dirname(statePath), { recursive: true });
+          // 실패 횟수는 incrementFailure 가 잠금 안에서 키별로 더한다 — 여기선 덮어쓰지 않는다.
+        },
+        mode: config.taskAgent?.mode,
+        // 하루 착지 칸은 상태 파일 잠금 안에서 확보·반환한다 — 두 CLI 프로세스가 같은 잔여 칸을 쓰지 않게.
+        reserveLanding: (day, limit) => withFileLockSync(`${statePath}.lock`, () => {
+          let disk: typeof state = {};
+          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first */ }
+          const used = disk.landingDay === day ? disk.landingsToday ?? 0 : 0;
+          if (used >= limit) return false;
+          mkdirSync(dirname(statePath), { recursive: true });
+          writeFileSync(statePath, JSON.stringify({ ...disk, landingDay: day, landingsToday: used + 1 }));
+          deps.landingDay = day; deps.landingsToday = used + 1;
+          return true;
+        }),
+        incrementFailure: (key) => withFileLockSync(`${statePath}.lock`, () => {
+          let disk: typeof state = {};
+          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { /* first */ }
+          const counts = { ...(disk.failureCounts ?? {}) };
+          counts[key] = (counts[key] ?? 0) + 1;
+          mkdirSync(dirname(statePath), { recursive: true });
+          writeFileSync(statePath, JSON.stringify({ ...disk, failureCounts: counts }));
+          return counts[key]!;
+        }),
+        releaseLanding: (day) => withFileLockSync(`${statePath}.lock`, () => {
+          let disk: typeof state = {};
+          try { disk = JSON.parse(readFileSync(statePath, 'utf8')); } catch { return; }
+          if (disk.landingDay !== day || !disk.landingsToday) return;
+          writeFileSync(statePath, JSON.stringify({ ...disk, landingsToday: disk.landingsToday - 1 }));
+          deps.landingsToday = disk.landingsToday - 1;
+        }),
+        observe: (_event, data) => debug.log('task-agent', 'action', data),
+        command: async args => {
+          const p = args[0] === 'gh'
+            // PR 조회는 착지할 작업 트리에서 — 다른 저장소에서 불러도 엉뚱한 PR 을 읽지 않게.
+            ? spawnSync('gh', args.slice(1), { encoding: 'utf8', ...(action.cwd ? { cwd: action.cwd } : {}) })
+            // 지금 돌고 있는 진입점으로 부른다 — 저장소 밖(설치본)에서 불러도 같은 elanous 를 쓴다.
+            : spawnSync(process.execPath, [process.argv[1]!, ...(process.argv.includes('--test') ? ['--test'] : []), ...args], { encoding: 'utf8' });
+          return { status: p.status ?? 1, stdout: p.stdout ?? '', stderr: p.stderr ?? '' };
+        },
+      };
+      const result = await executeNextAction(action, deps);
+      if (config.taskAgent?.mode === 'live') deps.saveState?.();
+      process.stdout.write(`${result}\n`);
+    });
 
 autopilotCmd
   .command('run <mission...>')

package/src/cli/decisions-cli.ts

@@ -53,6 +53,7 @@ export function formatDecisionDetail(e: DecisionEntry): string {
       ...(e.note ? [`메모: ${e.note}`] : [])] : []),
     ...(e.withdrawnAt ? [`철회: ${kst(e.withdrawnAt)} · ${e.withdrawReason}`] : []),
     '이력:', ...e.history.map(h => `  ${h.type} · ${h.at ? kst(h.at) : '시각 미상'} · ${h.by}${h.choice ? ` · ${h.choice}` : ''}${h.reason ? ` · ${h.reason}` : ''} · ${h.version ? version(h.version) : '판 미상'}`),
+    ...(e.pendingQuestion ? [`판단 재료:\n${e.pendingQuestion}`] : []),
     ...(e.refs?.length ? [`참조: ${e.refs.join(' · ')}`] : [])].join('\n');
 }
 
@@ -86,6 +87,7 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
   root.command('raise').description('SCQA·선택지와 권고로 결정 항목을 올린다')
     .requiredOption('--title <text>').requiredOption('--category <category>')
     .requiredOption('--s <text>').requiredOption('--c <text>').option('--q <text>').option('--a <text>')
+    .option('--pending-question <text>', '판단 재료 전문 (무엇·지금까지·재측·선택지별 결과·권고·확신·그냥 두면·근거)')
     .requiredOption('--option <key=label:consequence>', '선택지 (두 번 이상)', repeat, [] as string[])
     .option('--recommend <key>').option('--why <text>').option('--skip-recommend <reason>')
     .option('--xcheck <SEAT:메모>', '교차 확인 (반복)', repeat, [] as string[])
@@ -96,7 +98,7 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
     .option('--ref <url>', '참조 (반복)', repeat, [] as string[])
     .option('--due <when>', '기한 — UTC ISO(2026-10-04T09:00:00Z) 또는 +Nh(지금부터 N시간) · 기한 2시간 전 텔레그램·디스코드로 다시 알린다')
     .option('--json').option('--hq-override')
-    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; xcheck: string[]; noXcheck?: string; alternative?: string; dissent?: string; track?: DecisionTrack; agent?: string; session?: string; resumeQuestion?: string; run?: string; ref: string[]; json?: boolean; hqOverride?: boolean }) => fail(() => {
+    .action((o: { due?: string; title: string; category: DecisionCategory; s: string; c: string; q?: string; a?: string; pendingQuestion?: string; option: string[]; recommend?: string; why?: string; skipRecommend?: string; xcheck: string[]; noXcheck?: string; alternative?: string; dissent?: string; track?: DecisionTrack; agent?: string; session?: string; resumeQuestion?: string; run?: string; ref: string[]; json?: boolean; hqOverride?: boolean }) => fail(() => {
       if (o.run !== undefined && o.resumeQuestion === undefined) throw new Error('--run requires --resume-question');
       if (o.skipRecommend !== undefined && (o.recommend !== undefined || o.why !== undefined)) throw new Error('choose recommendation or skip, not both');
       if (o.skipRecommend === undefined && (!o.recommend || !o.why)) throw new Error('--recommend and --why required, or --skip-recommend <reason>');
@@ -111,6 +113,7 @@ export function registerDecisionsCommands(program: Command, config: DecisionLedg
       const who = agent(o.agent);
       if (!mayWrite('raise', o.hqOverride)) return;
       const entry = new DecisionLedger(config).raise({ title: o.title, category: o.category, scqa: { s: o.s, c: o.c, ...(o.q ? { q: o.q } : {}), ...(o.a ? { a: o.a } : {}) }, options,
+        ...(o.pendingQuestion ? { pendingQuestion: o.pendingQuestion } : {}),
         ...(crossCheck.length ? { crossCheck } : { crossCheckSkipped: o.noXcheck ?? 'missing' }),
         ...(o.alternative !== undefined ? { alternative: o.alternative } : {}), ...(o.dissent !== undefined ? { dissent: o.dissent } : {}),
         recommendation: o.skipRecommend !== undefined ? { skipped: true, reason: o.skipRecommend } : { option: o.recommend!, why: o.why! },

package/src/cli/intake-cli.ts

@@ -102,7 +102,7 @@ export async function runIntakeDigestCli(
   }
   const d = (deps.buildDigest ?? buildIntakeDigest)(root, day);
   if (opts.telegram) {
-    if (!d.absorbed.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
+    if (!d.absorbed.length && !d.news?.length) { console.log(`텔레그램: ${day} 흡수 0 — 보내지 않음`); return { empty: true }; }
     const text = renderDigestTelegram(d, { ...(opts.vault ? { vaultRoot: opts.vault } : {}), ...(opts.note ? { notePath: opts.note } : {}) });
     const sent = deps.sendTelegram
       ? await deps.sendTelegram(text)

package/src/cli/log-event-names.ts

@@ -1064,6 +1064,7 @@ export const KNOWN_LOG_EVENT_NAMES: ReadonlySet<string> = new Set([
   "redecompose-opus-tap",
   "redecompose-respawn",
   "redecompose-tap",
+  "reemit-target",
   "reflect.done",
   "refresh-attempt",
   "refused",

package/src/cli/pr-cli.ts

@@ -75,6 +75,8 @@ export interface PrLandOpts {
   excludeActiveRunFiles?: boolean;
   excludeActiveRunSources?: boolean;
   landReason?: string;
+  /** Explicit reason for bypassing the landing freeze. */
+  forceFreeze?: string;
   /** Land even though changed files would leak into the public export (the reason goes in --land-reason). */
   allowPublicLeak?: boolean;
 }
@@ -130,6 +132,8 @@ export interface PrLandDeps {
   overlapConfirmChannels?: ConfirmChannel[];
   overlapConfirmTimeoutMs?: number;
   decideOverlapLanding?: () => OverlapLandingDecision | Promise<OverlapLandingDecision>;
+  /** Operational freeze authority (isolated in tests). */
+  prodFreezeRoot?: string;
 }
 
 export const OVERLAP_DECISION_PROMPT = '겹친 파일이 있습니다. 이번 착지를 그대로 병합할까요?';
@@ -1132,6 +1136,10 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     out.error('✗ body: --body와 --body-file은 함께 사용할 수 없습니다.');
     return 1;
   }
+  if (opts.forceFreeze !== undefined && !opts.forceFreeze.trim()) {
+    out.error('✗ freeze: --force-freeze 에는 이유가 필요합니다.');
+    return 1;
+  }
   if (opts.allowPublicLeak && !opts.landReason?.trim()) {
     out.error('✗ public-export-leak: --allow-public-leak 에는 --land-reason "<이유>" 가 필요합니다.');
     return 1;
@@ -1649,7 +1657,8 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
   const headCommit = landedHead.ok && /^[a-f0-9]{40}$/i.test(landedHead.out.trim()) ? landedHead.out.trim() : undefined;
   const validPr = Number.isSafeInteger(prNumber) && prNumber > 0;
   const heldEntry = validPr && headCommit ? { prNumber, headCommit, repoRoot: cwd } : null;
-  const admission = admitLandingMerge(heldEntry, undefined, {}, validPr ? { prNumber, repoRoot: cwd, ...(headCommit ? { headCommit } : {}) } : undefined);
+  const admission = admitLandingMerge(heldEntry, undefined, {}, validPr ? { prNumber, repoRoot: cwd, ...(headCommit ? { headCommit } : {}) } : undefined,
+    { prodFreezeRoot: deps.prodFreezeRoot, forceReason: opts.forceFreeze });
   if (admission.kind === 'held' && !heldEntry) {
     out.error(`✗ freeze: ready PR의 검증 HEAD/번호를 보존하지 못했습니다: ${upsert.url}`);
     return 1;
@@ -1712,6 +1721,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     }
     return 1;
   }
+  if (opts.forceFreeze) debug.log('release-loop.freeze', 'force-merge', { pr: prNumber, reason: opts.forceFreeze.trim() });
   record('merge', true, { result: merged.kind, ...(merged.remoteBranchDeletion ? { remoteBranchDeletion: merged.remoteBranchDeletion.detail } : {}) });
   if (merged.remoteBranchDeletion) {
     out.log(`⚠ remote branch deletion: ${merged.remoteBranchDeletion.detail}`);
@@ -1763,6 +1773,7 @@ export function registerPrCommands(program: Command, deps: PrLandDeps = {}, queu
     .option('--exclude-active-run-files', '도는 런과 겹친 파일을 이번 착지에서 제외')
     .option('--exclude-active-run-sources', '⚠ 위험: --exclude-active-run-files 가 골 문서가 아닌 파일(소스)을 빼도 착지를 강행')
     .option('--land-reason <text>', '권고를 보고도 지금 내는 이유(예: 남이 기다리는 차단 해제)')
+    .option('--force-freeze <reason>', '동결을 넘겨 병합할 명시적 이유(필수)')
     .option('--allow-public-leak', '바뀐 파일이 공개본에 사적 흔적을 실어도 착지(이유는 --land-reason)')
     .action(async (opts: PrLandOpts) => {
       // ⛔⭐⭐⭐ **관측 sink 를 먼저 건다** — 라이브 도그푸드가 잡은 결함(2026-08-03).

package/src/cli/provider-cli.ts

@@ -392,6 +392,20 @@ export function registerProviderCommands(program: Command): void {
       console.log('   확인:  bun bin/elanous.mjs provider codex account list   ·   bun bin/elanous.mjs usage');
     });
 
+  // POD-TOKEN-PREREFRESH (10-06): 사람이 두 번 손으로 한 «백업 → refresh → 원자적 0600 쓰기 → import» 를 한 명령으로.
+  // ⛔ 토큰 값은 안 찍는다 — 남은 시간 전→후만. ⛔ default(~/.codex · 대표 기본 계정)는 거부.
+  accountCmd
+    .command('refresh <name>')
+    .description('그 계정의 codex 토큰을 호스트에서 갱신해 정본 스토어로 반영한다 (⛔ default 거부 · 토큰 값은 안 찍는다 · ⚠️ refresh 토큰은 갱신마다 회전 — 본부 한 곳에서만)')
+    .action(async (name: string) => {
+      const { refreshCodexAccountHome } = await import('../oauth/codex.js');
+      const r = await refreshCodexAccountHome(name);
+      if (!r.ok) { console.error(`갱신 실패(${r.kind}): ${r.message}`); process.exitCode = 1; return; }
+      const h = (v: number | null) => (v === null ? '?' : `${v}h`);
+      console.log(`✅ ${name} 갱신 — 남은 시간 ${h(r.beforeH)} → ${h(r.afterH)} · storeKey=${r.storeKey}`);
+      console.log(`   백업: ${r.backupPath}`);
+    });
+
   const resetCreditsCmd = codexCmd.command('reset-credits').description('리셋 크레딧 — 조회 · 관측 · 사용(⛔ 사용은 되돌릴 수 없다)');
 
   resetCreditsCmd

package/src/cli/self-update-canary.ts

@@ -0,0 +1,46 @@
+export type EdgeRailDecision = 'hold' | 'canary-install' | 'promote-all' | 'rollback' | 'wait-quiet';
+export interface EdgeRailPlan { decision: EdgeRailDecision; reason: string }
+export interface EdgeRailInput {
+  now: Date;
+  mainCommit: string;
+  installed: string;
+  seat: string;
+  canary: { seat: string; okRuns: number; startedAt: string } | null;
+  failureRate: { before: number; after: number; samples: number } | null;
+  quietWindow: boolean;
+  canaryOkRuns?: number;
+  failureMultiplier?: number;
+  minSamples?: number;
+  promoted?: boolean;
+}
+
+/** No I/O: unknown health, insufficient samples and unknown revision never trigger a cutover. */
+export function planEdgeRail(input: EdgeRailInput): EdgeRailPlan {
+  const { mainCommit, installed, seat, canary, failureRate, quietWindow } = input;
+  const okRuns = input.canaryOkRuns ?? 3;
+  const multiplier = input.failureMultiplier ?? 2;
+  const minSamples = input.minSamples ?? 30;
+  if (!Number.isFinite(input.now.getTime()) || !/^[a-f0-9]{12,40}$/i.test(mainCommit) || !/^[a-f0-9]{12,40}$/i.test(installed)
+    || !Number.isSafeInteger(okRuns) || okRuns < 1 || !Number.isFinite(multiplier) || multiplier <= 1
+    || !Number.isSafeInteger(minSamples) || minSamples < 1) return { decision: 'hold', reason: 'invalid or unknown rollout input' };
+  const same = mainCommit.startsWith(installed) || installed.startsWith(mainCommit);
+  if (canary && Date.parse(canary.startedAt) > input.now.getTime()) return { decision: 'hold', reason: 'canary started in the future' };
+  if (canary && (canary.seat !== 'OP' || !Number.isSafeInteger(canary.okRuns) || canary.okRuns < 0
+    || !Number.isFinite(Date.parse(canary.startedAt)))) return { decision: 'hold', reason: 'invalid canary state' };
+  if (failureRate) {
+    if (![failureRate.before, failureRate.after, failureRate.samples].every(Number.isFinite)
+      || failureRate.before < 0 || failureRate.after < 0 || failureRate.before > 1 || failureRate.after > 1
+      || !Number.isSafeInteger(failureRate.samples) || failureRate.samples < 0) return { decision: 'hold', reason: 'invalid failure-rate measurement' };
+    if (failureRate.samples < minSamples) return { decision: 'hold', reason: `failure-rate samples ${failureRate.samples} < ${minSamples}` };
+    if (same && canary && failureRate.after > 0 && failureRate.after >= failureRate.before * multiplier) return quietWindow
+      ? { decision: 'rollback', reason: `failure rate ${failureRate.after} >= ${multiplier}x ${failureRate.before}` }
+      : { decision: 'wait-quiet', reason: 'rollback requires quiet window for resident restart' };
+  }
+  if (canary && canary.okRuns < okRuns) return { decision: 'hold', reason: `OP canary ${canary.okRuns}/${okRuns} successful runs` };
+  if (same) return { decision: 'hold', reason: 'installed commit already matches main' };
+  if (input.promoted && canary && seat !== 'OP') return { decision: 'hold', reason: 'fleet promotion already completed' };
+  if (!canary && seat !== 'OP') return { decision: 'hold', reason: 'OP canary has not installed' };
+  if (!quietWindow) return { decision: 'wait-quiet', reason: 'resident restart requires quiet window' };
+  if (!canary) return { decision: 'canary-install', reason: 'install OP canary first' };
+  return { decision: 'promote-all', reason: `OP canary passed ${canary.okRuns}/${okRuns} successful runs` };
+}