elanous 0.2.34 → 0.2.36

package/src/repl/index.ts

@@ -47,6 +47,47 @@ import { buildReplayTurnsFromSession } from './replay.js';
 import type { LLMToolSpec, ContentBlock } from '../llm.js';
 import { inspectActiveProvider } from '../provider-summary.js';
 import { parse as parseYaml } from 'yaml';
+import type { PendingTaskNotification } from '../agent/task-notification.js';
+import { dispatchReplMessageTool, isReplMessageTool } from './ops-msg-bridge.js';
+import { buildSeatBootSystemMessages, type SeatBootDeps } from '../dashboard/seat-boot-preamble.js';
+import { installNextTuiSelfHealthTracker } from '../tui/chat/self-health-status.js';
+
+/** Private side channel for the next TUI. Ordinary REPL JSONL stdout is unchanged. */
+const NEXT_TUI_BG_PREFIX = 'ELANOUS_TUI_BG_STATUS\t';
+
+export function createNextTuiBackgroundBridge(sessionId: string, bufferedCount: () => number) {
+  if (process.env.ELANOUS_NEXT_TUI_BG_STATUS !== '1') return null;
+  const { globalAgentRegistry } = require('../agent/registry.js') as typeof import('../agent/registry.js');
+  const { globalTaskNotificationQueue } = require('../agent/task-notification.js') as typeof import('../agent/task-notification.js');
+  const unregisteredPromises = new Set<string>();
+  let last = '';
+  const emit = () => {
+    const tasks = globalAgentRegistry.list();
+    for (const task of tasks) unregisteredPromises.delete(task.id);
+    const running = tasks.filter((task) => task.background && (task.state === 'pending' || task.state === 'running')).length;
+    const frame = JSON.stringify({ sessionId, promised: unregisteredPromises.size > 0, running, pending: globalTaskNotificationQueue.size + bufferedCount() });
+    if (frame === last) return;
+    last = frame;
+    process.stderr.write(`${NEXT_TUI_BG_PREFIX}${frame}\n`);
+  };
+  const done = globalAgentRegistry.onTaskDone(emit);
+  const timer = setInterval(emit, 250);
+  timer.unref();
+  emit();
+  return {
+    beginTurn() { emit(); },
+    observeToolResult(name: string, args: Record<string, unknown>, result: unknown) {
+      if (name !== 'Agent' || args.run_in_background !== true) return;
+      if (!result || typeof result !== 'object') return;
+      const spawned = result as { taskId?: unknown; background?: unknown };
+      if (spawned.background !== true || typeof spawned.taskId !== 'string') return;
+      unregisteredPromises.add(spawned.taskId);
+      emit();
+    },
+    emit,
+    dispose() { clearInterval(timer); done.dispose(); },
+  };
+}
 
 /** REPL public entry — wires whichever input source the caller chose
  *  to the shared turn dispatcher. The CLI command (in src/index.ts)
@@ -141,14 +182,28 @@ function buildReplTools(): {
   })) {
     specs.push(spec);
   }
+  // The ops ledger is a runtime family, so the native-only catalog above
+  // cannot advertise it. Keep the REPL surface limited to seat mail.
+  const ledger = require('../skills/tools/ops-ledger.js') as typeof import('../skills/tools/ops-ledger.js');
+  const ask = require('../skills/tools/msg-ask.js') as typeof import('../skills/tools/msg-ask.js');
+  specs.push(ledger.buildMsgListTool(), ledger.buildMsgPostTool(), ask.buildMsgAskTool(), ledger.buildMsgAckTool());
   const bashMod = require('../skills/tools/index.js') as typeof import('../skills/tools/index.js');
   specs.push(bashMod.buildBashTool());
   dispatchByName.set('Bash', async (args) => bashMod.dispatchBash(args, { cwd: process.cwd() }));
+  // TUI-NEXT-QUEUE-AND-WAKE: the next TUI parent opens an IPC hop only for its own REPL children;
+  // the classic ScheduleWakeup spec is advertised and each call is answered by the parent's scheduler.
+  const wakeMod = require('../tui-client/next-wakeup.js') as typeof import('../tui-client/next-wakeup.js');
+  const wakeup = wakeMod.createReplWakeupTool(process as unknown as import('../tui-client/next-wakeup.js').WakeupIpcProcess);
+  if (wakeup) {
+    specs.push(wakeup.spec);
+    dispatchByName.set(wakeup.spec.name, wakeup.dispatch);
+  }
   const planner = sr.createSearchPlannerState({ maxAutoNarrowCandidates: 2 });
   const dispatch = async (name: string, args: Record<string, unknown>): Promise<unknown> => {
     try {
       const direct = dispatchByName.get(name);
       if (direct) return await direct(args);
+      if (isReplMessageTool(name)) return await dispatchReplMessageTool(name, args);
       return await sr.dispatchSessionRuntimeTool(name, args, {
         signal: undefined,
         userText: '',
@@ -192,6 +247,59 @@ function buildAgentSystemPrompt(
   }
 }
 
+/**
+ * 새 TUI REPL 의 시스템 프롬프트 «한 곳» — 범용 preamble ⊕ 자리 부트 카드(TUI-SESSION-BOOT).
+ *
+ * 새 TUI(`src/tui/entry.ts` → `src/tui-client/local-chat-turn.ts`)는 `elanous repl --json --stdin-jsonl`
+ * 자식으로 턴을 돌린다. 그래서 legacy 대시보드의 `buildDashboardTurnPreamble` 부트 경로는 지나지 않고
+ * «여기»만 지난다 — 자리 역할·미읽음 수를 첫 턴의 모델 입력에 싣는 자리도 여기 하나뿐이다.
+ *
+ * 카드는 `dashboard/seat-boot-preamble.ts` 의 `buildSeatBootSystemMessages` 를 그대로 쓴다(새 주입 로직 없음).
+ * 자리 판정이 서면 카드 한 장(대화마다 한 번 만든 같은 문면) · 자리가 아니면 빈 배열이라 주입 0건이다.
+ * 도구 표면이 꺼져 있으면(`enabledToolNames === undefined`) 종전처럼 범용 preamble 은 빠지고 카드만 남는다.
+ */
+export function buildReplSystemPrompt(ctx: {
+  cfg: UserConfig;
+  /** 도구 표면이 꺼져 있으면 undefined — 그때도 자리 부트 카드는 실린다. */
+  enabledToolNames: readonly string[] | undefined;
+  cwd: string;
+  sessionId?: string | undefined;
+  /** 시험·임베디드 호출부용 시임 — 기본은 실제 홈·msg 원장·process.env. */
+  seatBootDeps?: SeatBootDeps | undefined;
+}): string | undefined {
+  const base = ctx.enabledToolNames === undefined
+    ? undefined
+    : buildAgentSystemPrompt(ctx.cfg, ctx.enabledToolNames);
+  const card = buildSeatBootCardText(ctx);
+  if (card.length === 0) return base;
+  return base === undefined || base.length === 0 ? card : `${base}\n\n${card}`;
+}
+
+/** 자리 부트 카드 문면(system 메시지 0~1개를 이어 붙인 것). 자리가 아니면 ''. */
+function buildSeatBootCardText(ctx: {
+  cwd: string;
+  sessionId?: string | undefined;
+  seatBootDeps?: SeatBootDeps | undefined;
+}): string {
+  try {
+    return buildSeatBootSystemMessages(
+      { cwd: ctx.cwd, ...(ctx.sessionId !== undefined ? { sessionId: ctx.sessionId } : {}) },
+      ctx.seatBootDeps ?? {},
+    )
+      .map((message) => (typeof message.content === 'string' ? message.content : ''))
+      .filter((text) => text.length > 0)
+      .join('\n\n');
+  } catch (error) {
+    // 카드 오류가 턴을 막지는 않지만, 조용히 자리 문맥을 잃지 않도록 실패를 기록한다.
+    debug.log('dashboard.seat-boot', 'card-error', {
+      cwd: ctx.cwd,
+      sessionId: ctx.sessionId,
+      error: error instanceof Error ? error.message : String(error),
+    });
+    return '';
+  }
+}
+
 function loadAttachment(rawPath: string, baseDir: string): PendingAttachment | null {
   const resolved = isAbsolute(rawPath) ? rawPath : resolvePath(baseDir, rawPath);
   if (!existsSync(resolved)) {
@@ -224,10 +332,12 @@ async function runOneTurn(
   tools: ReturnType<typeof buildReplTools> | undefined,
   systemPrompt: string | undefined,
   jsonOutput: boolean,
+  nextTuiDelivery?: { pending: PendingTaskNotification[] },
+  onJsonDelta?: (delta: string) => void,
 ): Promise<{ reply: string; provider: string; model: string | null; durationMs: number; logPath: string | null }> {
   const startedAt = Date.now();
   const replyChunks: string[] = [];
-  const userImages = pendingAttachments.length > 0 ? pendingAttachments.map(a => a.block) : undefined;
+  const userImages = pendingAttachments.length > 0 ? pendingAttachments.map(a => a.block) : [];
   if (!jsonOutput) {
     process.stdout.write('  ');
   }
@@ -238,14 +348,29 @@ async function runOneTurn(
     const { applyToolPolicy } = require('../tool-runtime/tool-policy.js') as typeof import('../tool-runtime/tool-policy.js');
     replToolSpecs = applyToolPolicy(replToolSpecs, { deny: cfg.chat.toolDeny }) ?? replToolSpecs;
   }
+  // The classic dashboard has its own turn preamble. The next TUI's sticky
+  // REPL must deliver this child's completed tasks on the next parent turn.
+  let nextTuiNotifications = '';
+  if (nextTuiDelivery) {
+    const { globalTaskNotificationQueue, renderTaskNotificationsXml } =
+      require('../agent/task-notification.js') as typeof import('../agent/task-notification.js');
+    nextTuiDelivery.pending.push(...globalTaskNotificationQueue.drain());
+    nextTuiNotifications = renderTaskNotificationsXml(nextTuiDelivery.pending);
+  }
+  // Completion output is untrusted task data. Carry it as a user-role content
+  // block for this call, leaving the human prompt and system prompt intact.
+  if (nextTuiNotifications) userImages.unshift({ type: 'text', text: nextTuiNotifications });
   const result = await runTurn({
     userConfig: cfg,
     sessionId,
     userText,
     systemPrompt,
-    userImages,
+    userImages: userImages.length > 0 ? userImages : undefined,
     onDelta: (d) => {
-      if (jsonOutput) replyChunks.push(d);
+      if (jsonOutput) {
+        replyChunks.push(d);
+        onJsonDelta?.(d);
+      }
       else process.stdout.write(d);
     },
     tools: replToolSpecs,
@@ -272,6 +397,8 @@ async function runOneTurn(
       }
     },
   });
+  // A failed turn keeps the buffered notifications for the next JSONL prompt.
+  nextTuiDelivery?.pending.splice(0);
   const reply = jsonOutput ? replyChunks.join('') : '';
   const logPath = (() => {
     try {
@@ -476,11 +603,27 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
     } catch { /* suggestions must not interrupt the REPL */ }
   }
   const sessionIdRef = { current: session.id };
+  const selfHealthTracker = installNextTuiSelfHealthTracker();
+  selfHealthTracker?.setSessionId(session.id);
 
-  const tools = opts.enableTools ? buildReplTools() : undefined;
-  const systemPrompt = tools
-    ? buildAgentSystemPrompt(cfg, tools.specs.map(s => s.name))
-    : undefined;
+  const nextTuiDelivery = process.env.ELANOUS_NEXT_TUI_BG_STATUS === '1'
+    ? { pending: [] as PendingTaskNotification[] } : undefined;
+  const backgroundBridge = createNextTuiBackgroundBridge(session.id, () => nextTuiDelivery?.pending.length ?? 0);
+  const baseTools = opts.enableTools ? buildReplTools() : undefined;
+  const tools = baseTools && backgroundBridge ? {
+    ...baseTools,
+    dispatch: async (name: string, args: Record<string, unknown>) => {
+      const result = await baseTools.dispatch(name, args);
+      backgroundBridge.observeToolResult(name, args, result);
+      return result;
+    },
+  } : baseTools;
+  const systemPrompt = buildReplSystemPrompt({
+    cfg,
+    enabledToolNames: tools?.specs.map(s => s.name),
+    cwd: process.cwd(),
+    sessionId: session.id,
+  });
   const pendingAttachments: PendingAttachment[] = [];
 
   if (!opts.jsonOutput) {
@@ -548,6 +691,7 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         ui.header(`turn ${turnId}${turn.rotate ? ` · ${turn.rotate}` : ''}`);
         console.log(`  ❯ ${turn.prompt}`);
       }
+      backgroundBridge?.beginTurn();
       const result = await runOneTurn(
         cfg,
         sessionIdRef.current,
@@ -556,7 +700,9 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         tools,
         systemPrompt,
         opts.jsonOutput,
+        nextTuiDelivery,
       );
+      backgroundBridge?.emit();
       const failures = applyAsserts(result.reply, turn.asserts, sc.defaults?.asserts, turnId);
       if (opts.jsonOutput) {
         const out = {
@@ -577,7 +723,10 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
       }
       assertFailures += failures.length;
     }
-    if (opts.exitAfterScenario) return assertFailures > 0 ? 2 : 0;
+    if (opts.exitAfterScenario) {
+      backgroundBridge?.dispose();
+      return assertFailures > 0 ? 2 : 0;
+    }
   } // end if (scriptedScenario)
 
   // Phase B — interactive (TTY) or JSONL stdin (pipe).
@@ -608,15 +757,34 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         const att = loadAttachment(ap, process.cwd());
         if (att) turnAttachments.push(att);
       }
-      const result = await runOneTurn(
-        cfg,
-        sessionIdRef.current,
-        turn.prompt,
-        turnAttachments,
-        tools,
-        systemPrompt,
-        true, // JSONL stream → always JSON output
-      );
+      backgroundBridge?.beginTurn();
+      const selfHealth = selfHealthTracker?.snapshot(sessionIdRef.current) ?? null;
+      if (selfHealth && typeof turn.id === 'string') {
+        process.stdout.write(`${JSON.stringify({ event: 'self-health', turnId: turn.id, sessionId: sessionIdRef.current, selfHealth })}\n`);
+      }
+      const turnSystemPrompt = selfHealth ? `${systemPrompt}\n\n${selfHealth.line}` : systemPrompt;
+      let result: Awaited<ReturnType<typeof runOneTurn>>;
+      try {
+        result = await runOneTurn(
+          cfg,
+          sessionIdRef.current,
+          turn.prompt,
+          turnAttachments,
+          tools,
+          turnSystemPrompt,
+          true, // JSONL stream → always JSON output
+          nextTuiDelivery,
+          process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
+            ? (delta) => { process.stdout.write(`${JSON.stringify({ event: 'delta', turnId: turn.id, text: delta })}\n`); }
+            : undefined,
+        );
+      } catch (error) {
+        if (!backgroundBridge) throw error;
+        backgroundBridge.emit();
+        console.log(JSON.stringify({ sessionId: sessionIdRef.current, error: error instanceof Error ? error.message : String(error) }));
+        continue;
+      }
+      backgroundBridge?.emit();
       const failures = applyAsserts(result.reply, turn.asserts, undefined, turn.id ?? 't?');
       const out = {
         turnId: turn.id ?? null,
@@ -627,9 +795,12 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
         durationMs: result.durationMs,
         logPath: result.logPath,
         assertFailures: failures,
+        selfHealth,
       };
       console.log(JSON.stringify(out));
     }
