elanous 0.2.13 → 0.2.15

package/src/cli/logs-cli.ts

@@ -14,7 +14,7 @@
 // 같은 케이던스). 레벨 제어만 데몬 REST(/v1/logs/level — 런타임 상태라 프로세스
 // 경유 필수). 설계: 내부 문서 `PLAN-unified-log-fabric-2026-07-13` §LF3.
 
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import type { Command } from 'commander';
 import { homedir } from 'node:os';
 import { basename, dirname, join } from 'node:path';
@@ -37,7 +37,7 @@ import { isRenderCategory, RENDER_ORIENTED_PREFIXES } from '../mss/logging/rende
 import { readScopedRenderLogs } from '../mss/logging/scoped-level.js';
 import { formatClock } from '../time/format.js';
 import { HARNESS_SPACE_KINDS } from '../harness/harness-space.js';
-import { LogCursorNotFoundError, STORE_SAFETY_MAX } from '../mss/logging/log-store.js';
+import { LOG_RETENTION_DEFAULTS, LogCursorNotFoundError, STORE_SAFETY_MAX } from '../mss/logging/log-store.js';
 import { resolveDaemonEndpoint } from '../nexus/daemon-endpoint.js';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { debug } from '../debug/log.js';
@@ -705,6 +705,74 @@ export function categoryCandidateWarning(
   return `안내: 지정한 카테고리 이름은 이 로그 스토어에서 관측된 적 없습니다: ${shown}${rest > 0 ? ` 외 ${rest}개` : ''}.`;
 }
 
+/** A child-observation query can miss Pod-only logs even when the local store was read successfully. */
+export function podObservationGapNotice(
+  query: Pick<LogQuery, 'categories' | 'exactCategories' | 'events'>,
+  podRuns: number,
+): string | null {
+  if (podRuns <= 0) return null;
+  const childCategory = (category: string): boolean => ['self-implement', 'self-dev', 'harness']
+    .some((prefix) => category.startsWith(prefix));
+  const categories = [...(query.categories ?? []), ...(query.exactCategories ?? [])];
+  if (!categories.some(childCategory) && !(categories.length === 0 && (query.events?.length ?? 0) > 0)) return null;
+  return `안내: 이 창에 Pod 에서 돈 런 ${podRuns}개 — Pod 자식의 관측은 이 logs.db 에 수집되지 않는다(POD-OBS). 원장으로 본다: elanous self run-ledger <runId>`;
+}
+
+/** Select ledger roots independently of DB existence; --all includes registered roots with no logs.db. */
+function podLedgerDirectories(opts: LogsCliOpts, targets: readonly LogTarget[], instances: readonly LogInstanceView[]): string[] {
+  const roots = targets.map(({ dbPath }) => dirname(dirname(dbPath)));
+  if (opts.all && !opts.instance) {
+    roots.push(dirname(dirname(prodTarget().dbPath)));
+    for (const instance of instances) {
+      if (instance.kind !== 'test' || opts.includeTest) roots.push(instance.stateDir);
+    }
+  }
+  return [...new Set(roots.map((root) => join(root, 'run-ledger')))];
+}
+
+/** Read-only run-ledger scan over the independently selected instance roots. */
+async function countPodRunLedgers(
+  directories: readonly string[],
+  query: Pick<LogQuery, 'sinceMs' | 'untilMs'>,
+): Promise<{ podRuns: number; unreadableLedgers: number }> {
+  const { loadRunLedger } = await import('../self-implement/run-ledger.js');
+  const untilMs = query.untilMs ?? Date.now();
+  const sinceMs = query.sinceMs ?? untilMs - LOG_RETENTION_DEFAULTS.maxAgeDays * 86_400_000;
+  let podRuns = 0;
+  let unreadableLedgers = 0;
+  for (const directory of directories) {
+    let files: string[];
+    try { files = readdirSync(directory); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') unreadableLedgers += 1;
+      continue;
+    }
+    for (const file of files) {
+      if (!/^run-[a-zA-Z0-9-]+\.jsonl$/.test(file)) continue;
+      try {
+        const stamp = statSync(join(directory, file));
+        if (!stamp.isFile() || stamp.mtimeMs < sinceMs) continue;
+        const ledger = loadRunLedger(file.slice(0, -'.jsonl'.length), directory);
+        if (!ledger) { unreadableLedgers += 1; continue; }
+        const origin = ledger.find((entry) => entry.event === 'run-origin');
+        if (!origin || typeof origin.data.hostname !== 'string' || !origin.data.hostname.startsWith('si-task-')) continue;
+        let start = Number.POSITIVE_INFINITY;
+        let end = Number.NEGATIVE_INFINITY;
+        for (const entry of ledger) {
+          const time = entry.timestamp === undefined ? NaN : Date.parse(entry.timestamp);
+          if (!Number.isFinite(time)) continue;
+          start = Math.min(start, time);
+          end = Math.max(end, time);
+        }
+        // Older ledgers may have no timestamp at all; their mtime is the only available window evidence.
+        if (start === Number.POSITIVE_INFINITY) { start = stamp.mtimeMs; end = stamp.mtimeMs; }
+        if (start <= untilMs && end >= sinceMs) podRuns += 1;
+      } catch { unreadableLedgers += 1; }
+    }
+  }
+  return { podRuns, unreadableLedgers };
+}
+
 // ── 0건 --event 안내: 이미 찍힌 기록에서만 답한다 ────────────────────────
 //
 // 갈림 ① 어느 범위에서 모으나 — **고정 24시간 관측 창**.
