elanous 0.2.37 → 0.2.40

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/hq/fence-wrapper.ts

@@ -17,7 +17,7 @@ export function renderHqFenceWrapper({ entry, configDir, bun, logFile }: { entry
   if (!isAbsolute(bun)) throw new Error(`hq-fence: bun must be an absolute path: ${bun}`);
   const log = logFile ?? join(configDir, 'logs', 'hq-fence.log');
   return `#!/bin/sh
-# Arbiter (cloud-vm) outage: retain the lease, do not promote; hq fence owns that decision.
+# Arbiter outage: retain the lease, do not promote; hq fence owns that decision.
 ENTRY=${quote(entry)}
 CONFIG_DIR=${quote(configDir)}
 # cron has no PATH for bun — the absolute path was resolved when this wrapper was installed.

package/src/hq/transfer.ts

@@ -17,7 +17,7 @@ export interface TransferDeps {
   journalDir: string;
 }
 
-const aliases: Record<string, string[]> = { mbp: ['mbp', 'MacBookProM5'], node-b: ['node-b', 'MacStudioB1'] };
+const aliases: Record<string, string[]> = { mbp: ['mbp', 'MacBookProM5'], 'node-b': ['node-b', 'MacStudioB1'] };
 const valid = (alias: string, holder: string) => aliases[alias]?.includes(holder) ?? false;
 const leaseCommand = (action: 'release' | 'acquire', expected?: { holder: string; generation: number }) =>
   `elanous hq lease ${action}${expected ? ` --expected-holder '${expected.holder}' --expected-generation ${expected.generation}` : ''} --json`;

package/src/index.ts

@@ -4736,8 +4736,10 @@ selfCmd
   .option('--base <ref>', '커밋됐지만 PR 없는 변경의 비교 기준(ref...HEAD)')
   .option('--pr <number>', '열린 PR 번호에서 gh pr view files로 변경 파일을 읽는다')
   .option('--shards [number]', '메모리 예산에 맞춰 시험을 별도 프로세스로 분할한다 (기본 2)')
+  .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 경로만 · 원격 실행이면 그 호스트에서 가져온다)')
@@ -4745,9 +4747,10 @@ 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; 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; }
     if (opts.artifactDir !== undefined && !opts.artifactDir.trim()) { ui.error('self gate: --artifact-dir needs a non-empty directory'); process.exitCode = 2; return; }
     const shardIdentityFlags = [opts.orchestrationId, opts.shardId, opts.shardPosition].filter((value) => value !== undefined).length;
     if (shardIdentityFlags !== 0 && shardIdentityFlags !== 3) { ui.error('self gate: --orchestration-id, --shard-id and --shard-position are used as a set'); process.exitCode = 2; return; }
@@ -4763,11 +4766,11 @@ selfCmd
     const shards = opts.shards === undefined ? undefined : opts.shards === true ? 2 : Number(opts.shards);
     let ranLocal = false;
     let remoteArtifacts: { dir: string; fetch?: { ok: true; summaryPath: string; junitFiles: string[]; remoteDirKept: boolean } | { ok: false; reason: string } } | { unsupported: true } | undefined;
-    const runLocal = () => {
+    const runLocal = async () => {
       ranLocal = true;
       try {
-        const { runSelfGateCli } = require('./self-implement/gate-cli.js') as typeof import('./self-implement/gate-cli.js');
-        const result = runSelfGateCli(process.cwd(), { base: opts.base, pr: opts.pr, shards, ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), includeImporterTests: !!opts.includeImporters, ...(opts.artifactDir !== undefined ? { artifactDir: opts.artifactDir } : {}) });
+        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, noInherit: opts.inherit === false, ...(opts.artifactDir !== undefined ? { artifactDir: opts.artifactDir } : {}) });
         console.log(result.lines.join('\n'));
         return result.exitCode;
       } catch (error) {
@@ -4798,8 +4801,9 @@ selfCmd
       // origin/main is pinned to this machine's origin/main on the host; any other base is passed as its resolved sha.
       const remoteArgv = (sha: (ref: string) => string) => {
         const argv = remoteSelfGateArgv({
-          changed: opts.changed, base: opts.base, shards, fixedShardDistribution: opts.fixedShardDistribution,
+          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);
@@ -4837,7 +4841,7 @@ selfCmd
       const reason = error instanceof Error ? error.message : String(error);
       if (opts.local) {
         ui.error(`self gate dispatch failed: ${reason}`);
-        process.exitCode = runLocal();
+        process.exitCode = await runLocal();
       } else {
         ui.error(opts.remote !== undefined
           ? `self gate remote unmeasured — ${reason.replace(/\s+/g, ' ').trim()}`
@@ -6275,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`)에 있다 — 이 액션은 **의존 배선만** 한다.
@@ -6306,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 } : {}),
@@ -7056,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);
@@ -12230,11 +12246,20 @@ const realContinueSessionLookup: ContinueSessionLookup = {
   activeSessionId: () => getActiveSessionId(),
 };
 