+    backgroundBridge?.dispose();
+    selfHealthTracker?.dispose();
     return 0;
   }
 
@@ -709,6 +880,7 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
     }
     // Ordinary prompt.
     const turnAttachments = pendingAttachments.splice(0);
+    backgroundBridge?.beginTurn();
     await runOneTurn(
       cfg,
       sessionIdRef.current,
@@ -717,10 +889,13 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
       tools,
       systemPrompt,
       opts.jsonOutput,
+      nextTuiDelivery,
     );
+    backgroundBridge?.emit();
     if (exitRequested) break;
     rl.prompt();
   }
+  backgroundBridge?.dispose();
   return 0;
 }
 

package/src/repl/ops-msg-bridge.ts

@@ -0,0 +1,32 @@
+import type { MsgLedgerDeps } from '../skills/tools/ops-ledger.js';
+import type { MsgAskDeps } from '../skills/tools/msg-ask.js';
+
+const MESSAGE_TOOL_NAMES = new Set(['MsgList', 'MsgPost', 'MsgAsk', 'MsgAck']);
+
+/** The next TUI REPL can dispatch only its durable message tools directly.
+ * Other native runtimes keep the REPL's existing unavailable boundary. */
+export function isReplMessageTool(name: string): boolean {
+  return MESSAGE_TOOL_NAMES.has(name);
+}
+
+export async function dispatchReplMessageTool(
+  name: string,
+  args: Record<string, unknown>,
+  deps: { ledger?: MsgLedgerDeps; ask?: MsgAskDeps; signal?: AbortSignal } = {},
+): Promise<Record<string, unknown>> {
+  if (!isReplMessageTool(name)) throw new Error(`not a REPL message tool: ${name}`);
+  const { observeLedgerCall } = await import('../skills/tools/ops-ledger.js');
+  if (name === 'MsgAsk') {
+    const { dispatchMsgAsk } = await import('../skills/tools/msg-ask.js');
+    return observeLedgerCall(name, args,
+      () => dispatchMsgAsk(args, { ...deps.ask, signal: deps.signal ?? deps.ask?.signal }),
+      (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.question.id, replied: r.reply !== null } : {}) }));
+  }
+  const { dispatchMsgList, dispatchMsgPost, dispatchMsgAck } = await import('../skills/tools/ops-ledger.js');
+  if (name === 'MsgList') return observeLedgerCall(name, args, () => dispatchMsgList(args, deps.ledger),
+    (a, r) => ({ to: a.to, ...(r ? { count: r.count, after: r.after } : {}) }));
+  if (name === 'MsgPost') return observeLedgerCall(name, args, () => dispatchMsgPost(args, deps.ledger),
+    (a, r) => ({ from: a.from, to: a.to, ...(r ? { id: r.message.id } : {}) }));
+  return observeLedgerCall(name, args, () => dispatchMsgAck(args, deps.ledger),
+    (a, r) => ({ to: a.to, id: a.id, ...(r ? { cursor: r.cursor } : {}) }));
+}

