elanous 0.2.38 → 0.2.40

package/src/grok/agent-search.ts

@@ -55,6 +55,9 @@ export interface GrokAgentSearchOpts {
   signal?: AbortSignal;
   fetchImpl?: FetchLike;
   apiKey?: string;
+  /** Subscription proxy endpoint and required CLI headers. Omit for the metered xAI API. */
+  baseUrl?: string;
+  headers?: Record<string, string>;
 }
 
 export interface GrokCitation {
@@ -106,10 +109,13 @@ export async function grokAgentSearch(
 
   let res: Response;
   try {
-    res = await fetchImpl(GROK_RESPONSES_URL, {
+    const endpoint = opts.baseUrl
+      ? `${opts.baseUrl.replace(/\/$/, '').replace(/\/responses$/, '')}/responses`
+      : GROK_RESPONSES_URL;
+    res = await fetchImpl(endpoint, {
       method: 'POST',
       signal: ac.signal,
-      headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` },
+      headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}`, ...opts.headers },
       body: JSON.stringify({
         model,
         input,

package/src/grok/credential.ts

@@ -345,6 +345,11 @@ function readGrokCredential(opts: {
   return null;
 }
 
+/** Read-only credential check for synchronous provider availability. Never refreshes or calls the network. */
+export function peekGrokCredential(opts: { home?: string; model?: string } = {}): GrokCredential | null {
+  return readGrokCredential(opts);
+}
+
 export interface ResolveGrokCredentialOpts {
   env?: NodeJS.ProcessEnv;
   home?: string;

package/src/grounding/ref-index.ts

@@ -50,6 +50,8 @@ export interface ReferenceCard {
   kind: GroundingSource['kind'];
   name: string;
   oneLine: string;
+  /** Relative path that supplied oneLine, when a README was readable. */
+  oneLineFile?: string;
   directories: string[];
   receivedAt?: string;
   /** L1 */
@@ -57,6 +59,13 @@ export interface ReferenceCard {
   commands: string[];
   /** A file-count or byte limit cut the read short — the lists may be incomplete. */
   truncated: boolean;
+  /** Stable identity of this card inside the grounding orchestration log. */
+  orchestrationId: string;
+}
+
+/** Stable identity of this card inside the grounding orchestration log. */
+export function orchestrationId(kind: string, id: string): string {
+  return `grounding:${kind}:${id}`;
 }
 
 export function buildReferenceCard(
@@ -132,11 +141,13 @@ export function buildReferenceCard(
     kind: source.kind,
     name: packageName ?? basename(root),
     oneLine,
+    ...(oneLine && readme ? { oneLineFile: readme.name } : {}),
     directories,
     ...(receivedAt ? { receivedAt } : {}),
     titles,
     commands,
     truncated,
+    orchestrationId: orchestrationId(source.kind, source.id),
   };
 }
 

package/src/grounding/ref-vector.ts

@@ -0,0 +1,61 @@
+import type { Database } from 'bun:sqlite';
+import { chunkReport, hybridQueryKnowledge, ingestText, type EmbedFn, type HybridMatch } from '../domains/knowledge.js';
+import type { ReferenceCard } from './ref-index.js';
+
+export interface ReferenceIngestOptions {
+  embed: EmbedFn;
+  maxChunks?: number;
+}
+
+export interface ReferenceQueryOptions {
+  embed: EmbedFn;
+  k?: number;
+}
+
+/** Keep the source ID and a real relative file path together in each returned citation. */
+function sourceRef(id: string, file: string): string | null {
+  if (!id || !file || file.startsWith('/') || /^[a-zA-Z]:/.test(file) || file.split(/[\\/]/).some((part) => part === '..' || part === '.')) return null;
+  return `${id}#${file}`;
+}
+
+/** Index only card text whose original file is known; an invented README path must never become a citation. */
+export async function ingestReferenceCard(
+  db: Database,
+  card: ReferenceCard,
+  opts: ReferenceIngestOptions,
+): Promise<{ ingested: number; truncated: boolean }> {
+  const maxChunks = opts.maxChunks ?? 200;
+  if (!Number.isSafeInteger(maxChunks) || maxChunks < 0) throw new Error('reference maxChunks must be a nonnegative integer');
+  const entries: Array<{ file: string; text: string }> = [];
+  if (card.oneLine && card.oneLineFile) entries.push({ file: card.oneLineFile, text: card.oneLine });
+  for (const title of card.titles) entries.push({ file: title.file, text: title.title });
+  for (const command of card.commands) entries.push({ file: 'package.json', text: command });
+  const chunks = entries.flatMap(({ file, text }) => {
+    const ref = sourceRef(card.id, file);
+    return ref ? chunkReport(text).map((chunk) => ({ ref, text: chunk })) : [];
+  });
+  let ingested = 0;
+  const ts = card.receivedAt ?? new Date(0).toISOString();
+  for (const [index, chunk] of chunks.slice(0, maxChunks).entries()) {
+    if (await ingestText(db, {
+      id: `reference:${card.id}:${index}`,
+      ts,
+      kind: 'reference',
+      domain: 'elanous',
+      text: chunk.text,
+      source_ref: chunk.ref,
+    }, opts.embed)) ingested++;
+  }
+  return { ingested, truncated: card.truncated || chunks.length > maxChunks };
+}
+
+/** Reuse the knowledge hybrid ranker, but never return a result without a source link. */
+export async function queryReferences(
+  db: Database,
+  query: string,
+  opts: ReferenceQueryOptions,
+): Promise<HybridMatch[]> {
+  const k = Math.min(Math.max(opts.k ?? 5, 1), 20);
+  const matches = await hybridQueryKnowledge(db, query, { kind: 'reference', domain: 'elanous', k: 20, embed: opts.embed });
+  return matches.filter((match) => !!match.source_ref).slice(0, k);
+}

package/src/grounding/sources-cli.ts

@@ -118,7 +118,7 @@ export function registerGroundingSourcesCli(program: Command): void {
     .command('status [id]')
     .description('local-repo 신선도(로컬 참조만 · fetch/pull 없음)')
     .option('--json', 'JSON 출력')
-    .action((id: string | undefined, opts: { json?: boolean }) => {
+    .action(async (id: string | undefined, opts: { json?: boolean }) => {
       const listed = listGroundingSources(load());
       const targets = id ? listed.filter((source) => source.id === id) : listed;
       if (id && targets.length === 0) {
@@ -126,7 +126,7 @@ export function registerGroundingSourcesCli(program: Command): void {
         process.exitCode = 1;
         return;
       }
-      const rows = targets.map((source) => sourceStatus(source));
+      const rows = await Promise.all(targets.map((source) => sourceStatus(source)));
       if (opts.json) printJson(id ? rows[0] : rows);
       else for (const row of rows) {
         console.log(`${row.id} dirty=${String(row.dirty ?? false)} behind=${String(row.behind ?? 'unknown')}${row.branch ? ` branch=${row.branch}` : ''}`);

package/src/grounding/sources.ts

@@ -186,7 +186,21 @@ export function discoverReferenceSources(home: string): GroundingSource[] {
   return [...repos, ...docs];
 }
 
-export function sourceStatus(source: GroundingSource): GroundingSourceStatus {
+export async function sourceStatus(source: GroundingSource): Promise<GroundingSourceStatus> {
+  if ((source.kind === 'local-repo' || source.kind === 'local-docs') && source.path) {
+    // Wiring: the reference card is built from the existing status path (local git refs only).
+    try {
+      const { buildReferenceCard, nodeRefIndexFs } = await import('./ref-index.js');
+      const card = buildReferenceCard(source, nodeRefIndexFs);
+      debug.log('grounding.sources', 'card', {
+        id: source.id,
+        name: card.name,
+        orchestrationId: card.orchestrationId,
+      });
+    } catch (error) {
+      debug.log('grounding.sources', 'card-skip', { id: source.id, error: String(error) });
+    }
+  }
   if (source.kind !== 'local-repo' || !source.path) {
     const status: GroundingSourceStatus = { id: source.id, kind: source.kind, measured: false };
     debug.log('grounding.sources', 'status', { id: source.id, behind: 'unknown', dirty: false });

package/src/harness/harness-cli-command.ts

@@ -21,7 +21,7 @@ import { runGitCommand } from '../git-fs/runner.js';
 import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, resolveGoalAuthorGrade, tracedPathReferences, type GoalAuthorGrade, type GoalAuthorGradeSelection, type GoalType } from '../self-implement/goal-author.js';
 import { templateForGoalType } from '../self-implement/graph-templates.js';
 import { appendRunLedgerEntry, listRunLedgers, loadFederatedRunLedger, loadRunLedger, queryRunScreenKey, runLedgerDir, type RunLedgerEntry, type RunLedgerMatch, type RunLedgerWriter } from '../self-implement/run-ledger.js';
-import { classifyPodExit, parsePodTermination, type PodExitClass, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
+import { classifyPodExit, parsePodTermination, podFailureLedgerAxes, type PodExitClass, type PodFailureLedgerAxes, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
 import { classifyPodExitStop, readRunStopRecord, recordRunStop, runStopRecorded, RUN_STOP_EVENT } from '../self-implement/run-stop.js';
 import { captureStopKnowhowCandidate } from '../self-implement/stop-autoheal.js';
@@ -40,7 +40,7 @@ import { debug } from '../debug/log.js';
 import { installHarnessSalvageCommand, installHarnessSalvageRetentionCommand } from './harness-salvage-cli.js';
 import { decideNestedElanousLaunch, readNestedElanousDepth } from './nested-elanous-policy.js';
 import { dispatchTask, type DispatchTaskInput, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
-import { harnessLaunchBudgetDecision, launchRequestId, preLaunchGate, resolveLaunchBudget, type PreLaunchGateDeps } from '../execution-loop/launch-gate.js';
+import { LAUNCH_DOOR_RECEIPT_ENV, harnessLaunchBudgetDecision, launchRequestId, openLaunchRequestDoor, preLaunchGate, resolveLaunchBudget, type PreLaunchGateDeps } from '../execution-loop/launch-gate.js';
 import { PR_LABELS } from '../github/pr-labels.js';
 import { ghAutomationEnv } from '../autopilot/pr-manager.js';
 import { decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
@@ -842,7 +842,7 @@ export function recordHarnessPodStop(
         runId, site: 'pod-exit', class: scopeEscape ? 'scope-escape' : classifyPodExitStop(classified.reason),
         cause: `Pod exit ${status}: ${detail.podExitClass}${detail.lead ? ` — ${detail.lead}` : ''}`,
         evidenceRef, nextMove, ...(childEvidence ? { childEvidence } : {}),
-      }, (entry) => write({ ...entry, data: { ...entry.data, podExitClass: detail.podExitClass, tail: detail.tail } }));
+      }, (entry) => write({ ...entry, data: { ...entry.data, podExitClass: detail.podExitClass, tail: detail.tail, ...detail.axes } }));
       return true;
     }
     // The classified line is our own one-line verdict («Pod 안 자식이 실패했다 — OOMKilled»), not the raw output tail.
@@ -885,20 +885,24 @@ const POD_EXIT_CAUSE_LEAD_CHARS = 160;
  * The closed Pod exit class ⊕ the last meaningful output lines for an exit the host could not classify.
  * Empty output is no evidence at all — `unknown` with an empty tail, never a guess. Fail-soft: a throw reads as `unknown`.
  */
-function podExitDetail(runId: string, status: number, output: string | undefined): { podExitClass: PodExitClass; tail: string[]; lead: string } {
+function podExitDetail(runId: string, status: number, output: string | undefined): { podExitClass: PodExitClass; tail: string[]; lead: string; axes: PodFailureLedgerAxes } {
   let podExitClass: PodExitClass = 'unknown';
   let tail: string[] = [];
+  // The rejection's reason code · check name · untruncated path, and the absence of a child result line, are
+  //   kept as their own ledger fields — the human `cause` line is bounded and cannot carry them.
+  let axes: PodFailureLedgerAxes = {};
   if (output?.trim()) {
     try {
       const exit = classifyPodExit({ logs: output, containerExitCode: status });
       podExitClass = exit.class;
       tail = exit.tail.slice(-POD_EXIT_TAIL_LINES).map((line) => Array.from(line).slice(0, POD_EXIT_TAIL_LINE_CHARS).join(''));
-    } catch { podExitClass = 'unknown'; tail = []; }
+      axes = podFailureLedgerAxes(exit);
+    } catch { podExitClass = 'unknown'; tail = []; axes = {}; }
   }
   // The last meaningful line is where the child died (`Error: ENOSPC …`) — earlier tail lines are context.
   const lead = Array.from(tail.at(-1) ?? '').slice(0, POD_EXIT_CAUSE_LEAD_CHARS).join('');
-  try { debug.log('harness.pod', 'exit-classified-detail', { runId, podExitClass, tailLines: tail.length }); } catch { /* observation is fail-soft */ }
-  return { podExitClass, tail, lead };
+  try { debug.log('harness.pod', 'exit-classified-detail', { runId, podExitClass, tailLines: tail.length, ...axes }); } catch { /* observation is fail-soft */ }
+  return { podExitClass, tail, lead, axes };
 }
 
 /**
@@ -1179,13 +1183,30 @@ async function dispatchHarnessAskSay(
       return;
     }
     enterJourneyNode('launch-gate', journey);
+    // LAUNCH-SINGLE-DOOR-1C — 부모(hand)가 소비한 영수증 상속: 이 요청이면 그 영수증으로 지나간다(한 번만 읽고 지운다).
+    const inheritedLaunchDoorReceipt = process.env[LAUNCH_DOOR_RECEIPT_ENV];
+    delete process.env[LAUNCH_DOOR_RECEIPT_ENV];
+    // 주입된 문이 없으면 생산 우주의 기본 문을 쓴다(시험 환경은 관문 관례와 같이 건너뛴다 — 시험 단언이 단일문 때문에 바뀌지 않는다).
+    const launchDoor = gate.launchDoor ?? (process.env.NODE_ENV === 'test' ? undefined : openLaunchRequestDoor({ source: dryRunPreview.entrance }));
+    const launchDoorRequestId = launchDoor?.requestId(identity);
     const decision = await withJourneyNode('launch-gate', journey, async () => {
       const { budget, budgetSource, snapshotAgeSec } = await resolveLaunchBudget({
         provider: opts.childLlmProvider,
         measureLocal: gate.readBudget ?? (() => readHarnessLaunchBudget(opts)),
         env: gate.readBudget ? { ELANOUS_SUBSTRATE: 'local' } : process.env,   // an injected budget reader is a host measurement, whatever substrate runs the test
       });
-      return preLaunchGate({ goalId, budget, budgetSource, ...(snapshotAgeSec !== undefined ? { snapshotAgeSec } : {}), forceLaunch: opts.forceGate === true }, gate);
+      const gateDecision = preLaunchGate({ goalId, budget, budgetSource, ...(snapshotAgeSec !== undefined ? { snapshotAgeSec } : {}), forceLaunch: opts.forceGate === true }, gate);
+      // LAUNCH-SINGLE-DOOR-1C — 관문을 통과한 요청만 단일문을 두드린다: 소비 영수증은 requestId 기준 최초 1회만
+      // 발급되고, 이미 소비됐으면 중복 발사로 거절한다(force 와 부모 상속 영수증은 그대로 지나간다).
+      if (gateDecision.action !== 'proceed' || launchDoor === undefined || launchDoorRequestId === undefined) return gateDecision;
+      const doorConsumption = launchDoor.consume(launchDoorRequestId, {
+        force: opts.forceGate === true,
+        ...(inheritedLaunchDoorReceipt !== undefined ? { inheritedReceipt: inheritedLaunchDoorReceipt } : {}),
+      });
+      if (doorConsumption.status === 'refused') {
+        return { ...gateDecision, action: 'blocked-duplicate' as const, reason: doorConsumption.reason };
+      }
+      return gateDecision;
     });
     exitJourneyNode('launch-gate', { ...journey, outcome: decision.action === 'proceed' ? 'pass' : 'refuse', data: { action: decision.action } });
     if (decision.action !== 'proceed') {
@@ -1198,7 +1219,15 @@ async function dispatchHarnessAskSay(
       ...(decision.budget === 'unknown' ? ['budget unknown'] : decision.budget.action === 'next-provider' ? [decision.budget.reasons.join(' · ') || 'next-provider'] : []),
     ];
     if (warnings.length > 0) console.error(`⚠️ launch gate: ${warnings.join(' · ').split(/\r?\n/, 1)[0]}`);
-    await launch();
+    try {
+      await launch();
+    } catch (error) {
+      // LAUNCH-SINGLE-DOOR-1C — 발사 실패 사유를 원장에 append 한다(관측 — 소비된 영수증은 그대로다).
+      if (launchDoor !== undefined && launchDoorRequestId !== undefined) {
+        launchDoor.fail(launchDoorRequestId, error instanceof Error ? error.message : String(error));
+      }
+      throw error;
+    }
   }); } finally { if (!journeyPreset) delete process.env[JOURNEY_KEY_ENV]; }
 }
 

package/src/harness/harness-pod-dispatch.ts

@@ -27,6 +27,7 @@ import { podMemoryLimitFor, type PodMemoryTier } from '../task-orchestrator/surf
 import { oldDoorInternalEnv } from '../self-dev/old-door.js';
 import { selectPodMemoryTier } from './pod-memory-policy.js';
 import { preflightGoalDoneBoundary } from '../self-dev/dev-pipeline.js';
+import { forwardChildStderr } from '../surface/child-process.js';
 
 export interface HarnessPodDispatchInput {
   readonly entrance: 'cli-harness-ask' | 'cli-harness-say';
@@ -294,9 +295,14 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
     goalChars, ...(input.entrance === 'cli-harness-ask' ? { goalPath: input.input } : {}),
   });
   const run = deps.run ?? ((cmd: string, a: readonly string[], childEnv: NodeJS.ProcessEnv) => new Promise<number>((resolveStatus) => {
-    const child = (deps.spawnChild ?? spawn)(cmd, [...a], { stdio: deps.onOutput ? ['inherit', 'pipe', 'inherit'] : 'inherit', env: childEnv });
+    const ownsOutput = Boolean(deps.onOutput);
+    const child = (deps.spawnChild ?? spawn)(cmd, [...a], {
+      stdio: ownsOutput ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+      env: childEnv,
+    });
     child.stdout?.setEncoding('utf8');
     child.stdout?.on('data', (chunk: string) => { process.stdout.write(chunk); deps.onOutput?.(chunk); });
+    if (ownsOutput) forwardChildStderr(child.stderr);
     let forwarded: NodeJS.Signals | undefined;
     const forward = (signal: NodeJS.Signals) => {
       forwarded = signal;

package/src/index.ts

@@ -4739,6 +4739,7 @@ selfCmd
   .option('--shard-concurrency <number>', '동시에 실행할 조각 묶음 수 (1–4, 기본 3)')
   .option('--fixed-shard-distribution', '--shards N 과 함께만: RSS 사전 측정 없이 정렬된 파일을 N 조각에 라운드로빈 고정 배정한다(opt-in · 메모리 보증 아님 · 조각 타임아웃/OOM = unmeasured)')
   .option('--include-importers', '변경 모듈을 가져오는 importer 시험도 실행한다 (기본 caller 한도 밖까지)')
+  .option('--no-inherit', '이전 게이트 시험 영수증의 통과 시험을 상속하지 않고 전체 범위를 실행한다')
   .option('--remote [host]', 'GATE-REMOTE — 같은 커밋을 원격 호스트(기본 config gateRemote.host=node-b)에서 돌리고 결과만 가져온다(깨끗한 트리 · --pr 은 로컬)')
   .option('--local', '원격 실행을 끄고 명시적으로 로컬에서 돌린다')
   .option('--artifact-dir <dir>', '조각별 지금/기준 JUnit ⊕ summary.json 을 이 디렉토리에 남긴다(판정 불변 · JUnit 은 --shards 경로만 · 원격 실행이면 그 호스트에서 가져온다)')
@@ -4746,7 +4747,7 @@ selfCmd
   .option('--shard-id <id>', 'GATE-REMOTE-SHARD-PLAN — 조각 id(예: <orchestration-id>/shard-2). 원격 명령줄에 그대로 실린다')
   .option('--shard-position <n>', 'GATE-REMOTE-SHARD-PLAN — 조각 위치(1부터 정수). 원격 명령줄에 그대로 실린다')
   .option('--shard-plan <path>', 'GATE-REMOTE-SHARD-PLAN — 조각 계획 파일 경로. 주면 원격 명령줄에 --shard-plan 으로 실린다')
-  .action(async (opts: { changed?: boolean; base?: string; pr?: string; shards?: string | boolean; shardConcurrency?: string; fixedShardDistribution?: boolean; includeImporters?: boolean; remote?: string | boolean; local?: boolean; artifactDir?: string; orchestrationId?: string; shardId?: string; shardPosition?: string; shardPlan?: string }) => {
+  .action(async (opts: { changed?: boolean; base?: string; pr?: string; shards?: string | boolean; shardConcurrency?: string; fixedShardDistribution?: boolean; includeImporters?: boolean; inherit?: boolean; remote?: string | boolean; local?: boolean; artifactDir?: string; orchestrationId?: string; shardId?: string; shardPosition?: string; shardPlan?: string }) => {
     if (!opts.changed && opts.shards === undefined) { ui.error('self gate requires --changed or --shards'); process.exitCode = 2; return; }
     if (opts.fixedShardDistribution && opts.shards === undefined) { ui.error('self gate: --fixed-shard-distribution requires --shards <n>'); process.exitCode = 2; return; }
     if (opts.shardConcurrency !== undefined && (!/^[1-4]$/.test(opts.shardConcurrency))) { ui.error('self gate: --shard-concurrency must be 1–4'); process.exitCode = 2; return; }
@@ -4769,7 +4770,7 @@ selfCmd
       ranLocal = true;
       try {
         const { runSelfGateCliAsync } = require('./self-implement/gate-cli.js') as typeof import('./self-implement/gate-cli.js');
-        const result = await runSelfGateCliAsync(process.cwd(), { base: opts.base, pr: opts.pr, shards, ...(opts.shardConcurrency !== undefined ? { shardConcurrency: Number(opts.shardConcurrency) } : {}), ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), includeImporterTests: !!opts.includeImporters, ...(opts.artifactDir !== undefined ? { artifactDir: opts.artifactDir } : {}) });
+        const result = await runSelfGateCliAsync(process.cwd(), { base: opts.base, pr: opts.pr, shards, ...(opts.shardConcurrency !== undefined ? { shardConcurrency: Number(opts.shardConcurrency) } : {}), ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), includeImporterTests: !!opts.includeImporters, noInherit: opts.inherit === false, ...(opts.artifactDir !== undefined ? { artifactDir: opts.artifactDir } : {}) });
         console.log(result.lines.join('\n'));
         return result.exitCode;
       } catch (error) {
@@ -4802,6 +4803,7 @@ selfCmd
         const argv = remoteSelfGateArgv({
           changed: opts.changed, base: opts.base, shards, shardConcurrency: opts.shardConcurrency === undefined ? undefined : Number(opts.shardConcurrency), fixedShardDistribution: opts.fixedShardDistribution,
           includeImporters: opts.includeImporters,
+          noInherit: opts.inherit === false,
           // A measured commit without this option rejects it (exit ≠ 0) — read as not passed, never as a silent measured run.
           artifactDir: remoteArtifacts && 'dir' in remoteArtifacts ? remoteArtifacts.dir : undefined,
         }, sha);
@@ -6277,10 +6279,12 @@ selfCmd
   .option('--acp-timeout <sec>', 'ACP 리뷰 1턴 최대 대기 초(초과 시 cancel·기본 claude 600 · 그 외 300)')
   .option('--context <path>', '리뷰어가 함께 판단할 레포 상대 파일 경로(반복 가능)', (value: string, previous: string[] = []) => [...previous, value])
   .option('--context-text <text>', '리뷰어가 함께 판단할 텍스트(반복 가능)', (value: string, previous: string[] = []) => [...previous, value])
+  .option('--no-context-pack', '기본 저장소 리뷰 맥락 팩을 끈다')
   .option('--json', '구조화 출력 {pr, verdict, mustFix, shouldFix, reviewed}')
   .option('--save <name>', '리뷰 결과를 상태 디렉터리의 review-results/<name>-<PR>-<head12>.json에 저장')
+  .option('--since-review <saved review name|head>', '저장된 리뷰의 mustFix와 해당 head 이후 변경만 다시 판정')
   .option('--over-cap-reason <reason>', '저장 리뷰 r5 상한 이후 이번 호출 1회 예외 사유(doctor.review cap-override 기록)')
-  .action(async (prParts: string[], opts: { intent?: string; model?: string; acp?: boolean; acpModel?: string; acpBackend?: string; acpTimeout?: string; context?: string[]; contextText?: string[]; json?: boolean; save?: string; overCapReason?: string }) => {
+  .action(async (prParts: string[], opts: { intent?: string; model?: string; acp?: boolean; acpModel?: string; acpBackend?: string; acpTimeout?: string; context?: string[]; contextText?: string[]; contextPack?: boolean; json?: boolean; save?: string; sinceReview?: string; overCapReason?: string }) => {
     const prArgs = prParts.flatMap((p) => String(p).split(/[,\s]+/).filter(Boolean)); // 번호/#번호/URL·콤마목록.
     if (!prArgs.length) { ui.error('PR 필요: elanous self review <번호|URL> [..]'); process.exit(2); }
     // ⭐ 본문은 seam(`runSelfReviewCliCommand`)에 있다 — 이 액션은 **의존 배선만** 한다.
@@ -6308,6 +6312,7 @@ selfCmd
     const configuredReviewModel = apiReviewModelFromRoleSpec(reviewRoleSpec);
     const { results, failed } = await runSelfReviewCliCommand(prArgs, {
       ...opts,
+      noContextPack: opts.contextPack === false,
       ...(configuredReviewModel ? { configuredReviewModel } : {}),
       ...(configuredReviewModel && reviewRoleSpec?.provider ? { configuredReviewProvider: reviewRoleSpec.provider } : {}),
       ...(configuredAcpBackend ? { configuredAcpBackend } : {}),
@@ -7058,7 +7063,16 @@ agentCmd
     //   runAgentMissionCliCommand(테스트 가능 seam)로 추출. 액션은 I/O(print/exit)만 담당.
     const { resolveBackend } = await import('./agent-mission/driver.js');
     const { runAgentMissionCliCommand } = await import('./agent-mission/mission-cli.js');
-    const outcome = await runAgentMissionCliCommand(textParts, opts as import('./agent-mission/mission-cli.js').MissionCliOpts, { resolveBackend });
+    const controller = new AbortController();
+    const onSigint = (): void => { controller.abort(); };
+    process.once('SIGINT', onSigint);
+    let outcome: Awaited<ReturnType<typeof runAgentMissionCliCommand>>;
+    try {
+      outcome = await runAgentMissionCliCommand(textParts, opts as import('./agent-mission/mission-cli.js').MissionCliOpts,
+        { resolveBackend, signal: controller.signal });
+    } finally {
+      process.removeListener('SIGINT', onSigint);
+    }
     if (!outcome.ok) { console.error(`❌ ${outcome.message}`); process.exit(outcome.exitCode); }
     await writeStdoutJson(JSON.stringify(outcome.result, null, 2) + '\n');
     process.exit(outcome.exitCode);

package/src/input/external-input-queue.ts

@@ -43,6 +43,8 @@ export interface ExternalInputHost {
   submit(text: string, source: InputSourceRef): boolean;
   /** 지금 턴을 ESC 와 같은 경로로 멈춘다. 멈출 턴(escGate)이 없으면 false. 없으면 외부 stop 은 «턴 없음»으로 처리. */
   requestStop?(): boolean;
+  /** Consume submitted external text as the answer to a live non-modal TUI question. */
+  handleInlineChoice?(text: string): boolean;
   /** 외부 stop 의 결과 표지(채팅 로그 한 줄). */
   onExternalStop?(result: 'stopped' | 'no-turn' | 'failed'): void;
   /** 대기열의 현재 상태가 바뀌었다 — 화면 표지를 다시 그린다. */
@@ -214,6 +216,14 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
         try { turnActive = host.isTurnActive(); composer = host.composerText(); pendingKeys = host.hasPendingKeys(); }
         catch { return 'passthrough'; }
       }
+      if (line?.submit && host?.handleInlineChoice) {
+        let consumed = false;
+        try { consumed = host.handleInlineChoice(line.text); } catch { consumed = false; }
+        if (consumed) {
+          log('route', { length: chars.length, submit: true, turnActive, route: 'inline-choice', pending: pending.length });
+          return 'submitted';
+        }
+      }
       const { decision, reason } = decideExternalInputRoute({
         line, hostRegistered: host !== null, pendingCount: pending.length, turnActive, composerText: composer, pendingKeys,
       });

package/src/intake-plane/collect-telegram-saved.ts

@@ -22,6 +22,19 @@ export function savedMessageToRaws(m: SavedMessage): RawIntakeItem[] {
 }
 
 function cursorFile(root: string): string { return join(intakeLedgerDir(root), 'telegram-saved.cursor.json'); }
+function recoveryFile(root: string): string { return join(intakeLedgerDir(root), 'telegram-saved.recovery.json'); }
+
+function readRecoveryCursor(root: string): number | undefined {
+  try {
+    const cursor = Number(JSON.parse(readFileSync(recoveryFile(root), 'utf8')).lastId);
+    return Number.isSafeInteger(cursor) ? cursor : undefined;
+  } catch { return undefined; }
+}
+
+function writeRecoveryCursor(root: string, lastId: number): void {
+  mkdirSync(intakeLedgerDir(root), { recursive: true });
+  writeFileSync(recoveryFile(root), JSON.stringify({ lastId }) + '\n');
+}
 
 export function readSavedCursor(root: string): number {
   try { return Number(JSON.parse(readFileSync(cursorFile(root), 'utf8')).lastId) || 0; } catch { return 0; }
@@ -89,7 +102,27 @@ export function renderCollectTelegramSavedResult(res: CollectSavedResult): strin
  */
 export async function collectTelegramSaved(root: string, fetch: FetchSavedMessages, opts: { max: number; dryRun?: boolean }): Promise<CollectSavedResult> {
   const cursorBefore = readSavedCursor(root);
-  const messages = await fetch(cursorBefore, opts.max);
+  const fetched = await fetch(cursorBefore, opts.max);
+  let messages = fetched.filter((message) => Number.isSafeInteger(message.id) && message.id > cursorBefore);
+  // A cursor may have advanced without this consumer seeing the bounded interval. Scan that span
+  // once for each cursor value, even when the forward read has newer messages. Telegram's minId is
+  // exclusive, so include the cursor ID because another consumer may have consumed it.
+  if (cursorBefore > 0 && readRecoveryCursor(root) !== cursorBefore) {
+    const recoveryLimit = Math.max(1, opts.max);
+    let recoveryFrom = Math.max(0, cursorBefore - recoveryLimit - 1);
+    const recovered: SavedMessage[] = [];
+    while (recoveryFrom < cursorBefore) {
+      const recovery = await fetch(recoveryFrom, recoveryLimit);
+      const page = recovery.filter((message) => Number.isSafeInteger(message.id)
+        && message.id > recoveryFrom && message.id <= cursorBefore);
+      recovered.push(...page);
+      if (page.length < recoveryLimit) break;
+      const nextFrom = page.reduce((last, message) => Math.max(last, message.id), recoveryFrom);
+      if (nextFrom <= recoveryFrom) break;
+      recoveryFrom = nextFrom;
+    }
+    messages = [...recovered, ...messages];
+  }
   const rowsPerMessage = messages.map(savedMessageToRaws);
   const raws = rowsPerMessage.flat();
   const droppedByFilter = rowsPerMessage.filter((rows) => rows.length === 0).length;
@@ -98,6 +131,8 @@ export async function collectTelegramSaved(root: string, fetch: FetchSavedMessag
   if (!opts.dryRun) {
     result.ingest = ingestIntakeItems(root, 'telegram-saved', raws);
     if (cursorAfter > cursorBefore) writeSavedCursor(root, cursorAfter);
+    // The marker commits the scan only after ingestion succeeds; keep it monotonic at the saved cursor boundary.
+    writeRecoveryCursor(root, Math.max(cursorAfter, cursorBefore));
   }
   // ⛔ 본문·링크는 싣지 않는다 — 커서와 건수만. 두 축(메시지·원장 입력)을 따로 남겨 사흘 0 을 갈라 읽게.
   debug.log('intake.collect', 'telegram-saved', {