elanous 0.2.12 → 0.2.14

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/outputs-cli.ts

@@ -0,0 +1,92 @@
+import { accessSync, constants, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Command } from 'commander';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import type { OutputEntry } from '../outputs/ledger.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+type ListOptions = { since?: string; source?: string; limit?: string; json?: boolean };
+
+function sinceIso(value: string): string {
+  if (value === '24h' || value === '7d') {
+    return new Date(Date.now() - (value === '24h' ? 24 : 7 * 24) * 60 * 60 * 1000).toISOString();
+  }
+  if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?(?:Z|[+-]\d{2}:\d{2})$/.test(value)
+    || !Number.isFinite(Date.parse(value))
+    || new Date(`${value.slice(0, 10)}T00:00:00Z`).toISOString().slice(0, 10) !== value.slice(0, 10)) {
+    throw new Error(`invalid --since: ${value} (ISO|24h|7d)`);
+  }
+  return new Date(value).toISOString();
+}
+
+// listOutputs intentionally tolerates unreadable months. Detect inaccessible ledger files here so the CLI
+// does not report an incomplete read as a genuine zero (including when run as root under chmod 000).
+function assertReadableLedger(root: string): void {
+  const dir = join(root, 'outputs');
+  let names: string[];
+  try {
+    const info = statSync(dir);
+    if (!info.isDirectory() || (info.mode & 0o444) === 0 || (info.mode & 0o111) === 0) {
+      throw new Error(`outputs ledger directory unreadable: ${dir}`);
+    }
+    accessSync(dir, constants.R_OK | constants.X_OK);
+    names = readdirSync(dir);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return;
+    throw error;
+  }
+  for (const name of names.filter(name => /^outputs-\d{4}-(0[1-9]|1[0-2])\.jsonl$/.test(name) || name === 'outputs.jsonl')) {
+    const file = join(dir, name);
+    const info = statSync(file);
+    if (!info.isFile() || (info.mode & 0o444) === 0) throw new Error(`outputs ledger file unreadable: ${file}`);
+    accessSync(file, constants.R_OK);
+  }
+}
+
+export function registerOutputsCommands(program: Command): void {
+  program.command('outputs').description('산출물 원장 조회 (읽기 전용)')
+    .command('list').description('산출물 최신순 목록과 종류별 수')
+    .option('--since <ISO|24h|7d>', '이 시각 이후')
+    .option('--source <source>', 'exec|field-reel|field-feed')
+    .option('--limit <N>', '최대 건수 (기본 50)', '50')
+    .option('--json', 'JSON 출력')
+    .action(async (options: ListOptions) => {
+      try {
+        if (options.source !== undefined && !['exec', 'field-reel', 'field-feed'].includes(options.source)) {
+          throw new Error(`invalid --source: ${options.source} (exec|field-reel|field-feed)`);
+        }
+        if (!options.limit || !/^[1-9]\d*$/.test(options.limit) || !Number.isSafeInteger(Number(options.limit))) {
+          throw new Error(`invalid --limit: ${options.limit}`);
+        }
+        const scope = {
+          since: options.since === undefined ? undefined : sinceIso(options.since),
+          source: options.source as OutputEntry['source'] | undefined,
+          limit: Number(options.limit),
+        };
+        const displayedScope = { since: scope.since ?? null, source: scope.source ?? null, limit: scope.limit };
+        const root = effectiveInstanceRoot();
+        assertReadableLedger(root);
+        const { listOutputs } = await import('../outputs/ledger.js');
+        const items = listOutputs(scope, root);
+        const byKind: Record<string, number> = {};
+        for (const item of items) byKind[item.kind] = (byKind[item.kind] ?? 0) + 1;
+        debug.log('outputs.cli', 'list', { count: items.length, source: scope.source, since: scope.since });
+        if (options.json) {
+          await writeStdoutJson(`${JSON.stringify({ items, count: items.length, byKind, scope: displayedScope })}\n`);
+          return;
+        }
+        for (const item of items) {
+          const at = Number.isFinite(Date.parse(item.at))
+            ? new Intl.DateTimeFormat('sv-SE', { timeZone: 'Asia/Seoul', dateStyle: 'short', timeStyle: 'medium', hourCycle: 'h23' }).format(new Date(item.at))
+            : item.at;
+          console.log(`${at} KST · ${item.kind} · ${item.title} · ${item.source}/${item.sourceId} · ${item.seat ?? '—'} · ${item.path ?? item.url ?? '—'}`);
+        }
+        if (!items.length) console.log(`scope: ${JSON.stringify(displayedScope)}`);
+        console.log(`${items.length}개 · 종류별 수 ${JSON.stringify(byKind)}`);
+      } catch (error) {
+        console.error(`outputs list: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+      }
+    });
+}

package/src/cli/persona-cli.ts

@@ -9,6 +9,8 @@ import { parsePersonaYaml } from '../persona/loader.js';
 import { resolveRepositoryPersonaDir, resolveStatePersonaDir } from '../persona/global-registry.js';
 import { UnknownPersonaSchemaKeyError, choosePersonaId, clonePreset, describePreset, editPersona, findPreset, loadPresetIndex, loadPresets, presetToProfileYaml } from '../persona/presets.js';
 import { addTeamSet, listTeamSets, removeTeamSet } from '../persona/team-set.js';
+import { validateTeamFile } from '../persona/team.js';
+import { runPersonaLoopOnce } from '../seat-loop/seat-loop.js';
 
 interface StoredPersona { personaId: string; displayName: string; description?: string; preset?: string; title?: string; path: string }
 
@@ -68,6 +70,18 @@ function editOptions(fromFile: string | undefined, assignments: readonly string[
 }
 
 export function registerPersonaCommands(program: Command): void {
+  program.command('team').description('Validate a YAML team definition')
+    .command('validate <file>').description('Check team schema, persona references and handoff order')
+    .action((file: string) => {
+      try {
+        const definition = validateTeamFile(file);
+        console.log(`Valid team ${definition.name}`);
+      } catch (error) {
+        console.error(error instanceof Error ? error.message.replace(/\s+/g, ' ').trim() : String(error));
+        process.exitCode = 2;
+      }
+    });
+
   const team = program.command('team-set').description('Install, remove and list persona team sets');
   team.command('add <file>').description('Install a YAML team set').action((file: string) => {
     try { const result = addTeamSet(file); console.log(`Installed team-set ${result['team-set']}`); }
@@ -178,6 +192,21 @@ export function registerPersonaCommands(program: Command): void {
       }
     });
 
+  persona.command('loop <name>')
+    .description('Shadow-pick one todo for a saved persona without executing it')
+    .requiredOption('--once', 'Pick exactly one todo')
+    .option('--json', 'JSON output')
+    .action(async (name: string, opts: { json?: boolean }) => {
+      try {
+        const entry = await runPersonaLoopOnce(name);
+        if (opts.json) console.log(JSON.stringify(entry));
+        else console.log(entry.todo ? `그림자 선택 — ${entry.todo.title} (${entry.todo.id})` : '할 일 없음');
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+      }
+    });
+
   persona.command('show <name>')
     .description('Show one of your personas (id or name), or a preset')
     .option('--json', 'JSON output')

package/src/cli/pod-cli.ts

@@ -6,9 +6,10 @@ import { debug } from '../debug/log.js';
 import { readPodMemoryAdvice } from './pod-memory-advice.js';
 import { getUserConfig } from '../user-config.js';
 import { listCodexAccountsInStore } from '../oauth/codex-account-store.js';
-import { parsePodPool, resolvePodPoolSpec, type PoolKubectl } from '../task-orchestrator/surfaces/pod-pool.js';
+import { parsePodPool, resolvePodPoolSpec, podPoolHostLease, type PoolKubectl } from '../task-orchestrator/surfaces/pod-pool.js';
 import { leaseKubectl, measurePoolLease, probePoolDns, recommendConcurrency, type PoolLeaseMeasure, type PoolDnsProbe } from '../task-orchestrator/surfaces/pod-lease.js';
 import { POD_COMMAND_DEADLINE_SECONDS, runPodCommand, type PodCommandResult, type RunPodCommandOptions } from '../task-orchestrator/surfaces/pod-command-job.js';
+import { hostLeaseCounts, leaseHasPendingPod } from '../pod-lease/host-lease.js';
 
 export interface PodCliIo {
   log: (line: string) => void;
@@ -78,8 +79,13 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
         const perAccount = (deps.perAccount ?? (() => getUserConfig().pod?.lease?.perAccount ?? 4))();
         const decision = recommendConcurrency(measure, { capacity: members.reduce((sum, m) => sum + m.capacity, 0), accounts: accounts ?? -1, perAccount });
         if (!context) { decision.recommended = null; decision.limitedBy = null; decision.reason = '측정 불가: cluster (current context)'; }
-        const result = { pool: spec, ...measure, accounts, perAccount, ...decision };
-        debug.log('pod.lease', 'status', { pool: spec ? members.map((m) => ({ capacity: m.capacity })) : null, running: decision.running, pending: decision.pending, unleasedRunning: decision.unleasedRunning, recommended: decision.recommended, limitedBy: decision.limitedBy });
+        const records = members.length ? podPoolHostLease(members).live() : [];
+        const host = hostLeaseCounts(records);
+        // Pending Pods and Job-only reservations are disjoint; a lease for an already Pending Job is the same Job.
+        const waitingJobs = decision.pending === null ? null : decision.pending +
+          records.filter((r) => r.stage === 'job' && !leaseHasPendingPod(r, decision.pendingJobs ?? [])).length;
+        const result = { pool: spec, ...measure, accounts, perAccount, ...decision, reserved: host.reserved, waitingJobs };
+        debug.log('pod.lease', 'status', { pool: spec ? members.map((m) => ({ capacity: m.capacity })) : null, running: decision.running, pending: decision.pending, reserved: host.reserved, waitingJobs, unleasedRunning: decision.unleasedRunning, recommended: decision.recommended, limitedBy: decision.limitedBy });
         if (opts.json) io.log(JSON.stringify(result));
         else {
           io.log(`풀: ${(spec ?? context) || '?'}`);
@@ -89,6 +95,7 @@ export function registerPodCommands(program: Command, deps: PodCliDeps = {}): vo
             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(`권장 지금 ${decision.recommended ?? '?'} 개 더 (limitedBy=${decision.limitedBy ?? 'unknown'})${decision.reason ? ` · ${decision.reason}` : ''}`);
+          io.log(`예약(저작 중) ${host.reserved} · 대기 Job ${waitingJobs ?? '?'} · 실행 ${decision.running ?? '?'}`);
           io.log(`임대 없는 실행 ${decision.unleasedRunning ?? '?'}`);
           io.log(`capacity: ${decision.capacitySlots ?? '?'} 칸 (상한 ${members.reduce((sum, m) => sum + m.capacity, 0)} − Running ${decision.running ?? '?'} − Pending ${decision.pending ?? '?'}; 권장 수에서 건강한 멤버의 임대 없는 실행 차감)`);
           io.log(`memory: ${decision.memorySlots ?? '?'} 칸 (할당 가능 − Running 하니스 상한 합; 골당 16Gi · 모든 네임스페이스의 노드별 기존 예약을 반영해 배치 가능 ${decision.placeableSlots ?? '?'} 칸)`);

package/src/cli/pr-cli.ts

@@ -53,6 +53,9 @@ 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 };
 
@@ -1573,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 등 다른 값은 기다려도 안 풀린다(그대로 실패를 낸다).
@@ -1587,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 의 병합 가능 상태를 같이 싣는다.
     //   되읽기에 실패하면 종전 문면 그대로다(못 읽은 것을 「충돌 아님」으로 적지 않는다).
@@ -1635,8 +1664,21 @@ export async function runPrLand(opts: PrLandOpts = {}, deps: PrLandDeps = {}): P
   return 0;
 }
 
-export function registerPrCommands(program: Command, deps: PrLandDeps = {}): void {
+export function registerPrCommands(program: Command, deps: PrLandDeps = {}, queueDeps: L8ShadowQueueDeps = {}): void {
   const pr = program.command('pr').description('PR landing commands');
+  const queue = pr.command('queue').description('Shadow merge queue (never lands PRs)');
+  const queueAction = async (action: () => Promise<unknown>) => {
+    try {
+      (deps.out ?? liveOut).log(JSON.stringify(await action()));
+    } catch (error) {
+      (deps.out ?? liveOut).error(`✗ merge-queue: ${String(error)}`);
+      (deps.setExitCode ?? ((code: number) => { process.exitCode = code; }))(1);
+    }
+  };
+  queue.command('status').description('Show pending PRs and shadow verdicts').action(() => queueAction(() => statusL8ShadowQueue(process.cwd(), queueDeps)));
+  queue.command('enqueue <pr>').description('Pin a ready PR at the tail of the shadow queue').action((prNumber: string) => queueAction(() => enqueueL8ShadowQueue(process.cwd(), shadowPrNumber(prNumber), queueDeps)));
+  queue.command('run').description('Evaluate the first PR without merging').requiredOption('--shadow', 'Only evaluate; never land').action(() => queueAction(() => runL8ShadowQueue(process.cwd(), queueDeps)));
+
   pr.command('land')
     .description('현재 브랜치 PR을 생성 또는 갱신해 ready 상태로 만들고 squash merge')
     .option('--base <branch>', 'PR base branch')

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 };