elanous 0.2.32 → 0.2.35

package/src/repl/index.ts

@@ -47,6 +47,46 @@ 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';
+
+/** 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,6 +181,11 @@ 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() }));
@@ -149,6 +194,7 @@ function buildReplTools(): {
     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 +238,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 +323,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 +339,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 +388,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 {
@@ -477,10 +595,24 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
   }
   const sessionIdRef = { current: 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 +680,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 +689,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 +712,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 +746,29 @@ 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();
+      let result: Awaited<ReturnType<typeof runOneTurn>>;
+      try {
+        result = await runOneTurn(
+          cfg,
+          sessionIdRef.current,
+          turn.prompt,
+          turnAttachments,
+          tools,
+          systemPrompt,
+          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,
@@ -630,6 +782,7 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
       };
       console.log(JSON.stringify(out));
     }
+    backgroundBridge?.dispose();
     return 0;
   }
 
@@ -709,6 +862,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 +871,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/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}\``;
+}

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

@@ -66,14 +66,9 @@ import { resolveModelAlias } from '../intelligence-map/model-alias.js';
 import { BUILTIN_CATALOG } from '../intelligence-map/model-catalog.js';
 import { BEDROCK_DEFAULT_MODEL, BEDROCK_MODELS, findBedrockModel, resolveBedrockModelId } from '../llm/bedrock.js';
 import { ZAI_CODING_DEFAULT_MODEL, ZAI_CODING_MODELS } from '../llm/zai-coding-plan.js';
-
-/** `dev --plan` 도움말이 가리키는 대응 문. ⛔ 도움말에 이 문자열을 리터럴로 다시 적지 마라. */
-export const DEV_PLAN_REPLACEMENT = 'elanous harness say';
-
-/** `dev --plan` 옵션 도움말. 목적지는 인자(기본=상수)에서만 온다. */
-export function formatDevPlanOptionHelp(replacement: string = DEV_PLAN_REPLACEMENT): string {
-  return `은퇴한 staged 하니스 옵션 — 지정하면 명시적으로 거부됨 · 대응 문 \`${replacement}\``;
-}
+import { isVerifiedOpenGatewayModel, OPENGATEWAY_DEFAULT_MODEL, OPENGATEWAY_VERIFIED_MODELS } from '../llm/opengateway-models.js';
+import { DEV_PLAN_REPLACEMENT } from './cli-help-text.js';
+export { DEV_PLAN_REPLACEMENT, formatDevPlanOptionHelp } from './cli-help-text.js';
 
 /** dev CLI 옵션(commander) — `--no-*` 는 false 로 도착. input/executor 는 액션이 빌드해 별도 전달. */
 /** `src/index.ts` dev command wrapper must not append a second JSON document after hold emits its result. */