package/src/seat-loop/knowhow-lint.ts

@@ -139,7 +139,7 @@ interface KnowhowCard {
 }
 
 /** 카드 제목 — `## K-<자리>-<번호>` 뒤에는 줄 끝·공백·콜론·em 대시만 온다. */
-const CARD_HEADING = /^[ \t]{0,3}##\s+(K-[A-Za-z]+-\d+)(?=$|\s|:|—)/u;
+const CARD_HEADING = /^[ \t]{0,3}##\s+(K-[A-Za-z]+(?:-[A-Za-z]{1,4})?-\d+)(?=$|\s|:|—)/u;
 /** 카드처럼 보이는 `##` 제목(예: `## K-OP-7a`) — CARD_HEADING 을 벗어나면 인식 실패로 명시 거부한다. */
 const CARD_HEADING_LIKE = /^[ \t]{0,3}##\s*(K-[^\s:]*)/iu;
 

package/src/self-dev/ask-launch-flow.ts

@@ -44,7 +44,7 @@ import {
   type GoalClarificationSelfResolver,
 } from '../self-implement/goal-author-clarification.js';
 import { classifyReauthoredAsk, countMissingAuthoredConstraintMarkers, askGoalTypeDeclaration, declaredGoalType, parseGoalId } from '../self-implement/goal-author.js';
