elanous 0.2.14 → 0.2.15

package/src/hq/move-plan.ts

@@ -0,0 +1,126 @@
+// Read-only inventory of work tied to the current HQ host before moving it.
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { join } from 'node:path';
+import { inventoryCrontab, listSchedules, openSchedulesDb, parseCronLine } from '../domains/schedule-registry.js';
+import { cronLaunchedActionsWithFence, listAllLoops, type AllLoopEntry, type LoopRegistryOptions } from '../loops/registry.js';
+import { defaultSshRunner, type SshRunner } from './lease.js';
+import { FENCE_ROLES } from './hq.js';
+
+type Measurement<T> = { status: 'measured'; value: T } | { status: '못 잼'; reason: string };
+interface MovePlan {
+  to: string;
+  from: string | null;
+  unfencedCron: Measurement<Array<{ raw: string; cron: string; command: string }>>;
+  hostLoops: Measurement<AllLoopEntry[]>;
+  targetHost: Measurement<{ exists: boolean; name: string | null }>;
+  nexusLaunchd: Measurement<{ present: boolean; measuredOn: 'local' }>;
+}
+
+type CommandResult = { status: number | null; stdout: string; stderr: string };
+interface MovePlanDeps {
+  crontab?: () => CommandResult;
+  loops?: typeof listAllLoops;
+  loopOptions?: LoopRegistryOptions;
+  ssh?: SshRunner;
+  launchctl?: () => CommandResult;
+  localHost?: () => string;
+  hostFile?: string;
+}
+
+const measured = <T>(value: T): Measurement<T> => ({ status: 'measured', value });
+const unknown = <T>(reason: string): Measurement<T> => ({ status: '못 잼', reason });
+const run = (command: string, args: string[]): CommandResult => {
+  const r = spawnSync(command, args, { encoding: 'utf8', timeout: 15_000, env: process.env });
+  return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? String(r.error ?? '') };
+};
+const message = (error: unknown) => error instanceof Error ? error.message : String(error);
+
+// Only known HQ jobs qualify by script name; a random scripts/*.ts is not HQ work.
+const HQ_SCRIPTS = new Set([
+  'steward.ts', 'draft-cleanup.ts', 'test-diet.ts', 'contract-coordinator.ts',
+  'market-posture.ts', 'mission-request-judge.ts',
+]);
+function isHqAction(script: string): boolean {
+  if (/(?:^|\/)(?:eln|elanous|elanous\.mjs)$/i.test(script)) return true;
+  if (/(?:^|\/)\.elanous(?:\/|$)/i.test(script)) return true;
+  const match = script.match(/(?:^|\/)scripts\/([^/\s]+\.ts)$/);
+  return !!match && HQ_SCRIPTS.has(match[1]!);
+}
+
+export function hqMovePlan(to: string, deps: MovePlanDeps = {}): MovePlan {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9.-]*$/.test(to) || to.includes('..')) throw new Error('hq move-plan: invalid host');
+  let unfencedCron: MovePlan['unfencedCron'];
+  let hostLoops: MovePlan['hostLoops'];
+  let localName: string | undefined;
+  let localHostError: string | undefined;
+  try {
+    const value = readFileSync(deps.hostFile ?? join(homedir(), '.elanous-hq', 'host'), 'utf8');
+    const name = value.endsWith('\n') ? value.slice(0, -1) : value;
+    if (!name || name !== name.trim() || /[\r\n]/.test(name)) throw new Error('invalid local HQ host file');
+    localName = name;
+  } catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') localHostError = message(error); }
+  const from = deps.localHost?.() ?? localName ?? null;
+  let text = '';
+  try {
+    const r = (deps.crontab ?? (() => run('crontab', ['-l'])))();
+    if (r.status !== 0 && !(r.status === 1 && /no crontab for /i.test(r.stderr))) {
+      throw new Error(r.stderr.trim() || `crontab -l exit=${r.status}`);
+    }
+    text = r.status === 0 ? r.stdout : '';
+    const rows = text.split('\n').map(raw => ({ raw, parsed: parseCronLine(raw) }))
+      .filter((row): row is { raw: string; parsed: { cron: string; command: string } } => row.parsed !== null);
+    unfencedCron = measured(rows.filter(({ parsed }) =>
+      cronLaunchedActionsWithFence(parsed.command).some(action =>
+        !!action.script && !(FENCE_ROLES as readonly string[]).includes(action.fenceRole ?? '')
+        && isHqAction(action.script)))
+      .map(({ raw, parsed }) => ({ raw, cron: parsed.cron, command: parsed.command })));
+  } catch (error) { unfencedCron = unknown(message(error)); }
+  try {
+    if (unfencedCron.status !== 'measured') throw new Error(unfencedCron.reason);
+    // The registry accepts an already-inventoried schedule set. Never open the production DB.
+    const db = openSchedulesDb(':memory:');
+    let schedules: ReturnType<typeof listSchedules>;
+    try { inventoryCrontab(db, { crontab: text }); schedules = listSchedules(db); }
+    finally { db.close(); }
+    if (localHostError) throw new Error(localHostError);
+    if (!from) throw new Error('local HQ host identity not confirmed (~/.elanous-hq/host missing)');
+    // Cron rows use os.hostname(); match that label only after confirming this machine's HQ identity.
+    const names = new Set([from, hostname()]);
+    hostLoops = measured((deps.loops ?? listAllLoops)({ ...deps.loopOptions, schedules })
+      .filter(loop => !!loop.host && names.has(loop.host)));
+  } catch (error) { hostLoops = unknown(message(error)); }
+  let targetHost: MovePlan['targetHost'];
+  try {
+    const r = (deps.ssh ?? defaultSshRunner)(to,
+      'if [ -f "$HOME/.elanous-hq/host" ]; then printf "present\\n"; cat "$HOME/.elanous-hq/host"; elif [ ! -e "$HOME/.elanous-hq/host" ]; then printf "absent\\n"; else exit 2; fi');
+    if (r.status !== 0) throw new Error(r.stderr.trim() || `ssh exit=${r.status}`);
+    const [presence, ...lines] = r.stdout.split('\n');
+    if (presence === 'absent') targetHost = measured({ exists: false, name: null });
+    else if (presence === 'present' && lines.join('\n').trim() && !/[\r\n]/.test(lines.join('\n').trim()))
+      targetHost = measured({ exists: true, name: lines.join('\n').trim() });
+    else throw new Error('target host file unreadable or empty');
+  } catch (error) { targetHost = unknown(message(error)); }
+  let nexusLaunchd: MovePlan['nexusLaunchd'];
+  try {
+    const r = (deps.launchctl ?? (() => run('launchctl', ['list', 'com.elanous.nexus'])))();
+    if (r.status === 0) nexusLaunchd = measured({ present: true, measuredOn: 'local' });
+    else if (r.status !== null && /Could not find service|service not found|not found/i.test(r.stderr)) nexusLaunchd = measured({ present: false, measuredOn: 'local' });
+    else throw new Error(r.stderr.trim() || `launchctl exit=${r.status}`);
+  } catch (error) { nexusLaunchd = unknown(message(error)); }
+  return { to, from, unfencedCron, hostLoops, targetHost, nexusLaunchd };
+}
+
+export function formatMovePlan(plan: MovePlan): string {
+  const lines = [`hq move-plan: ${plan.from ?? '못 잼'} → ${plan.to} (read-only)`];
+  const section = <T>(name: string, result: Measurement<T>, render: (value: T) => string[]) => {
+    lines.push(`${name}: ${result.status === 'measured' ? '' : `못 잼 (${result.reason})`}`.trimEnd());
+    if (result.status === 'measured') lines.push(...render(result.value));
+  };
+  section('① unfenced elanous crontab', plan.unfencedCron, rows => rows.length ? rows.map(row => `  ${row.raw}`) : ['  none']);
+  section('② local host loops (loop status --all)', plan.hostLoops, rows => rows.length ? rows.map(row => `  ${row.id} · ${row.host} · ${row.title}`) : ['  none']);
+  section('③ target ~/.elanous-hq/host', plan.targetHost, host => [`  ${host.exists ? host.name : 'absent'}`]);
+  section('④ local launchd com.elanous.nexus', plan.nexusLaunchd, service => [`  ${service.present ? 'present' : 'absent'} (measured on local machine)`]);
+  return lines.join('\n');
+}

