elanous 0.2.20 → 0.2.21

package/src/browser-cdp/client.ts

@@ -7,11 +7,9 @@
 // `{id, method, params}` messages, receive `{id, result}` or
 // `{id, error}`.
 //
-// Scope kept narrow: navigate + screenshot + evaluate + close.
-// The MVP targets "open a page for the user to see + capture a
-// PNG" which covers the display-plus-screenshot flow the plan
-// describes. Full Puppeteer feature parity is explicitly out of
-// scope.
+// Scope kept narrow: navigation, capture, evaluation and CDP input.
+// Approval of mutating actions belongs to the caller, not this transport.
+// Full Puppeteer feature parity is explicitly out of scope.
 
 import { CHROME_NO_KEYCHAIN_FLAGS } from './chrome-flags.js';
 import { spawn, type ChildProcess } from 'node:child_process';
@@ -126,6 +124,8 @@ export interface CdpClient {
   setScriptExecutionDisabled(value: boolean): Promise<void>;
   /** Dispatch one primary-button click at viewport coordinates. */
   click?(coordinates: { x: number; y: number }): Promise<void>;
+  /** Insert text at the focused element (approval is the caller's responsibility). */
+  input?(text: string): Promise<void>;
   /** Dispose — closes Chrome + WebSocket. */
   close(): Promise<void>;
   readonly isAlive: boolean;
@@ -513,6 +513,11 @@ async function buildClientFromTransport(
       await runOnPage('Input.dispatchMouseEvent', { type: 'mousePressed', ...params });
       await runOnPage('Input.dispatchMouseEvent', { type: 'mouseReleased', ...params });
     },
+    async input(text) {
+      // Newlines can submit a form even without an Enter key event.
+      if (/[\r\n]/.test(text)) throw new Error('CDP input refuses newlines');
+      await runOnPage('Input.insertText', { text });
+    },
     async close() {
       if (!alive) return;
       alive = false;

package/src/cli/ops-cli.ts

@@ -213,6 +213,17 @@ opsCmd.command('status').description('현재 상태 종합(미션·태스크·
     }
     return o.allInstances ? runOpsFleet(o.json === true, o.includeTest === true) : runOps('snapshot', o);
   });
+// OPS-OVERVIEW-CLI (RFC-ops-overview-flow-health-cli-2026-10-08) — 판정 먼저 · 이유 사슬 · 절. 못 잼 = null(0 아님).
+opsCmd.command('overview').description('흐름 한 장 — 저작→구현→착지가 흐르나(판정 먼저·이유 사슬) · 판·일꾼·기계·착지·루프 · 못 잼은 null · exit 0=흐름 정상/저하 3=그 밖 1=수집 실패')
+  .option('--json', '칸 꼴 그대로 ⊕ 머리 {verdict, reasons, nextActions, meta.elapsedMs}')
+  .option('--watch [seconds]', '주기 재조회(기본 30초)')
+  .option('--since <window>', '착지 창(<n>m|h|d · 기본 1h)', '1h')
+  .option('--owner <owner>', '일꾼 절 거르기 — seat:TC · TC · unassigned · all')
+  .option('--version <v>', '판(기본: 다음 컷)')
+  .action(async (o: { json?: boolean; watch?: string | boolean; since?: string; owner?: string; version?: string }) => {
+    const { runOpsOverview } = await import('./ops-overview-cli.js');
+    process.exitCode = await runOpsOverview(o);
+  });
 opsCmd.command('health').description('이상 판정만(blocked·errored·stale)').option('--json')
   .action((o: OpsOpts) => runOps('health', o));
 opsCmd.command('timeline').description('상태 전이 최근순 통합')

package/src/cli/ops-overview-cli.ts