+const realNextTuiContinueSessionLookup: ContinueSessionLookup = {
+  projectIdForCwd: (cwd) => suggestProjectForFolder(cwd)?.id ?? null,
+  latestForProject: (projectId) => listSessions({ limit: 1, projectId, source: 'tui' })[0]?.id ?? null,
+  latestGlobal: () => listSessions({ limit: 1, source: 'tui' })[0]?.id ?? null,
+  activeSessionId: () => {
+    const id = getActiveSessionId();
+    return id && (loadSession(id) as unknown as { source?: string } | null)?.source === 'tui' ? id : null;
+  },
+};
+
 /**
  * TUI-CONTINUE-SESSION (0.2.35) — `--continue`(id 없는 `--resume`)의 «최근 세션» 을 cwd 기준으로
  * 먼저 좁힌다: cwd 가 속한 프로젝트(`primaryFolder` 또는 그 하위 디렉토리)의 최신 세션 id.
- * 매칭 프로젝트가 없거나 그 프로젝트에 세션이 하나도 없으면 전역 최신으로 폴백한다 —
- * 프로젝트와 무관한 디렉토리·화면의 이어가기 동작은 종전 그대로다.
+ * 프로젝트가 없거나 그 프로젝트에 세션이 없으면 전역 최신으로 폴백한다.
  */
 export function latestSessionIdForContinue(
   cwd: string = process.cwd(),
@@ -12245,6 +12270,26 @@ export function latestSessionIdForContinue(
   return localId ?? lookup.latestGlobal();
 }
 
+/** Next TUI only: resume a project TUI session, never an automation or cross-project session. */
+export function latestNextTuiSessionIdForContinue(
+  cwd: string = process.cwd(),
+  lookup: ContinueSessionLookup = realNextTuiContinueSessionLookup,
+): string | null {
+  const projectId = lookup.projectIdForCwd(cwd);
+  return projectId ? lookup.latestForProject(projectId) : lookup.latestGlobal();
+}
+
+/** Keep the source-filtered session selection scoped to the Next TUI entry. */
+export function latestRootSessionIdForContinue(
+  tuiEntry: 'classic' | 'next',
+  cwd: string = process.cwd(),
+  lookup?: ContinueSessionLookup,
+): string | null {
+  return tuiEntry === 'next'
+    ? latestNextTuiSessionIdForContinue(cwd, lookup ?? realNextTuiContinueSessionLookup)
+    : latestSessionIdForContinue(cwd, lookup ?? realContinueSessionLookup);
+}
+
 /**
  * cwd 가 프로젝트 안이면 활성 표지보다 cwd 프로젝트의 최신 세션 선택을 우선한다.
  * 프로젝트 밖에서는 종전처럼 활성 표지가 전역 최신보다 우선한다.
@@ -12501,17 +12546,16 @@ async function main(): Promise<void> {
   // 우선순위: `--resume <id>` > `--continue`·id 없는 `--resume`(최신) > (폐기 예정) ELANOUS_RESUME_SESSION.
   //   ⛔ 명시 인자가 있으면 환경변수가 이기지 않는다(TUI-H8 r1 must-fix).
   const { resolveLatestSessionId, resolveRootResumeSessionId } = await import('./session/session-start.js');
+  const continueLookup = tuiEntry === 'next' ? realNextTuiContinueSessionLookup : realContinueSessionLookup;
   const rootResume = resolveRootResumeSessionId({
     ...(resumeFromFlag !== undefined ? { flagId: resumeFromFlag } : {}),
     continueLatest,
     // 명시 인자가 있으면 env 를 «읽지도» 않는다(폐기 경고가 명시 이어하기에 섞이지 않게).
     readEnvId: () => readDeprecatedEnvForResume('ELANOUS_RESUME_SESSION').value ?? null,
     latest: () => resolveLatestSessionId({
-      // TUI-CONTINUE-SESSION (0.2.35) — 활성 표지가 «다른 프로젝트» 세션이면 버리고 cwd 기준으로 고른다.
-      activeSessionId: () => activeSessionIdForContinue(),
-      // TUI-CONTINUE-SESSION (0.2.35) — «지금 이 디렉토리» 의 프로젝트 최근 세션을 먼저 본다.
-      //   그 프로젝트에 세션이 없으면 종전대로 전역 최신으로 폴백(다른 화면 동작 보존).
-      latestSessionId: () => latestSessionIdForContinue(),
+      // Next TUI는 사람 TUI 세션만 이어가고, classic dashboard의 기존 선택은 보존한다.
+      activeSessionId: () => activeSessionIdForContinue(process.cwd(), continueLookup),
+      latestSessionId: () => latestRootSessionIdForContinue(tuiEntry),
       // TUI-H8-FOLLOW ① — 활성 표지가 사라진 세션이면 최신 세션으로(#28509 리뷰 should-fix).
       sessionExists: (id) => loadSession(id) !== null,
     }),
@@ -12714,7 +12758,7 @@ async function main(): Promise<void> {
       return;
     }
     const { showNextTui } = await import('./tui/entry.js');
-    await showNextTui({ resumeSessionId });
+    await showNextTui({ resumeSessionId, sidetabMode: getUserConfig().tui?.sidetab ?? 'collapsed' });
     bootTimer.phase('show-next');
     bootTimer.done();
   } else {

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; }
@@ -37,7 +50,50 @@ function writeSavedCursor(root: string, lastId: number): void {
   writeFileSync(cursorFile(root), JSON.stringify({ lastId, at: new Date().toISOString() }) + '\n');
 }
 
-export interface CollectSavedResult { cursorBefore: number; cursorAfter: number; messages: number; raws: number; dryRun: boolean; ingest?: IngestResult }
+export interface CollectSavedResult {
+  cursorBefore: number;
+  cursorAfter: number;
+  /** fetch 가 돌려준 «저장된 메시지» 수 — 커서 이후 읽은 것. */
+  messages: number;
+  /** 그중 savedMessageToRaws 가 0줄로 버린 메시지 수(빈 몸통) — «필터» 축. */
+  droppedByFilter: number;
+  /** 원장에 넣으려고 만든 입력 줄 수 — «원장 입력» 축. messages 와 다른 값이다. */
+  raws: number;
+  dryRun: boolean;
+  ingest?: IngestResult;
+}
+
+/** «메시지 0»·«원장 입력 0» 의 까닭 — 필터로 비었는지 다른 주체가 이미 가져갔는지 갈라 읽는다. */
+export type SavedCollectDiagnosis = 'new-items' | 'no-new-messages' | 'filtered-out' | 'already-consumed';
+
+export function diagnoseSavedCollect(res: CollectSavedResult): SavedCollectDiagnosis {
+  // 원장 입력이 있고 새로/합쳐 들어간 것이 있으면 정상 흡수다(dry-run 은 넣을 예정).
+  if (res.raws > 0 && (!res.ingest || res.ingest.added + res.ingest.merged > 0)) return 'new-items';
+  if (res.messages === 0) return 'no-new-messages';
+  if (res.droppedByFilter === res.messages) return 'filtered-out';
+  return 'already-consumed';
+}
+
+/** 사람이 읽는 한 덩이 — «메시지 0» 과 «원장 입력 0» 을 다른 줄로 갈라 보여준다. */
+export function renderCollectTelegramSavedResult(res: CollectSavedResult): string {
+  const lines = [
+    `텔레그램 저장된 메시지: 읽음 ${res.messages} · 필터로 버림 ${res.droppedByFilter} · 원장 입력 ${res.raws} · 커서 ${res.cursorBefore} → ${res.cursorAfter}${res.dryRun ? ' (dry-run · 안 씀)' : ''}`,
+  ];
+  if (res.ingest) lines.push(`원장: 새 ${res.ingest.added} · 합침 ${res.ingest.merged} · 이미 끝난 것 ${res.ingest.seen} · 버림 ${res.ingest.skipped}`);
+  const diagnosis = diagnoseSavedCollect(res);
+  if (diagnosis === 'no-new-messages') {
+    lines.push(`메시지 0 — 커서 ${res.cursorBefore} 이후 새 저장 메시지가 없다${res.cursorBefore > 0 ? ' (커서는 이미 다른 주체가 넘겼을 수 있다)' : ''}`);
+  } else if (diagnosis === 'filtered-out') {
+    lines.push(`원장 입력 0 은 필터 때문이다 — 링크·메모 문장이 없는 빈 메시지 ${res.droppedByFilter}건`);
+  } else if (diagnosis === 'already-consumed') {
+    lines.push(`원장 입력 ${res.raws} · 새 0 — 같은 항목을 다른 주체(queue)가 이미 가져갔다 (이미 끝난 것 ${res.ingest?.seen ?? 0})`);
+  } else if (res.dryRun) {
+    lines.push(`원장에 들어갈 것 ${res.raws}건 (dry-run — 쓰지 않았다)`);
+  } else {
+    lines.push(`원장에 새 것 ${res.ingest?.added ?? 0}건이 들어갔다`);
+  }
+  return lines.join('\n');
+}
 
 /**
  * 커서 이후 메시지를 한 번에 최대 max 개 읽어 원장에 넣고 커서를 옮긴다.
@@ -46,16 +102,44 @@ export interface CollectSavedResult { cursorBefore: number; cursorAfter: number;
  */
 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 raws = messages.flatMap(savedMessageToRaws);
