elanous 0.2.19 → 0.2.21

package/src/cli/release-cli.ts

@@ -45,6 +45,7 @@ import type { PrereleaseKind } from '../../scripts/release-loop/release-version.
 import { releaseReadiness } from '../../scripts/release-loop/release-readiness.js';
 import { runReleaseIfReady } from './release-run-if-ready.js';
 import { formatPreflight, releasePreflight } from '../../scripts/release-loop/preflight.js';
+import { defaultReleaseGraphRunsRoot, formatPublishProposal, measurePublishWindow, proposePublishAt, publishWindowWarning } from '../../scripts/release-loop/publish-window.js';
 import { autoStartScheduledRelease, type AutoStartDeferral } from '../release-loop/auto-start.js';
 import { landingFreezeMessage, LandingFrozenError, readLandingFreeze } from '../release-loop/landing-freeze.js';
 import { formatLightRc, runLightRc, type LightRcDeps } from '../release-loop/light-rc.js';
@@ -609,6 +610,8 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     }
     return hqCliWriteAllowed(command, override, ledgerFenceDeps());
   };
+  // PUBLISH-TIME-FROM-GATE: the measured cut→publish window comes from the same ledger as the schedule (prod by default).
+  const publishMeasure = () => measurePublishWindow({ root: defaultReleaseGraphRunsRoot(scheduleLedgerRoot()) });
   schedule.command('list').option('--json', '결과 JSON').action((o: { json?: boolean }) => {
     const rows = listSchedules(scheduleLedgerRoot());
     if (o.json) console.log(JSON.stringify(rows));
@@ -618,15 +621,27 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .action((o: { version: string; json?: boolean }) => {
       const row = getSchedule(o.version, scheduleLedgerRoot());
       if (!row) throw new CliUserError(`없는 판 일정: ${o.version}`, '판 일정 등록: elanous release schedule set --version <v> --cut-at <iso> --land-by <iso>');
-      if (o.json) console.log(JSON.stringify(row)); else console.log(formatSchedule(row));
+      const measure = publishMeasure();
+      const proposedPublishAt = proposePublishAt(row.cutAt, measure);
+      if (o.json) console.log(JSON.stringify({ ...row, proposedPublishAt, measuredPublishMedianSeconds: measure.medianSeconds, measuredPublishSamples: measure.samples.map(({ version, seconds }) => ({ version, seconds })) }));
+      else { console.log(formatSchedule(row)); console.log(formatPublishProposal(row.cutAt, measure)); }
     });
   schedule.command('set').requiredOption('--version <v>', '갱신할 판')
     .option('--cut-at <iso>', '오프셋 포함 컷 시각').option('--land-by <iso>', '오프셋 포함 착지 마감')
-    .option('--freeze-from <iso>', '동결 시작').option('--freeze-until <iso>', '동결 종료').option('--json', '결과 JSON').option('--hq-override')
-    .action((o: { version: string; cutAt?: string; landBy?: string; freezeFrom?: string; freezeUntil?: string; json?: boolean; hqOverride?: boolean }) => {
-      if (o.cutAt === undefined && o.landBy === undefined && o.freezeFrom === undefined && o.freezeUntil === undefined) throw new CliUserError('갱신할 시각을 지정하라', '--cut-at <iso> 또는 --land-by <iso>');
+    .option('--freeze-from <iso>', '동결 시작').option('--freeze-until <iso>', '동결 종료')
+    .option('--publish-at <iso>', '오프셋 포함 발행 시각(실측 컷→발행 중앙값보다 짧으면 경고 · 제안은 schedule show)')
+    .option('--json', '결과 JSON').option('--hq-override')
+    .action((o: { version: string; cutAt?: string; landBy?: string; freezeFrom?: string; freezeUntil?: string; publishAt?: string; json?: boolean; hqOverride?: boolean }) => {
+      if (o.cutAt === undefined && o.landBy === undefined && o.freezeFrom === undefined && o.freezeUntil === undefined && o.publishAt === undefined) throw new CliUserError('갱신할 시각을 지정하라', '--cut-at <iso> 또는 --land-by <iso> 또는 --publish-at <iso>');
       if (!mayWriteLedger('release schedule set', Boolean(o.hqOverride), scheduleLedgerRoot())) return;
-      const row = setSchedule(o.version, { cutAt: o.cutAt, landBy: o.landBy, freezeFrom: o.freezeFrom, freezeUntil: o.freezeUntil }, process.env.ELANOUS_TRACK || 'cli', scheduleLedgerRoot());
+      const row = setSchedule(o.version, { cutAt: o.cutAt, landBy: o.landBy, freezeFrom: o.freezeFrom, freezeUntil: o.freezeUntil, publishAt: o.publishAt }, process.env.ELANOUS_TRACK || 'cli', scheduleLedgerRoot());
+      // A stored publish time shorter than the measured median warns on stderr (one line) — --json stdout stays parseable.
+      if (row.publishAt && (o.publishAt !== undefined || o.cutAt !== undefined)) {
+        const measure = publishMeasure();
+        const warning = publishWindowWarning(row.cutAt, row.publishAt, measure);
+        debug.log('release.schedule', 'publish-window', { version: row.version, cutAt: row.cutAt, publishAt: row.publishAt, medianSeconds: measure.medianSeconds, samples: measure.samples.length, warned: warning !== null });
+        if (warning) console.error(warning);
+      }
       if (o.json) console.log(JSON.stringify(row)); else console.log(formatSchedule(row));
     });
   release.command('place <id>').description('칸의 우선순위·마감·용량으로 판 배치')

package/src/cli/retro-cli.ts

@@ -0,0 +1,78 @@
+import { existsSync } from 'node:fs';
+import type { Command } from 'commander';
+import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
+
+type RetroFact = { store: string; at: string; category: string; event: string; kind: 'draft-birth' | 'draft-death' | 'stop-reason' | 'ta-outcome'; data: unknown };
+
+const FACT_EVENTS = new Map<string, RetroFact['kind']>([
+  ['rework-blocked-draft-pr', 'draft-birth'],
+  ['lineage-supersede', 'draft-death'],
+  ['resolved', 'stop-reason'],
+  ['decision', 'stop-reason'],
+  ['action', 'ta-outcome'],
+  ['task-agent.action', 'ta-outcome'],
+]);
+
+export function parseRetroSince(value: string, now = Date.now()): number {
+  const match = /^([1-9]\d*)([smhd])$/.exec(value);
+  if (!match) throw new Error('--since requires a positive duration (e.g. 24h)');
+  const duration = Number(match[1]) * ({ s: 1000, m: 60000, h: 3600000, d: 86400000 }[match[2]!] ?? 0);
+  if (!Number.isSafeInteger(duration) || !Number.isSafeInteger(now - duration)) throw new Error('--since duration is out of range');
+  return now - duration;
+}
+
+export function collectRetroFacts(sinceMs: number, targets: readonly { name: string; dbPath: string }[] = [{ name: 'current', dbPath: logsDbPath() }]): { facts: RetroFact[]; unavailable: string[] } {
+  const facts: RetroFact[] = [];
+  const unavailable: string[] = [];
+  const untilMs = Date.now();
+  for (const target of targets) {
+    if (!existsSync(target.dbPath)) { unavailable.push(target.name); continue; }
+    try {
+      const store = LogStore.openReadOnly(target.dbPath);
+      try {
+        let beforeId: number | undefined;
+        for (;;) {
+          const rows = store.query({ sinceMs, beforeId, limit: 1000 });
+          for (const row of rows) {
+            if (Date.parse(row.ts) > untilMs) continue;
+            const kind = FACT_EVENTS.get(row.event);
+            if (!kind || (row.event === 'resolved' && row.category !== 'self-dev.supervisor') || ((row.event === 'task-agent.action' || row.event === 'action') && row.category !== 'task-agent')) continue;
+            let data: unknown;
+            try { data = row.data === null ? null : JSON.parse(row.data); } catch { data = row.data; }
+            const record = data && typeof data === 'object' && !Array.isArray(data) ? data as Record<string, unknown> : {};
+            if (row.event === 'rework-blocked-draft-pr' && (row.category !== 'self-implement' || !Number.isInteger(record.number) || record.skipped || record.error)) continue;
+            if (row.event === 'lineage-supersede' && (row.category !== 'self-implement' || !Array.isArray(record.closed) || record.closed.length === 0)) continue;
+            if (row.event === 'resolved' && typeof record.stopReason !== 'string') continue;
+            if (row.event === 'decision' && (row.category !== 'self-dev.supervisor' || record.action !== 'stop' || typeof record.stopReason !== 'string')) continue;
+            if ((row.event === 'task-agent.action' || row.event === 'action') && (row.category !== 'task-agent' || typeof record.result !== 'string' || !record.result.trim())) continue;
+            facts.push({ store: target.name, at: row.ts, category: row.category, event: row.event, kind, data });
+          }
+          if (rows.length < 1000) break;
+          beforeId = rows.at(-1)!.id;
+        }
+      } finally { store.close(); }
+    } catch { unavailable.push(target.name); }
+  }
+  facts.sort((a, b) => b.at.localeCompare(a.at));
+  return { facts, unavailable };
+}
+
+export function registerRetroCommands(program: Command): void {
+  program.command('retro').description('Read-only retrospective facts from existing logs')
+    .command('facts').description('Draft births/deaths, stop reasons and task-agent outcomes')
+    .option('--since <duration>', 'Lookback duration', '24h')
+    .option('--json', 'JSON output')
+    .action((opts: { since: string; json?: boolean }) => {
+      try {
+        const sinceMs = parseRetroSince(opts.since);
+        const result = { since: new Date(sinceMs).toISOString(), ...collectRetroFacts(sinceMs) };
+        console.log(opts.json ? JSON.stringify(result) : [
+          `retro facts since ${result.since} · ${result.facts.length} facts · unavailable: ${result.unavailable.join(', ') || 'none'}`,
+          ...result.facts.map((fact) => `${fact.at} ${fact.kind} ${fact.category}.${fact.event} ${JSON.stringify(fact.data)}`),
+        ].join('\n'));
+      } catch (error) {
+        console.error(`retro facts: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 2;
+      }
+    });
+}

package/src/cli/tasks-cli.ts

@@ -1,4 +1,6 @@
-import { readFileSync } from 'node:fs';
+import { closeSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { loadRunLedger as loadRunLedgerSync } from '../self-implement/run-ledger.js';
 import { join, resolve } from 'node:path';
 import { InvalidArgumentError, Option, type Command } from 'commander';
 import { debug } from '../debug/log.js';
@@ -8,7 +10,7 @@ import { checklistDevVersion } from '../release-loop/checklist.js';
 import { cardsBoard, countBoardTasks, INTERNAL_PACK_PROJECT, mergeBoards, releasePackBoard, type BoardNode } from '../task-agent/board.js';
 import type { Task } from '../task-orchestrator/types.js';
 import { cardPrNumber, COMPLETION_KINDS, handTask, nextMoveFor, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
-import { refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
+import { readCardSalvageBranch, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
 import { advanceMission, handMission, MissionAdvanceError, openMissionIds, recordPieceRef, type AdvanceMissionResult, type MissionDecompose, type PieceEvidenceReader } from '../task-agent/mission.js';
 
 type TaskRow = Pick<Task, 'id' | 'title' | 'priority' | 'status' | 'createdAt' | 'approval' | 'generatedBy'>;
@@ -32,6 +34,10 @@ export interface TasksCliDeps {
   releaseBoard?: () => BoardNode[];
   /** `tasks show`·`advance` 의 런 근거 읽기(시험 주입) — 기본 = 런 원장(이 우주 ⊕ 연합) ⊕ 호스트 logs 의 Pod job-finished. */
   cardRunEvidence?: CardRunEvidenceDeps;
+  /** HARNESS-PARENT-ON-MSB1 — 원격 부모 카드의 원장 거울(시험 주입). 기본 = ssh 로 `<prodRoot>/remote-parents/<host>/run-ledger`. */
+  remoteLedgerMirror?: (card: TaskCard) => void;
+  /** `tasks parents` 의 낡은 부모 보고 의존(시험 주입). */
+  staleParents?: import('../task-agent/parent-host.js').StaleParentDeps;
 }
 
 /** `<조각id>=<값>` 반복 인자. */
@@ -82,14 +88,147 @@ export function taskLauncherArgv(configDir: string, args: readonly string[]): st
   return [ELANOUS_CLI_ENTRY, '--config-dir', configDir, ...args];
 }
 
-export async function defaultTaskLauncher(args: string[], cwd?: string, context?: TaskLaunchContext, deps: { spawn?: DetachedSpawn } = {}): Promise<void | TaskLaunchReceipt> {
+/** STOP-RECORD launch-failed: 발사 직후 이 창 안에 자식이 비0 으로 끝나면 «발사 실패»로 본다. */
+export const LAUNCH_EARLY_EXIT_WINDOW_MS = 3_000;
+
+export interface DefaultTaskLauncherDeps {
+  spawn?: DetachedSpawn;
+  /** 조기 종료 감시 창(ms) — context(런 id)가 있을 때만 · 0 이면 감시하지 않는다(옛 동작). */
+  earlyExitWindowMs?: number;
+  /** 자식 stderr 를 받을 디렉토리(시험 주입). 기본 = `<tmpdir>/elanous-task-launch`. */
+  stderrDir?: string;
+  /** stop 줄 기록기(시험 주입). 기본 = 런 원장. */
+  writeStop?: import('../self-implement/run-ledger.js').RunLedgerWriter;
+  /** 이미 stop 이 있나(시험 주입). 기본 = 이 우주 런 원장 ⊕ 이 프로세스 기록. */
+  hasStop?: (runId: string) => boolean;
+  /** HARNESS-PARENT-ON-MSB1 — 원격 부모 대상(시험 주입). undefined = 설정·env 에서 푼다 · null = 끔. */
+  parentHost?: import('../task-agent/parent-host.js').ParentHostConfig | null;
+  /** 원격 ssh(시험 주입). */
+  ssh?: import('../task-agent/parent-host.js').SshRunner;
+  /** HQ 발사 동결(holdLaunches) 여부(시험 주입). */
+  launchHoldActive?: () => boolean;
+  /** HQ 판(시험 주입). */
+  localVersion?: string;
+  /** 원격 → 로컬 되돌림 알림(시험 주입). 기본 = stderr 한 줄. */
+  notice?: (line: string) => void;
+}
+
+/**
+ * HARNESS-PARENT-ON-MSB1 — 켜져 있고 발사 전 점검이 통과하면 원격(ssh)에서 부모를 띄운다(PR 까지만 · 병합은 HQ).
+ * 막히면 null — 호출부가 종전 로컬 발사로 간다(관측: task-agent parent-host-fallback).
+ */
+async function tryRemoteParent(args: string[], cwd: string | undefined, context: TaskLaunchContext, deps: DefaultTaskLauncherDeps): Promise<TaskLaunchReceipt | null> {
+  const parentHostModule = await import('../task-agent/parent-host.js');
+  let target = deps.parentHost;
+  if (target === undefined) {
+    const { getUserConfig } = await import('../user-config.js');
+    let configured: Parameters<typeof parentHostModule.resolveParentHost>[0];
+    try { configured = getUserConfig().taskAgent?.parentHost; } catch { configured = undefined; }
+    target = parentHostModule.resolveParentHost(configured);
+  }
+  if (!target) return null;
+  const notice = deps.notice ?? ((line: string) => { try { process.stderr.write(`${line}\n`); } catch { /* ignore */ } });
+  const fallback = (gaps: string[], facts: Record<string, string> = {}): null => {
+    try { debug.log('task-agent', 'parent-host-fallback', { host: target!.host, runId: context.runId, gaps, facts }); } catch { /* fail-soft */ }
+    notice(`[parent-host] ${target!.host} 로 못 띄움 — 로컬 발사로 간다: ${gaps.join(' · ')}`);
+    return null;
+  };
+  if (cwd) return fallback(['project-target-is-local']);
+  let launchHoldActive = false;
+  try {
+    if (deps.launchHoldActive) launchHoldActive = deps.launchHoldActive();
+    else {
+      const { readLandingFreeze } = await import('../release-loop/landing-freeze.js');
+      const { prodInstanceRoot } = await import('../instance/resolve.js');
+      launchHoldActive = readLandingFreeze(prodInstanceRoot())?.holdLaunches === true;
+    }
+  } catch { launchHoldActive = true; /* 못 읽으면 막힌 것으로(fail-closed) */ }
+  const preflight = parentHostModule.preflightParentHost({ target, localVersion: deps.localVersion ?? parentHostModule.localElanousVersion(), launchHoldActive, ...(deps.ssh ? { ssh: deps.ssh } : {}) });
+  if (!preflight.ok) return fallback(preflight.gaps, preflight.facts);
+  try {
+    const launched = parentHostModule.launchRemoteParent(target, args, context.env, deps.ssh);
+    try { debug.log('task-agent', 'parent-host-launched', { host: target.host, runId: context.runId, pid: launched.pid, log: launched.log }); } catch { /* fail-soft */ }
+    return { runId: context.runId, parentHost: { host: target.host, ...(target.configDir ? { configDir: target.configDir } : {}), pid: launched.pid, log: launched.log } };
+  } catch (error) {
+    // «확실히 안 떴다»일 때만 로컬로 — 불확실(ssh 끊김 등)은 던져 카드를 launch-failed 로 남긴다(중복 발사 방지).
+    if (error instanceof parentHostModule.RemoteParentNotLaunchedError) return fallback([error.message]);
+    try { debug.log('task-agent', 'parent-host-launch-uncertain', { host: target.host, runId: context.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+    throw error;
+  }
+}
+
+/** stderr 파일의 첫 비어 있지 않은 줄(최대 4KB 만 읽는다 — 원 로그 꼬리를 싣지 않는다). */
+function firstStderrLine(path: string): string {
+  try {
+    const fd = openSync(path, 'r');
+    try {
+      const buf = Buffer.alloc(4096);
+      const n = readSync(fd, buf, 0, buf.length, 0);
+      return buf.subarray(0, n).toString('utf8').split(/\r?\n/).map((line) => line.trim()).find((line) => line.length > 0) ?? '';
+    } finally { closeSync(fd); }
+  } catch { return ''; }
+}
+
+export async function defaultTaskLauncher(args: string[], cwd?: string, context?: TaskLaunchContext, deps: DefaultTaskLauncherDeps = {}): Promise<void | TaskLaunchReceipt> {
+  if (context) {
+    const remote = await tryRemoteParent(args, cwd, context, deps);
+    if (remote) return remote;
+  }
   const spawn = deps.spawn ?? ((await import('node:child_process')).spawn as unknown as DetachedSpawn);
   const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
   const { prodInstanceRoot } = await import('../instance/resolve.js');
   const configDir = getElanousConfigDirOverride() ?? prodInstanceRoot();
-  // TA-CARD-RUN-LINK: 런 id 를 자식 환경에 얹는다 — `harness say` 의 런(호스트 orchestrate)이 그 id 를 상속한다.
-  await spawnDetachedConfirmed(spawn, process.execPath, taskLauncherArgv(configDir, args), SPAWN_CONFIRM_TIMEOUT_MS, cwd, context?.env);
-  return context ? { runId: context.runId } : undefined;
+  const argv = taskLauncherArgv(configDir, args);
+  const window = context ? deps.earlyExitWindowMs ?? LAUNCH_EARLY_EXIT_WINDOW_MS : 0;
+  if (!context || window <= 0) {
+    // TA-CARD-RUN-LINK: 런 id 를 자식 환경에 얹는다 — `harness say` 의 런(호스트 orchestrate)이 그 id 를 상속한다.
+    await spawnDetachedConfirmed(spawn, process.execPath, argv, SPAWN_CONFIRM_TIMEOUT_MS, cwd, context?.env);
+    return context ? { runId: context.runId } : undefined;
+  }
+  // STOP-RECORD launch-failed: stdio 를 버리면 자식이 exit 2 로 죽어도 흔적이 0 이고 카드는 «launched» 로 남는다
+  // (ORCH-LIVE-1008). stderr 만 파일로 받고(파이프는 부모가 먼저 끝나면 자식을 EPIPE 로 죽인다), 짧은 창 안의 종료를 본다.
+  const stderrDir = deps.stderrDir ?? join(tmpdir(), 'elanous-task-launch');
+  mkdirSync(stderrDir, { recursive: true });
+  const stderrPath = join(stderrDir, `${context.runId}.stderr`);
+  // 'w' — 같은 runId 재발사가 지난 시도의 stderr 를 이번 cause 로 읽지 않게(리뷰 must-fix).
+  const fd = openSync(stderrPath, 'w');
+  let exited: Promise<{ code: number | null; signal: string | null }> | undefined;
+  const watched: DetachedSpawn = (command, spawnArgs, options) => {
+    const child = (spawn as unknown as (c: string, a: string[], o: unknown) => ReturnType<DetachedSpawn>)(command, spawnArgs, { ...options, stdio: ['ignore', 'ignore', fd] });
+    const emitter = child as unknown as { once?: (event: 'exit', listener: (code: number | null, signal: string | null) => void) => unknown };
+    exited = new Promise((done) => { emitter.once?.('exit', (code, signal) => done({ code, signal })); });
+    return child;
+  };
+  try {
+    await spawnDetachedConfirmed(watched, process.execPath, argv, SPAWN_CONFIRM_TIMEOUT_MS, cwd, context.env);
+  } finally {
+    try { closeSync(fd); } catch { /* the child keeps its own copy */ }
+  }
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const early = exited
+    ? await Promise.race([exited, new Promise<undefined>((done) => { timer = setTimeout(() => done(undefined), window); })])
+    : undefined;
+  if (timer) clearTimeout(timer);
+  if (early && early.code !== 0) {
+    const first = firstStderrLine(stderrPath);
+    const cause = `child rc=${early.code ?? early.signal ?? 'unknown'}${first ? `: ${first}` : ''}`;
+    const { boundRunStopCause, recordRunStop, runStopRecorded, RUN_STOP_EVENT } = await import('../self-implement/run-stop.js');
+    const hasStop = deps.hasStop ?? ((id: string) => {
+      if (runStopRecorded(id)) return true;
+      try { return (loadRunLedgerSync(id) ?? []).some((entry) => entry.event === RUN_STOP_EVENT); } catch { return false; }
+    });
+    // 자식이 같은 runId 로 이미 stop 을 썼으면 더하지 않는다(런마다 한 줄 · 리뷰 must-fix).
+    if (hasStop(context.runId)) throw new Error(`발사 직후 자식이 종료했다 — ${boundRunStopCause(cause)}`);
+    const entry = recordRunStop({
+      runId: context.runId, site: 'launch-failed', class: 'launch-failed',
+      cause,
+      evidenceRef: stderrPath,
+      nextMove: 'Fix the launch argv/config from the stderr evidence, then re-hand the card',
+    }, ...(deps.writeStop ? [deps.writeStop] : []));
+    // handTask 가 이 예외로 카드를 `launch-failed` 로 적는다(«launched» 로 남지 않게).
+    throw new Error(`발사 직후 자식이 종료했다 — ${String(entry.data.cause)}`);
+  }
+  return { runId: context.runId };
 }
 
 /** `spawn` 의 필요한 면만(시험 주입). */
@@ -131,6 +270,21 @@ export function spawnDetachedConfirmed(spawnFn: DetachedSpawn, command: string,
   });
 }
 
+/** HARNESS-PARENT-ON-MSB1 — 카드가 원격 부모면 그 런 원장(⊕ Pod 자식)을 HQ 거울로 당긴다. 실패는 관측만(«없음»으로 읽히지 않게). */
+async function mirrorRemoteCardLedger(cardId: string, deps: TasksCliDeps): Promise<void> {
+  let card: TaskCard | undefined;
+  try { card = readTaskCard(cardId, deps.taskStatePath); } catch { return; }
+  if (!card?.parentHost || !card.runId) return;
+  try {
+    if (deps.remoteLedgerMirror) { deps.remoteLedgerMirror(card); return; }
+    const { mirrorRemoteRunLedgers } = await import('../task-agent/parent-host.js');
+    const { prodInstanceRoot } = await import('../instance/resolve.js');
+    mirrorRemoteRunLedgers(card.parentHost, card.runId, prodInstanceRoot());
+  } catch (error) {
+    try { debug.log('task-agent', 'remote-ledger-mirror-failed', { card: cardId, host: card.parentHost.host, runId: card.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+  }
+}
+
 function moveLine(card: TaskCard): string {
   const move = nextMoveFor(card);
   return `${move.kind}${move.command ? ` — elanous ${move.command.map(shellQuote).join(' ')}` : ''} (${move.reason})`;
@@ -365,6 +519,32 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       }
     });
 
+  tasks.command('parents')
+    .description('낡은 하니스 부모 보고(읽기 전용 · 죽이지 않는다) — 나이 ≥ N 시간이고 런 원장이 끝났거나(run-status) Pod 이 없는 `harness say|ask` 부모')
+    .option('--older-than <hours>', '나이 하한(시간)', '6')
+    .option('--no-pods', 'Pod 목록을 재지 않는다(원장 근거만)')
+    .option('--json', 'JSON 출력')
+    .action(async (opts: { olderThan: string; pods?: boolean; json?: boolean }) => {
+      const hours = Number(opts.olderThan);
+      if (!Number.isFinite(hours) || hours < 0) { out(`--older-than 는 0 이상 수다: ${opts.olderThan}`); process.exitCode = 1; return; }
+      const { staleHarnessParents } = await import('../task-agent/parent-host.js');
+      const injected = deps.staleParents ?? {};
+      const loadLedger = injected.loadLedger ?? ((runId: string) => loadRunLedgerSync(runId));
+      let podRuns = injected.podRuns;
+      let labelOf = injected.labelOf;
+      if (!podRuns && opts.pods !== false) {
+        const queue = await import('../harness/harness-queue.js');
+        podRuns = () => queue.readHarnessQueuePodRuns();
+        labelOf = queue.queueRunLabelValue;
+      }
+      const report = staleHarnessParents(hours, { ...injected, loadLedger, ...(podRuns ? { podRuns } : {}), ...(labelOf ? { labelOf } : {}) });
+      try { debug.log('task-agent', 'stale-parents', { olderThanHours: hours, scanned: report.scanned, stale: report.rows.length, podRunsMeasured: report.podRunsMeasured }); } catch { /* fail-soft */ }
+      if (opts.json) { out(JSON.stringify({ olderThanHours: hours, ...report })); return; }
+      out(`하니스 부모 ${report.scanned} · 나이 ≥ ${hours}h 중 낡음 후보 ${report.rows.length}${report.podRunsMeasured ? '' : ' · ⚠ Pod 목록 못 잼(원장 근거만)'} — 읽기 전용(죽이지 않는다)`);
+      out('pid\t나이h\t자리\t판\t런\t사유');
+      for (const row of report.rows) out([row.pid, row.ageHours, row.seat ?? '-', row.version ?? '-', row.runId ?? '-', row.reasons.join(',')].join('\t'));
+    });
+
   tasks.command('board')
     .description('보드 — 프로젝트 › 목표 › 이정표 › 과제. 과제 카드(project·goal·milestone)와 내부 팩(릴리스 체크리스트 = elanous › 판 › 칸)을 합쳐 읽는다(쓰지 않는다)')
     .option('--project <id>', '이 프로젝트만')
@@ -492,6 +672,8 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           // 런 id 가 있으면 원장에서 골 id · PR 을 묶는다(찾았을 때만 적는다 · 실패는 그대로 보인다).
           const bindable = card?.pieces ? card.pieces : card ? [card.id] : [];
           for (const cardId of bindable) {
+            // HARNESS-PARENT-ON-MSB1: 원격 부모 런은 원장이 그 호스트에 있다 — HQ 거울로 먼저 당긴다(읽기 전용).
+            await mirrorRemoteCardLedger(cardId, deps);
             try { await refreshCardRunBinding(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
               // 근거 없음으로 보인다 — 원장 부재와 갈리게 실패는 남긴다.
               try { debug.log('task-agent', 'card-bind-failed', { card: cardId, via: 'show', error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
@@ -523,8 +705,18 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           }
           return;
         }
-        if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card) }));
-        else for (const line of taskCardLines(card)) out(line);
+        // DRAFT-NOT-ARCHIVE: 멈춘 런이 draft PR 대신 남긴 수확 가지(원장 `salvaged`). 못 읽었으면 «못 읽음»(⛔ 없음 아님).
+        let salvage: Awaited<ReturnType<typeof readCardSalvageBranch>> = { salvageBranch: null };
+        try { salvage = await readCardSalvageBranch(card, deps.cardRunEvidence ?? {}); }
+        catch (error) { salvage = { salvageBranch: null, readErrors: [error instanceof Error ? error.message : String(error)] }; }
+        const salvageUnread = !salvage.salvageBranch && !!salvage.readErrors?.length;
+        if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card), salvageBranch: salvage.salvageBranch, ...(salvageUnread ? { salvageBranchUnread: true } : {}) }));
+        else {
+          for (const line of taskCardLines(card)) out(line);
+          if (card.parentHost) out(`부모 호스트: ${card.parentHost.host}${card.parentHost.pid ? ` (pid ${card.parentHost.pid})` : ''} · PR 까지만 — 병합은 HQ${card.parentHost.log ? ` · 로그 ${card.parentHost.host}:${card.parentHost.log}` : ''}`);
+          if (salvage.salvageBranch) out(`수확 가지: ${salvage.salvageBranch} (draft PR 대신)`);
+          else if (salvageUnread) out('수확 가지: 못 읽음(원장 읽기 실패)');
+        }
         return;
       }
       try {

package/src/dashboard/index.ts

@@ -769,6 +769,15 @@ export function clearEscAbortToolState(toolState: EscAbortToolState): void {
   toolState.activeToolNamesByCallId.clear();
 }
 
+export function activeEscHarnessSpace(
+  toolState: EscAbortToolState,
+  spacesByCallId: ReadonlyMap<string, string>,
+): string | null {
+  const active = [...toolState.activeToolNamesByCallId].filter(([, name]) =>
+    (SELF_IMPLEMENT_TOOL_NAMES as readonly string[]).includes(name));
+  return active.length === 1 ? spacesByCallId.get(active[0]![0]) ?? null : null;
+}
+
 /** Reset per-turn ESC tool tracking before a new stream runtime begins. */
 export function createDashboardTurnStreamRuntimeEscBoundary(toolState: EscAbortToolState): void {
   clearEscAbortToolState(toolState);
@@ -1324,6 +1333,8 @@ import {
   PULSE_HALF_PERIOD_MS,
 } from '../agent-activity-hud.js';
 import { DASHBOARD_CLARIFICATION_REQUEST, consumeStreamingTopModalEscape, createEscAbortGate, createHarnessEscHint, routeStreamingEscapeKey } from '../esc-abort-gate.js';
+import { enqueueSoftStop, readSoftStopRequestStatus } from '../harness/control-inbox.js';
+import { setSelfImplementSoftStopSpaceObserver } from '../self-implement/self-implement-runtime.js';
 import { createViEditor, type ViEditorHandle } from '../vi-editor.js';
 import { launchEditor, canLaunchEditor } from '../editor-launcher.js';
 import { createSshPickerModal } from '../ssh/ssh-picker-modal.js';
@@ -6700,6 +6711,13 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
    * this function is invoked.
    */
   const escAbortToolState = createEscAbortToolState();
+  const escHarnessSpacesByCallId = new Map<string, string>();
+  setSelfImplementSoftStopSpaceObserver((callId, spaceId) => {
+    const toolName = escAbortToolState.activeToolNamesByCallId.get(callId);
+    if (toolName && (SELF_IMPLEMENT_TOOL_NAMES as readonly string[]).includes(toolName)) {
+      escHarnessSpacesByCallId.set(callId, spaceId);
+    }
+  });
   let clarificationModalId: string | null = null;
 
   const attachChatStreamingKeys = (abortCtrl: AbortController): () => void => {
@@ -6713,6 +6731,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     // so the user can make an informed call.
     let abortGateModalId: string | null = null;
     const showHarnessEscHint = createHarnessEscHint((line) => pushChatLine(line));
+    let stoppedHarnessSpace: string | null = null;
+    const activeHarnessSpace = (): string | null => activeEscHarnessSpace(escAbortToolState, escHarnessSpacesByCallId);
     const escGate = createEscAbortGate({
       abortCtrl,
       getRunningCount: () => getEscAbortRunningCount(escAbortToolState),
@@ -6726,14 +6746,25 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       requestRedraw: () => draw(),
       getTheme: () => currentThemeTokens(),
       getWaitingTargetNames: () => getEscAbortWaitingToolNames(escAbortToolState),
+      shouldAbortImmediately: () => activeHarnessSpace() !== null,
       onAbortPending: ({ targets }) => {
-        if (!showHarnessEscHint(targets)) {
+        const spaceId = activeHarnessSpace();
+        if (spaceId) {
+          try {
+            enqueueSoftStop(spaceId);
+            if (readSoftStopRequestStatus(spaceId).status !== 'present') throw new Error('soft-stop marker not persisted');
+            stoppedHarnessSpace = spaceId;
+            pushChatLine('  ⏹ 멈췄다 — 해당 하니스 런에 중단 요청을 보냈습니다.');
+          } catch {
+            pushChatLine('  ⚠ 하니스 런 중단 요청을 보내지 못했습니다. /harness runs 에서 확인해 주세요.');
+          }
+        } else if (!showHarnessEscHint(targets)) {
           pushChatLine(`  ⏳ 중단 요청됨 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
         }
         chatScrollOffset = -1;
       },
       onAbortRepeat: ({ repeat, targets }) => {
-        if (!showHarnessEscHint(targets)) {
+        if (!stoppedHarnessSpace && !showHarnessEscHint(targets)) {
           pushChatLine(`  ⏳ ESC 재시도 ${repeat}회 — ${formatEscAbortWaitingTargets(targets)} 종료를 기다리는 중입니다.`);
         }
         chatScrollOffset = -1;
@@ -7251,7 +7282,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     return () => {
       cleanup();
       escGate.dispose();
-      settleEscAbortPendingLines(chatLines, chatLinesStartIndex);
+      if (!stoppedHarnessSpace) settleEscAbortPendingLines(chatLines, chatLinesStartIndex);
       userScrolledDuringStream = false;
       streamingInFlight = false;
     };
@@ -15674,6 +15705,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             pushChatLine,
             draw,
             signal: acpTurnRef.abortCtrl?.signal ?? new AbortController().signal,
+            toolCallId: ctx?.callId,
             // ⛔⭐ 폴백은 `''` 가 아니라 `undefined` 다 — 「안 넘김」과 「말했는데 어휘가 없음」은 «다른 값»이다.
             //   harnessMentionState(session-runtime 소비처)는 `undefined → 'absent'` · `'' → 'not-matched'` 로
             //   가른다. `?? ''` 로 접으면 그 둘이 같은 값이 되고, 그것이 2026-08-06 에 「TUI 가 하니스에게
@@ -15695,9 +15727,10 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             ptyDashboardOn:
               uc.shell.allowDashboardPty === true && (acpPtyAvailable?.() ?? false),
             getToolRuntime: (toolName) => runtime.getToolRuntime(toolName),
-            dispatchToolRuntime: (toolName, input) =>
+            dispatchToolRuntime: (toolName, input, toolCallId) =>
               runtime.dispatchToolByName(toolName, input, {
                 surface: 'tui',
+                toolCallId,
                 signal: acpTurnRef.abortCtrl?.signal,
                 // ⭐ Agent-family context. Without these two the sub-agent runs
                 //  text-only (see getTools above). `agentDispatchTool` routes the
@@ -19171,6 +19204,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
             createTurnStreamRuntime: (initialAssistantStart) => {
               latestTurnUsage = undefined;
               createDashboardTurnStreamRuntimeEscBoundary(escAbortToolState);
+              escHarnessSpacesByCallId.clear();
               liveTypeaheadEchoes.length = 0;
               const toolRendering = {
                 ...getUserConfig().chat.rendering.tool,
@@ -19225,6 +19259,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
                   const toolCall = call as DashboardTurnStreamCall;
                   turnStreamRuntime.onToolResult(toolCall);
                   settleEscAbortToolCall(escAbortToolState, toolCall);
+                  escHarnessSpacesByCallId.delete(toolCall.id);
                 },
               };
             },
@@ -19524,6 +19559,7 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
     closeDashboardTui();
     throw err;
   } finally {
+    setSelfImplementSoftStopSpaceObserver(null);
     if (tuiSeatAskTimer) clearInterval(tuiSeatAskTimer);
   }
 }

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -1505,15 +1505,16 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps, decideLedg
 
   registry.register(['help', '?'], (_args, ctx) => {
     const { cols, rows } = termSize();
+    // The transient modal paints only height - 2 content rows and does not scroll.
+    // The builder adds columns to fit that budget; only when it still overflows, use the scrollable chat log.
+    const minHeight = Math.min(6, Math.max(3, rows - 2));
+    const modalContentRows = Math.max(minHeight, Math.min(rows - 4, Math.floor(rows * 0.7))) - 2;
     const lines = buildEssentialHelpLines({
       names: registry.names(),
       descriptions: SLASH_COMMANDS,
       width: Math.max(1, Math.floor(cols * 0.7) - 2),
+      maxRows: modalContentRows,
     });
-    // The transient modal paints only height - 2 content rows and does not scroll.
-    // When the catalog outgrows it, use the scrollable chat log instead of hiding keys.
-    const minHeight = Math.min(6, Math.max(3, rows - 2));
-    const modalContentRows = Math.max(minHeight, Math.min(rows - 4, Math.floor(rows * 0.7))) - 2;
     if (ctx.showHelpModal && lines.length <= modalContentRows) {
       ctx.showHelpModal({ title: 'Dashboard help', lines });
     } else {