@@ -1480,9 +1548,25 @@ export async function runLogsCli(opts: LogsCliOpts, deps: RunLogsCliDeps = {}):
     : {};
   const queryStatus = registryScope.queryStatus;
   const unopenedStoreBanner = unopenedStores === undefined ? '안 본 스토어 수 미측정' : `안 본 스토어 ${unopenedStores}개`;
+  const podGap = !opts.topFailures && podObservationGapNotice(query, 1) !== null
+    ? await countPodRunLedgers(podLedgerDirectories(opts, resolved.targets, registryScope.instances), query)
+    : null;
+  const podNotice = podGap ? podObservationGapNotice(query, podGap.podRuns) : null;
+  const podGapMeta = podGap && (podNotice || podGap.unreadableLedgers > 0)
+    ? { _meta: { type: 'log-query-pod-observation-gap', ...podGap } }
+    : null;
+  const emitPodGap = (): void => {
+    if (!opts.json && podGap) {
+      if (podNotice) console.error(`${podNotice}${podGap.unreadableLedgers > 0 ? ` (못 읽은 원장 ${podGap.unreadableLedgers})` : ''}`);
+      else if (podGap.unreadableLedgers > 0) console.error(`안내: Pod 원장 조회 중 못 읽은 원장 ${podGap.unreadableLedgers}개 — Pod 런 수를 확정할 수 없다(POD-OBS).`);
+    }
+    if (podGapMeta && podGap) debug.log('logs.query', 'pod-observation-gap', podGap);
+  };
   if (opened.length === 0) {
     console.error(`elanous logs: 열 수 있는 로그 스토어 없음 — ${missing.join(' · ') || '타겟 0'} · scope=${JSON.stringify(scope)} · queryStatus=${JSON.stringify(queryStatus)}`);
     console.error('  스토어는 해당 인스턴스 데몬(LF0 이후)이 한 번은 떠야 생성됩니다.');
+    if (opts.json && podGapMeta) console.log(JSON.stringify(podGapMeta));
+    emitPodGap();
     return 1;
   }
   if (missing.length > 0) console.error(`elanous logs: 스킵 — ${missing.join(' · ')}`);
@@ -1666,6 +1750,7 @@ export async function runLogsCli(opts: LogsCliOpts, deps: RunLogsCliDeps = {}):
     // JSONL 소비자는 stdout만 읽는다. 결손·중복 성격·상한 메타도 별도 행으로 내어 행별 JSON 파싱을 보존한다.
     if (opts.json && multiSurfaceDuplicateMeta) outputLines.unshift(JSON.stringify(multiSurfaceDuplicateMeta));
     if (opts.json && unreadableMeta) outputLines.unshift(JSON.stringify(unreadableMeta));
+    if (opts.json && podGapMeta) outputLines.unshift(JSON.stringify(podGapMeta));
     if (unreadableInstances.length > 0 && !opts.json) {
       outputLines.unshift(`⚠️ 못 읽은 인스턴스 ${unreadableInstances.length}개: ${unreadableInstances.join(', ')}`);
     }
