elanous 0.2.28 → 0.2.29

package/src/self-implement/run-ledger.ts

@@ -260,6 +260,8 @@ export interface FederatedRunLedgerLookupOptions {
 
 export interface RunLedgerLookupOptions extends FederatedRunLedgerLookupOptions {
   all?: boolean;
+  /** Single-directory scope for the non-federated lookup; default = `runLedgerDir()`. */
+  dir?: string;
   list?: (path: string) => string[];
 }
 
@@ -306,7 +308,7 @@ export function loadFederatedRunLedger(runId: string, options: FederatedRunLedge
 }
 
 function lookupRunLedgerTargets(options: RunLedgerLookupOptions): RunLedgerLookupTarget[] {
-  return options.all ? resolveFederatedRunLedgerTargets(options) : [{ ledgerDirectory: runLedgerDir(), targetName: null }];
+  return options.all ? resolveFederatedRunLedgerTargets(options) : [{ ledgerDirectory: options.dir ?? runLedgerDir(), targetName: null }];
 }
 
 /** Find exact canonical IDs first; otherwise scan canonical ledger filenames for a normalized unique prefix. */
@@ -433,6 +435,95 @@ export function recordHumanStoppedRun(runId: string, options: HumanStopRunLedger
   }, options.dir);
 }
 