package/src/hq/promote.ts

@@ -1,6 +1,10 @@
 // HQ promotion runbook: read-only preview by default; all remote mutations are behind --apply.
 import { spawnSync } from 'node:child_process';
 import { getUserConfig } from '../user-config.js';
+import { debug } from '../debug/log.js';
+import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { appendSeatRequestRows, listSeatRequests, withSeatRequestLedgerLock } from '../seat-dispatch/seat-request-ledger.js';
 import { parseLease, sshLeaseStore, defaultSshRunner, localShellRunner } from './lease.js';
 
 export interface PromoteRunner {
@@ -295,6 +299,33 @@ export function promoteHq(host: string, apply = false, runner: PromoteRunner = d
   }
 }
 
+/** One OP seat request (never a CEO decision card · 대표 10-05 10:03); idempotent by key. */
+export type HqOpRequest = { key: string; text: string; [field: string]: unknown };
+export type HqOpRequestWriter = (request: HqOpRequest) => { key: string; created: boolean };
+
+export function writeOpSeatRequest(request: HqOpRequest, root = effectiveInstanceRoot()): { key: string; created: boolean } {
+  const path = join(root, 'seat-requests', 'requests.jsonl');
+  return withSeatRequestLedgerLock(path, () => {
+    if (listSeatRequests(root).some((row) => row.key === request.key)) return { key: request.key, created: false };
+    appendSeatRequestRows(path, [{ ...request, seat: 'OP', status: 'pending' as const, queuedAt: new Date().toISOString(), source: 'hq-arbiter' }]);
+    return { key: request.key, created: true };
+  });
+}
+
+/** Propose promotion to the OP seat for a silent lease generation; the runbook runs only under explicit opt-in (see hqArbiterCheck). */
+export function proposeHqPromotion(
+  input: { holder: string; standby: string; generation: number; streak: number },
+  deps: { request?: HqOpRequestWriter; log?: typeof debug.log } = {},
+): { promoted: false; requestKey: string; created: boolean } {
+  const key = `hq:promote:${input.holder}:${input.generation}`;
+  const written = (deps.request ?? writeOpSeatRequest)({ key,
+    text: `본부 ${input.holder}(임대 세대 ${input.generation}) 연속 무응답 ${input.streak}회 — ${input.standby} 승격을 OP 가 판단한다(자동 승격 꺼짐). 승격하면 \`eln hq promote --to ${input.standby} --apply\`.`,
+    holder: input.holder, standby: input.standby, generation: input.generation, streak: input.streak });
+  try { (deps.log ?? debug.log.bind(debug))('hq.arbiter', 'promote-proposed', { ...input, ref: key, mode: 'op-request', created: written.created }); }
+  catch { /* observation cannot change the proposal */ }
+  return { promoted: false, requestKey: key, created: written.created };
+}
+
 export function formatPromote(result: PromoteResult): string {
   return [`hq promote --to ${result.host} ${result.apply ? '--apply' : '(dry-run)'}`,
     ...result.lines.map(line => `${line.step}: ${line.status} · ${line.measurement}${line.status === 'ready' ? ` · ${line.command}` : ''}`)].join('\n');

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';
@@ -80,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';
@@ -856,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);
@@ -937,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...>', '-- 뒤의 명령')
@@ -947,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 {
@@ -962,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')
@@ -3457,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 분포를 읽기 전용으로 출력한다')
@@ -4379,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 () => {
@@ -4613,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');
@@ -4651,17 +4700,31 @@ const selfOrchestrateCmd = selfCmd
               if (!opts.json) ui.warn(podGrokSkippedLine(grokCheck));
             }
           }
-          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) && grokSubscriptionUsable,
-            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 });
@@ -4670,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 });
@@ -4697,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);

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