elanous 0.2.28 → 0.2.31

package/src/session/pending-input.ts

@@ -13,29 +13,48 @@
 //   ACP 에 진짜 `steer` 메서드가 필요하다(`clientSessionSteer` 가 이미 있으나 elanous 자체
 //   backend 는 `steer()` 를 «구현하지 않는다» — 호출자도 0이다). 그 확장은 별건이다.
 
+import { randomUUID } from 'node:crypto';
 import { debug } from '../debug/log.js';
 
+/** 레지스트리 항목 — ⭐ id 는 «원본 큐»가 배수·되꺼내기·턴 종료 승격을 짝지을 때 쓴다(10-14 중복 수리). */
+export interface PendingUserInputItem {
+  id: string;
+  text: string;
+}
+
+export type PendingUserInputDrained = (drained: readonly string[], items: readonly PendingUserInputItem[]) => void;
+
 interface PendingBucket {
-  items: string[];
+  items: PendingUserInputItem[];
   /** 배수될 때 «원본 큐»도 비우라고 알린다 — 안 그러면 같은 발화가 턴 끝에 «또» 나간다. */
-  onDrained?: (drained: readonly string[]) => void;
+  onDrained?: PendingUserInputDrained;
 }
 
 const buckets = new Map<string, PendingBucket>();
+let nextPendingId = 0;
+// 프로세스마다 다른 머리 — 재기동 뒤 `pending-1` 이 다시 나와 로그에서 id 가 겹치는 것을 막는다(실물 10-15).
+const pendingIdPrefix = randomUUID().slice(0, 8);
 
-/** 이 세션의 도는 턴에 끼워 넣을 발화를 쌓는다. */
+/**
+ * 이 세션의 도는 턴에 끼워 넣을 발화를 쌓는다. 쌓인 항목의 id 를 낸다(안 쌓았으면 null).
+ * ⭐ 호출측은 이 id 로 «자기가 넣은 항목»만 다시 떨어낸다 — 문자열·위치로 짝지으면 같은 버킷에 든
+ *   남의 항목(goal-loop 제어 메모 등)까지 지운다.
+ */
 export function enqueuePendingUserInput(
   sessionId: string,
   text: string,
-  onDrained?: (drained: readonly string[]) => void,
-): void {
+  onDrained?: PendingUserInputDrained,
+): string | null {
   const trimmed = text.trim();
-  if (!sessionId || trimmed.length === 0) return;
+  if (!sessionId || trimmed.length === 0) return null;
   const bucket = buckets.get(sessionId) ?? { items: [] };
-  bucket.items.push(trimmed);
+  nextPendingId += 1;
+  const id = `pending-${pendingIdPrefix}-${nextPendingId}`;
+  bucket.items.push({ id, text: trimmed });
   if (onDrained) bucket.onDrained = onDrained;
   buckets.set(sessionId, bucket);
-  debug.log('llm.interjection', 'enqueued', { sessionId, queued: bucket.items.length });
+  debug.log('llm.interjection', 'enqueued', { sessionId, id, queued: bucket.items.length });
+  return id;
 }
 
 /**
@@ -45,12 +64,60 @@ export function enqueuePendingUserInput(
 export function drainPendingUserInput(sessionId: string): string[] {
   const bucket = buckets.get(sessionId);
   if (!bucket || bucket.items.length === 0) return [];
-  const drained = bucket.items;
+  const items = bucket.items;
   bucket.items = [];
-  try { bucket.onDrained?.(drained); } catch { /* 통지 실패가 배수를 막지 않는다 */ }
+  const drained = items.map(item => item.text);
+  // ⭐ 주입 횟수의 정본 관측 — 이 id 들이 지금 루프 경계로 넘어간다(RFC v2 P1 ⓑ · 내용은 남기지 않는다).
+  debug.log('llm.interjection', 'drained', { sessionId, ids: items.map(item => item.id) });
+  try { bucket.onDrained?.(drained, items); } catch { /* 통지 실패가 배수를 막지 않는다 */ }
   return drained;
 }
 