-import { observeFrontNodeEntry } from './graph-front-nodes.js';
+import { observeFrontNodeEntry, observeFrontNodeExit, observeFrontNodeUnit, type AuthorExitOutcome } from './graph-front-nodes.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { decomposeSelfDevGoal, type SelfDevDecomposeOptions, type SelfDevDecomposition } from './decompose.js';
 import { observeDecomposerSelection, readFabricDecomposeConfig, selectFabricDecomposer } from './self-orchestrate-runtime.js';
@@ -392,7 +392,7 @@ export async function recommendLaunchDecomposition(
       ...(input.runId === undefined ? {} : { runId: input.runId }),
       ...(decomposeGoalType === null ? {} : { goalType: decomposeGoalType }),
     });
-    const result = await Promise.race([
+    const result = await observeFrontNodeUnit('decompose', input.runId ?? process.env.ELANOUS_RUN_ID, decomposeGoalType ?? undefined, () => Promise.race([
       deps.decomposeGoal
         ? deps.decomposeGoal(document!)
         : decomposeSelfDevGoal(document!, {
@@ -401,7 +401,7 @@ export async function recommendLaunchDecomposition(
           observation: prelaunchDecompositionObservation(document!),
         }),
       timeout,
-    ]);
+    ]));
     if (result === timedOut) {
       // ⛔ 「시간 초과」를 「못 쟀다」로 뭉개지 않는다 — 분해기는 «아직 답하는 중»이고
       //   그 답은 `prelaunch-decomposition` 이름으로 «따로» 내려앉는다(위 주석).
@@ -886,7 +886,7 @@ export async function runAskLaunchFlow(
   if (launchPreflight === false) return { kind: 'stopped-before-authoring' };
 
   await deps.beforeAuthoring?.();
-  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = []): Promise<{
+  const authorAndPreflight = async (authorAskText: string = input.askText, machineSuggestedTargetPaths: readonly string[] = [], attempt = 1): Promise<{
     readonly goalFile: string;
     readonly decision: ReturnType<typeof decideAskPreflight>;
   }> => {
@@ -918,6 +918,12 @@ export async function runAskLaunchFlow(
       })(),
       ...(launchPreflight === undefined ? {} : { launchPreflight }),
       selfResolveClarifications: selfResolveClarifications.value,
+    }).catch((error: unknown) => {
+      // GRAPH-AUTHOR-FAIL-EDGE: 저작기가 던진 자리 = author `fail` 출구. ⛔ 관측만 하고 같은 오류를 그대로 다시 던진다.
+      observeFrontNodeExit({ node: 'author', outcome: 'fail' }, {
+        ...frontObservation, attempt, reason: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
     });
     deps.print(`[ask] 저작됨: ${authored.path}`);
     // AUTHOR-TRACE: the authored goal file can be cleaned up later — keep path ⊕ sha256 ⊕ size in the run ledger and
@@ -1064,16 +1070,47 @@ export async function runAskLaunchFlow(
     return { goalFile, decision };
   };
 
+  // GRAPH-AUTHOR-FAIL-EDGE ① — 저작 «끝»의 결과를 그래프 이름으로 남긴다(관측 · 다음 걸음은 아래 코드가 그대로 정한다).
+  const authorNotGrounded = (decision: ReturnType<typeof decideAskPreflight>): boolean =>
+    decision.result.blockers.length > 0 && decision.result.blockers.every((blocker) => blocker.kind === 'no-target-paths');
+  const observeAuthorExit = (
+    attempt: number,
+    result: { readonly goalFile: string; readonly decision: ReturnType<typeof decideAskPreflight> },
+    outcome: AuthorExitOutcome,
+    taken?: { readonly node: string; readonly reason: string },
+  ): void => {
+    const goalType = input.goalType ?? declaredGoalType(input.askText);
+    observeFrontNodeExit({ node: 'author', outcome }, {
+      attempt,
+      goalFile: result.goalFile,
+      ...(input.runId === undefined ? {} : { runId: input.runId }),
+      ...(goalType === null ? {} : { goalType }),
+      ...(taken === undefined ? {} : { taken: taken.node, reason: taken.reason }),
+      ...(outcome === 'not-grounded' ? { blockers: result.decision.result.blockers } : {}),
+    });
+  };
+
   let authored = await authorAndPreflight();
   let reauthored = false;
   const retryableNoTargetPaths = !input.forceRequested
     && !authored.decision.shouldLaunch
     && authored.decision.result.blockers.length > 0
     && authored.decision.result.blockers.every((blocker) => blocker.kind === 'no-target-paths');
+  if (authorNotGrounded(authored.decision)) {
+    // 재시도 대상이면 그래프 답(re-ground) 그대로 · --force 로 재시도를 안 하면 코드가 간 곳을 실제 걸음으로 남긴다.
+    observeAuthorExit(1, authored, 'not-grounded', retryableNoTargetPaths ? undefined : {
+      node: authored.decision.shouldLaunch ? 'plan' : 'needs-human', reason: 'force-requested · no auto re-author',
+    });
+  } else {
+    observeAuthorExit(1, authored, 'ok');
+  }
   if (retryableNoTargetPaths) {
     const first = authored;
     reauthored = true;
     deps.print('[ask] ⑴ ⚠️ 대상 경로를 못 찾아 자동 재저작 한 번을 시도한다');
+    observeFrontNodeExit({ node: 're-ground', outcome: 'retry' }, {
+      attempt: 1, goalFile: first.goalFile, ...(input.runId === undefined ? {} : { runId: input.runId }),
+    });
     let candidates: ReturnType<typeof findAskPathCandidates> = { tokens: [], paths: [] };
     if (parseAskTargetPathHintsResult(input.askText).labelMissing) {
       try {
@@ -1107,7 +1144,9 @@ export async function runAskLaunchFlow(
     recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, outcome: 'started' });
     authored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
-      : input.askText, selectedPaths);
+      : input.askText, selectedPaths, 2);
+    // 두 번째 not-grounded 는 re-ground 예산(max_visits 1)을 넘어 needs-human(근거 카드)으로 — 판정은 observeFrontNodeExit 가 선언에서 읽는다.
+    observeAuthorExit(2, authored, !authored.decision.shouldLaunch && authorNotGrounded(authored.decision) ? 'not-grounded' : 're-authored');
     deps.log('ask-auto-reauthor', {
       candidatePathCount: candidates.paths.length,
       firstGoalFile: first.goalFile,

package/src/self-dev/cli-help-text.ts

@@ -0,0 +1,17 @@
+import { CLI_HARNESS_RUN_ENTRANCE, describeEntranceCommand } from './entrance-registry.js';
+
+/** Shared help text stays independent of the CLI execution graphs.
+ * The deprecated harness help comes from the entrance registry so its
+ * destination and status cannot drift from the declared entrance. */
+export const HARNESS_RUN_REPLACEMENT = 'elanous harness say <objective>';
+export const HARNESS_RUN_DEPRECATION_HELP = describeEntranceCommand(
+  CLI_HARNESS_RUN_ENTRANCE,
+  HARNESS_RUN_REPLACEMENT,
+  '이 입구는 더 이상 실행되지 않습니다.',
+).trimEnd();
+
+/** `dev --plan` help points to this one replacement. */
+export const DEV_PLAN_REPLACEMENT = 'elanous harness say';
+export function formatDevPlanOptionHelp(replacement: string = DEV_PLAN_REPLACEMENT): string {
+  return `은퇴한 staged 하니스 옵션 — 지정하면 명시적으로 거부됨 · 대응 문 \`${replacement}\``;
+}