@@ -1676,6 +1761,7 @@ export async function runLogsCli(opts: LogsCliOpts, deps: RunLogsCliDeps = {}):
       const output = `${outputLines.join('\n')}\n`;
       await new Promise<void>((resolve, reject) => process.stdout.write(output, (error) => error ? reject(error) : resolve()));
     }
+    emitPodGap();
     const eventWarning = eventCategoryWarning(opts.event);
     if (eventWarning) {
       console.error(eventWarning);
@@ -1744,6 +1830,8 @@ export async function runLogsCli(opts: LogsCliOpts, deps: RunLogsCliDeps = {}):
   }
   seed.sort((a, b) => a.row.ts_ms - b.row.ts_ms || a.row.id - b.row.id);
   for (const m of seed.slice(-20)) emit(m.row, m.name, m.path);
+  if (opts.json && podGapMeta) console.log(JSON.stringify(podGapMeta));
+  emitPodGap();
   const cursors = new Map<string, number>();
   for (const { name, store } of opened) {
     try { cursors.set(name, store.maxId()); } catch { cursors.set(name, 0); }
@@ -1993,6 +2081,20 @@ logsCmd.command('durations')
     process.exit(runLogsToolDurations(merged));
   });
 
+logsCmd.command('model-input')
+  .description('최근 노드 종류별 모델 입력 토큰 기준선 (중앙값·p90·못 잼 별도 집계, 기본 3일)')
+  .option('--since <t>', '조회 시작 (기본 3d · 30s|15m|2h|7d 또는 ISO)')
+  .option('--json', '구조화 JSON 출력')
+  .option('--test', 'cwd 레포의 격리 테스트 인스턴스(.elanous-test/)')
+  .option('--instance <name>', '레지스트리 등록 인스턴스')
+  .option('--all', '등록된 모든 로그 인스턴스 연합 조회')
+  .option('--include-test', '--all 연합에 격리 test 인스턴스 포함')
+  .action(async (o: import('./logs-model-input.js').LogsModelInputOpts, cmd: { optsWithGlobals(): Record<string, unknown> }) => {
+    const merged = { ...cmd.optsWithGlobals(), ...o } as import('./logs-model-input.js').LogsModelInputOpts;
+    const { runLogsModelInput } = await import('./logs-model-input.js');
+    process.exitCode = runLogsModelInput(merged);
+  });
+
 logsCmd.command('degenerate')
   .description('수치 로그 필드의 always-same/all-zero/표본 부족 퇴화를 NDJSON으로 판정 (기본 표본 50)')
   .option('--category <prefix>', '카테고리 접두 필터 (복수는 쉼표)')

package/src/cli/logs-model-input.ts

