elanous 0.2.29 → 0.2.31

package/src/self-implement/train-reach-grouping.ts

@@ -0,0 +1,157 @@
+import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
+import { isAbsolute } from 'node:path';
+import { selectGateTestFiles } from './gate-cli.js';
+
+export interface TrainReachCandidate {
+  pr: string;
+  headSha: string;
+  tree: string;
+  changedFiles: string[];
+}
+
+export interface TrainReachInput {
+  version: 1;
+  baseSha: string;
+  queueSig: string;
+  prs: TrainReachCandidate[];
+}
+
+export interface TrainReachObservation {
+  changedFiles: readonly string[];
+  testFiles: readonly string[];
+  unverified: readonly string[];
+  unrunImporterTotal: number | null;
+  lookupFailed?: string;
+  routeLookupFailures: readonly { source: string; reason: string }[];
+  callerTestsOverflow: readonly { file: string }[];
+  alwaysIncludeMissing: readonly string[];
+}
+
+export interface TrainReachGroup {
+  prs: string[];
+  reachTests: string[];
+  interactionTests: string[];
+  overlapEdges: Array<{ a: string; b: string; tests: string[]; paths: string[] }>;
+  status: 'measured' | 'unmeasured';
+  capacityBlocked: boolean;
+  reasons: string[];
+}
+
+export interface TrainReachDecision {
+  version: 1;
+  baseSha: string;
+  queueSig: string;
+  parallelSafe: boolean;
+  groups: TrainReachGroup[];
+  deferred: Array<{ pr: string; reason: string }>;
+}
+
+type InspectCandidate = (candidate: TrainReachCandidate, baseSha: string) => TrainReachObservation;
+
+const SHA40 = /^[a-f0-9]{40}$/i;
+const SHA256 = /^[a-f0-9]{64}$/i;
+const safePath = (path: string) => path.length > 0 && !path.startsWith('/')
+  && !path.includes('\\') && !/[\x00-\x1f\x7f]/.test(path)
+  && !path.split('/').some((part) => part === '..' || part === '.');
+const sortedUnique = (values: readonly string[]) => [...new Set(values)].sort();
+
+function git(tree: string, ...args: string[]): string {
+  const result = spawnSync('git', args, { cwd: tree, encoding: 'utf8', timeout: 15_000, maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+  if (result.status !== 0 || result.error) {
+    throw new Error(`git ${args[0]} unmeasured: ${result.error?.message ?? result.stderr?.trim() ?? `rc=${result.status}`}`);
+  }
+  return result.stdout.trim();
+}
+
+/** The selector's own base...HEAD comparison is independently checked against the queue snapshot. */
+function inspectTrainReachCandidate(candidate: TrainReachCandidate, baseSha: string): TrainReachObservation {
+  if (git(candidate.tree, 'rev-parse', 'HEAD').toLowerCase() !== candidate.headSha.toLowerCase()) {
+    throw new Error('tree HEAD differs from queued headSha');
+  }
+  if (git(candidate.tree, 'status', '--porcelain=v1')) throw new Error('tree is dirty');
+  git(candidate.tree, 'cat-file', '-e', `${baseSha}^{commit}`);
+  const observation = selectGateTestFiles(candidate.tree, { base: baseSha, includeImporterTests: true });
+  if (git(candidate.tree, 'rev-parse', 'HEAD').toLowerCase() !== candidate.headSha.toLowerCase()) {
+    throw new Error('tree HEAD changed during reach selection');
+  }
+  if (git(candidate.tree, 'status', '--porcelain=v1')) throw new Error('tree changed during reach selection');
+  return observation;
+}
+
+function validateInput(input: TrainReachInput): void {
+  if (input?.version !== 1 || !SHA40.test(input.baseSha) || !SHA256.test(input.queueSig) || !Array.isArray(input.prs)) {
+    throw new Error('train reach input identity unmeasured');
+  }
+  const seen = new Set<string>();
+  for (const candidate of input.prs) {
+    if (!/^[1-9]\d*$/.test(candidate?.pr) || seen.has(candidate.pr) || !SHA40.test(candidate.headSha)
+      || !isAbsolute(candidate.tree) || !Array.isArray(candidate.changedFiles) || candidate.changedFiles.length === 0
+      || !candidate.changedFiles.every((path) => typeof path === 'string' && safePath(path))) {
+      throw new Error(`train reach candidate invalid: ${candidate?.pr ?? 'unknown'}`);
+    }
+    seen.add(candidate.pr);
+  }
+}
+
+/** Pure grouping after one independently measured selector observation per queued PR. */
+export function buildTrainReachDecision(input: TrainReachInput, inspect: InspectCandidate = inspectTrainReachCandidate): TrainReachDecision {
+  validateInput(input);
+  const measured: Array<{ candidate: TrainReachCandidate; tests: string[]; files: string[] }> = [];
+  const deferred: TrainReachDecision['deferred'] = [];
+  for (const candidate of input.prs) {
+    try {
+      const observed = inspect(candidate, input.baseSha);
+      const actual = sortedUnique(observed.changedFiles);
+      const expected = sortedUnique(candidate.changedFiles);
+      if (actual.length !== expected.length || actual.some((path, index) => path !== expected[index])) {
+        throw new Error('changedFiles differ from selector observation');
+      }
+      if (observed.lookupFailed || observed.routeLookupFailures.length || observed.unrunImporterTotal !== 0
+        || observed.callerTestsOverflow.length || observed.alwaysIncludeMissing.length || observed.unverified.length) {
+        throw new Error('test selection has unmeasured reach');
+      }
+      if (!observed.testFiles.every(safePath)) throw new Error('selected test path invalid');
+      measured.push({ candidate, tests: sortedUnique(observed.testFiles), files: sortedUnique(observed.changedFiles) });
+    } catch (error) {
+      deferred.push({ pr: candidate.pr, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+
+  const parent = measured.map((_, index) => index);
+  const find = (index: number): number => {
+    while (parent[index] !== index) index = parent[index] = parent[parent[index]];
+    return index;
+  };
+  const edges: Array<{ left: number; right: number; tests: string[]; paths: string[] }> = [];
+  for (let left = 0; left < measured.length; left++) {
+    for (let right = left + 1; right < measured.length; right++) {
+      const tests = measured[left].tests.filter((path) => measured[right].tests.includes(path));
+      const paths = measured[left].files.filter((path) => measured[right].files.includes(path));
+      if (!tests.length && !paths.length) continue;
+      edges.push({ left, right, tests, paths });
+      parent[find(right)] = find(left);
+    }
+  }
+  const components = new Map<number, number[]>();
+  for (let index = 0; index < measured.length; index++) {
+    const root = find(index);
+    components.set(root, [...(components.get(root) ?? []), index]);
+  }
+  const groups = [...components.values()].map((indices): TrainReachGroup => {
+    const prs = indices.map((index) => measured[index].candidate.pr);
+    const counts = new Map<string, number>();
+    for (const index of indices) for (const test of measured[index].tests) counts.set(test, (counts.get(test) ?? 0) + 1);
+    const reachTests = sortedUnique([...counts.keys()]);
+    const interactionTests = reachTests.filter((test) => (counts.get(test) ?? 0) > 1);
+    const overlapEdges = edges.filter(({ left, right }) => indices.includes(left) && indices.includes(right))
+      .map(({ left, right, tests, paths }) => ({ a: measured[left].candidate.pr, b: measured[right].candidate.pr, tests, paths }));
+    const capacityBlocked = indices.length > 5;
+    const reasons = capacityBlocked ? ['connected reach group exceeds five PR train limit'] : [];
+    return { prs, reachTests, interactionTests, overlapEdges,
+      status: 'measured', capacityBlocked, reasons };
+  });
+  return { version: 1, baseSha: input.baseSha, queueSig: input.queueSig,
+    parallelSafe: deferred.length === 0 && groups.every(({ status, capacityBlocked }) => status === 'measured' && !capacityBlocked),
+    groups, deferred };
+}

package/src/self-implement/train-scenario-layers.ts

@@ -0,0 +1,133 @@
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { isGateSpawnLaneFile } from '../self-dev/spawn-lane-files.js';
+import { isTestPath } from './importer-test-index.js';
+import type { TrainReachDecision, TrainReachInput } from './train-reach-grouping.js';
+
+export interface TrainRiskEvidence {
+  /** Only evidence-backed paths; an empty list asserts no known hot paths for this queue. */
+  verifiedHotFiles: Array<{ path: string; evidence: string }>;
+  /** Both endpoints are test paths; evidence must describe a reproduced interaction. */
+  verifiedInterferencePairs: Array<{ a: string; b: string; evidence: string }>;
+  /** Unreproduced pairs remain visible and prohibit parallel apply when either endpoint is reached. */
+  suspectedPairs: Array<{ a: string; b: string; reason: string }>;
+}
+
+export interface TrainScenarioGroup {
+  prs: string[];
+  reachTests: string[];
+  interactionTests: string[];
+  riskTests: string[];
+  riskReasons: Array<{ test: string; reason: string; evidence: string }>;
+  groupRiskReasons: Array<{ reason: string; evidence: string }>;
+  canaryTests: string[];
+  scenarioTests: string[];
+  populationSize: number;
+  eligiblePopulationSize: number;
+  canaryTarget: number;
+  /** Reproducible SHA-256 input prefix: baseSha, queueSig, and sorted PRs separated by NUL. */
+  canarySelectionKey: string;
+  canaryHashMethod: string;
+  unmeasured: string[];
+}
+
+export interface TrainScenarioDecision {
+  version: 1;
+  baseSha: string;
+  queueSig: string;
+  parallelSafe: boolean;
+  groups: TrainScenarioGroup[];
+  unmeasured: string[];
+}
+
+const sorted = (paths: readonly string[]) => [...new Set(paths)].sort();
+const validPath = (path: unknown): path is string => typeof path === 'string' && !!path && !path.startsWith('/') && !path.includes('\\')
+  && !/[\x00-\x1f\x7f]/.test(path) && !path.split('/').some((part) => part === '.' || part === '..');
+const hash = (value: string) => createHash('sha256').update(value).digest('hex');
+
+/** Read the tracked test population from the pinned base commit, including paths containing spaces. */
+export function readTrainTestPopulation(tree: string, baseSha: string): string[] {
+  if (!/^[a-f0-9]{40}$/i.test(baseSha)) throw new Error('invalid baseSha for test population');
+  const result = spawnSync('git', ['ls-tree', '-r', '-z', '--name-only', baseSha],
+    { cwd: tree, encoding: 'utf8', timeout: 30_000, maxBuffer: 256 * 1024 * 1024 });
+  if (result.error || result.status !== 0) throw new Error(`test population unmeasured: ${result.error?.message ?? result.stderr?.trim() ?? result.status}`);
+  return sorted(result.stdout.split('\0').filter(isTestPath));
+}
+
+/** Pure scenario composition. No unverified hot path or interference guess is promoted to a verified risk. */
+export function buildTrainScenarioDecision(
+  input: TrainReachInput, reach: TrainReachDecision, population: readonly string[], evidence: TrainRiskEvidence,
+): TrainScenarioDecision {
+  if (reach.version !== 1 || reach.baseSha !== input.baseSha || reach.queueSig !== input.queueSig
+    || !Array.isArray(population) || !population.every((path) => typeof path === 'string' && validPath(path) && isTestPath(path))
+    || !evidence || !Array.isArray(evidence.verifiedHotFiles) || !Array.isArray(evidence.verifiedInterferencePairs)
+    || !Array.isArray(evidence.suspectedPairs)) throw new Error('scenario identity or population unmeasured');
+  const tests = sorted(population);
+  const commonTests = new Set(tests);
+  const known = new Set([...tests, ...reach.groups.flatMap((group) => group.reachTests)]);
+  const validEvidence = (value: unknown): value is string => typeof value === 'string' && value.trim().length > 0;
+  for (const item of evidence.verifiedHotFiles) {
+    if (!validPath(item?.path) || !validEvidence(item?.evidence)) throw new Error('hot-file evidence unmeasured');
+  }
+  for (const item of [...evidence.verifiedInterferencePairs, ...evidence.suspectedPairs]) {
+    if (!validPath(item?.a) || !validPath(item?.b) || !known.has(item.a) || !known.has(item.b)
+      || item.a === item.b || !validEvidence(item && 'evidence' in item ? item.evidence : item?.reason)) {
+      throw new Error('interference-pair evidence unmeasured');
+    }
+  }
+  const changedByPr = new Map(input.prs.map(({ pr, changedFiles }) => [pr, changedFiles]));
+  const groups = reach.groups.map((group): TrainScenarioGroup => {
+    const reached = new Set(group.reachTests);
+    if ([...reached].some((path) => !validPath(path) || !isTestPath(path))) throw new Error('reached test path invalid');
+    const riskReasons: TrainScenarioGroup['riskReasons'] = [];
+    const groupRiskReasons: TrainScenarioGroup['groupRiskReasons'] = [];
+    const unavailable: string[] = [];
+    const risk = new Set<string>();
+    const addRisk = (test: string, reason: string, source: string): void => {
+      risk.add(test);
+      riskReasons.push({ test, reason, evidence: source });
+    };
+    for (const test of reached) if (isGateSpawnLaneFile(test)) addRisk(test, 'spawn-lane', 'src/self-dev/spawn-lane-files.ts');
+    const changed = new Set(group.prs.flatMap((pr) => changedByPr.get(pr) ?? []));
+    for (const hot of evidence.verifiedHotFiles) if (changed.has(hot.path)) {
+      groupRiskReasons.push({ reason: `hot-file:${hot.path}`, evidence: hot.evidence });
+    }
+    for (const pair of evidence.verifiedInterferencePairs) {
+      if (reached.has(pair.a) || reached.has(pair.b)) {
+        const endpoints: Array<[string, string]> = [[pair.a, pair.b], [pair.b, pair.a]];
+        for (const [test, other] of endpoints) {
+          if (reached.has(test) || commonTests.has(test)) addRisk(test, `interference-with:${other}`, pair.evidence);
+          else unavailable.push(`verified interference endpoint unavailable in every PR head: ${test}`);
+        }
+      }
+    }
+    const canaryPrefix = `${input.baseSha}\0${input.queueSig}\0${sorted(group.prs).join(',')}`;
+    const used = new Set([...reached, ...risk]);
+    const eligible = tests.filter((test) => !used.has(test));
+    const canaryTarget = eligible.length ? Math.max(1, Math.round(eligible.length * 0.02)) : 0;
+    const canaryTests = eligible
+      .sort((a, b) => hash(`${canaryPrefix}\0${a}`).localeCompare(hash(`${canaryPrefix}\0${b}`)) || a.localeCompare(b))
+      .slice(0, canaryTarget).sort();
+    const scenarioTests = sorted([...reached, ...risk, ...canaryTests]);
+    const scenarioSet = new Set(scenarioTests);
+    const unmeasured = [...unavailable, ...evidence.suspectedPairs
+      .filter((pair) => scenarioSet.has(pair.a) || scenarioSet.has(pair.b))
+      .map((pair) => `suspected interference ${pair.a} ↔ ${pair.b}: ${pair.reason}`)];
+    return { prs: group.prs, reachTests: group.reachTests, interactionTests: group.interactionTests,
+      riskTests: sorted([...risk]), riskReasons, groupRiskReasons, canaryTests,
+      scenarioTests, populationSize: tests.length, eligiblePopulationSize: eligible.length,
+      canaryTarget, canarySelectionKey: canaryPrefix,
+      canaryHashMethod: 'sha256(canarySelectionKey\\0path)', unmeasured };
+  });
+  const unmeasured = groups.flatMap((group) => group.unmeasured);
+  // A verified interference pair executed by multiple scenarios bars parallel trains, including canary selection.
+  for (const pair of evidence.verifiedInterferencePairs) {
+    const aOwners = groups.flatMap((group, index) => group.scenarioTests.includes(pair.a) ? [index] : []);
+    const bOwners = groups.flatMap((group, index) => group.scenarioTests.includes(pair.b) ? [index] : []);
+    if (aOwners.some((a) => bOwners.some((b) => a !== b))) {
+      unmeasured.push(`verified interference crosses groups ${pair.a} ↔ ${pair.b}: ${pair.evidence}`);
+    }
+  }
+  return { version: 1, baseSha: input.baseSha, queueSig: input.queueSig,
+    parallelSafe: reach.parallelSafe && unmeasured.length === 0, groups, unmeasured };
+}

package/src/self-implement/uncommitted-work.ts

@@ -1,4 +1,5 @@
 import { spawnSync } from 'node:child_process';
+import { SPAWN_SYNC_MAX_BUFFER } from '../util/spawn-sync-output.js';
 import { isElanousRuntimeArtifactPath } from './gate-scope.js';
 
 export type UncommittedWork =
@@ -19,6 +20,7 @@ export function detectUncommittedWork(worktree: string): UncommittedWork {
       env: gitEnv,
       encoding: 'utf8',
       timeout: 10_000,
+      maxBuffer: SPAWN_SYNC_MAX_BUFFER,
     });
   } catch (error) {
     return { status: 'unavailable', reason: error instanceof Error ? error.message : String(error) };

package/src/session/pending-input.ts

@@ -99,6 +99,25 @@ export function removePendingUserInput(
   return removedIds.length;
 }
 
+/**
+ * id 로 고른 항목을 버킷 «맨 앞»으로 옮긴다(주어진 순서대로) — «지금 밀어 넣기»가 끊을 수 없는 도구 때문에
+ * 다음 경계로 떨어질 때, 같은 버킷의 다른 항목(goal-loop 메모 등)보다 먼저 들어가게 한다. 옮긴 수를 낸다.
+ */
+export function prioritizePendingUserInput(ids: readonly string[]): number {
+  if (ids.length === 0) return 0;
+  const order = new Map(ids.map((id, index) => [id, index]));
+  let moved = 0;
+  for (const bucket of buckets.values()) {
+    const front = bucket.items.filter(item => order.has(item.id))
+      .sort((a, b) => (order.get(a.id) ?? 0) - (order.get(b.id) ?? 0));
+    if (front.length === 0) continue;
+    bucket.items = [...front, ...bucket.items.filter(item => !order.has(item.id))];
+    moved += front.length;
+  }
+  if (moved > 0) debug.log('llm.interjection', 'prioritized', { requested: ids.length, moved });
+  return moved;
+}
+
 /** 지금 이 세션에 대기 중인 수(관측·표시용). 비우지 «않는다». */
 export function pendingUserInputCount(sessionId: string): number {
   return buckets.get(sessionId)?.items.length ?? 0;

package/src/session/session-start.ts

@@ -0,0 +1,224 @@
+// 🧭 세션 시작 결정 — «인자 없음 = 깨끗한 새 세션», 이어하기는 명시 인자일 때만 (TUI-H8-SESSION-NEW-DEFAULT · 대표 10-16 #73).
+//
+// S: `elanous chat` · `agent` · `repl` 은 인자 없이 뜨면 «활성 세션»(~/.local/state/elanous/active)을 조용히 이어받았다.
+//    그래서 앞 프로세스가 도구 호출 도중 죽은 기록(호출·결과 짝이 깨진 꼬리)까지 이어받아 첫 턴이 400 으로 죽었다(#69).
+// C: 다른 에이전트(codex·claude·grok)는 인자 없음 = 새 세션 · 이어하기 = `--resume`/`--continue` 다.
+// A: 시작 결정을 이 함수 하나로 모으고, 결정마다 `session`/`start` 한 줄을 남긴다(관측).
+//    ⛔ 자리 맥락은 세션이 아니라 자리 문서(AGENTS.local.md · `.AGENTS.local.last-session.md` · 부트 카드)가 매 턴 싣는다 —
+//       새 세션이어도 맥락은 그대로다(`turn-preamble.ts` · `universal-preamble.ts`).
+
+import { debug } from '../debug/log.js';
+
+export type SessionStartOrigin = 'new' | 'resume';
+export type SessionStartReason =
+  | 'default-new'
+  | 'force-new'
+  | 'explicit-session'
+  | 'continue-active'
+  | 'continue-latest'
+  | 'continue-no-active';
+
+export interface SessionStartDecision {
+  origin: SessionStartOrigin;
+  reason: SessionStartReason;
+  /** 이어받을 세션 id(명시 id 는 호출부가 이미 풀어서 넘긴다). 새 세션이면 undefined. */
+  sessionIdHint?: string;
+}
+
+/** 단일 결정 — 명시 id > `--new` > `--continue`/`--resume`(활성 세션 ⊕ 표지가 낡았으면 최신 세션) > 기본 새 세션.
+ *  `sessionExists`·`latestSessionId` 를 주면 활성 표지가 «사라진 세션»을 가리킬 때 최신 세션으로 넘어간다
+ *  (TUI-H8-FOLLOW ① · #28509 리뷰 should-fix). 안 주면 옛 동작(표지를 그대로 믿는다). */
+export function decideSessionStart(input: {
+  explicitSessionId?: string;
+  continueActive: boolean;
+  forceNew: boolean;
+  activeSessionId: () => string | null;
+  sessionExists?: (id: string) => boolean;
+  latestSessionId?: () => string | null;
+}): SessionStartDecision {
+  if (input.explicitSessionId) {
+    return { origin: 'resume', reason: 'explicit-session', sessionIdHint: input.explicitSessionId };
+  }
+  if (input.forceNew) return { origin: 'new', reason: 'force-new' };
+  if (input.continueActive) {
+    const picked = pickContinueSession(input);
+    if (!picked) return { origin: 'new', reason: 'continue-no-active' };
+    return {
+      origin: 'resume',
+      reason: picked.from === 'active' ? 'continue-active' : 'continue-latest',
+      sessionIdHint: picked.id,
+    };
+  }
+  return { origin: 'new', reason: 'default-new' };
+}
+
+/** 존재 확인 — 확인 자체가 실패하면 «있다»고 보지 않는다(이어받을 수 없는 세션을 고르지 않는다). */
+function sessionAlive(exists: ((id: string) => boolean) | undefined, id: string): boolean {
+  if (!exists) return true;
+  try { return exists(id); } catch { return false; }
+}
+
+/** «이어하기» 대상 — 활성 표지 ⊕ (표지가 없거나 사라진 세션이면) 최신 세션. 낡은 표지는 `session`/`active-marker-stale` 로 남긴다. */
+function pickContinueSession(deps: {
+  activeSessionId: () => string | null;
+  sessionExists?: (id: string) => boolean;
+  latestSessionId?: () => string | null;
+}): { id: string; from: 'active' | 'latest' } | null {
+  let active: string | null = null;
+  try { active = deps.activeSessionId(); } catch { /* 활성 표지 읽기 실패 — 최신 세션으로 넘어간다 */ }
+  if (active && sessionAlive(deps.sessionExists, active)) return { id: active, from: 'active' };
+  const picked = pickLatest(deps, active);
+  if (active) {
+    // 관측은 «실제로 고른 결과»로 남긴다(r1 should-fix — 최신이 없어 새 세션이면 fallback:'none').
+    try {
+      debug.log('session', 'active-marker-stale', { activeSessionId: active, fallback: picked ? 'latest' : 'none' });
+    } catch { /* 관측 실패가 시작을 막지 않는다 */ }
+  }
+  return picked;
+}
+
+function pickLatest(deps: {
+  sessionExists?: (id: string) => boolean;
+  latestSessionId?: () => string | null;
+}, staleActive: string | null): { id: string; from: 'latest' } | null {
+  if (!deps.latestSessionId) return null;
+  let latest: string | null = null;
+  try { latest = deps.latestSessionId(); } catch { return null; }
+  if (!latest || latest === staleActive || !sessionAlive(deps.sessionExists, latest)) return null;
+  return { id: latest, from: 'latest' };
+}
+
+/** `elanous --resume`/`--continue` 처럼 id 없이 «이어하기»만 받은 표면이 이어받을 세션 — 활성 표지 ⊕ 없거나 사라졌으면 최신. */
+export function resolveLatestSessionId(deps: {
+  activeSessionId: () => string | null;
+  latestSessionId: () => string | null;
+  sessionExists?: (id: string) => boolean;
+}): string | null {
+  return pickContinueSession(deps)?.id ?? null;
+}
+
+/** 세션 id 꼴인가 — 세션 id 는 uuid v4(`randomUUID` · 8-4-4-4-12 hex)이고 «고유 접두»도 받는다.
+ *  uuid 의 «접두»(하이픈은 9·14·19·24번째 자리에만) 4~36자 ⊕ 숫자 하나 이상(«face»·«deadbeef» 같은 낱말을 id 로 먹지 않게).
+ *  숫자 없는 hex 접두를 id 로 쓰려면 `--session <id>` 를 쓴다. */
+export function looksLikeSessionId(value: string): boolean {
+  const v = value.trim().toLowerCase();
+  if (v.length < 4 || v.length > 36 || !/[0-9]/.test(v)) return false;
+  for (let i = 0; i < v.length; i += 1) {
+    const c = v[i]!;
+    const hyphenSlot = i === 8 || i === 13 || i === 18 || i === 23;
+    if (hyphenSlot ? c !== '-' : !/[0-9a-f]/.test(c)) return false;
+  }
+  return true;
+}
+
+/** `--resume [id]` 뒤 위치 인자 — Commander 는 값 선택형 옵션 뒤 첫 낱말을 값으로 먹는다.
+ *  그 값이 세션 id 꼴이 아니면 «id 없는 --resume ⊕ 프롬프트 낱말»로 되돌린다(TUI-H8-FOLLOW ②).
+ *  `argv` 를 주면 되돌린 낱말을 입력 «순서 그대로» 끼운다(`chat hello --resume world` → `hello world`);
+ *  안 주면 맨 앞에 놓는다. */
+export function splitResumeArgument(
+  resume: string | boolean | undefined,
+  parts: readonly string[],
+  surface: 'chat' | 'agent',
+  argv?: readonly string[],
+): { resume: string | boolean | undefined; parts: string[] } {
+  if (typeof resume !== 'string' || looksLikeSessionId(resume)) return { resume, parts: [...parts] };
+  const at = argv ? resumeInsertIndex(argv, parts, resume, surface) : 0;
+  try {
+    debug.log('session', 'resume-value-as-prompt', { surface, words: resume.split(/\s+/).filter(Boolean).length, at });
+  } catch { /* 관측 실패가 시작을 막지 않는다 */ }
+  return { resume: true, parts: [...parts.slice(0, at), resume, ...parts.slice(at)] };
+}
+
+/** chat·agent argv 를 «한 번» 토큰화한 결과 — 위치 인자(순서대로) ⊕ `--resume` 값이 몇 번째 위치 인자 «앞»에 왔나.
+ *  (r3 TF 결정: 한 지점 땜질 대신 토큰화로 일반화 — 리뷰 진동을 끊는다.)
+ *  규칙(Commander 와 같은 읽기):
+ *   - 명령 낱말(`chat`/`agent`) «뒤»부터 본다(앞은 루트 옵션).
+ *   - `--` 뒤는 전부 위치 인자.
+ *   - `--resume=X` → X 가 resume 값. `--resume X` → X 가 `-` 로 시작하지 않으면 resume 값(값 선택형).
+ *   - 값을 받는 옵션(`--session`)은 `--session X`·`--session=X` 모두 값을 건너뛴다.
+ *   - 그 밖의 `-` 로 시작하는 토큰은 값 없는 플래그(`--continue` 등 · `--continue=X` 는 Commander 가 거부한다).
+ *   - 나머지는 위치 인자. */
+export function tokenizeResumeArgv(
+  argv: readonly string[],
+  surface: 'chat' | 'agent',
+): { positionals: string[]; resumeValue: string | null; resumeValueAt: number | null } {
+  const VALUE_OPTIONS = new Set(['--session']);
+  const positionals: string[] = [];
+  let resumeValue: string | null = null;
+  let resumeValueAt: number | null = null;
+  let afterDoubleDash = false;
+  for (let i = argv.indexOf(surface) + 1; i < argv.length; i += 1) {
+    const token = argv[i]!;
+    if (afterDoubleDash) { positionals.push(token); continue; }
+    if (token === '--') { afterDoubleDash = true; continue; }
+    if (token.startsWith('--resume=')) {
+      resumeValue = token.slice('--resume='.length);
+      resumeValueAt = positionals.length;
+      continue;
+    }
+    if (token === '--resume') {
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith('-')) {
+        resumeValue = next;
+        resumeValueAt = positionals.length;
+        i += 1;
+      }
+      continue;
+    }
+    const eq = token.indexOf('=');
+    if (token.startsWith('--') && VALUE_OPTIONS.has(eq >= 0 ? token.slice(0, eq) : token)) {
+      if (eq < 0) i += 1;
+      continue;
+    }
+    if (token.startsWith('-')) continue;
+    positionals.push(token);
+  }
+  return { positionals, resumeValue, resumeValueAt };
+}
+
+/** 되돌린 낱말을 끼울 자리 — 토큰화 결과가 Commander 가 준 값·위치 인자와 «다르면» 맨 앞(옛 동작)으로 접고 남긴다. */
+function resumeInsertIndex(argv: readonly string[], parts: readonly string[], resume: string, surface: 'chat' | 'agent'): number {
+  const t = tokenizeResumeArgv(argv, surface);
+  const agrees = t.resumeValue === resume
+    && t.resumeValueAt !== null
+    && t.positionals.length === parts.length
+    && t.positionals.every((p, i) => p === parts[i]);
+  if (agrees) return t.resumeValueAt!;
+  try { debug.log('session', 'resume-argv-mismatch', { surface, positionals: t.positionals.length, parts: parts.length }); } catch { /* best-effort */ }
+  return 0;
+}
+
+/** 대시보드 TUI 루트 이어하기 — 우선순위 `--resume <id>` > `--continue`·id 없는 `--resume`(최신 세션) >
+ *  (폐기 예정) `ELANOUS_RESUME_SESSION`. ⛔ 명시 인자가 있으면 환경변수가 이기지 않는다. 아무것도 없으면 새 세션. */
+export function resolveRootResumeSessionId(input: {
+  flagId?: string;
+  continueLatest: boolean;
+  /** 폐기 예정 env 읽기 — 명시 인자가 하나도 없을 때만 «부른다»(읽기 자체가 폐기 경고를 낸다 · r2 must-fix). */
+  readEnvId: () => string | null | undefined;
+  latest: () => string | null;
+}): { sessionId?: string; source: 'flag' | 'continue' | 'continue-none' | 'env' | 'none' } {
+  const flagId = (input.flagId ?? '').trim();
+  if (flagId) return { sessionId: flagId, source: 'flag' };
+  if (input.continueLatest) {
+    const latest = input.latest();
+    return latest ? { sessionId: latest, source: 'continue' } : { source: 'continue-none' };
+  }
+  const envId = (input.readEnvId() ?? '').trim();
+  if (envId) return { sessionId: envId, source: 'env' };
+  return { source: 'none' };
+}
+
+/** 관측 — 세션이 «어떻게» 시작됐나. 실패해도 시작을 막지 않는다. */
+export function observeSessionStart(data: {
+  surface: 'chat' | 'agent' | 'repl' | 'tui' | 'ask';
+  origin: SessionStartOrigin;
+  reason: string;
+  sessionId?: string | null;
+  [key: string]: unknown;
+}): void {
+  try {
+    debug.log('session', 'start', data);
+  } catch {
+    // Observation must never block a session start.
+  }
+}

package/src/session-runtime/parallel-dispatch.ts

@@ -93,31 +93,48 @@ export function partitionByParallelSafety<T extends { name: string }>(
  *
  *   When `safe.length < 2`, the helper degenerates into pure sequential
  *   dispatch in original order — no parallelism benefit for 0-1 safe
- *   calls so we keep behaviour identical to pre-P2. */
+ *   calls so we keep behaviour identical to pre-P2.
+ *
+ *   ⭐ `signal` (TUI-ESC-ABORT-TOOLS · 2026-10-15) — 턴 중단(Esc)이 걸리면 묶음 안
+ *   «남은» 호출을 새로 시작하지 않는다. 순차 갈래·unsafe 갈래에서 호출마다
+ *   `signal.aborted` 를 보고, 참이면 그 호출과 뒤의 호출을 부르지 않는다.
+ *   ⛔ 이미 시작한 호출은 끊지 않는다(진행 중 도구의 중단은 도구가 받는 신호의 몫).
+ *   ⛔ 병렬(safe) 묶음은 한꺼번에 시작되므로 시작 «전»에만 본다.
+ *   부르지 않은 호출의 결과 칸은 비어 있다 — 호출자가 «중단됨» 결과로 채워
+ *   공급자 이력의 tool_call/tool_result 짝을 지킨다(`skippedIndices`). */
 export async function dispatchWithParallelSafety<T extends { name: string }>(
   calls: readonly T[],
   dispatchOne: (call: T, index: number) => Promise<void>,
-): Promise<{ safeCount: number; unsafeCount: number; parallelActivated: boolean }> {
+  signal?: AbortSignal,
+): Promise<{ safeCount: number; unsafeCount: number; parallelActivated: boolean; skippedIndices: number[] }> {
   const { safe, unsafe } = partitionByParallelSafety(calls);
   const parallelActivated = safe.length >= 2;
+  const skippedIndices: number[] = [];
   if (!parallelActivated) {
     // Fall back to pure sequential in original order. Keeps pre-P2
     // behaviour bit-exact when only one read tool is in the batch
     // (common case — no benefit to firing Promise.all for a single
     // call).
     for (let i = 0; i < calls.length; i += 1) {
+      if (signal?.aborted) { skippedIndices.push(i); continue; }
       await dispatchOne(calls[i]!, i);
     }
-    return { safeCount: safe.length, unsafeCount: unsafe.length, parallelActivated };
+    return { safeCount: safe.length, unsafeCount: unsafe.length, parallelActivated, skippedIndices };
   }
   // Parallel kickoff for the safe group. Promise.all is safe here
   // because `dispatchOne` is expected to catch its own errors and
   // write an error result into the caller's storage — we never want
   // one failing Read to cancel two sibling Reads.
-  await Promise.all(safe.map(({ call, index }) => dispatchOne(call, index)));
+  if (signal?.aborted) {
+    for (const { index } of safe) skippedIndices.push(index);
+  } else {
+    await Promise.all(safe.map(({ call, index }) => dispatchOne(call, index)));
+  }
   // Unsafe group: sequential, in original order.
   for (const { call, index } of unsafe) {
+    if (signal?.aborted) { skippedIndices.push(index); continue; }
     await dispatchOne(call, index);
   }
-  return { safeCount: safe.length, unsafeCount: unsafe.length, parallelActivated };
+  skippedIndices.sort((a, b) => a - b);
+  return { safeCount: safe.length, unsafeCount: unsafe.length, parallelActivated, skippedIndices };
 }

package/src/skills/tools/dev-harness.ts

@@ -96,6 +96,8 @@ export function buildRunDevHarnessTool(): LLMToolSpec {
 
 /** dev-harness 실행 seam 세트(테스트/대체 주입). */
 export interface DevHarnessDeps {
+  /** 시험 전용 target HOME. 생략하면 resolveHarnessTarget 의 실제 homedir 기본값을 쓴다. */
+  targetHome?: string;
   /** 하니스 구동(기본 runStagedHarnessOnSurface). */
   runHarness?: (opts: RunHarnessOnSurfaceOptions) => Promise<HarnessResult>;
   /** In-process 실행 직전의 관측 전용 디스패치 seam. */
@@ -319,7 +321,7 @@ export async function dispatchRunDevHarness(
   let targetResolution: HarnessTargetResolution | undefined;
   if (!targetOptions && target) {
     const elanousBinRoot = resolveMainRepoRoot(process.cwd()) ?? process.cwd();
-    const resolution = resolveHarnessTarget(target);
+    const resolution = resolveHarnessTarget(target, { home: deps?.targetHome });
     targetResolution = resolution;
     debug.log('harness.frontdoor', 'target.resolved', {
       target, kind: resolution.status, elanousBinRoot,
@@ -343,7 +345,7 @@ export async function dispatchRunDevHarness(
         debug.log('harness.frontdoor', 'refused', { target, reason: 'outside-home-declined', interactive: ux.interactive });
         return { output: `RunDevHarness ⚠️ 거부: 홈 밖 시스템경로 '${target}' — 진입 ${ux.interactive ? '취소됨(HITL 미승인).' : '승인 채널 없음(fail-closed).'}` };
       }
-      const authorized = revalidateHarnessTarget(resolution);
+      const authorized = revalidateHarnessTarget(resolution, { home: deps?.targetHome });
       if (authorized.status === 'normalization-failed' || authorized.status === 'missing') {
         debug.log('harness.frontdoor', 'refused', { target, reason: 'outside-home-revalidation-failed', detail: authorized.reason });
         return { output: `RunDevHarness ⚠️ 거부: target '${target}' — 승인 중 경로 재검증에 실패했습니다.` };
@@ -369,7 +371,7 @@ export async function dispatchRunDevHarness(
   // Recheck immediately before handing paths to seams; a symlink retarget after
   // classification must not reach staging or apply through stale options.
   if (targetResolution) {
-    const revalidated = revalidateHarnessTarget(targetResolution);
+    const revalidated = revalidateHarnessTarget(targetResolution, { home: deps?.targetHome });
     if (revalidated.status === 'normalization-failed') {
       debug.log('harness.frontdoor', 'refused', { target, reason: 'target-revalidation-failed', detail: revalidated.reason });
       return { output: `RunDevHarness ⚠️ 거부: target '${target}' — 스테이징 전 경로 재검증에 실패했습니다.` };
@@ -421,7 +423,7 @@ export async function dispatchRunDevHarness(
   });
   if (targetResolution) {
     const assertStableTarget = (): void => {
-      const current = revalidateHarnessTarget(targetResolution!);
+      const current = revalidateHarnessTarget(targetResolution!, { home: deps?.targetHome });
       if (current.status === 'normalization-failed' || current.status === 'missing') {
         debug.log('harness.frontdoor', 'refused', { target, reason: 'target-revalidation-failed', detail: current.reason });
         throw new Error(`harness target revalidation failed: ${current.reason ?? current.status}`);