@@ -1369,7 +1364,7 @@ function childModelCatalogProvider(provider: string): string {
 
 function isKnownChildLlmProvider(provider: string): boolean {
   // ZAI-POD-CHILD (0.2.24) — glm = Z.ai GLM Coding Plan 직결(`ZAI_API_KEY` · src/llm/zai-coding-plan.ts). Pod 자식이 `--child-llm-provider glm` 으로 뜬다.
-  return ['grok', 'anthropic', 'claude-acp', 'gemini', 'openai', 'openai-codex', 'local', 'openrouter', 'bedrock', 'glm'].includes(normalizeChildLlmProvider(provider));
+  return ['grok', 'anthropic', 'claude-acp', 'gemini', 'openai', 'openai-codex', 'local', 'openrouter', 'opengateway', 'bedrock', 'glm'].includes(normalizeChildLlmProvider(provider));
 }
 
 function findPickerCatalogModel(provider: string, id: string): CatalogModelView | undefined {
@@ -1380,6 +1375,7 @@ function findPickerCatalogModel(provider: string, id: string): CatalogModelView
     case 'openai':
     case 'openai-codex': return findCodexModel(id);
     case 'openrouter': return findOpenRouterChildModel(id);
+    case 'opengateway': return findOpenGatewayChildModel(id);
     case 'bedrock': return findBedrockChildModel(id);
     case 'glm': return (ZAI_CODING_MODELS as readonly string[]).includes(id)
       ? { id, tier: /flash/i.test(id) ? 'budget' : 'balanced', supportsThinking: true, recommended: id === ZAI_CODING_DEFAULT_MODEL }
@@ -1412,6 +1408,11 @@ function findOpenRouterChildModel(id: string): CatalogModelView | undefined {
   };
 }
 
+function findOpenGatewayChildModel(id: string): CatalogModelView | undefined {
+  if (!isVerifiedOpenGatewayModel(id)) return undefined;
+  return { id, tier: 'better', supportsThinking: false, recommended: id === OPENGATEWAY_DEFAULT_MODEL };
+}
+
 function thinkingFromBuiltin(tags: readonly string[] | undefined, reasoningEffortCeiling: string | undefined): boolean {
   if (tags?.includes('reasoning')) return true;
   return reasoningEffortCeiling != null && reasoningEffortCeiling !== 'off' && reasoningEffortCeiling !== 'none';
@@ -1448,6 +1449,7 @@ function listImplementationChildModelCandidates(provider: string): string[] {
       case 'openai':
       case 'openai-codex': return CODEX_MODELS.map((model) => model.id);
       case 'openrouter': return [...new Set(MODEL_TIERS.map((t) => LLM_TIER_MAP_BY_PROVIDER.openrouter[t].model))];
+      case 'opengateway': return [...OPENGATEWAY_VERIFIED_MODELS];
       case 'bedrock': return BEDROCK_MODELS.map((model) => model.id);
       case 'glm': return [...ZAI_CODING_MODELS];
       default: return [];

package/src/self-dev/draft-residue.ts

@@ -4,7 +4,7 @@ import { gunzipSync } from 'node:zlib';
 import { basename, dirname, join } from 'node:path';
 import { findGitDir } from '../git-fs/locate.js';
 import { debug } from '../debug/log.js';
-import { PR_LABELS } from '../github/pr-labels.js';
+import { PR_LABELS, PR_LABEL_NAMES } from '../github/pr-labels.js';
 import { appendRunLedgerEntry, listRunLedgers, loadRunLedger, runLedgerDir, type RunLedgerEntry } from '../self-implement/run-ledger.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { clipRegateDetail, regateFailureFacts, type HostRegateFailure } from '../self-implement/regate-detail.js';
@@ -64,6 +64,7 @@ function sameCardSlot(previous: ResiduePr, current: ResiduePr, slot: string): bo
   return cardOf(previous.body) === slot && cardOf(current.body) === slot;
 }
 const harvestable = PR_LABELS.find((label) => label.name === 'elanous:harvestable')!.name;
+const running = PR_LABELS.find((label) => label.name === PR_LABEL_NAMES.running)!.name;
 const superseded = PR_LABELS.find((label) => label.name === 'elanous:superseded')!.name;
 
 export function classifyPodTerminal(input: PodTerminalInput): PrTerminalRecord {
@@ -120,6 +121,8 @@ export interface DraftResidueAdapters {
   /** Complete changed-path inventory for the newly opened PR; undefined is unmeasured. */
   listPrChangedPaths?(repository: string, number: number): Promise<readonly string[] | undefined> | readonly string[] | undefined;
   addLabel(repository: string, number: number, label: string): Promise<void> | void;
+  /** Remove one state label from a PR — RUN-STOP-RELEASES-RUNNING-LABEL drops `elanous:running` on terminal record. */
+  removeLabel?(repository: string, number: number, label: string): Promise<void> | void;
   setLabels(repository: string, number: number, change: { add: string; remove: readonly string[] }): Promise<void> | void;
   comment(repository: string, number: number, body: string): Promise<void> | void;
   closePr(repository: string, number: number): Promise<void> | void;
@@ -243,6 +246,7 @@ export function defaultAdapters(sources: ResidueRunStatusSources = defaultRunSta
       } catch { return undefined; }
     },
     addLabel: (repository, number, label) => { gh(['pr', 'edit', String(number), '-R', repository, '--add-label', label]); },
+    removeLabel: (repository, number, label) => { gh(['pr', 'edit', String(number), '-R', repository, '--remove-label', label]); },
     setLabels: (repository, number, change) => {
       const flags = [...(change.add ? ['--add-label', change.add] : []), ...change.remove.flatMap((label) => ['--remove-label', label])];
       if (flags.length) gh(['pr', 'edit', String(number), '-R', repository, ...flags]);
@@ -455,6 +459,38 @@ export async function applyPodTerminal(record: PrTerminalRecord, ctx: DraftResid
       return skipped('protected');
     }
     if (record.terminalClass !== 'landed') {
+      // RUN-STOP-RELEASES-RUNNING-LABEL: a finished run must not stay protected by its own `elanous:running`
+      // state label. Release only that state label; other state labels stay. A failed release is observed,
+      // never a reason to abort the terminal record. Only the GitHub write is guarded: a ledger write failure is a
+      // normal (retryable) terminal failure. An `attempt` effect written before the GitHub write lets a replay
+      // record the release even when the label is already gone (review r1: success must not be lost).
+      if (!completed('running-label-released', pr.number)) {
+        const attempted = completed('running-label-release-attempt', pr.number);
+        let released = false;
+        if (pr.labels.includes(running)) {
+          step = 'ledger';
+          if (!attempted) acknowledge('running-label-release-attempt', pr.number);
+          try {
+            if (!adapters.removeLabel) throw new Error('remove-label-unobserved');
+            step = 'remove-label';
+            await adapters.removeLabel(record.repository, pr.number, running);
+            released = true;
+          } catch (labelError) {
+            const reason = labelError instanceof Error ? labelError.message : String(labelError);
+            log('label-release-failed', { prNumber: pr.number, reason });
+            // The failure reason belongs in the ledger as well. Writing it is outside the GitHub guard: a ledger
+            // failure here is a normal retryable terminal failure (review r2), never a silently dropped reason.
+            step = 'ledger';
+            adapters.appendLedger({ runId: ctx.ledgerRunId, event: 'pr-terminal-effect',
+              data: { childRunId: record.childRunId, effect: 'label-release-failed', number: pr.number, reason } }, ctx.ledgerDir);
+          }
+        } else if (attempted) released = true;
+        if (released) {
+          step = 'ledger';
+          acknowledge('running-label-released', pr.number);
+          log('running-label-released', { prNumber: pr.number });
+        }
+      }
       if (!completed('harvestable', pr.number)) {
         if (!pr.labels.includes(harvestable)) {
           step = 'add-label';