@@ -0,0 +1,131 @@
+import { existsSync } from 'node:fs';
+import type { LogStoreRow } from '../mss/logging/log-store.js';
+import { LogStore } from '../mss/logging/log-store.js';
+import type { ModelInputObservation } from '../harness/model-input-observation.js';
+import { collectDegenerateRows } from './logs-degenerate.js';
+import { parseSince, resolveLogTargets } from './logs-cli.js';
+
+const DAY_MS = 86_400_000;
+const CATEGORY = 'harness.model-input';
+const EVENT = 'recorded';
+
+type Baseline = { scope: ModelInputObservation['scope']; nodeKind: string; measured: number; unmeasured: number; median: number | null; p90: number | null };
+export interface ModelInputReport {
+  since: string;
+  until: string;
+  stores: string[];
+  records: number;
+  baselines: Baseline[];
+}
+export interface LogsModelInputOpts {
+  since?: string;
+  json?: boolean;
+  test?: boolean;
+  instance?: string;
+  all?: boolean;
+  includeTest?: boolean;
+}
+export interface LogsModelInputDeps {
+  exists: typeof existsSync;
+  openReadOnly: typeof LogStore.openReadOnly;
+  resolveTargets: typeof resolveLogTargets;
+  now: () => number;
+  write: (line: string) => void;
+  writeError: (line: string) => void;
+}
+const DEFAULT_DEPS: LogsModelInputDeps = {
+  exists: existsSync, openReadOnly: LogStore.openReadOnly, resolveTargets: resolveLogTargets,
+  now: Date.now, write: console.log, writeError: console.error,
+};
+
+/** Only observations with a known state enter the baseline; unavailable usage is not zero. */
+export function summarizeModelInput(rows: readonly LogStoreRow[], since: string, until: string, stores: string[]): ModelInputReport {
+  const groups = new Map<string, { scope: Baseline['scope']; nodeKind: string; values: number[]; unmeasured: number }>();
+  let records = 0;
+  for (const row of rows) {
+    if (row.category !== CATEGORY || row.event !== EVENT || !row.data) continue;
+    let data: unknown;
+    try { data = JSON.parse(row.data); } catch { continue; }
+    if (!data || typeof data !== 'object' || Array.isArray(data)) continue;
+    const observation = data as Partial<ModelInputObservation>;
+    if ((observation.scope !== 'harness-node' && observation.scope !== 'loop-tick')
+      || typeof observation.nodeKind !== 'string' || !observation.nodeKind.trim()) continue;
+    const measured = observation.status === 'measured'
+      && typeof observation.inputTokens === 'number'
+      && Number.isSafeInteger(observation.inputTokens) && observation.inputTokens >= 0;
+    const unmeasured = observation.status === 'unmeasured' && observation.inputTokens === null;
+    if (!measured && !unmeasured) continue;
+    const key = JSON.stringify([observation.scope, observation.nodeKind]);
+    const group = groups.get(key) ?? { scope: observation.scope, nodeKind: observation.nodeKind, values: [], unmeasured: 0 };
+    if (measured) group.values.push(observation.inputTokens as number);
+    else group.unmeasured += 1;
+    groups.set(key, group);
+    records += 1;
+  }
+  const baselines = [...groups.values()].map(({ scope, nodeKind, values, unmeasured }): Baseline => {
+    values.sort((a, b) => a - b);
+    const n = values.length;
+    return {
+      scope, nodeKind, measured: n, unmeasured,
+      median: n === 0 ? null : n % 2 === 1 ? values[Math.floor(n / 2)]! : (values[n / 2 - 1]! + values[n / 2]!) / 2,
+      p90: n === 0 ? null : values[Math.ceil(n * 0.9) - 1]!,
+    };
+  }).sort((a, b) => a.scope.localeCompare(b.scope) || a.nodeKind.localeCompare(b.nodeKind));
+  return { since, until, stores, records, baselines };
+}
+
+export function renderModelInput(report: ModelInputReport): string {
+  return [
+    `model input tokens · ${report.since} ~ ${report.until} · stores=${report.stores.join(', ') || '(없음)'} · records=${report.records}`,
+    'scope\tnodeKind\tmeasured\tmedian\tp90\t못 잼',
+    ...(report.baselines.length === 0 ? ['(관측 표본 없음)'] : report.baselines.map((item) =>
+      `${item.scope}\t${item.nodeKind}\t${item.measured}\t${item.median ?? '—'}\t${item.p90 ?? '—'}\t${item.unmeasured}`)),
+  ].join('\n');
+}
+
+/** Read the entire bounded time window rather than just the newest default page. */
+export function runLogsModelInput(opts: LogsModelInputOpts, deps: LogsModelInputDeps = DEFAULT_DEPS): number {
+  const untilMs = deps.now();
+  const relative = opts.since === undefined ? null : /^(\d+)(s|m|h|d)$/.exec(opts.since.trim());
+  const unitMs = { s: 1_000, m: 60_000, h: 3_600_000, d: DAY_MS };
+  const sinceMs = opts.since === undefined ? untilMs - 3 * DAY_MS
+    : relative ? untilMs - Number(relative[1]) * unitMs[relative[2] as keyof typeof unitMs]
+      : parseSince(opts.since);
+  if (sinceMs === null || !Number.isFinite(sinceMs) || sinceMs > untilMs) {
+    deps.writeError('elanous logs model-input: --since 파싱 불가 또는 미래 시각 (예: 3d, ISO)');
+    return 1;
+  }
+  const resolved = deps.resolveTargets({ test: opts.test, instance: opts.instance, all: opts.all, includeTest: opts.includeTest });
+  if (resolved.error) { deps.writeError(`elanous logs model-input: ${resolved.error}`); return 1; }
+  const rows: LogStoreRow[] = [];
+  const stores: string[] = [];
+  // Without a stable observation ID, equal timestamps and payloads in different
+  // stores may belong to distinct executions. Count every stored record.
+  for (const target of resolved.targets) {
+    if (!deps.exists(target.dbPath)) {
+      deps.writeError(`elanous logs model-input: 로그 스토어 없음: ${target.name} (${target.dbPath})`);
+      return 1;
+    }
+    let store: LogStore;
+    try { store = deps.openReadOnly(target.dbPath); }
+    catch (error) {
+      deps.writeError(`elanous logs model-input: ${target.name} 열기 실패: ${String(error)}`);
+      return 1;
+    }
+    try {
+      const scan = collectDegenerateRows(store, { exactCategories: [CATEGORY], events: [EVENT], sinceMs, untilMs });
+      if (scan.truncated) {
+        deps.writeError(`elanous logs model-input: ${target.name} 스캔 상한 도달 — --since 창을 좁혀라`);
+        return 1;
+      }
+      stores.push(target.name);
+      rows.push(...scan.rows);
+    } catch (error) {
+      deps.writeError(`elanous logs model-input: ${target.name} 조회 실패: ${String(error)}`);
+      return 1;
+    } finally { store.close(); }
+  }
+  const report = summarizeModelInput(rows, new Date(sinceMs).toISOString(), new Date(untilMs).toISOString(), stores);
+  deps.write(opts.json ? JSON.stringify(report) : renderModelInput(report));
+  return 0;
+}

