elanous 0.2.13 → 0.2.15

package/src/index.ts

@@ -31,6 +31,7 @@ import { collectCommandEntrances, renderCommandEntrances } from './self-dev/entr
 import { isGoalAuthorFileName } from './self-implement/goal-document.js';
 import { DEV_PIPELINE_SINK_SURFACE } from './self-implement/self-cli-sink-surface.js';
 import { registerPrivateLedgerCommands } from './cli/private-ledger-commands.js';
+import { registerSeatRequestsCommands } from './cli/seat-requests-cli.js';
 import { applyTestStateDirFlagFromArgv } from './cli/test-state-dir-flag.js';
 import { applyTestFlagFromArgv, observeTestFlagOwnership, uncoveredTestFlagPaths, staleTestFlagPaths } from './cli/test-flag.js';
 import { registerPtyTakeoverCommands } from './cli/pty-takeover-cli.js';
@@ -46,6 +47,7 @@ import { registerPublishCommands } from './cli/publish-cli.js';
 import { registerAutopilotCommands } from './cli/autopilot-cli.js';
 import { registerRoleCommands } from './cli/role-cli.js';
 import { registerMachineCommands } from './cli/machine-cli.js';
+import { registerAgentEnvCommands } from './cli/agent-env-cli.js';
 import { registerScheduleCommands } from './cli/schedule-cli.js';
 export { runSchedule, scheduleCreatePlan } from './cli/schedule-cli.js';
 export type { ScheduleDispatch } from './cli/schedule-cli.js';
@@ -63,6 +65,8 @@ import { registerUsageCommand } from './cli/usage-cli.js';
 import { registerLiveCommands } from './cli/live-cli.js';
 import { registerResearchCommand } from './cli/research-cli.js';
 import { registerReleaseCommands } from './cli/release-cli.js';
+import { registerFreezeCommands } from './cli/freeze-cli.js';
+import { registerFlowCommands } from './cli/flow-cli.js';
 import { registerModelWatchCommand } from './cli/model-watch-cli.js';
 import { registerIntakeCommands } from './cli/intake-cli.js';
 import { registerTasksCommands } from './cli/tasks-cli.js';
@@ -78,6 +82,7 @@ import { registerStartCommand } from './cli/start-cli.js';
 import { registerGroundingSourcesCli } from './grounding/sources-cli.js';
 import { registerGraphCommands } from './graph-runner/graph-cli.js';
 import { registerLoopCommands } from './loops/loop-cli.js';
+import { registerHqMovePlanCommand } from './hq/hq.js';
 import { registerCardCommand } from './task-cards/card-cli.js';
 import { registerLaunchHeadCommands } from './launch-head/launch-head-cli.js';
 import { acpServerHelpText } from './boot/acp-server-help.js';
@@ -854,6 +859,7 @@ registerPrCommands(program);
 registerRepoCommands(program);
 registerRoleCommands(program);
 registerMachineCommands(program);
+registerAgentEnvCommands(program);
 // CLI entry: where action → resolveCurrentInstance → resolveInstance (instance universe).
 registerWhereCommand(program);
 registerShadowCommand(program);
@@ -869,6 +875,8 @@ registerUsageCommand(program);
 registerLiveCommands(program);
 registerResearchCommand(program);
 registerReleaseCommands(program);