+/**
+ * id 로 항목을 떨어낸다 — 원본 큐가 그 발화를 «다른 길»(턴 종료 승격·되꺼내기·중단 복원)로
+ * 가져갔을 때 부른다. 세션을 몰라도 된다(id 는 프로세스 안에서 유일하다).
+ * 소비자 배수가 아니므로 onDrained 를 부르지 않는다. 지운 수를 낸다.
+ */
+export type PendingUserInputRemovalReason = 'submitted-as-prompt' | 'restored-after-interrupt' | 'recalled' | 'unspecified';
+
+export function removePendingUserInput(
+  ids: readonly string[],
+  reason: PendingUserInputRemovalReason = 'unspecified',
+): number {
+  if (ids.length === 0) return 0;
+  const wanted = new Set(ids);
+  const removedIds: string[] = [];
+  for (const bucket of buckets.values()) {
+    bucket.items = bucket.items.filter(item => {
+      if (!wanted.has(item.id)) return true;
+      removedIds.push(item.id);
+      return false;
+    });
+  }
+  // ⭐ «실제로» 뺀 id 만 남긴다 — 이미 배수·삭제된 id 를 다시 빼려 한 것은 requested 로만 보인다.
+  debug.log('llm.interjection', 'removed', { ids: removedIds, requested: ids.length, removed: removedIds.length, reason });
+  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;
@@ -60,17 +127,20 @@ export function pendingUserInputCount(sessionId: string): number {
  * 턴/세션이 끝나면 버린다 — 남겨 두면 다음 턴에 «유령 발화»가 들어간다.
  * promotedInput 이 있으면 정식 프롬프트로 승격된 그 발화 하나만 떨어낸다.
  * 부분 삭제는 소비자 배수가 아니므로 bucket 과 onDrained 콜백을 보존하고 콜백을 호출하지 않는다.
+ * ⭐ 자기가 넣은 항목을 id 로 떨어내는 일은 `removePendingUserInput(ids)` 가 따로 한다(같은 글이 둘이면 문자열로는 못 가른다).
  */
 export function clearPendingUserInput(sessionId: string, promotedInput?: string): void {
   if (promotedInput === undefined) {
+    const dropped = buckets.get(sessionId)?.items.map(item => item.id) ?? [];
     buckets.delete(sessionId);
+    if (dropped.length > 0) debug.log('llm.interjection', 'discarded', { sessionId, ids: dropped });
     return;
   }
 
   const bucket = buckets.get(sessionId);
   if (!bucket) return;
 
-  const matchIndex = bucket.items.indexOf(promotedInput);
+  const matchIndex = bucket.items.findIndex(item => item.text === promotedInput);
   if (matchIndex === -1) return;
   bucket.items.splice(matchIndex, 1);
 }

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/index.ts

@@ -740,6 +740,12 @@ const SESSION_RUNTIME_TOOL_FAMILY_RULES: SessionRuntimeToolFamilyRule[] = [
     names: ['run_shell'],
     match: () => false,
   },
+  {
+    id: 'ops-ledger',
+    description: 'In-process seat messages and release checklist operations.',
+    names: ['msg_list', 'msg_post', 'msg_ack', 'checklist_list', 'checklist_add', 'checklist_set', 'checklist_edit', 'checklist_move'],
+    match: () => false,
+  },
   {
     // OH8 follow-up (PR-1) — multi-filter run_tests. A coding agent that
     // passes multiple test filters needs to know each one actually ran;
@@ -1735,7 +1741,7 @@ const ESSENTIAL_NATIVE_RULE_IDS = [
 const ESSENTIAL_HOST_FAMILY_IDS = ['self-ops', 'release-read'] as const;
 // Keep this TUI essential addition out of the shared control/agent self-ops family.
 const ESSENTIAL_HOST_EXTRA_NAMES = ['logs_query'] as const;
-const ESSENTIAL_RUNTIME_FAMILY_IDS = ['bash', 'run-shell', 'pty-shell', 'run-tests', 'elanous_skills_list', 'skill_exec', 'code-grounding'] as const;
+const ESSENTIAL_RUNTIME_FAMILY_IDS = ['bash', 'run-shell', 'ops-ledger', 'pty-shell', 'run-tests', 'elanous_skills_list', 'skill_exec', 'code-grounding'] as const;
 const ESSENTIAL_OPTIONAL_TOOL_NAMES = [
   'GetDashboardState',
   'TerminalModalList', 'TerminalModalObserve', 'TerminalModalFocus', 'TerminalModalDetach', 'TerminalModalKill',

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