package/src/cli/pod-cli.ts

@@ -94,6 +94,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
             const mem = (v: number | null) => v === null ? '?' : `${(v / 1024 ** 3).toFixed(1)}Gi`;
             io.log(`${m.context} | ${m.capacity} | ${m.running ?? '?'} | ${m.pending ?? '?'} | ${mem(m.memoryLimitBytes)}/${mem(m.allocatableMemoryBytes)} | ${m.allocatableCpuMillicores === null ? '?' : m.allocatableCpuMillicores / 1000}${m.reason ? ` (${m.reason})` : ''}`);
           }
+          io.log(`실측 점유: ${measure.members.map((m) => `${m.context} ${m.running === null || m.pending === null ? '못 쟀다' : m.running + m.pending}/${m.capacity}`).join(' · ') || '?'}`);
           io.log(`권장 지금 ${decision.recommended ?? '?'} 개 더 (limitedBy=${decision.limitedBy ?? 'unknown'})${decision.reason ? ` · ${decision.reason}` : ''}`);
           io.log(`예약(저작 중) ${host.reserved} · 대기 Job ${waitingJobs ?? '?'} · 실행 ${decision.running ?? '?'}`);
           io.log(`임대 없는 실행 ${decision.unleasedRunning ?? '?'}`);
@@ -155,6 +156,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         });
         if (result.image) io.error(`[pod] image ${result.image} · job ${result.job}`);
         io.log(result.artifactsDir);
+        if (result.artifacts?.error) io.error(`산출 회수 못 함: ${result.artifacts.error}`);
         io.exit(result.exitCode);
       } catch (err) {
         io.error(err instanceof Error ? err.message : String(err));

package/src/cli/pr-cli.ts

@@ -53,6 +53,8 @@ import {
 } from './pr-granularity.js';
 import { branchLineageSlug, findSiblingPrs } from './pr-lineage.js';
 import { parseReleaseNoteSection } from '../release-loop/release-note.js';
+import { landingFreezeMessage } from '../release-loop/landing-freeze.js';
+import { admitLandingMerge } from '../self-implement/frozen-merges.js';
 import { enqueueL8ShadowQueue, runL8ShadowQueue, shadowPrNumber, statusL8ShadowQueue, type L8ShadowQueueDeps } from '../self-implement/l8-merge-queue.js';
 
 export { branchLineageSlug, findSiblingPrs };
@@ -1574,7 +1576,32 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     return 0;
   }
 