+/** Ledger-recording options shared by the non-blocking observers — never part of the recorded entry payload. */
+export interface NonBlockingRunLedgerOptions {
+  /** 관측 시각 — 생략하면 now */
+  timestamp?: string;
+  /** 원장 디렉터리 — 생략하면 정본 run ledger dir */
+  dir?: string;
+}
+
+/** The settled-result payload a non-blocking request records under its requestId. */
+export interface NonBlockingRunResultLedgerEntry {
+  kind: string;
+  reason?: string;
+  /** 런이 실제로 산출한 next만 담는다 — 값이 없으면 키를 생략한다(unknown 보존). */
+  next?: string;
+  ok?: boolean;
+  runId?: string;
+}
+
+/**
+ * Record a non-blocking request's immediate pending state under its minted requestId.
+ * Event-kind naming follows the `recordHumanStoppedRun` observer-event precedent; never changes a run itself.
+ */
+export function recordNonBlockingRunPending(requestId: string, options: NonBlockingRunLedgerOptions = {}): void {
+  const recordedAt = options.timestamp ?? new Date().toISOString();
+  appendRunLedgerEntry({
+    timestamp: recordedAt,
+    runId: requestId,
+    event: 'non-blocking-pending',
+    data: { requestId, kind: 'pending', recordedAt },
+  }, options.dir);
+}
+
+/**
+ * Record a non-blocking request's settled result (kind·reason·next) under the same requestId.
+ * The payload is the second argument; ledger placement options (timestamp·dir) stay a separate third argument
+ * so no option ever leaks into the recorded entry (RunLedgerEntry format stays unchanged).
+ * Event-kind naming follows the `recordHumanStoppedRun` observer-event precedent; never changes a run itself.
+ */
+export function recordNonBlockingRunResult(
+  requestId: string,
+  entry: NonBlockingRunResultLedgerEntry,
+  options: NonBlockingRunLedgerOptions = {},
+): void {
+  const recordedAt = options.timestamp ?? new Date().toISOString();
+  appendRunLedgerEntry({
+    timestamp: recordedAt,
+    runId: requestId,
+    event: 'non-blocking-result',
+    data: {
+      requestId,
+      kind: entry.kind,
+      ...(entry.reason === undefined ? {} : { reason: entry.reason }),
+      ...(entry.next === undefined ? {} : { next: entry.next }),
+      ...(entry.ok === undefined ? {} : { ok: entry.ok }),
+      ...(entry.runId === undefined ? {} : { runId: entry.runId }),
+      recordedAt,
+    },
+  }, options.dir);
+}
+
+/** The non-blocking request record a ledger carries for its runId; latest result wins over the pending entry. */
+export interface NonBlockingRunLedgerRecord {
+  requestId: string;
+  kind: string;
+  reason?: string;
+  /** next는 런이 실제로 산출한 값만 담는다 — 원장에 적힌 값이 없으면 이 키도 없다(unknown 보존). */
+  next?: string | null;
+}
+
+/** Read the non-blocking request record from an already-loaded ledger; null when the ledger carries none. */
+export function readNonBlockingRunRecord(ledger: readonly RunLedgerEntry[]): NonBlockingRunLedgerRecord | null {
+  let record: NonBlockingRunLedgerRecord | null = null;
+  for (const entry of ledger) {
+    if (entry.event === 'non-blocking-pending' && record === null) {
+      record = { requestId: entry.runId, kind: 'pending', next: null };
+      continue;
+    }
+    if (entry.event !== 'non-blocking-result' || typeof entry.data.kind !== 'string') continue;
+    const reason = typeof entry.data.reason === 'string' ? entry.data.reason : undefined;
+    record = {
+      requestId: entry.runId,
+      kind: entry.data.kind,
+      ...(reason === undefined ? {} : { reason }),
+      ...(typeof entry.data.next === 'string' ? { next: entry.data.next } : {}),
+    };
+  }
+  return record;
+}
+
 function parseRunLedgerEntry(line: string, lineNumber: number, expectedRunId: string): RunLedgerEntry {
   let parsed: unknown;
   try {
@@ -1210,6 +1301,8 @@ export interface UnfinishedRunLedgerEntry {
   lastActivityStatus: LastActivityStatus;
   /** ⭐ 「남은 것」을 «가려» 보여 주는 등급 — 종전엔 이 조회가 한 값뿐이라 회고에서 못 갈랐다. */
   lifecycle: UnfinishedRunLifecycle;
+  /** Non-blocking request record (kind·reason·next) carried by this runId's ledger; absent for runs without one. */
+  nonBlocking?: NonBlockingRunLedgerRecord;
 }
 
 export interface UnfinishedRunLedgerQuery {
@@ -1294,7 +1387,10 @@ function hasCanonicalRunStatus(ledger: readonly RunLedgerEntry[]): boolean {
 }
 
 /** Events that may follow a terminal run-status without reopening the run. Anything else stays unfinished. */
-export const TRAILING_BOOKKEEPING_EVENTS = ['pipeline-traversal-shadow', 'run-rollup', 'progress-delivery', 'progress-delivery-outcome'] as const;
+// `non-blocking-pending`/`non-blocking-result` are observer records of the non-blocking request
+// surface (#26634 칸 NONBLOCKING-RESULT-LEDGER). They carry the requestId result, never a run
+// lifecycle, so appending them after a terminal run-status must not reopen the run.
+export const TRAILING_BOOKKEEPING_EVENTS = ['pipeline-traversal-shadow', 'run-rollup', 'progress-delivery', 'progress-delivery-outcome', 'non-blocking-pending', 'non-blocking-result'] as const;
 
 const TRAILING_BOOKKEEPING_EVENT_SET = new Set<string>(TRAILING_BOOKKEEPING_EVENTS);
 
@@ -1559,6 +1655,7 @@ interface UnfinishedLedgerFacts {
   targetRoot: string | null;
   goalFile: string | null;
   fixedLifecycle: UnfinishedRunLifecycle;
+  nonBlocking: NonBlockingRunLedgerRecord | null;
 }
 
 // A full federated scan can exceed 5,000 files; keep the previous scan resident for mtime-checked reuse.
@@ -1589,6 +1686,7 @@ function unfinishedLedgerFacts(ledger: readonly RunLedgerEntry[]): UnfinishedLed
     targetRoot: ledgerTargetRoot(ledger),
     goalFile: ledgerGoalDocument(ledger),
     fixedLifecycle: classifyUnfinishedLifecycle(ledger, null, 0),
+    nonBlocking: readNonBlockingRunRecord(ledger),
   };
 }
 
@@ -1698,7 +1796,9 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
     if (facts.terminal) {
       terminal += 1;
       if (facts.terminalByTrailingRunStatus) terminalByTrailingRunStatus += 1;
-      continue;
+      // A run carrying a non-blocking request record stays queryable by requestId even after its
+      // terminal run-status; runs without one keep the exact previous skip behavior.
+      if (!facts.nonBlocking) continue;
     }
 
     const branch = facts.branch;
@@ -1726,7 +1826,7 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
           : goalDocument.status === 'directory-unreadable'
             ? 'goal-directory-unreadable'
             : 'goal-document-not-found';
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus, ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus, ...unknownDeclaredPaths(), pathMatchReasons: {}, goalDocumentPath: null, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle, ...(facts.nonBlocking ? { nonBlocking: facts.nonBlocking } : {}) });
       continue;
     }
     try {
@@ -1734,9 +1834,9 @@ export function queryUnfinishedRunLedgers(options: UnfinishedRunLedgerQueryOptio
       const text = typeof document === 'string' ? document : document.toString('utf8');
       const paths = [...new Set(tracedPathReferences(text).map((reference) => reference.path))];
       const declared = declaredPathsFromGoalDocument(text);
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: paths, plannedPathStatus: paths.length > 0 ? goalDocument.source === 'ledger' ? 'found-ledger-goal-file' : 'found-branch-fallback' : 'no-traced-paths', ...declared, pathMatchReasons: pathMatchReasons(declared.declaredPaths, paths), goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: paths, plannedPathStatus: paths.length > 0 ? goalDocument.source === 'ledger' ? 'found-ledger-goal-file' : 'found-branch-fallback' : 'no-traced-paths', ...declared, pathMatchReasons: pathMatchReasons(declared.declaredPaths, paths), goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle, ...(facts.nonBlocking ? { nonBlocking: facts.nonBlocking } : {}) });
     } catch {
-      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus: 'goal-document-unreadable', declaredPaths: [], declaredPathStatus: 'goal-document-unreadable', pathMatchReasons: {}, goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle });
+      entries.push({ runId, branch, status: 'terminal-status-missing', plannedPaths: [], plannedPathStatus: 'goal-document-unreadable', declaredPaths: [], declaredPathStatus: 'goal-document-unreadable', pathMatchReasons: {}, goalDocumentPath: goalDocument.path, goalLookupBasis, goalDocumentSearchDirectory: searchDirectory, ...activity, lifecycle, ...(facts.nonBlocking ? { nonBlocking: facts.nonBlocking } : {}) });
     }
   }
   entries.sort((left, right) => left.runId.localeCompare(right.runId));