+registerFreezeCommands(program);
+registerFlowCommands(program);
 // HQ-HB · HQ-FENCE (10-04): one writer across mbp · node-b · cloud-vm — lease on the arbiter, 2-of-3 quorum, generation fencing.
 const hqCmd = program.command('hq').description('본부 임대 — 하트비트·중재·단일 작성자 래퍼');
 async function hqSink(): Promise<void> {
@@ -897,6 +905,19 @@ hqCmd.command('lease').argument('<action>', 'acquire|renew|status|release')
       if (!result.ok) process.exitCode = 2;
     } catch (error) { if (error instanceof CliUserError) throw error; console.error(`hq lease: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
   });
+hqCmd.command('promote').description('HQ 승격 런북 (기본 dry-run · --apply 일 때만 변경)')
+  .requiredOption('--to <host>', '승격 대상 호스트')
+  .option('--apply', '대기 사본을 승격 우주에 반영하고 넥서스·rescue 실행')
+  .option('--json', 'JSON 출력')
+  .action(async (opts: { to: string; apply?: boolean; json?: boolean }) => {
+    try {
+      const { promoteHq, formatPromote } = await import('./hq/promote.js');
+      const result = promoteHq(opts.to, opts.apply === true);
+      if (opts.json) await writeStdoutJson(`${JSON.stringify(result)}\n`);
+      else console.log(formatPromote(result));
+      if (!result.ok) process.exitCode = 1;
+    } catch (error) { console.error(`hq promote: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
 hqCmd.command('heartbeat').description('보유자는 갱신 · 아니면 대기(보유자에 닿는지 중재자에 보고)').option('--json', 'JSON 출력')
   .action(async (opts: { json?: boolean }) => {
     try {
@@ -920,6 +941,18 @@ hqCmd.command('seen').description('이 호스트가 본 가장 높은 임대 세
     else console.log(result.seen ? `hq seen: generation ${result.generation}` : 'hq seen: never');
     process.exitCode = result.seen ? 0 : 3;
   });
+registerHqMovePlanCommand(hqCmd);
+hqCmd.command('fence-audit').description('운영 crontab 의 HQ 울타리 밖 쓰기 잡 목록과 감싼 줄 제안(읽기 전용)')
+  .option('--json', 'JSON 출력')
+  .action(async (opts: { json?: boolean }) => {
+    try {
+      await hqSink();
+      const rows = (await import('./hq/fence-audit.js')).hqFenceAudit();
+      if (opts.json) await writeStdoutJson(`${JSON.stringify(rows)}\n`);
+      else if (!rows.length) console.log('hq fence-audit: unfenced 0');
+      else for (const row of rows) console.log(`${row.raw}\n  role: ${row.recommendedRole}\n  suggested: ${row.suggestedLine}`);
+    } catch (error) { console.error(`hq fence-audit: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
+  });
 hqCmd.command('fence').description('이 호스트가 임대를 쥐었을 때만 명령 실행(아니면 건너뜀 · exit 0)')
   .requiredOption('--role <role>', 'telegram-poller|cron|seat-loop|release-run|conatus|git-push')
   .argument('<command...>', '-- 뒤의 명령')
@@ -930,6 +963,7 @@ hqCmd.command('fence').description('이 호스트가 임대를 쥐었을 때만
     process.exitCode = hqFenceRun(opts.role as 'cron', command);
   });
 const seatCmd = program.command('seat').description('분배된 자리의 하루 루프와 보고');
+registerSeatRequestsCommands(seatCmd);
 seatCmd.command('answer <askId> <answer>').description('자리 질문에 답을 남기고 원래 표면으로 회신 예약')
   .action(async (askId: string, answer: string) => {
     try {
@@ -945,10 +979,10 @@ seatCmd.command('loop').requiredOption('--seat <SEAT>', 'MK|OP|TC|UX')
     try {
       // V3 F5: without the sink, the seat loop's judgment lines (seat.loop) never reach the log store when cron runs it.
       await (await import('./domains/standalone-log-sink.js')).registerStandaloneLogSink('seat-loop');
-      const { runSeatLoopTurn } = await import('./seat-loop/seat-loop.js');
+      const { runSeatLoopTurn, seatLoopTickLine } = await import('./seat-loop/seat-loop.js');
       const result = await runSeatLoopTurn(opts.seat);
       if (opts.json) await writeStdoutJson(`${JSON.stringify(result)}\n`);
-      else console.log(`seat loop ${opts.seat}: ${result.status}${'runId' in result && result.runId ? ` ${result.runId}` : ''}`);
+      else console.log(seatLoopTickLine(result));
     } catch (error) { console.error(`seat loop: ${error instanceof Error ? error.message : String(error)}`); process.exitCode = 1; }
   });
 seatCmd.command('report').requiredOption('--seat <SEAT>', 'MK|OP|TC|UX')
@@ -3034,6 +3068,8 @@ export async function runHarnessOrchestrateExecution(
     prior,
     goals,
     pid,
+    ...(['OP', 'TC', 'MK', 'UX'].includes(process.env.ELANOUS_HARNESS_SEAT ?? '')
+      ? { seat: process.env.ELANOUS_HARNESS_SEAT as SelfDevRunState['seat'] } : {}),
     runIdSource,
     now,
     onPersistenceFailure: reportPersistenceFailure,
@@ -3151,7 +3187,7 @@ contextCmd.command('condense')
       if (!/^[1-9]\d*h$/.test(opts.since)) throw new Error('--since requires positive hours, e.g. 24h');
       const { runContextCondense } = await import('./context-bus/condense.js');
       const report = await runContextCondense({ hours: Number(opts.since.slice(0, -1)), apply: opts.apply === true });
-      await writeStdoutJson(JSON.stringify({ since: report.since, until: report.until, cards: report.cards, conflicts: report.conflicts, skipped: report.skipped, folded: report.folded, ...(report.applied ? { applied: report.applied } : {}) }) + '\n');
+      await writeStdoutJson(JSON.stringify({ since: report.since, until: report.until, cards: report.cards, conflicts: report.conflicts, skipped: report.skipped, folded: report.folded, droppedHarnessChild: report.droppedHarnessChild, funnel: report.funnel, ...(report.applied ? { applied: report.applied } : {}) }) + '\n');
       if (!opts.json) await writeStdoutFully(report.markdown);
     } catch (error) {
       console.error(`context condense: ${error instanceof Error ? error.message : String(error)}`);
@@ -3438,6 +3474,22 @@ selfCmd
     }
   });
 
+selfCmd
+  .command('speed-claims')
+  .description('런 원장 발사→종결 시간의 자리별·결과별 분포를 읽기 전용으로 출력한다')
+  .option('--json', '구조화된 JSON으로 출력한다')
+  .action(async (opts: { json?: boolean }) => {
+    try {
+      const { measureSpeedClaims, renderSpeedClaims } = await import('./self-implement/speed-claims.js');
+      const result = measureSpeedClaims();
+      if (opts.json) await writeStdoutJson(JSON.stringify(result) + '\n');
+      else console.log(renderSpeedClaims(result));
+    } catch (error) {
+      console.error(`speed-claims measurement failed: ${error instanceof Error ? error.message : String(error)}`);
+      process.exitCode = 1;
+    }
+  });
+
 selfCmd
   .command('goal-source-distribution')
   .description('self-implement 런 원장의 start goalSource 분포를 읽기 전용으로 출력한다')
@@ -4300,6 +4352,35 @@ selfCmd
     } catch (e) { console.error(`⛔ ${(e as Error).message}`); process.exitCode = 1; }
   });
 
+export async function announceLaunchQuotaPolicy(input: {
+  runId: string;
+  current: import('./oauth/codex-quota-policy.js').ResolvedCodexQuotaPolicy;
+  universe: { kind: 'prod' | 'test'; root: string };
+  production?: import('./oauth/codex-quota-policy.js').ResolvedCodexQuotaPolicy;
+}): Promise<{ line: string; warning?: string; quotaPolicy: {
+  policy: import('./oauth/codex-quota-policy.js').CodexQuotaPolicy;
+  source: import('./oauth/codex-quota-policy.js').ResolvedCodexQuotaPolicy['source'];
+  universeKind: 'prod' | 'test';
+} }> {
+  const { describeLaunchQuotaPolicy } = await import('./oauth/codex-quota-policy.js');
+  const { appendRunLedgerEntry } = await import('./self-implement/run-ledger.js');
+  const described = describeLaunchQuotaPolicy(input);
+  const data = { policy: input.current.policy, source: input.current.source, universe: input.universe,
+    ...(described.warning ? { warning: described.warning } : {}) };
+  try {
+    appendRunLedgerEntry({ runId: input.runId, timestamp: new Date().toISOString(), event: 'launch-quota-policy', data });
+  } catch (error) {
+    debug.log('pod.quota-policy', 'ledger-unavailable', { runId: input.runId, error: String(error) }, { level: 'warn' });
+    throw new Error(`pod launch quota policy ledger write failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+  debug.log('pod.quota-policy', 'announced', data);
+  return { ...described, quotaPolicy: { policy: input.current.policy, source: input.current.source, universeKind: input.universe.kind } };
+}
+
+export function withLaunchQuotaPolicy<T extends object>(results: readonly T[], quotaPolicy: Awaited<ReturnType<typeof announceLaunchQuotaPolicy>>['quotaPolicy'] | undefined): (T & { quotaPolicy?: Awaited<ReturnType<typeof announceLaunchQuotaPolicy>>['quotaPolicy'] })[] {
+  return quotaPolicy ? results.map((result) => ({ ...result, quotaPolicy })) : [...results];
+}
+
 // self orchestrate — 병렬 self-dev(S1·2026-07-21) — N개 독립 goal 을 각자 `elanous self implement` 서브프로세스로
 //   TOX 디스패처 위에서 동시성캡 병렬 실행. 각 잡=자기 프로세스=자기 harness-space(병렬안전). 엔진(그래프/
 //   디스패처)은 기존 재사용·새 조각=self-implement surface 어댑터. [[PLAN-parallel-self-dev-orchestrator-2026-07-21]].
@@ -4331,6 +4412,9 @@ const selfOrchestrateCmd = selfCmd
   .option('--no-pod-rebuild', 'pod: 이미지 판(elanous.commit)이 HEAD 와 달라도 다시 굽지 않는다 — 측정은 «이미지 판»을 잰다')
   .option('--pod-pass-env <keys>', 'pod: 호스트 env 에서 Pod 로 넘길 키(쉼표) — 예 OPENROUTER_API_KEY,ANTHROPIC_API_KEY(벤치마크 과금 경로)')
   .option('--bench-arms <spec>', 'pod 벤치마크: 골 1개를 팔마다 «라벨 한 줄만 다르게» 복제해 동시에 — "id=provider[:model][@KEY+KEY];…" (예 codex=openai-codex;or-kimi=openrouter:openrouter/moonshotai/kimi-k3@OPENROUTER_API_KEY) · --auto-merge 거부 · RFC fleet 슈퍼바이저 §A3')
+  .addOption(new Option('--child-llm-provider <id>', 'pod: 구현 자식 LLM provider(openai-codex|grok) — 하니스 --child-llm-provider 가 이 자리로 온다(10-05)').hideHelp())
+  .addOption(new Option('--child-llm-model <id>', 'pod: 구현 자식 LLM model(--child-llm-provider 와 함께)').hideHelp())
+  .addOption(new Option('--child-llm-effort <level>', 'pod: 구현 자식 추론 노력(--child-llm-provider 와 함께)').hideHelp())
   .option('--help-all', '모든 orchestrate 옵션 표시')
   .action(function (this: Command, parts: string[], opts: { goalFile?: string[]; concurrency?: string; autoMerge?: boolean; autoReview?: boolean; openPr?: boolean; base?: string; teardown?: boolean; resume?: string; board?: boolean; decompose?: boolean; fabricDecompose?: boolean; maxTasks?: string; supervise?: boolean; superviseRounds?: string; json?: boolean }) {
     return (async () => {
@@ -4458,6 +4542,8 @@ const selfOrchestrateCmd = selfCmd
         prior,
         goals,
         pid: process.pid,
+        ...(['OP', 'TC', 'MK', 'UX'].includes(process.env.ELANOUS_HARNESS_SEAT ?? '')
+          ? { seat: process.env.ELANOUS_HARNESS_SEAT as SelfDevRunState['seat'] } : {}),
         runIdSource,
         now: () => Date.now(),
       });
@@ -4492,6 +4578,7 @@ const selfOrchestrateCmd = selfCmd
       //   coordinator 해석(decompose·run-identity·checkpoint·board)은 액션에 유지·감독 콜백은 runtime 으로 주입.
       // ☸️ 실행 칸 — pod 면 self-implement 자식을 k8s Job 으로(계약 동일 · 슈퍼바이저 무수정).
       const substrate = (opts as { substrate?: string }).substrate ?? 'local';
+      let launchQuotaPolicy: Awaited<ReturnType<typeof announceLaunchQuotaPolicy>>['quotaPolicy'] | undefined;
       let podSpawn: import('./task-orchestrator/surfaces/self-implement.js').SelfImplementJobSpawn | undefined;
       let podTargets: { context: string; namespace: string }[] | undefined;
       if (substrate === 'pod') {
@@ -4562,6 +4649,19 @@ const selfOrchestrateCmd = selfCmd
         let rotationAccounts: readonly string[] | undefined;
         let podProvider: 'openai-codex' | 'grok' = 'openai-codex';
         let grokApiKeyOptIn = false;
+        {
+          // 10-05 PODPROVIDER: refuse child choices this Pod launch cannot honour instead of dropping them.
+          const child = opts as { childLlmProvider?: string; childLlmModel?: string; childLlmEffort?: string };
+          const named = child.childLlmProvider?.trim();
+          const refuse = !named && (child.childLlmModel?.trim() || child.childLlmEffort?.trim())
+            ? 'pod: --child-llm-model/--child-llm-effort 는 --child-llm-provider 와 함께'
+            : named && benchArms
+              ? 'pod: --child-llm-provider 는 --bench-arms 와 함께 못 쓴다(팔마다 모델이 하나다)'
+              : named === 'grok' && explicitPodAccount
+                ? 'pod: --child-llm-provider grok 은 --pod-account 와 함께 못 쓴다(그것은 codex 계정을 고정한다)'
+                : undefined;
+          if (refuse) { ui.error(refuse); debug.log('self-implement.pod', 'child-provider-refused', { provider: named ?? null, reason: refuse }); process.exit(2); }
+        }
         if (!explicitPodAccount && !benchArms) {
           const { inspectCodexRotation } = await import('./oauth/codex-account-store.js');
           const { planPodProvider, makePodAccountBroker } = await import('./task-orchestrator/surfaces/pod-account-broker.js');
@@ -4574,34 +4674,57 @@ const selfOrchestrateCmd = selfCmd
           const resolvedQuota = resolveCodexQuotaPolicy(getUserConfig().llm);
           const quotaPolicy = resolvedQuota.policy;
           // POL1 — say which policy this launch uses and where it came from; warn when a test universe disagrees with production.
-          try {
-            const { effectiveInstanceRoot, prodInstanceRoot } = await import('./instance/resolve.js');
-            const { describeLaunchQuotaPolicy } = await import('./oauth/codex-quota-policy.js');
-            const root = effectiveInstanceRoot();
-            const kind = root === prodInstanceRoot() ? 'prod' as const : 'test' as const;
-            let production: ReturnType<typeof resolveCodexQuotaPolicy> | undefined;
-            if (kind === 'test') {
-              try {
-                const { readFileSync } = await import('node:fs');
-                const prodLlm = (JSON.parse(readFileSync(`${prodInstanceRoot()}/config.json`, 'utf8')) as { llm?: Record<string, unknown> }).llm;
-                production = resolveCodexQuotaPolicy(prodLlm);
-              } catch { /* no production config on this machine */ }
+          const { effectiveInstanceRoot, prodInstanceRoot } = await import('./instance/resolve.js');
+          const root = effectiveInstanceRoot();
+          const kind = root === prodInstanceRoot() ? 'prod' as const : 'test' as const;
+          let production: ReturnType<typeof resolveCodexQuotaPolicy> | undefined;
+          if (kind === 'test') {
+            try {
+              const { readFileSync } = await import('node:fs');
+              const prodLlm = (JSON.parse(readFileSync(`${prodInstanceRoot()}/config.json`, 'utf8')) as { llm?: Record<string, unknown> }).llm;
+              production = resolveCodexQuotaPolicy(prodLlm);
+            } catch { /* no production config on this machine */ }
+          }
+          const described = await announceLaunchQuotaPolicy({ runId, current: resolvedQuota, universe: { kind, root }, ...(production ? { production } : {}) });
+          launchQuotaPolicy = described.quotaPolicy;
+          debug.log('self-implement.pod', 'quota-policy', { policy: resolvedQuota.policy, source: resolvedQuota.source, universe: kind, productionPolicy: production?.policy ?? null });
+          if (!opts.json) { ui.info(described.line); if (described.warning) ui.warn(described.warning); }
+          // GROK-OPTIONAL (10-05): an expiring grok subscription the host cannot refresh is dropped from the chain here,
+          // so the launch goes on with codex instead of dying later in hostGrokCredentials.
+          let grokSubscriptionUsable = credential?.kind === 'subscription';
+          if (grokSubscriptionUsable && codexPolicyAllowsFallback(quotaPolicy)) {
+            const { podGrokSubscriptionUsable, podGrokSkippedLine } = await import('./task-orchestrator/surfaces/self-implement-pod.js');
+            const grokCheck = podGrokSubscriptionUsable();
+            if (!grokCheck.usable) {
+              grokSubscriptionUsable = false;
+              if (!opts.json) ui.warn(podGrokSkippedLine(grokCheck));
             }
-            const described = describeLaunchQuotaPolicy({ current: resolvedQuota, universe: { kind, root }, ...(production ? { production } : {}) });
-            debug.log('self-implement.pod', 'quota-policy', { policy: resolvedQuota.policy, source: resolvedQuota.source, universe: kind, productionPolicy: production?.policy ?? null });
-            if (!opts.json) { ui.info(described.line); if (described.warning) ui.warn(described.warning); }
-          } catch { /* the line is advice; the launch goes on */ }
-          const plan = planPodProvider({
+          }
+          // 10-05 PODPROVIDER: a launch that named the child provider gets it, or is refused — never a silent codex.
+          const namedChild = (opts as { childLlmProvider?: string }).childLlmProvider?.trim();
+          const { podNamedChildProvider, podFallbackCredentials, podGrokSubscriptionUsable: namedGrokUsable } = await import('./task-orchestrator/surfaces/self-implement-pod.js');
+          const namedChildDecision = podNamedChildProvider(namedChild, {
+            grokSubscription: namedChild === 'grok' && credential?.kind === 'subscription' && (grokSubscriptionUsable || namedGrokUsable().usable),
+            grokApiKey: credential?.kind === 'api_key' && grokApiKeyOptIn,
+          });
+          if (namedChildDecision.refuse) { ui.error(namedChildDecision.refuse); debug.log('self-implement.pod', 'child-provider-refused', { provider: namedChild, reason: namedChildDecision.refuse }); process.exit(2); }
+          // A named codex child must stay codex — the plan may not fall back to grok (post-review must-fix).
+          const namedCodex = namedChildDecision.provider === 'openai-codex';
+          const plan: import('./task-orchestrator/surfaces/pod-account-broker.js').PodProviderPlan = namedChildDecision.provider === 'grok'
+            ? { provider: 'grok', excluded: [], grokSubscriptionEligible: credential?.kind === 'subscription' }
+            : planPodProvider({
             codexCandidates: inspectCodexRotation().candidates,
             // Per-account caps (대표 default:97) override the Pod default cap — without them default was dropped at 60%.
             thresholdPercentByAccount: getUserConfig().llm?.codexAccountRotationThresholdPercentByAccount,
             // 대표 한도 정책 한 값(`llm.codexQuotaPolicy`) — 크레딧·폴백을 같이 정한다.
             creditsAllowed: codexPolicyAllowsCredits(quotaPolicy),
-            grokSubscription: codexPolicyAllowsFallback(quotaPolicy) && credential?.kind === 'subscription',
-            grokApiKey: codexPolicyAllowsFallback(quotaPolicy) && credential?.kind === 'api_key',
+            ...podFallbackCredentials(namedChildDecision.provider, {
+              grokSubscription: codexPolicyAllowsFallback(quotaPolicy) && grokSubscriptionUsable,
+              grokApiKey: codexPolicyAllowsFallback(quotaPolicy) && credential?.kind === 'api_key',
+            }),
             grokApiKeyOptIn,
           });
-          if (plan.provider === null) { ui.error(`pod: 쓸 codex 계정이 없다 — ${plan.reasons.join(' · ')} · 계정을 명시하려면 --pod-account <이름>`); process.exit(2); }
+          if (plan.provider === null) { ui.error(`pod: 쓸 codex 계정이 없다 — ${plan.reasons.join(' · ')}${namedCodex ? ' · child provider 를 openai-codex 로 지정해 grok 으로 넘기지 않는다' : ''} · 계정을 명시하려면 --pod-account <이름>`); process.exit(2); }
           podProvider = plan.provider;
           if (plan.provider === 'openai-codex') {
             accountBroker = makePodAccountBroker({ usable: plan.accounts, excluded: plan.excluded });
@@ -4610,6 +4733,10 @@ const selfOrchestrateCmd = selfCmd
             { const { emitDecision } = await import('./live/detail-switch.js');
               emitDecision({ kind: 'ROUTE', what: `Pod 계정 배분 ${plan.accounts.join(' → ')}`, reason: plan.excluded.length ? `뺌 ${plan.excluded.map((x) => `${x.name}(${x.why})`).join(', ')}` : '모든 계정 여유', purpose: plan.creditAccounts ? '구독 잔량 0 — 정책상 크레딧으로 병렬 조각을 돌린다' : '병렬 조각이 한 계정에 몰리지 않게 잔량 순으로 돌려 준다', phase: 'dispatch', target: `Pod ${plan.accounts.length}계정`, paths: plan.accounts.length + plan.excluded.length }); }
             if (!opts.json) ui.info(`[pod] 계정 배분(잔량 순 · 돌려 가며): ${plan.accounts.join(' → ')}${plan.creditAccounts ? ' · 💳 크레딧(구독 잔량 0 · 허가됨)' : ''}${plan.excluded.length ? ` · 뺌 ${plan.excluded.map((x) => `${x.name}(${x.why})`).join(', ')}` : ''}`);
+          } else if (namedChildDecision.provider === 'grok') {
+            const model = (opts as { childLlmModel?: string }).childLlmModel?.trim() || defaultGrokModel().id;
+            debug.log('self-implement.pod', 'provider-named', { provider: 'grok', model, credential: credential?.kind ?? null });
+            if (!opts.json) ui.info(`[pod] child provider = grok(모델 ${model}) — 발사 인자로 지정됨`);
           } else {
             const model = defaultGrokModel().id;
             debug.log('self-implement.pod', 'provider-fallback', { from: 'openai-codex', to: 'grok', excluded: plan.excluded, model });
@@ -4637,7 +4764,10 @@ const selfOrchestrateCmd = selfCmd
             ...(podSource.kind === 'bundle' ? { headCommit: podSource.headCommit, sizeBytes: podSource.sizeBytes } : {}),
           });
         }
-        const podBase = { hostSupervised: opts.supervise === true, ...(remoteOnlyPool ? { imageCommit: image.imageCommit } : {}), account: podProvider === 'grok' ? 'grok' : explicitPodAccount ?? 'team', ...(accountBroker ? { accountBroker, rotationAccounts } : {}), ...(podProvider === 'grok' ? { provider: 'grok' as const, grokApiKeyOptIn } : {}), passEnv, ...(pool ? { pool } : {}), ...((opts as { podSkillEnv?: boolean }).podSkillEnv ? { skillEnv: true } : {}), ...(podSource ? { source: podSource } : {}) };
+        const childFlags = opts as { childLlmProvider?: string; childLlmModel?: string; childLlmEffort?: string };
+        const podChildLlm = childFlags.childLlmProvider?.trim() ? { childProviderExplicit: true, ...(childFlags.childLlmModel?.trim() ? { childModel: childFlags.childLlmModel.trim() } : {}), ...(childFlags.childLlmEffort?.trim() ? { childEffort: childFlags.childLlmEffort.trim() } : {}) } : {};
+        if (childFlags.childLlmProvider?.trim()) debug.log('self-implement.pod', 'child-provider-named', { provider: childFlags.childLlmProvider.trim(), model: childFlags.childLlmModel ?? null, podProvider });
+        const podBase = { hostSupervised: opts.supervise === true, ...podChildLlm, ...(remoteOnlyPool ? { imageCommit: image.imageCommit } : {}), account: podProvider === 'grok' ? 'grok' : explicitPodAccount ?? 'team', ...(accountBroker ? { accountBroker, rotationAccounts } : {}), ...(podProvider === 'grok' ? { provider: 'grok' as const, grokApiKeyOptIn } : {}), passEnv, ...(pool ? { pool } : {}), ...((opts as { podSkillEnv?: boolean }).podSkillEnv ? { skillEnv: true } : {}), ...(podSource ? { source: podSource } : {}) };
         if (benchArms) {
           const { benchPodSpawn } = await import('./task-orchestrator/surfaces/self-implement-pod.js');
           podSpawn = benchPodSpawn(benchArms, podBase);
@@ -4714,7 +4844,7 @@ const selfOrchestrateCmd = selfCmd
           debug.log('self-dev.reduce', 'orchestrate-reduce', { runId, shards: shards.length, kind: r.kind });
         }
       }
-      if (opts.json) { await writeStdoutJson(JSON.stringify(results) + '\n'); await reportRun(results); return; }
+      if (opts.json) { await writeStdoutJson(JSON.stringify(withLaunchQuotaPolicy(results, launchQuotaPolicy)) + '\n'); await reportRun(results); return; }
       const done = results.filter((r) => r.status === 'done').length;
       const promoted = results.filter((r) => r.prUrl).length;
       const incomplete = results.length - done;
@@ -6811,7 +6941,8 @@ const selfDevCmd = program
         const { dispatchHarnessOnPod } = await import('./harness/harness-pod-dispatch.js');
         const { devAskPodDispatchInput } = await import('./harness/harness-substrate-default.js');
         const { classifyHarnessPodExit, harnessPodRunId, recordClassifiedHarnessPodExit, warnRecentIncidentBurst } = await import('./harness/harness-cli-command.js');
-        warnRecentIncidentBurst();
+        warnRecentIncidentBurst(undefined, undefined, undefined,
+          { entrance: 'cli-dev-ask', seat: opts.seat });
         let podOutput = '';
         let podRunId: string | undefined;
         const previousLeaseId = process.env.ELANOUS_POD_RESERVED_LEASE;
@@ -6831,7 +6962,8 @@ const selfDevCmd = program
         }
         if (status !== 0) {
           const classified = classifyHarnessPodExit({ status }, podOutput, { ...(podRunId ? { runId: podRunId } : {}) });
-          recordClassifiedHarnessPodExit(podRunId ?? harnessPodRunId(podOutput), classified.reason, status);
+          recordClassifiedHarnessPodExit(podRunId ?? harnessPodRunId(podOutput), classified.reason, status,
+            { entrance: 'cli-dev-ask', seat: opts.seat, output: podOutput });
           for (const line of classified.lines) console.error(line);
         }
         completionGuard.conclude();

package/src/intake-plane/check.ts

@@ -61,8 +61,22 @@ export interface IntakeCheckEvidence {
   readonly contrary?: boolean;
 }
 
+export interface IntakeReplacementCandidate {
+  readonly tool: string;
+  readonly paidDependency: string;
+  readonly status: '현장 시험 필요';
+  /** A comparison claim is not evidence that any of these checks have passed. */
+  readonly trial: {
+    readonly installation: '미검증';
+    readonly sampleRun: '미검증';
+    readonly license: '미검증';
+    readonly maintenanceStatus: '미검증';
+  };
+}
+
 export interface IntakeCheckItem {
   readonly fact: string;
+  readonly replacementCandidate?: IntakeReplacementCandidate;
   /** Source identity preserved from the supplied fact for card-backed goal evidence. */
   readonly sourceRef?: string;
   readonly originalClaims?: readonly string[];
@@ -1053,6 +1067,40 @@ function factKey(text: string): string {
   return text.replace(/\s+/g, ' ').trim().toLowerCase();
 }
 
+/** A stated possibility is a trial candidate, not proof of a working replacement. */
+function replacementCandidate(fact: string): IntakeReplacementCandidate | undefined {
+  if (!/(?:대체(?:하|한|할| 가능| 후보|재)|replace|replacement|alternative to)/i.test(fact)
+    || /(?:대체하지\s*(?:는|도|조차|를)?\s*(?:않|못)|대체\s*못|대체할\s*수\s*(?:는|도|가)?\s*없|대체(?:가|는| 후보가)?\s*(?:아니|불가)|cannot replace|can't replace|does not replace|not a replacement)/i.test(fact)) return undefined;
+  const paid = fact.match(/(?:유료|paid)\s*(?:(?:서비스|의존성|도구|툴|API|dependency|service|tool)\s*)?`?([a-z][\w.-]+)`?/i);
+  // firecrawl is a named paid-dependency example even when the claim omits the word "paid".
+  const paidDependency = paid?.[1] ?? fact.match(/(?:^|[^\w])`?(firecrawl)`?(?=$|[^\w])/i)?.[1];
+  if (!paidDependency) return undefined;
+  const names = [...fact.matchAll(/`([a-z][\w.-]+)`/gi)].map((match) => match[1]!);
+  const explicit = names.filter((name) => name.toLowerCase() !== paidDependency.toLowerCase());
+  const plain = fact.match(/^\s*([a-z][\w.-]+)\s*(?:가|이|는|은|으로|로|can\b|could\b|may\b)/i)?.[1];
+  const tool = explicit.length === 1 ? explicit[0] : explicit.length === 0 ? plain : undefined;
+  if (!tool || tool.toLowerCase() === paidDependency.toLowerCase() || tool.toLowerCase() === 'elanous') return undefined;
+  // Names appearing together do not establish the direction of replacement.
+  const clause = fact.replace(/`/g, '').replace(/(?:유료|paid)\s*(?:(?:서비스|의존성|도구|툴|API|dependency|service|tool)\s*)?/gi, '');
+  const escape = (name: string): string => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const name = (value: string): string => `(?<![\\w.-])${escape(value)}(?![\\w.-])`;
+  const toolName = name(tool);
+  const dependencyName = name(paidDependency);
+  const replaces = (subject: string, object: string): boolean => [
+    new RegExp(`${subject}\\s*(?:이|가|은|는)?\\s+${object}\\s*(?:을|를)\\s*대체(?:하|한|할| 가능| 후보|재)`, 'i'),
+    new RegExp(`${object}\\s*(?:을|를)\\s+${subject}\\s*(?:이|가|은|는)\\s*대체(?:하|한|할| 가능| 후보|재)`, 'i'),
+    new RegExp(`${subject}\\s+(?:can |could |may )?replace(?:s|d)?\\s+${object}`, 'i'),
+    new RegExp(`${subject}\\s+(?:is |could be |may be )?(?:an? )?(?:replacement|alternative)\\s+to\\s+${object}`, 'i'),
+  ].some((pattern) => pattern.test(clause));
+  if (!replaces(toolName, dependencyName) || replaces(dependencyName, toolName)) return undefined;
+  return {
+    tool,
+    paidDependency,
+    status: '현장 시험 필요',
+    trial: { installation: '미검증', sampleRun: '미검증', license: '미검증', maintenanceStatus: '미검증' },
+  };
+}
+
 function isLens(value: string): value is PreprocessLens {
   return (PREPROCESS_LENSES as readonly string[]).includes(value);
 }
@@ -1414,8 +1462,17 @@ export function runIntakeCheck(
     }
     // src/index.ts intake check .action → runIntakeCheck / runIntakeCheckDocument → runIntakeCheck → judgeFact.
     const judged = judgeFact(fact, ruler, deps);
+    const candidate = replacementCandidate(fact.text);
+    const verdict = candidate && judged.verdict !== '못 쟀다' ? '판단 필요' : judged.verdict;
+    const current = candidate && judged.verdict !== '못 쟀다'
+      ? `${judged.current} · 대체 후보 ${candidate.tool} → ${candidate.paidDependency}: 설치·샘플 실행·라이선스·유지보수 상태 현장 시험 필요`
+      : judged.current;
     const item: IntakeCheckItem = {
       ...judged,
+      verdict,
+      current,
+      line: `${fact.text} → ${current} → ${verdict}`,
+      ...(candidate ? { replacementCandidate: candidate } : {}),
       quotes: [quote],
       ...(fact.sourceRef ? { sourceRef: fact.sourceRef } : {}),
       ...(fact.originalClaim ? { originalClaims: [fact.originalClaim] } : {}),
@@ -1711,6 +1768,11 @@ export function renderIntakeCheckReport(report: IntakeCheckReport): string {
   for (const item of report.items) {
     lines.push(item.line);
     lines.push(`  판정: ${item.verdict}`);
+    if (item.replacementCandidate) {
+      const candidate = item.replacementCandidate;
+      lines.push(`  대체 후보: ${candidate.tool} → 유료 의존성 ${candidate.paidDependency} (${candidate.status})`);
+      lines.push('  현장 시험: 설치 미검증 · 샘플 실행 미검증 · 라이선스 미검증 · 유지보수 상태 미검증');
+    }
     if (item.goalDraftPath) lines.push(`  골 초안: ${item.goalDraftPath}`);
     for (const quote of item.quotes) lines.push(`  인용: ${quote}`);
     for (const original of item.originalClaims ?? []) lines.push(`  원 주장: ${original}`);
@@ -1746,6 +1808,7 @@ export function intakeCheckReportJson(report: IntakeCheckReport): Record<string,
       current: item.current,
       verdict: item.verdict,
       line: item.line,
+      ...(item.replacementCandidate ? { replacementCandidate: item.replacementCandidate } : {}),
       quotes: item.quotes,
       evidence: item.evidence,
       patterns: item.patterns,

package/src/intake-plane/digest.ts

@@ -1,12 +1,12 @@
 // 흡수 하루 다이제스트 — 그날 흡수한 것을 사람이 «발견»하는 자리. 노트 절(마크다운) ⊕ 텔레그램 짧은 판.
 // 결정론만: 요약 한 줄은 각 노트가 이미 쓴 「한 줄 결론」을 뽑는다(LLM 을 다시 부르지 않는다).
 import { existsSync, readFileSync } from 'node:fs';
-import { basename, join, relative } from 'node:path';
+import { basename, join } from 'node:path';
 import { loadIntakeLedger, type IntakeItem } from './items.js';
 import { readSavedCursorAt } from './collect-telegram-saved.js';
 import { intakeOutboxDir, kstDay } from './route.js';
 
-export interface DigestEntry { id: string; sources: string[]; url?: string; note?: string; noteName?: string; oneLiner?: string; axis: string }
+export interface DigestEntry { id: string; sources: string[]; url?: string; note?: string; noteName?: string; oneLiner?: string; axis: string; impact?: { fact: string; current: string; action: string } }
 export interface IntakeDigest { day: string; absorbed: DigestEntry[]; goals: { fact: string; url?: string }[]; review?: { fact: string; note?: string }[]; grounding: number; release: number; manual: number; savedSilence?: { days: number; lastNewAt: string } }
 
 const AXIS_LABEL: Record<string, string> = {
@@ -43,17 +43,38 @@ const SAVED_SILENCE_MS = 48 * 3600_000;
 export function buildIntakeDigest(root: string, day: string, readFile: (p: string) => string | undefined = (p) => (existsSync(p) ? readFileSync(p, 'utf8') : undefined), now: Date = new Date()): IntakeDigest {
   const items = [...loadIntakeLedger(root).items.values()]
     .filter((i) => (i.status === 'absorbed' || i.status === 'routed') && kstDay(i.lastSeenAt) === day && i.outputs.some((o) => o.kind === 'note'));
+  const out = intakeOutboxDir(root);
+  const relevant = new Map<string, NonNullable<DigestEntry['impact']>>();
+  for (const [folder, action] of [
+    ['goals', '없는 기능의 골 후보를 세운다'],
+    ['manual', '문서·약속을 현재 동작에 맞게 보강한다'],
+    ['review', '대조 근거를 추가로 확인한다'],
+    ['release', '이미 착지한 기능의 바깥 맥락을 릴리스 노트에 반영한다'],
+  ] as const) {
+    for (const row of readJsonl(join(out, folder, `${day}.jsonl`))) {
+      if (typeof row.id !== 'string' || relevant.has(row.id)) continue;
+      const fact = folder === 'release' ? row.title : row.fact;
+      if (typeof fact !== 'string' || !fact.trim()) continue;
+      relevant.set(row.id, {
+        fact,
+        current: typeof (folder === 'release' ? row.summary : row.current) === 'string'
+          ? String(folder === 'release' ? row.summary : row.current) : '대조 근거 없음',
+        action,
+      });
+    }
+  }
   const absorbed = items.map((i: IntakeItem): DigestEntry => {
     const note = [...i.outputs].reverse().find((o) => o.kind === 'note')?.ref;
     const md = note ? readFile(note) : undefined;
+    const impact = relevant.get(i.id);
     return {
       id: i.id, sources: i.sources, ...(i.url ? { url: i.url } : {}),
       ...(note ? { note, noteName: basename(note, '.md') } : {}),
       ...(md ? { oneLiner: noteOneLiner(md) } : {}),
       axis: AXIS_LABEL[i.judgement?.axis ?? i.axis ?? ''] ?? (i.sources.includes('telegram-saved') ? '내가 저장한 것' : '그 밖'),
+      ...(impact ? { impact } : {}),
     };
   });
-  const out = intakeOutboxDir(root);
   const goals = readJsonl(join(out, 'goals', `${day}.jsonl`)).map((g) => ({ fact: String(g.fact ?? ''), ...(g.url ? { url: String(g.url) } : {}) }));
   const review = readJsonl(join(out, 'review', `${day}.jsonl`)).map((r) => ({ fact: String(r.fact ?? ''), ...(r.note ? { note: String(r.note) } : {}) }));
   const grounding = readJsonl(join(out, 'grounding.jsonl')).filter((g) => typeof g.at === 'string' && kstDay(g.at) === day).length;
@@ -94,18 +115,19 @@ export function renderDigestMarkdown(d: IntakeDigest): string {
   return L.join('\n');
 }
 
-/** 텔레그램 짧은 판 — 수 · 한 줄 요약 다섯 · 골 후보 · 노트 자리. */
-export function renderDigestTelegram(d: IntakeDigest, opts: { vaultRoot?: string; notePath?: string } = {}): string {
-  const L = [`📰 *${d.day} 흡수 ${d.absorbed.length}편*`];
-  if (d.savedSilence) L.push(`⚠️ 저장된 메시지 새 글 ${d.savedSilence.days}일째 0 — 저장한 곳 확인`);
-  for (const e of d.absorbed.slice(0, 5)) L.push(`• ${e.oneLiner ?? e.noteName ?? e.url ?? e.id}`);
-  if (d.absorbed.length > 5) L.push(`… 외 ${d.absorbed.length - 5}편`);
-  if (d.goals.length) L.push('', `🔴 엘라누스에 없는 것 ${d.goals.length}건 — 골 후보`);
-  if (d.review?.length) L.push(`${d.goals.length ? '' : '\n'}🟡 사람이 가를 것 ${d.review.length}건 — 노트 🧭 절`);
-  if (opts.vaultRoot && opts.notePath) {
-    const vault = basename(opts.vaultRoot);
-    const file = relative(opts.vaultRoot, opts.notePath).replace(/\.md$/, '');
-    L.push('', `📂 obsidian://open?vault=${encodeURIComponent(vault)}&file=${encodeURIComponent(file)}`);
+/** 텔레그램 — 흡수 렌즈가 대조한 항목만 SCQA 짧은 판으로 낸다. */
+export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: string; notePath?: string } = {}): string {
+  const touching = d.absorbed.filter((e) => e.impact);
+  const L = [`흡수 ${d.absorbed.length} → 우리에게 닿는 것 ${touching.length}`];
+  if (!touching.length) return L[0];
+  for (const e of touching.slice(0, 3)) {
+    L.push('',
+      `S 무엇: ${e.impact!.fact}`,
+      `C 우리에게 왜: ${e.impact!.current}`,
+      `A 그래서 무엇을 하나: ${e.impact!.action}`,
+      `🔗 원문 링크: ${e.url?.trim() || '링크 없음'}`,
+    );
   }
+  if (d.absorbed.length > touching.length) L.push('', `그 밖 ${d.absorbed.length - touching.length}건 · 닿지 않음`);
   return L.join('\n');
 }

package/src/intake-plane/front-classifier.ts

@@ -18,6 +18,12 @@ export interface FrontClassifierDecision extends IntakeFrontRouteDecision {
   urlRoute: UrlRouteDecision | null;
 }
 
+/** Only Telegram links explicitly routed to saved/absorbed work enter the event lane. */
+export function telegramAbsorbUrls(input: FrontClassifierInput, decision: FrontClassifierDecision): string[] {
+  if (input.surface !== 'telegram' || decision.track !== 'absorb' || !decision.urlRoute) return [];
+  return decision.urlRoute.urls;
+}
+
 const QUESTION_WORD_RE = new RegExp(
   `(?:${INTAKE_FRONT_QUESTION_WORDS.map((word) => /^[a-z]+$/i.test(word) ? `(?<![\\p{L}\\p{N}_])${word}(?![\\p{L}\\p{N}_])` : word).join('|')})[.!?。？！]*$`,
   'iu',

package/src/intake-plane/items.ts

@@ -5,6 +5,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { debug } from '../debug/log.js';
 import { findTrack } from '../autopilot/mission-phase-track.js';
+import { wasIntakeEventScheduled } from './route.js';
 
 export const INTAKE_SOURCES = ['x', 'youtube', 'github', 'telegram-saved', 'telegram-bot', 'memo', 'pwa'] as const;
 export type RegisteredIntakeSourceKind = 'rss' | 'command';
@@ -243,13 +244,13 @@ export function parseRawIntakeJsonl(text: string): { raws: RawIntakeItem[]; bad:
  */
 const STALE_QUEUED_MS = 24 * 3600_000;
 
-export function pickAbsorbQueue(instanceRoot: string, opts: { max: number; laneMax?: number; kind?: IntakeKind; dryRun?: boolean }, now = new Date().toISOString()): IntakeItem[] {
+export function pickAbsorbQueue(instanceRoot: string, opts: { max: number; laneMax?: number; kind?: IntakeKind; dryRun?: boolean }, now = new Date().toISOString(), taskStatus?: Parameters<typeof wasIntakeEventScheduled>[3]): IntakeItem[] {
   const userLeft = (i: IntakeItem) => i.sources.some((s) => s === 'telegram-saved' || s === 'memo');
   const score = (i: IntakeItem) => Math.max(0, ...Object.entries(i.signals).filter(([k]) => k.endsWith('.score')).map(([, v]) => v));
   const eligible = [...loadIntakeLedger(instanceRoot).items.values()]
     // queued 로 옮긴 뒤 흡수·표시가 없이 하루가 지난 것(흡수 도중 죽은 판)은 다시 고른다.
     .filter((i) => (i.status === 'new' || (i.status === 'queued' && Date.parse(now) - Date.parse(i.lastSeenAt) > STALE_QUEUED_MS))
-      && !!i.url && (!opts.kind || i.kind === opts.kind))
+      && !!i.url && !wasIntakeEventScheduled(instanceRoot, i.url, now, taskStatus) && (!opts.kind || i.kind === opts.kind))
     .sort((a, b) => Number(userLeft(b)) - Number(userLeft(a)) || b.sources.length - a.sources.length || score(b) - score(a) || b.lastSeenAt.localeCompare(a.lastSeenAt));
   const laneMax = opts.laneMax ?? 30;
   const lane = eligible.filter((i) => i.sources.includes('telegram-saved')).slice(0, Math.max(0, laneMax));