@@ -0,0 +1,50 @@
+import { debug } from '../debug/log.js';
+import { collectOverview, parseSince } from '../ops/overview-collect.js';
+import { computeVerdict, renderOverview, unmeasuredCells, verdictExitCode, VERDICT_LABEL } from '../ops/overview.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+export interface OpsOverviewOptions { json?: boolean; watch?: string | boolean; since?: string; owner?: string; version?: string }
+
+/** 한 번 모아서 내고 exit code 를 돌려준다(RFC §A4: flowing·degraded 0 · 그 밖 3 · 수집 실패 1). */
+async function once(o: OpsOverviewOptions, previous: string | null): Promise<{ code: number; verdict: string | null }> {
+  const started = performance.now();
+  let since: { ms: number; label: string };
+  try { since = parseSince(o.since); } catch (error) { console.error(String((error as Error).message)); return { code: 1, verdict: null }; }
+  try {
+    const snapshot = await collectOverview({ sinceMs: since.ms, sinceLabel: since.label, ...(o.owner ? { owner: o.owner } : {}), ...(o.version ? { version: o.version } : {}) });
+    const result = computeVerdict(snapshot);
+    const elapsedMs = Math.round(performance.now() - started);
+    const unmeasured = unmeasuredCells(snapshot);
+    debug.log('ops.overview', 'computed', { verdict: result.verdict, elapsedMs, unmeasured });
+    debug.flush();
+    if (o.json) {
+      await writeStdoutJson(JSON.stringify({ verdict: result.verdict, verdictLabel: VERDICT_LABEL[result.verdict], reasons: result.reasons, nextActions: result.nextActions,
+        meta: { elapsedMs, source: 'local', unmeasured }, ...snapshot }, null, 2) + '\n');
+    } else {
+      const text = renderOverview(snapshot, result, { elapsedMs });
+      if (previous !== null && previous !== result.verdict) console.log(`🔔 판정 바뀜: ${previous} → ${result.verdict}`);
+      console.log(text);
+    }
+    return { code: verdictExitCode(result.verdict), verdict: result.verdict };
+  } catch (error) {
+    debug.log('ops.overview', 'failed', { reason: String(error) });
+    debug.flush();
+    console.error(`ops overview 수집 실패: ${String(error)}`);
+    return { code: 1, verdict: null };
+  }
+}
+
+export async function runOpsOverview(o: OpsOverviewOptions): Promise<number> {
+  // 독립 CLI 프로세스는 데몬 StoreSink 를 물려받지 않는다 — 등록 없이는 debug.log 가 logs.db 에 안 닿는다(관측 안 한 것).
+  try { await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('cli'); } catch { /* fail-open */ }
+  if (o.watch === undefined || o.watch === false) return (await once(o, null)).code;
+  const seconds = o.watch === true ? 30 : Number(o.watch);
+  if (!Number.isFinite(seconds) || seconds < 5) { console.error('--watch 는 5초 이상'); return 1; }
+  let previous: string | null = null;
+  for (;;) {
+    if (!o.json) process.stdout.write('\x1b[2J\x1b[H');
+    const r = await once(o, previous);
+    previous = r.verdict ?? previous;
+    await new Promise((res) => setTimeout(res, seconds * 1000));
+  }
+}

package/src/cli/pod-cli.ts