+  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;
   const cursorAfter = messages.reduce((mx, m) => Math.max(mx, m.id), cursorBefore);
-  const result: CollectSavedResult = { cursorBefore, cursorAfter, messages: messages.length, raws: raws.length, dryRun: !!opts.dryRun };
+  const result: CollectSavedResult = { cursorBefore, cursorAfter, messages: messages.length, droppedByFilter, raws: raws.length, dryRun: !!opts.dryRun };
   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));
   }
-  // ⛔ 본문·링크는 싣지 않는다 — 커서와 건수만.
-  debug.log('intake.collect', 'telegram-saved', { cursorBefore, cursorAfter, messages: messages.length, raws: raws.length, dryRun: !!opts.dryRun });
+  // ⛔ 본문·링크는 싣지 않는다 — 커서와 건수만. 두 축(메시지·원장 입력)을 따로 남겨 사흘 0 을 갈라 읽게.
+  debug.log('intake.collect', 'telegram-saved', {
+    cursorBefore, cursorAfter, messages: messages.length, droppedByFilter, raws: raws.length,
+    ...(result.ingest ? { added: result.ingest.added, merged: result.ingest.merged, seen: result.ingest.seen, skipped: result.ingest.skipped } : {}),
+    diagnosis: diagnoseSavedCollect(result), dryRun: !!opts.dryRun,
+  });
   return result;
 }