elanous 0.2.27 → 0.2.29

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/self-implement/speed-claims.ts

@@ -2,7 +2,7 @@ import { spawnSync } from 'node:child_process';
 import { readFileSync, readdirSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { prodInstanceRoot } from '../instance/resolve.js';
+import { prodInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
 import { seatOfTree } from '../loops/orchestrator/traffic.js';
 import { getUserConfig, ORCHESTRATOR_DEFAULTS } from '../user-config.js';
 import { isRunStatus } from './run-status-mapping.js';
@@ -30,6 +30,7 @@ export interface SpeedClaimsMeasurement {
   rows: SpeedClaimsRow[];
   note: string;
   parent: ParentSpeedClaimsMeasurement;
+  daily: SpeedClaimsDailyMeasurement;
 }
 export interface ParentSpeedClaimsEvent {
   ts: string;
@@ -58,6 +59,32 @@ export interface ParentSpeedClaimsMeasurement {
   note: string;
 }
 
+export interface SpeedClaimsReleaseEvent {
+  ts: string;
+  version: string;
+}
+
+export interface SpeedClaimsDailyRow {
+  date: string;
+  landedPrCount: number | null;
+  releasedCount: number | null;
+}
+
+export interface SpeedClaimsDailySourceStatus {
+  status: 'measured' | 'unmeasured';
+  undatedCount: number;
+}
+
+export interface SpeedClaimsDailyMeasurement {
+  scope: 'last-30-days';
+  windowStart: string;
+  windowEnd: string;
+  landedPrs: SpeedClaimsDailySourceStatus;
+  releases: SpeedClaimsDailySourceStatus;
+  rows: SpeedClaimsDailyRow[];
+  note: string;
+}
+
 export interface SpeedClaimsOptions {
   dir?: string;
   list?: (path: string) => string[];
@@ -65,6 +92,8 @@ export interface SpeedClaimsOptions {
   readSeat?: (runId: string, ledgerDirectory: string, entries: readonly RunLedgerEntry[]) => SpeedClaimsSeat;
   readParentEvents?: () => readonly ParentSpeedClaimsEvent[];
   readParentQueue?: () => unknown;
+  now?: number;
+  readReleaseEvents?: () => readonly SpeedClaimsReleaseEvent[];
 }
 
 const NOTE = 'Child-ledger elapsed minutes from the first child event (or checkpoint creation when unavailable) to the recorded child end, including retries and resumes; this is not the parent launch-to-done interval. Only finished runs enter quartiles (linear interpolation at ranks (n-1)*p). In-progress runs (including parked) and missing, unreadable or invalid timestamps are excluded, not assigned zero. Seats come from the same state root checkpoint, launch queue or recorded launch tree; unresolved seats are counted separately. A completed run without a recorded merge is not a merge.';
@@ -192,6 +221,98 @@ function readParentQueueFromState(): unknown {
   return JSON.parse(readFileSync(join(prodInstanceRoot(), 'harness', 'queue.json'), 'utf8')) as unknown;
 }
 
+const DAILY_WINDOW_DAYS = 30;
+const DAY_MS = 86_400_000;
+const DAILY_NOTE = 'Daily rows cover the last 30 UTC calendar days ending on the measurement day. Landed PRs are child run-ledger merged events (merged=true), identified by PR number with the run id as fallback when no number is recorded, de-duplicated across runs, retries and resumes, and attributed to the earliest recorded landing timestamp. Issued releases use the release ledger publishedAt, never a tag target commit date, and are de-duplicated by version. Identities without any valid timestamp are counted as undated, never as a day. A count of zero means the day was queried and had no events; unmeasured means the source could not be queried, and the JSON value is null. Start-to-land and external-change-to-reflection timings stay with the parent and child measurements above.';
+const VERSION_TAG = /^v?\d+(?:\.\d+)+(?:-[\w.]+)?$/;
+
+interface DailyObservation {
+  key: string;
+  ts: number | null;
+}
+
+function utcDayOf(ts: number): string {
+  return new Date(ts).toISOString().slice(0, 10);
+}
+
+/** Landed-PR identity: the recorded PR number, else the run id (one run lands at most one PR). */
+function landedPrIdentity(data: unknown, runId: string): string {
+  const number = object(data)?.number;
+  if (typeof number === 'number' && Number.isInteger(number) && number > 0) return `pr-${number}`;
+  if (typeof number === 'string' && /^\d+$/.test(number.trim()) && Number(number.trim()) > 0) return `pr-${Number(number.trim())}`;
+  return runId;
+}
+
+/** De-duplicate repeated identities by their earliest valid timestamp; identities without any valid timestamp are reported as undated, never dropped silently. */
+function dailyBuckets(observations: readonly DailyObservation[]): { counts: Map<string, number>; undated: number } {
+  const earliest = new Map<string, number>();
+  const undated = new Set<string>();
+  for (const { key, ts } of observations) {
+    if (key.length === 0) continue;
+    if (ts === null) { undated.add(key); continue; }
+    const known = earliest.get(key);
+    if (known === undefined || ts < known) earliest.set(key, ts);
+  }
+  const counts = new Map<string, number>();
+  for (const ts of earliest.values()) {
+    const day = utcDayOf(ts);
+    counts.set(day, (counts.get(day) ?? 0) + 1);
+  }
+  let undatedCount = 0;
+  for (const key of undated) if (!earliest.has(key)) undatedCount++;
+  return { counts, undated: undatedCount };
+}
+
+/** Read-only daily census of landed PRs and issued releases over the last 30 UTC days. */
+function measureDailySpeedClaims(
+  landed: readonly DailyObservation[],
+  landedMeasured: boolean,
+  releases: readonly SpeedClaimsReleaseEvent[] | null,
+  now: number,
+): SpeedClaimsDailyMeasurement {
+  const windowEnd = utcDayOf(now);
+  const startMs = Date.parse(`${windowEnd}T00:00:00.000Z`) - (DAILY_WINDOW_DAYS - 1) * DAY_MS;
+  const landedBuckets = dailyBuckets(landed);
+  const releaseBuckets = releases === null
+    ? null
+    : dailyBuckets(releases.map((event) => ({ key: event.version.trim().replace(/^v(?=\d)/, ''), ts: parseTime(event.ts) })));
+  const landedComplete = landedMeasured && landedBuckets.undated === 0;
+  const releasesComplete = releaseBuckets !== null && releaseBuckets.undated === 0;
+  return {
+    scope: 'last-30-days', windowStart: utcDayOf(startMs), windowEnd,
+    landedPrs: { status: landedComplete ? 'measured' : 'unmeasured', undatedCount: landedBuckets.undated },
+    releases: { status: releasesComplete ? 'measured' : 'unmeasured', undatedCount: releaseBuckets?.undated ?? 0 },
+    rows: Array.from({ length: DAILY_WINDOW_DAYS }, (_, index) => {
+      const date = utcDayOf(startMs + index * DAY_MS);
+      return {
+        date,
+        landedPrCount: landedComplete ? (landedBuckets.counts.get(date) ?? 0) : null,
+        releasedCount: releasesComplete ? (releaseBuckets!.counts.get(date) ?? 0) : null,
+      };
+    }),
+    note: DAILY_NOTE,
+  };
+}
+
+/** Release manifests record the actual publication time; lightweight tags have no creation timestamp. */
+function readReleaseEventsFromLedger(): SpeedClaimsReleaseEvent[] {
+  const root = join(releaseLedgerRoot(), 'release');
+  const versions = readdirSync(root).filter((version) => VERSION_TAG.test(version));
+  const events: SpeedClaimsReleaseEvent[] = [];
+  for (const version of versions) {
+    // Absence and corruption are both unmeasured; only a readable manifest proves preparation.
+    const value: unknown = JSON.parse(readFileSync(join(root, version, 'release.json'), 'utf8')) as unknown;
+    const record = object(value);
+    if (record?.version !== version) throw new Error(`release manifest version mismatch: ${version}`);
+    if (!Object.hasOwn(record, 'publishedAt')) continue; // Prepared, not yet published.
+    if (typeof record.publishedAt !== 'string' || parseTime(record.publishedAt) === null) throw new Error(`invalid release publication time: ${version}`);
+    events.push({ version, ts: record.publishedAt });
+  }
+  // A checkout without tags or a release history cannot establish a queried zero.
+  if (versions.length === 0) throw new Error('release publication history unavailable');
+  return events;
+}
+
 /** Parent launch-to-done census; no child ledger id is used as a join key. */
 export function measureParentSpeedClaims(
   events: readonly ParentSpeedClaimsEvent[], queue?: unknown,
@@ -262,7 +383,13 @@ export function measureParentSpeedClaims(
 
 /** Read-only elapsed-time census of canonical local run ledgers, including unsuccessful runs. */
 export function measureSpeedClaims(options: SpeedClaimsOptions = {}): SpeedClaimsMeasurement {
+  const now = options.now ?? Date.now();
   const ledgerDirectory = resolve(options.dir ?? runLedgerDir());
+  let releaseEvents: readonly SpeedClaimsReleaseEvent[] | null = null;
+  try {
+    const events = (options.readReleaseEvents ?? readReleaseEventsFromLedger)();
+    releaseEvents = Array.isArray(events) ? events : null;
+  } catch { /* An unreadable release source marks releases unmeasured; it does not erase landed-PR observations. */ }
   let parent: ParentSpeedClaimsMeasurement;
   try {
     const events = (options.readParentEvents ?? readParentEventsFromLogs)();
@@ -272,21 +399,27 @@ export function measureSpeedClaims(options: SpeedClaimsOptions = {}): SpeedClaim
   } catch {
     parent = { ...measureParentSpeedClaims([]), status: 'cannot-measure' };
   }
-  const result: SpeedClaimsMeasurement = {
+  const result: Omit<SpeedClaimsMeasurement, 'daily'> = {
     scope: 'self-implement-run-ledger', ledgerDirectory, status: 'measured',
     completedCount: 0, inProgressCount: 0, cannotMeasureCount: 0, unknownSeatCount: 0, rows: [], note: NOTE, parent,
   };
   let files: string[];
   try { files = (options.list ?? readdirSync)(ledgerDirectory); }
-  catch { return { ...result, status: 'cannot-measure' }; }
+  catch { return { ...result, status: 'cannot-measure', daily: measureDailySpeedClaims([], false, releaseEvents, now) }; }
 
+  const landed: DailyObservation[] = [];
+  let ledgerUnreadable = false;
   const groups = new Map<string, { seat: SpeedClaimsSeat; outcome: SpeedClaimsOutcome; values: number[] }>();
   for (const file of files.sort()) {
     const runId = file.endsWith('.jsonl') ? file.slice(0, -'.jsonl'.length) : '';
     if (!CANONICAL_RUN_ID.test(runId)) continue;
     try {
       const entries = loadRunLedger(runId, ledgerDirectory, options.read);
-      if (!entries || entries.length === 0) { result.cannotMeasureCount++; continue; }
+      if (!entries || entries.length === 0) { ledgerUnreadable = true; result.cannotMeasureCount++; continue; }
+      const merges = entries.filter((entry) => entry.event === 'merged' && entry.data.merged === true);
+      const numbered = new Set(merges.map((entry) => landedPrIdentity(entry.data, runId)).filter((key) => key !== runId));
+      if (numbered.size > 1) ledgerUnreadable = true; // Conflicting PR identities cannot establish a daily count.
+      else for (const entry of merges) landed.push({ key: numbered.size === 1 ? [...numbered][0]! : runId, ts: parseTime(entry.timestamp) });
       const end = endOfRun(entries);
       const first = time(entries[0]);
       const createdAt = checkpointFor(runId, ledgerDirectory)?.createdAt;
@@ -306,14 +439,14 @@ export function measureSpeedClaims(options: SpeedClaimsOptions = {}): SpeedClaim
       group.values.push((endTime! - start) / 60_000);
       groups.set(key, group);
       result.completedCount++;
-    } catch { result.cannotMeasureCount++; }
+    } catch { result.cannotMeasureCount++; ledgerUnreadable = true; }
   }
   result.rows = [...groups.values()].map(({ seat, outcome, values }) => {
     values.sort((a, b) => a - b);
     return { seat, outcome, count: values.length, underOneMinuteCount: values.filter((minutes) => minutes < 1).length, medianMinutes: percentile(values, 0.5), q1Minutes: percentile(values, 0.25), q3Minutes: percentile(values, 0.75) };
   }).sort((a, b) => SEATS.indexOf(a.seat) - SEATS.indexOf(b.seat) || a.outcome.localeCompare(b.outcome));
   if (result.cannotMeasureCount > 0) result.status = 'cannot-measure';
-  return result;
+  return { ...result, daily: measureDailySpeedClaims(landed, !ledgerUnreadable, releaseEvents, now) };
 }
 
 export function renderSpeedClaims(result: SpeedClaimsMeasurement): string {
@@ -334,5 +467,11 @@ export function renderSpeedClaims(result: SpeedClaimsMeasurement): string {
     `parent cannot measure (excluded): ${result.parent.cannotMeasureCount}`,
     ...result.parent.rows.map((row) => `seat=${row.seat} stage=${row.stage} merged=${row.merged} count=${row.count} median=${row.medianMinutes}m q1=${row.q1Minutes}m q3=${row.q3Minutes}m`),
     `parent note: ${result.parent.note}`,
+    'daily landed PRs / issued releases (last 30 days, UTC):',
+    `daily window: ${result.daily.windowStart}..${result.daily.windowEnd}`,
+    `landed PRs status: ${result.daily.landedPrs.status} (undated: ${result.daily.landedPrs.undatedCount})`,
+    `issued releases status: ${result.daily.releases.status} (undated: ${result.daily.releases.undatedCount})`,
+    ...result.daily.rows.map((row) => `date=${row.date} landed=${row.landedPrCount ?? 'unmeasured'} released=${row.releasedCount ?? 'unmeasured'}`),
+    `daily note: ${result.daily.note}`,
   ].join('\n');
 }

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',