@@ -151,6 +151,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
       try {
         const result = await run({
           command: commandArgs,
+          returnLogs: true,
           ...(opts.pool ? { pool: opts.pool } : {}),
           ...(skills.length ? { skills } : {}),
           ...(opts.llm === 'grok' ? { llm: 'grok' as const } : {}),

package/src/cli/tasks-cli.ts

@@ -34,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>=<값>` 반복 인자. */
@@ -97,6 +101,60 @@ export interface DefaultTaskLauncherDeps {
   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 만 읽는다 — 원 로그 꼬리를 싣지 않는다). */
@@ -112,6 +170,10 @@ function firstStderrLine(path: string): string {
 }
 
 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');
@@ -208,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})`;
@@ -442,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>', '이 프로젝트만')
@@ -569,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 */ }
@@ -608,6 +713,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
         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('수확 가지: 못 읽음(원장 읽기 실패)');
         }

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/esc-abort-gate.ts

@@ -55,6 +55,8 @@ export interface EscAbortGateDeps {
   getTheme?: () => ThemeTokens | null | undefined;
   /** Names shown/logged while a turn abort request is waiting for running work to unwind. */
   getWaitingTargetNames?: () => readonly string[];
+  /** Only an identified foreground harness run may bypass the sub-agent confirmation. */
+  shouldAbortImmediately?: () => boolean;
   /** Called before abortTurnOnly so the UI can paint a visible pending state immediately. */
   onAbortPending?: (event: { running: number; repeat: number; targets: readonly string[] }) => void;
   /** Called when another Escape arrives after the first abort request. */
@@ -211,7 +213,7 @@ export function createEscAbortGate(deps: EscAbortGateDeps): EscAbortGate {
         return;
       }
       const running = deps.getRunningCount();
-      if (running <= 0) {
+      if (running <= 0 || deps.shouldAbortImmediately?.()) {
         debug.log('esc.abort', 'abort-immediately', { running, repeat: Math.max(0, escapePresses - 1) });
         abortPendingTurn(running);
         return;

package/src/graph-runner/graph-cli.ts

@@ -94,6 +94,63 @@ export function registerGraphCommands(program: Command, runsDeps: { root?: strin
         process.exitCode = 1;
       }
     });
+  graph.command('wizard <prompt>')
+    .description('말 한 줄로 그래프 YAML 을 짓고 같은 검증기 ⊕ graph run --dry-run 으로 확인한다(저장하지 않는다) — --from 이면 그 그래프를 고친다')
+    .option('--kind <kind>', 'harness | workflow', 'harness')
+    .option('--from <file>', '고칠 그래프 YAML (편집 경로)')
+    .option('--out <file>', 'YAML 을 이 파일에 쓰고, 하니스면 같은 폴더에 recipes.yaml 도 쓴다(있으면 덮지 않는다)')
+    .option('--json', '결과를 JSON 으로')
+    .option('--run', '생성된 그래프의 dry-run 경로를 보여 준다(--dry-run 과 함께만)')
+    .option('--dry-run', '--run 과 함께: 명령을 실행하지 않고 경로만 걷는다')
+    .action(async (prompt: string, opts: { kind: string; from?: string; out?: string; json?: boolean; run?: boolean; dryRun?: boolean }) => {
+      try {
+        if (opts.kind !== 'harness' && opts.kind !== 'workflow') throw new Error('--kind must be harness or workflow');
+        if (opts.run && !opts.dryRun) throw new Error('--run is only supported with --dry-run (run the saved graph with `elanous graph run <file>`)');
+        if (opts.run && opts.kind !== 'harness') throw new Error('--run --dry-run walks harness graphs only');
+        await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('graph');
+        const { generateGraphFromPrompt } = await import('../graph-wizard/generate.js');
+        const currentYaml = opts.from ? readFileSync(opts.from, 'utf8') : undefined;
+        const started = Date.now();
+        const result = await generateGraphFromPrompt({ prompt, kind: opts.kind, ...(currentYaml ? { currentYaml } : {}) });
+        const ms = Date.now() - started;
+        let recipesNote: string | undefined;
+        if (opts.out) {
+          const { writeFileSync } = await import('node:fs');
+          const { dirname } = await import('node:path');
+          writeFileSync(opts.out, result.yaml);
+          if (result.recipes) {
+            const recipesPath = join(dirname(resolve(opts.out)), 'recipes.yaml');
+            if (existsSync(recipesPath) && readFileSync(recipesPath, 'utf8') !== result.recipes) recipesNote = `recipes.yaml 이 이미 있어 덮지 않았다: ${recipesPath}`;
+            else { writeFileSync(recipesPath, result.recipes); recipesNote = `recipes ${recipesPath}`; }
+          }
+        }
+        if (opts.json) {
+          await writeStdoutJson(JSON.stringify({ ...result, ms, ...(recipesNote ? { recipesNote } : {}) }) + '\n');
+        } else {
+          if (!opts.out) process.stdout.write(result.yaml);
+          console.log(`# ${result.ok ? 'ok' : 'invalid'} · id ${result.id} · base ${result.base ?? '-'} · attempts ${result.attempts} · ${(ms / 1000).toFixed(1)}s${opts.out ? ` · saved ${opts.out}` : ''}`);
+          console.log(`# ${result.summary}`);
+          if (recipesNote) console.log(`# ${recipesNote}`);
+          for (const issue of result.issues) console.log(`# issue: ${issue}`);
+          if (result.dryRun && (opts.run || !result.ok)) console.log(`# dry-run ${result.dryRun.status}: ${result.dryRun.path.join(' → ')}`);
+        }
+        if (!result.ok) process.exitCode = 1;
+      } catch (error) {
+        console.error(`graph wizard: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
+  graph.command('step <step>')
+    .description('그래프 마법사 단계 하나를 실행한다(graph run 의 cmd 노드가 부른다 · 마지막 줄 JSON {outcome})')
+    .option('--arg <text>', '단계 인자')
+    .option('--retries <n>', '실패하면 이 횟수만큼 다시 시도', '0')
+    .action(async (step: string, opts: { arg?: string; retries: string }) => {
+      const { runWizardStepWithRetries } = await import('../graph-wizard/steps.js');
+      const result = runWizardStepWithRetries(step, opts.arg, Number.parseInt(opts.retries, 10) || 0);
+      if (result.error) console.error(result.error);
+      console.log(JSON.stringify({ outcome: result.outcome, tries: result.tries, ...(result.text ? { text: result.text.slice(0, 20_000) } : {}), ...(result.error ? { error: result.error } : {}) }));
+      if (result.outcome === 'fail') process.exitCode = 1;
+    });
   graph.command('tick <file>')
     .description('Advance one graph run, resuming a pending decision or starting only when requested')
     .option('--start', 'Start a new run when the graph is idle')

package/src/graph-runner/graph-run-api.ts

@@ -13,6 +13,8 @@ import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { jsonResponse } from '../nexus/api/json-response.js';
 import { defaultGraphsDir } from '../self-implement/graph-templates.js';
 import { runGraph, type GraphRunState } from './runner.js';
+import { readWizardSteps, wizardRecipesFor } from '../graph-wizard/saved-steps.js';
+import { stringify as stringifyYaml } from 'yaml';
 
 const GRAPH_ID = /^[a-z0-9-]+$/;
 const RUN_ID = /^ed-[a-z0-9]+-[a-f0-9]{6}$/;
@@ -148,6 +150,17 @@ export function handleGraphRunStart(rawId: string, deps: GraphRunApiDeps = {}):
     recipeText = readFileSync(recipesFile, 'utf8');
     const parsed: unknown = parseYaml(recipeText);
     allowed = new Set(parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? Object.keys(parsed) : []);
+    // GRAPH-WIZARD-SAVE-RECIPES — a wizard graph's own steps (saved as a validated sidecar) become recipes here,
+    // generated by the server from the step library; they take precedence for the nodes that carry them.
+    const steps = readWizardSteps(mineDirOf(deps), id, readFileSync(mine.file, 'utf8'));
+    const generated = steps ? wizardRecipesFor(readFileSync(mine.file, 'utf8'), steps) : {};
+    if (Object.keys(generated).length) {
+      const base = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+      const merged = { ...base, ...generated };
+      recipeText = stringifyYaml(merged);
+      allowed = new Set(Object.keys(merged));
+      debug.log('graphs.run', 'wizard-recipes', { id, nodes: Object.keys(generated) });
+    }
   } catch {
     return jsonResponse({ error: 'recipes-unavailable' }, 503);
   }

package/src/graph-wizard/archetypes.ts

@@ -0,0 +1,88 @@
+/**
+ * 마법사 «원형» — 사람이 말로 자주 시키는 일의 뼈대 셋. graphs/** 의 운영 템플릿(개발·출시 루프)은
+ * «모아서 요약해 보내기» 같은 말과 낱말이 안 겹쳐 엉뚱한 기반(lecture-note)을 골랐다(10-08 라이브 실측).
+ * 원형은 기반 후보 «맨 앞»에 서고, 키워드가 겹치는 만큼 점수를 얻는다.
+ */
+export interface WizardArchetype { id: string; description: string; keywords: string[]; text: string }
+
+export const WIZARD_ARCHETYPES: readonly WizardArchetype[] = [
+  {
+    id: 'wizard-collect-summarize-send',
+    description: '모아서 요약해 보내기 — 검색·수집 → 요약 → 텔레그램/알림 발송 (브리핑·다이제스트·동향)',
+    keywords: ['뉴스', '모아', '수집', '검색', '찾아', '요약', '정리', '보내', '알려', '텔레그램', '브리핑', '동향', '소식', 'news', 'digest', 'summary'],
+    text: `graph_id: wizard-collect-summarize-send
+loop:
+  title: 모아서 요약해 보내기
+  description: 검색으로 모은 내용을 요약해 텔레그램으로 보낸다
+  trigger:
+    cron: "0 8 * * *"
+version: 1
+entry_node: collect
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: collect, kind: agent, recipe: 'cmd:collect', max_visits: 1 }  # 수집 | web-search | 검색어
+  - { node_id: summarize, kind: agent, recipe: 'cmd:summarize', max_visits: 1 }  # 요약 | summarize | 핵심 5줄 한국어
+  - { node_id: send, kind: agent, recipe: 'cmd:send', max_visits: 1 }  # 텔레그램 발송 | telegram-send
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: collect, on: outcome, map: { ok: summarize, fail: failed } }
+  - { from: summarize, on: outcome, map: { ok: send, fail: failed } }
+  - { from: send, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+  {
+    id: 'wizard-review-merge',
+    description: 'PR 리뷰 후 머지 — 리뷰 → must-fix 없으면 승인 뒤 머지 (있으면 멈추고 알림)',
+    keywords: ['pr', '리뷰', '머지', '병합', '풀리퀘', 'must', 'fix', 'review', 'merge'],
+    text: `graph_id: wizard-review-merge
+loop:
+  title: PR 리뷰 후 머지
+  description: PR 을 리뷰하고 must-fix 가 없으면 머지한다
+  trigger:
+    events: [pr-opened]
+version: 1
+entry_node: review
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: review, kind: judge, recipe: 'cmd:review', max_visits: 1 }  # PR 리뷰 | gh-pr-review
+  - { node_id: approve-merge, kind: hitl, recipe: 'approval:approve-merge', max_visits: 1 }  # 머지 승인 | approval
+  - { node_id: merge, kind: git, recipe: 'cmd:merge', max_visits: 1 }  # PR 머지 | gh-pr-merge
+  - { node_id: notify, kind: agent, recipe: 'cmd:notify', max_visits: 1 }  # must-fix 알림 | notify-me | PR 에 must-fix 가 있어 머지하지 않았다
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: review, on: outcome, map: { ok: approve-merge, must-fix: notify, fail: failed } }
+  - { from: approve-merge, on: outcome, map: { ok: merge, fail: failed } }
+  - { from: merge, on: outcome, map: { ok: done, fail: failed } }
+  - { from: notify, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+  {
+    id: 'wizard-research-approve-publish',
+    description: '조사해 정리하고 승인 뒤 게시 — 조사 → 표/초안 정리 → 사람 승인 → 게시',
+    keywords: ['조사', '가격', '경쟁', '표', '정리', '승인', '올려', '게시', '노션', '초안', '블로그', '보고서'],
+    text: `graph_id: wizard-research-approve-publish
+loop:
+  title: 조사해 정리하고 승인 뒤 게시
+  description: 조사한 내용을 표로 정리하고 사람 승인 뒤 게시한다
+  trigger:
+    events: [manual]
+version: 1
+entry_node: research
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: research, kind: agent, recipe: 'cmd:research', max_visits: 1 }  # 조사 | web-search | 조사 주제
+  - { node_id: tabulate, kind: agent, recipe: 'cmd:tabulate', max_visits: 1 }  # 표로 정리 | llm | 결과를 마크다운 표로 정리
+  - { node_id: approve, kind: hitl, recipe: 'approval:approve', max_visits: 1 }  # 게시 승인 | approval
+  - { node_id: publish, kind: agent, recipe: 'cmd:publish', max_visits: 1 }  # 게시 | custom | 게시처에 올리기
+  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }  # 완료
+  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }  # 실패
+edges:
+  - { from: research, on: outcome, map: { ok: tabulate, fail: failed } }
+  - { from: tabulate, on: outcome, map: { ok: approve, fail: failed } }
+  - { from: approve, on: outcome, map: { ok: publish, fail: failed } }
+  - { from: publish, on: outcome, map: { ok: done, fail: failed } }
+`,
+  },
+];