-  let merged = manager.mergePrOutcome(upsert.url);
+  const prNumber = Number(/\/(\d+)$/.exec(upsert.url)?.[1]);
+  const landedHead = run('git', ['rev-parse', 'HEAD'], { cwd });
+  const headCommit = landedHead.ok && /^[a-f0-9]{40}$/i.test(landedHead.out.trim()) ? landedHead.out.trim() : undefined;
+  const validPr = Number.isSafeInteger(prNumber) && prNumber > 0;
+  const heldEntry = validPr && headCommit ? { prNumber, headCommit, repoRoot: cwd } : null;
+  const admission = admitLandingMerge(heldEntry, undefined, {}, validPr ? { prNumber, repoRoot: cwd, ...(headCommit ? { headCommit } : {}) } : undefined);
+  if (admission.kind === 'held' && !heldEntry) {
+    out.error(`✗ freeze: ready PR의 검증 HEAD/번호를 보존하지 못했습니다: ${upsert.url}`);
+    return 1;
+  }
+  if (admission.kind === 'held') {
+    const frozen = admission.freeze;
+    debug.log('harness.merge', 'frozen', { prUrl: upsert.url, reason: frozen.reason, until: frozen.until });
+    record('freeze', true, { url: upsert.url, reason: frozen.reason, until: frozen.until });
+    out.log(`✓ ready: ${upsert.url} — ${landingFreezeMessage(frozen)} · 병합 연기`);
+    return 0;
+  }
+  if (admission.kind === 'taken') {
+    record('freeze', true, { url: upsert.url, resumedElsewhere: true });
+    out.log(`✓ ready: ${upsert.url} — 동결이 막 풀려 보류 병합 재개가 이 PR 을 맡았습니다`);
+    return 0;
+  }
+  const landing = admission;
+  let merged: ReturnType<typeof manager.mergePrOutcome>;
+  try {
+  merged = manager.mergePrOutcome(upsert.url);
   // `GIT-S14` — 병합이 «미완료(OPEN)»로 끝났고 GitHub 가 아직 `mergeable=UNKNOWN`(병합 가능 여부 계산 중)이면
   //   짧게 기다렸다 다시 병합한다. 표본 셋(08-25 · 09-24 🅢 #20233 등)이 모두 «같은 명령 재시도에 병합»이었다.
   //   ⛔ UNKNOWN 일 때만 재시도한다 — CONFLICTING 등 다른 값은 기다려도 안 풀린다(그대로 실패를 낸다).
@@ -1588,6 +1615,7 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
     await sleep(PR_LAND_MERGEABLE_UNKNOWN_WAIT_MS);
     merged = manager.mergePrOutcome(upsert.url);
   }