@@ -1885,7 +1985,11 @@ export function queryFederatedUnfinishedRunLedgers(options: FederatedUnfinishedR
   //   📏 실측(2026-08-11): 미완 57 중 ***7*** 이 다른 원장에 종결을 갖고 있었다.
   // ⛔ 판정 술어는 스캐너와 «같은 것»을 쓴다(`run-status` 또는 `terminal`) — 어휘를 새로 만들지 않는다.
   const terminatedElsewhere = new Set<string>();
-  const unfinishedRunIds = requestedRunIds === undefined ? new Set(entries.map((entry) => entry.runId)) : new Set([...requestedRunIds].filter((runId) => entries.some((entry) => entry.runId === runId)));
+  // Runs carrying a non-blocking request record never drop out of the union: their requestId
+  // reason·next must survive restarts and cross-directory reconciliation alike.
+  const unfinishedRunIds = requestedRunIds === undefined
+    ? new Set(entries.filter((entry) => !entry.nonBlocking).map((entry) => entry.runId))
+    : new Set([...requestedRunIds].filter((runId) => entries.some((entry) => entry.runId === runId && !entry.nonBlocking)));
   for (const runId of unfinishedRunIds) {
     for (const ledgerDirectory of ledgerDirectories) {
       try {

package/src/self-implement/running-runs.ts

@@ -9,7 +9,7 @@ import { isPidAlive } from '../git-fs/worktree.js';
 import { LogStore } from '../mss/logging/log-store.js';
 import { loadSelfDevRun, selfDevRunsDir, type SelfDevRunState } from '../self-dev/run-store.js';
 import { listPtyManifestRowsAt } from '../pty-shell/pty-manifest.js';
-import { classifyFederatedLedgerDirectoryReadFailure, isTerminatedUnfinishedLifecycle, queryFederatedUnfinishedRunLedgers, resolveFederatedRunLedgerDirectories, type FederatedUnfinishedRunLedgerEntry, type FederatedUnfinishedRunLedgerQuery, type UnfinishedRunLifecycle } from './run-ledger.js';
+import { classifyFederatedLedgerDirectoryReadFailure, isTerminatedUnfinishedLifecycle, queryFederatedUnfinishedRunLedgers, resolveFederatedRunLedgerDirectories, type FederatedUnfinishedRunLedgerEntry, type FederatedUnfinishedRunLedgerQuery, type NonBlockingRunLedgerRecord, type UnfinishedRunLifecycle } from './run-ledger.js';
 import { SELF_IMPLEMENT_PROGRESS_STAGES } from './orchestrator.js';
 
 export type RunningRunStatus = 'running' | 'probable-running' | 'ended-unclosed' | 'unknown';
@@ -55,6 +55,8 @@ export interface RunningRunAssessment {
   readonly ptyUpdatedAt: number | null;
   readonly ledgerDirectories: readonly string[];
   readonly ptyRefs: readonly Pick<FederatedPtyRef, 'instance' | 'id' | 'kind'>[];
+  /** Non-blocking request record (kind·reason·next) carried by this runId's ledger; absent for runs without one. */
+  readonly nonBlocking?: NonBlockingRunLedgerRecord;
 }
 
 export interface RunningRunsObservation {
@@ -376,14 +378,16 @@ export function assessRunningRuns(
     const ledgerDirectories = [...new Set(matchingLedgers.map((entry) => entry.ledgerDirectory))].sort();
     const phase = { phaseObservation: phaseObservation === 'not-observed' && latestPhase ? 'observed' as const : phaseObservation, lastPhase: latestPhase?.phase ?? null, lastPhaseObservedAt: latestPhase?.observedAt ?? null };
     const ptyRefs = refs.map(({ instance, id, kind }) => ({ instance, id, kind }));
+    const nonBlocking = matchingLedgers.find((entry) => entry.nonBlocking)?.nonBlocking;
+    const nonBlockingField = nonBlocking === undefined ? {} : { nonBlocking };
     if (matchingLedgers.some((entry) => isTerminatedUnfinishedLifecycle(entry.lifecycle))) {
-      return { runId, status: 'ended-unclosed' as const, presence: refs.length > 0 ? 'ledger-and-pty-observed' as const : 'ledger-without-pty-observed' as const, reason: 'ledger-positive-termination-evidence', lifecycle, lastActivityTimestamp, ...phase, ptyUpdatedAt, ledgerDirectories, ptyRefs };
+      return { runId, status: 'ended-unclosed' as const, presence: refs.length > 0 ? 'ledger-and-pty-observed' as const : 'ledger-without-pty-observed' as const, reason: 'ledger-positive-termination-evidence', lifecycle, lastActivityTimestamp, ...phase, ptyUpdatedAt, ledgerDirectories, ptyRefs, ...nonBlockingField };
     }
     if (refs.length > 0 && lifecycle === 'live') {
-      return { runId, status: 'running' as const, presence: 'ledger-live-and-pty-observed' as const, reason: 'ledger-live-and-pty-alive', lifecycle, lastActivityTimestamp, ...phase, ptyUpdatedAt, ledgerDirectories, ptyRefs };
+      return { runId, status: 'running' as const, presence: 'ledger-live-and-pty-observed' as const, reason: 'ledger-live-and-pty-alive', lifecycle, lastActivityTimestamp, ...phase, ptyUpdatedAt, ledgerDirectories, ptyRefs, ...nonBlockingField };
     }
     if (matchingLedgers.length > 0 && lifecycle === 'live' && pty.unreadable.length === 0 && refs.length === 0) {
-      return { runId, status: 'probable-running' as const, presence: 'ledger-live-pty-not-observed' as const, reason: 'ledger-without-live-pty', lifecycle, lastActivityTimestamp, ...phase, ptyUpdatedAt, ledgerDirectories, ptyRefs };
+      return { runId, status: 'probable-running' as const, presence: 'ledger-live-pty-not-observed' as const, reason: 'ledger-without-live-pty', lifecycle, lastActivityTimestamp, ...phase, ptyUpdatedAt, ledgerDirectories, ptyRefs, ...nonBlockingField };
     }
     const ledgerUnreadable = hasUnreadableLedgerObservation(ledgerObservation);
     const reason = matchingLedgers.length === 0
@@ -395,7 +399,7 @@ export function assessRunningRuns(
       : matchingLedgers.length === 0 ? 'pty-without-ledger-observed'
       : refs.length === 0 ? 'ledger-without-pty-observed'
       : 'ledger-and-pty-observed';
-    return { runId, status: 'unknown' as const, presence, reason, lifecycle, lastActivityTimestamp, ...phase, ptyUpdatedAt, ledgerDirectories, ptyRefs };
+    return { runId, status: 'unknown' as const, presence, reason, lifecycle, lastActivityTimestamp, ...phase, ptyUpdatedAt, ledgerDirectories, ptyRefs, ...nonBlockingField };
   });
   const counts: Record<RunningRunStatus, number> = { running: 0, 'probable-running': 0, 'ended-unclosed': 0, unknown: 0 };
   for (const entry of entries) counts[entry.status] += 1;
@@ -657,7 +661,7 @@ export function renderRunningRuns(result: RunningRunsResult): string {
     `observed live ptys: ${result.pty.observedRefCount} without runId: ${result.pty.withoutRunIdCount} not counted as running: ${result.pty.notCountedRefCount}`,
     `unreadable pty roots: ${result.pty.unreadable.join(',') || 'none'}`,
     `phase stores: ${result.phases?.targetCount ?? 0} readable: ${result.phases?.readableTargetCount ?? 0} unreadable: ${result.phases?.unreadableTargetCount ?? 0} unreadable targets: ${result.phases?.unreadableTargets.join(',') || 'none'} non-stage events discarded: ${result.phases?.discardedNonStageEventCount ?? 0}`,
-    ...result.entries.map((entry) => `runId=${entry.runId} status=${entry.status} presence=${entry.presence} reason=${entry.reason} lifecycle=${entry.lifecycle ?? 'none'} lastActivity=${entry.lastActivityTimestamp ?? 'null'} phaseObservation=${entry.phaseObservation ?? 'not-observed'} lastPhase=${entry.lastPhase ?? 'none'} lastPhaseObservedAt=${entry.lastPhaseObservedAt ?? 'none'} ledgerDirectories=${entry.ledgerDirectories.join(',') || 'none'} ptyRefs=${entry.ptyRefs.map((ref) => `${ref.instance}:${ref.id}`).join(',') || 'none'}`),
+    ...result.entries.map((entry) => `runId=${entry.runId} status=${entry.status} presence=${entry.presence} reason=${entry.reason} lifecycle=${entry.lifecycle ?? 'none'} lastActivity=${entry.lastActivityTimestamp ?? 'null'} phaseObservation=${entry.phaseObservation ?? 'not-observed'} lastPhase=${entry.lastPhase ?? 'none'} lastPhaseObservedAt=${entry.lastPhaseObservedAt ?? 'none'} ledgerDirectories=${entry.ledgerDirectories.join(',') || 'none'} ptyRefs=${entry.ptyRefs.map((ref) => `${ref.instance}:${ref.id}`).join(',') || 'none'}${entry.nonBlocking ? ` nonBlocking=kind:${entry.nonBlocking.kind} reason:${entry.nonBlocking.reason ?? 'none'} next:${entry.nonBlocking.next ?? 'none'}` : ''}`),
     partial
       ? `quantity scope: running=unknown lowerBound=${lowerBound} population=${result.quantities.running.population}; total=unknown entries=unknown population=${result.quantities.total.population}; ${observationScopeText(result.observation)}`
       : `quantity scope: running=${result.quantities.running.value} population=${result.quantities.running.population}; total=${result.quantities.total.value} entries=${result.quantities.entries.value} population=${result.quantities.total.population}; ${observationScopeText(result.observation)}`,

package/src/self-implement/self-implement-runtime.ts

@@ -29,6 +29,7 @@ import { normalizeTargetPaths, observeDecomposerSelection, selectFabricDecompose
 import { parseAskProseTitle } from '../self-dev/launch-preflight.js';
 import { getUserConfig } from '../user-config.js';
 import { mintRunId } from '../harness/harness-space.js';
+import { recordNonBlockingRunPending, recordNonBlockingRunResult } from './run-ledger.js';
 
 type SelfImplementApprover = NonNullable<SelfImplementSeams['approvePr']>;
 type SelfImplementGoalAuthor = (ask: string, cwd: string, deps?: { goalTitle?: string }) => Promise<{ path: string }>;
@@ -67,6 +68,16 @@ export function setSelfImplementRuntimeDeps(d: SelfImplementRuntimeDeps | null):
   runtimeDeps = d ?? {};
 }
 
+// ── non-blocking 원장 기록 dir (테스트 seam · 기본 = 정본 run ledger dir) ──
+// #26634 칸 NONBLOCKING-RESULT-LEDGER: pending requestId 와 완료 kind·reason·next 를
+// appendRunLedgerEntry 로 정본 run ledger 에 보존한다. 테스트 격리에서만 이 dir 을 바꾼다.
+let nonBlockingLedgerDir: string | undefined;
+
+/** 테스트 헬퍼 — non-blocking 원장 기록 dir 주입. null = un-set(정본 run ledger dir). */
+export function _setSelfImplementNonBlockingLedgerDirForTesting(dir: string | null): void {
+  nonBlockingLedgerDir = dir ?? undefined;
+}
+
 // ── seam factory (테스트 seam) ──
 let seamsFactory: (o: DefaultSeamsOptions) => SelfImplementSeams = defaultSeams;
 
@@ -859,6 +870,9 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
       const runId = allocatedRunId ?? mintRunId();
       const requestId = runId;
       const lookup = `eln logs --category self-implement --event runtime.non-blocking-completed,runtime.non-blocking-failed --grep ${requestId} --since 3h --all --include-test`;
+      const ledgerDirOptions = nonBlockingLedgerDir === undefined ? {} : { dir: nonBlockingLedgerDir };
+      // 즉시 pending 관측 기록 — appendRunLedgerEntry 는 fail-soft 계약이라 호출자가 지킨다.
+      try { recordNonBlockingRunPending(requestId, ledgerDirOptions); } catch { /* observer record cannot break the run */ }
       void drive(runId).then(
         (result) => {
           debug.log('self-implement', result.kind === 'failed' ? 'runtime.non-blocking-failed' : 'runtime.non-blocking-completed', {
@@ -870,6 +884,16 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
             ok: result.ok,
             ...(result.stage === undefined ? {} : { stage: result.stage }),
           }, result.kind === 'failed' ? { level: 'warn' } : undefined);
+          try {
+            recordNonBlockingRunResult(requestId, {
+              kind: result.kind,
+              ...(result.reason === undefined ? {} : { reason: result.reason }),
+              // next는 런이 실제로 산출한 값만 원장에 남긴다(unknown 보존 — 기본 문구 지어내기 없음).
+              ...(result.next === undefined ? {} : { next: result.next }),
+              ok: result.ok,
+              ...(result.runId ? { runId: result.runId } : {}),
+            }, ledgerDirOptions);
+          } catch { /* observer record cannot break the run */ }
         },
         (error) => {
           const reason = error instanceof Error ? error.message : String(error);
@@ -879,6 +903,14 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
             reason,
             next: '요청과 실패 이유를 확인한 뒤 다시 요청',
           }, { level: 'warn' });
+          try {
+            // reject 경로엔 런이 산출한 next가 없다 — 원장에는 생략해 unknown 보존(기본 문구는 debug.log 임시 경로에만 남긴다).
+            recordNonBlockingRunResult(requestId, {
+              kind: 'failed',
+              reason,
+              ok: false,
+            }, ledgerDirOptions);
+          } catch { /* observer record cannot break the run */ }
         },
       );
       return {

package/src/session/pending-input.ts

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

package/src/session-runtime/index.ts

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