+  } finally { landing.end(merged!?.ok === true); }
   if (!merged.ok) {
     // `GIT-S76` — 「미완료(OPEN)」만으로는 «충돌»과 «아직 계산 중»이 안 갈린다. GitHub 의 병합 가능 상태를 같이 싣는다.
     //   되읽기에 실패하면 종전 문면 그대로다(못 읽은 것을 「충돌 아님」으로 적지 않는다).

package/src/cli/private-ledger-commands.ts

@@ -1,11 +1,32 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { Command } from 'commander';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { debug } from '../debug/log.js';
+import { hqCliWriteAllowed, type HqDeps } from '../hq/hq.js';
+import { isIsolatedLedgerWriteRoot } from '../hq/ledger-write-target.js';
 
-// Private local ledgers (decisions · directives) are absent from the public export;
+// Private local ledgers (decisions · directives · claims · lesson) are absent from the public export;
 // JS-only distributions still register them. Kept out of src/index.ts so the `self`
 // block stays free of direct sink registration (see self-cli-sink-surface.test.ts).
-export function registerPrivateLedgerCommands(program: Command): void {
+const privateLedgerWrites: Record<string, readonly string[]> = {
+  claims: ['add', 'verify', 'publish', 'link', 'retract', 'list', 'show', 'render', 'recheck'], // list/show can mark expired evidence stale
+  lesson: ['add', 'recur', 'enforce', 'promote'],
+  directives: ['sync', 'search', 'list'], // search/list refresh the persistent index too
+};
+
+function mayWritePrivateLedger(name: string, args: readonly string[], hqDeps: HqDeps, ledgerRoot: string): boolean {
+  const action = args[0];
+  if (!action || !privateLedgerWrites[name]?.includes(action)) return true;
+  const command = `${name} ${action}`;
+  if (isIsolatedLedgerWriteRoot(ledgerRoot)) {
+    try { debug.log('hq.fence', 'skipped-isolated', { root: ledgerRoot, command }); } catch { /* observation is fail-soft */ }
+    return true;
+  }
+  return hqCliWriteAllowed(command, false, hqDeps);
+}
+
+export function registerPrivateLedgerCommands(program: Command, hqDeps: HqDeps = {}, ledgerRoot = elanousStateRoot()): void {
   if (existsSync(resolve(import.meta.dir, 'decisions-cli.ts')) || existsSync(resolve(import.meta.dir, 'decisions-cli.js'))) {
     program.command('decisions').description('대표 결정 로컬 원장').allowUnknownOption().allowExcessArguments(true)
       .action(async (_opts: unknown, command: Command) => {
@@ -18,13 +39,42 @@ export function registerPrivateLedgerCommands(program: Command): void {
         await privateProgram.parseAsync(['decisions', ...command.args], { from: 'user' });
       });
   }
+  if (existsSync(resolve(import.meta.dir, 'claims-cli.ts')) || existsSync(resolve(import.meta.dir, 'claims-cli.js'))) {
+    program.command('claims').description('소구점 실측 근거 로컬 원장').allowUnknownOption().allowExcessArguments(true)
+      .addHelpText('after', '\n  add <id>      주장 등록\n  verify <id>   실측 근거 기록\n  publish <id>  유효 근거로 공개\n  link <id>     체크리스트 연결\n  retract <id>  소구점 철회\n  list          소구점 목록\n  show <id>     근거·연결·이력 보기\n  render        deck·site·notice 문면 생성\n  recheck       낡은 근거 재측 요청\n\n각 명령의 옵션: elanous claims <명령> --help')
+      .action(async (_opts: unknown, command: Command) => {
+        if (!mayWritePrivateLedger('claims', command.args, hqDeps, ledgerRoot)) return;
+        try { await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('claims'); }
+        catch { /* Logging must not prevent recording a claim. */ }
+        const privateClaimsModule: string = './claims-cli.js';
+        const { registerClaimsCommands } = await import(privateClaimsModule) as { registerClaimsCommands: (program: Command, options: { stateDir: string; instanceRoot: string }) => void };
+        const privateProgram = new Command();
+        registerClaimsCommands(privateProgram, { stateDir: ledgerRoot, instanceRoot: ledgerRoot });
+        await privateProgram.parseAsync(['claims', ...command.args], { from: 'user' });
+      });
+  }
+  if (existsSync(resolve(import.meta.dir, 'lesson-cli.ts')) || existsSync(resolve(import.meta.dir, 'lesson-cli.js'))) {
+    program.command('lesson').description('교훈 · 재발 로컬 원장').allowUnknownOption().allowExcessArguments(true)
+      .addHelpText('after', '\n  import           문서 교훈 미리 보기 (--apply 로 적재)\n  add <id>         사고·원인·처방 등록\n  recur <id>       재발 기록\n  enforce <id>     강제 자리 기록\n  promote <id>     규칙 경로 기록\n  find <query>     교훈 검색\n  show <id>        발생·이력 보기\n  candidates       반복 교훈 목록\n\n각 명령의 옵션: elanous lesson <명령> --help')
+      .action(async (_opts: unknown, command: Command) => {
+        if (!mayWritePrivateLedger('lesson', command.args, hqDeps, ledgerRoot)) return;
+        try { await (await import('../domains/standalone-log-sink.js')).registerStandaloneLogSink('lesson'); }
+        catch { /* Logging must not prevent recording a lesson. */ }
+        const privateLessonModule: string = './lesson-cli.js';
+        const { registerLessonCommands } = await import(privateLessonModule) as { registerLessonCommands: (program: Command, options: { stateDir: string }) => void };
+        const privateProgram = new Command();
+        registerLessonCommands(privateProgram, { stateDir: ledgerRoot });
+        await privateProgram.parseAsync(['lesson', ...command.args], { from: 'user' });
+      });
+  }
   if (existsSync(resolve(import.meta.dir, 'directives-cli.ts')) || existsSync(resolve(import.meta.dir, 'directives-cli.js'))) {
     program.command('directives').description('대표 지시 로컬 색인·검색').allowUnknownOption().allowExcessArguments(true)
       .action(async (_opts: unknown, command: Command) => {
+        if (!mayWritePrivateLedger('directives', command.args, hqDeps, ledgerRoot)) return;
         const privateDirectivesModule: string = './directives-cli.js';
-        const { registerDirectivesCommands } = await import(privateDirectivesModule) as { registerDirectivesCommands: (program: Command) => void };
+        const { registerDirectivesCommands } = await import(privateDirectivesModule) as { registerDirectivesCommands: (program: Command, options: { stateDir: string }) => void };
         const privateProgram = new Command();
-        registerDirectivesCommands(privateProgram);
+        registerDirectivesCommands(privateProgram, { stateDir: ledgerRoot });
         await privateProgram.parseAsync(['directives', ...command.args], { from: 'user' });
       });
   }

package/src/cli/pty-drive-verdict.ts

@@ -8,6 +8,8 @@ export interface FinalPtyEvidence {
   readonly screen: string;
   readonly inputHistory: readonly string[];
   readonly exitCode: number | null;
+  /** A separately verified mission artifact; tool-history failures are not final-answer failures. */
+  readonly artifactEvidence?: boolean;
 }
 
 // eslint-disable-next-line no-control-regex
@@ -16,7 +18,7 @@ const FAILURE = /(?:\bcommand not found\b|\bnot recognized as (?:an internal or
 const SUCCESS = /(?:\b[1-9]\d*\s+(?:pass|passed)\b|\btests?:\s*[1-9]\d*\s+passed\b|\bbuild successful\b|\b(?:successfully|succeeded)\b|\bGOAL-COMPLETE\b)/i;
 
 /** Failure wins over success; an exit code of zero is not itself proof of the goal. */
-export function verdictForFinalPtyScreen({ screen, inputHistory, exitCode }: FinalPtyEvidence): PtyDriveVerdict {
+export function verdictForFinalPtyScreen({ screen, inputHistory, exitCode, artifactEvidence = false }: FinalPtyEvidence): PtyDriveVerdict {
   if (exitCode !== null && exitCode !== 0) {
     return { kind: 'done-but-failed', reason: `child exit code ${exitCode}`, evidence: null };
   }
@@ -32,7 +34,14 @@ export function verdictForFinalPtyScreen({ screen, inputHistory, exitCode }: Fin
   }));
   const lines = screen.replace(ANSI, '').replace(/\r/g, '\n').split('\n')
     .map((line) => line.trim()).filter((line) => line && !inputs.has(line) && !echoedLiterals.has(line) && ![...inputs].some((input) => line.endsWith(`$ ${input}`) || line.endsWith(`> ${input}`)));
-  const failure = lines.find((line) => FAILURE.test(line));
+  const toolNoMatch = (line: string) =>
+    /\b(?:rg|grep|diff)\b.*\bexit(?:ed)?\s*(?:with\s*)?(?:code\s*)?1\b|\bexit(?:ed)?\s*(?:with\s*)?(?:code\s*)?1\b.*\b(?:rg|grep|diff)\b/i.test(line)
+    && !/(?:\b(?:error|fatal|exception)\s*:|\b(?:build failed|tests? failed|failed to|permission denied|command not found)\b)/i.test(line);
+  // Codex renders tool status as «• Failed (exit 1) …». It is not the agent's final answer.
+  // For artifact-backed missions, consider only answer text following the last tool block.
+  const lastTool = artifactEvidence ? lines.reduce((index, line, i) => /^•\s+(?:Ran|Failed|Running|Worked)\b/i.test(line) ? i : index, -1) : -1;
+  const answer = lastTool < 0 ? lines : lines.slice(lastTool + 1).filter((line) => !/^[└│]/.test(line));
+  const failure = (artifactEvidence ? answer : lines).find((line) => FAILURE.test(line) && !toolNoMatch(line));
   if (failure) return { kind: 'done-but-failed', reason: failure, evidence: null };
   const evidence = lines.find((line) => SUCCESS.test(line) && !/\b0\s+(?:pass|passed)\b/i.test(line));
   if (evidence) return { kind: 'success', reason: 'final PTY screen has success evidence', evidence };