elanous 0.2.35 → 0.2.37

package/src/cli/release-cli.ts

@@ -48,7 +48,7 @@ import type { AcceptedRegression } from '../../scripts/release-loop/resume.js';
 import type { PrereleaseKind } from '../../scripts/release-loop/release-version.js';
 import { releaseReadiness } from '../../scripts/release-loop/release-readiness.js';
 import { runReleaseIfReady } from './release-run-if-ready.js';
-import { ReleaseRunClaimConflict, findActiveReleaseRun, readActiveForceReleaseRun, readReleaseRunLock, withDirectReleaseRunLock, withForceReleaseRunMarker } from './release-single-flight.js';
+import { ReleaseRunClaimConflict, findActiveReleaseRun, readActiveForceReleaseRun, isPidAlive, readReleaseRunLock, withDirectReleaseRunLock, withForceReleaseRunMarker } from './release-single-flight.js';
 import { formatPreflight, releasePreflight } from '../../scripts/release-loop/preflight.js';
 import { defaultReleaseGraphRunsRoot, formatPublishProposal, measurePublishWindow, proposePublishAt, publishWindowWarning } from '../../scripts/release-loop/publish-window.js';
 import { autoStartScheduledRelease, type AutoStartDeferral } from '../release-loop/auto-start.js';
@@ -57,7 +57,7 @@ import { landingFreezeMessage, LandingFrozenError, readLandingFreeze } from '../
 import { formatLightRc, runLightRc, type LightRcDeps } from '../release-loop/light-rc.js';
 import { applyWatchList, formatGateHistory, gateHistory, ghMergedPrs } from '../../scripts/release-loop/gate-history.js';
 import { registerRfcCommands } from './rfc-cli.js';
-import { checklistCodenames, checklistVersion, isReleaseVersion, readChecklistContext, registerChecklistReadCommands } from './release-checklist-read-cli.js';
+import { checklistCodenames, checklistVersion, isReleaseVersion, readChecklistContext, registerChecklistReadCommands, type ChecklistEvidenceReader } from './release-checklist-read-cli.js';
 
 export { isReleaseVersion } from './release-checklist-read-cli.js';
 
@@ -547,19 +547,35 @@ export interface LandedButYellowDeps {
   evidenceAdd?: typeof features.evidenceAdd;
   schedules?: typeof features.readSchedules;
   released?: typeof features.releasedVersion;
+  /** Isolated cache location for tests; production defaults to the installation release ledger. */
+  mergedPrCacheFile?: () => string;
 }
 
 /** A spawn failure (gh missing from PATH) resolves `status: null` with the error text — the shape the sync runner gave. */
-const defaultMergedPrRunner: MergedPrRunner = (command, args, cwd) => new Promise((resolve) => {
+const defaultMergedPrRunner: MergedPrRunner = (command, args, cwd, timeoutMs) => new Promise((resolve) => {
   const out: Buffer[] = [], err: Buffer[] = [];
   const failed = (error: unknown) => resolve({ status: null, stdout: Buffer.concat(out).toString('utf8'), stderr: String(error) });
   let child: ReturnType<typeof spawn>;
+  let timedOut = false;
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  let killTimeout: ReturnType<typeof setTimeout> | undefined;
   try { child = spawn(command, [...args], { cwd, env: process.env, stdio: ['ignore', 'pipe', 'pipe'] }); }
   catch (error) { failed(error); return; }
+  if (timeoutMs !== undefined) timeout = setTimeout(() => {
+    timedOut = true;
+    child.kill('SIGTERM');
+    // The caller has already reached its explicit limit. Give gh a short cleanup window, then
+    // force-close it so an ignoring child cannot keep the CLI alive for the former 5s grace.
+    killTimeout = setTimeout(() => child.kill('SIGKILL'), 100);
+  }, timeoutMs);
   child.stdout?.on('data', (chunk: Buffer) => out.push(chunk));
   child.stderr?.on('data', (chunk: Buffer) => err.push(chunk));
   child.on('error', failed);
-  child.on('close', (code) => resolve({ status: code, stdout: Buffer.concat(out).toString('utf8'), stderr: Buffer.concat(err).toString('utf8') }));
+  child.on('close', (code) => {
+    if (timeout !== undefined) clearTimeout(timeout);
+    if (killTimeout !== undefined) clearTimeout(killTimeout);
+    resolve({ status: code, stdout: Buffer.concat(out).toString('utf8'), stderr: Buffer.concat(err).toString('utf8'), ...(timedOut ? { timedOut: true } : {}) });
+  });
 });
 
 function printLandedRows(rows: ReturnType<typeof landedButYellow>, items: ReturnType<typeof listChecklist>['items']): void {
@@ -588,7 +604,7 @@ function compareReleaseVersions(a: string, b: string): number {
   return 0;
 }
 
-export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}, lightRcDeps: LightRcDeps = {}, rehearsalDeps: RehearsalDeps = {}, resumeDeps: ResumeReleaseDeps = {}): void {
+export function registerReleaseCommands(program: Command, releaseRunDeps: UnattendedReleaseDeps = {}, landedDeps: LandedButYellowDeps = {}, hqDeps: HqDeps = {}, lightRcDeps: LightRcDeps = {}, rehearsalDeps: RehearsalDeps = {}, resumeDeps: ResumeReleaseDeps = {}, checklistEvidenceReader?: ChecklistEvidenceReader): void {
   registerRfcCommands(program);
   const release = program.command('release').description('공개 배포 한 판 — prepare(로컬) → publish(--yes) → verify (docs/manual/MANUAL-versioning-and-release-2026-09-25.md)');
   const schedule = release.command('schedule').description('판별 컷·착지 마감 조회·갱신');
@@ -780,13 +796,15 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
       console.log(renderRefsStatus(rows));
       console.log(`칸 ${rows.length} · 🟢 ${byStatus.green} · 🟡 ${byStatus.yellow} · 🔴 ${byStatus.red} · ✅ ${byStatus.done}`);
     });
-  registerChecklistReadCommands(checklist);
+  registerChecklistReadCommands(checklist, checklistEvidenceReader);
   withContext(checklist.command('landed-but-yellow').description('병합 PR 이 있지만 노랑·빨강인 칸(기본 읽기 전용)'))
     .option('--owner <owner>', '자리 또는 하위 자리로 거르기')
     .option('--open', '미발행 일정 판 중 칸이 있는 판 전부')
     .option('--apply-evidence', '확실한 PR 짝의 근거를 붙인다(상태는 그대로)')
     .option('--dry-run', '근거 추가 없이 계획만 출력')
-    .action(async (opts: { owner?: string; open?: boolean; applyEvidence?: boolean; dryRun?: boolean }, cmd: Command) => {
+    .option('--limit <ms>', '병합 PR 창 조회 시간 상한(밀리초) — 기본 무제한, 명시하면 초과 시 부분 결과와 stopReason·남은 칸 판 목록을 낸다')
+    .option('--time-budget <ms>', 'deprecated alias of --limit')
+    .action(async (opts: { owner?: string; open?: boolean; applyEvidence?: boolean; dryRun?: boolean; limit?: string; timeBudget?: string }, cmd: Command) => {
       // Stage timings (LANDED-YELLOW-FAST): which step ate the time — `elanous logs --category release.landed-yellow`.
       let stageAt = performance.now();
       const stage = (name: string, data: Record<string, unknown>) => {
@@ -835,10 +853,20 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           .map((item) => Date.parse(item.updatedAt)).filter((at) => Number.isFinite(at)));
         const since = updated.length ? new Date(updated.reduce((earliest, at) => Math.min(earliest, at))).toISOString().slice(0, 10)
           : new Date(now.getTime() - 7 * 86_400_000).toISOString().slice(0, 10);
+        if (opts.limit !== undefined && opts.timeBudget !== undefined) throw new CliUserError('--limit 과 --time-budget 중 하나만 지정할 수 있다');
+        const timeBudget = opts.limit ?? opts.timeBudget;
+        const timeBudgetMs = timeBudget === undefined ? undefined : Number(timeBudget);
+        if (timeBudgetMs !== undefined && (!Number.isFinite(timeBudgetMs) || timeBudgetMs <= 0)) {
+          throw new CliUserError(`잘못된 시간 상한: ${timeBudget}`, '--limit <ms> — 양의 밀리초 수치');
+        }
         const syncRun = landedDeps.run;
         const runAsync: MergedPrRunner = landedDeps.runAsync ?? (syncRun ? async (command, args, cwd) => syncRun(command, args, cwd) : defaultMergedPrRunner);
-        const { prs, truncated, calls } = await fetchMergedChecklistPrs(since, now, runAsync, process.cwd());
-        stage('merged-prs', { n: prs.length, calls, since, truncated });
+        const cacheFile = landedDeps.mergedPrCacheFile?.() ?? ((landedDeps.run || landedDeps.runAsync) ? undefined : join(releaseLedgerRoot(), 'release', 'landed-but-yellow-cache.json'));
+        const { prs, truncated, calls, stopReason, remainingWindows } = await fetchMergedChecklistPrs(since, now, runAsync, process.cwd(), {
+          ...(cacheFile ? { cacheFile } : {}),
+          timeBudgetMs,
+        });
+        stage('merged-prs', { n: prs.length, calls, since, truncated, ...(stopReason !== undefined ? { stopReason, remainingWindows: remainingWindows.length } : {}) });
         const results: Array<{ version: string; rows?: ReturnType<typeof landedButYellow>; plan?: ReturnType<typeof evidencePlan> }> = [];
         let totalAdded = 0, totalSkipped = 0;
         for (const snapshot of snapshots) {
@@ -869,9 +897,14 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
         if (opts.open) {
           if (opts.applyEvidence && !opts.dryRun) debug.log('release.checklist', 'evidence-synced', { versions: snapshots.map(({ version }) => version), added: totalAdded, skippedMention: totalSkipped });
           if (!json) console.log(`판 ${snapshots.length} · 붙임 합 ${totalAdded} · 건너뜀(언급만) 합 ${totalSkipped}`);
+          else if (stopReason !== undefined) await writeStdoutJson(`${JSON.stringify({ results, stopReason, remainingVersions: snapshots.map(({ version }) => version), remainingWindows })}\n`);
           else await writeStdoutJson(`${JSON.stringify(results)}\n`);
-        } else if (json) await writeStdoutJson(`${JSON.stringify(opts.applyEvidence || opts.dryRun ? results[0]!.plan : results[0]!.rows)}\n`);
+        } else if (json) {
+          const output = opts.applyEvidence || opts.dryRun ? results[0]!.plan : results[0]!.rows;
+          await writeStdoutJson(`${JSON.stringify(stopReason === undefined ? output : { results, stopReason, remainingVersions: snapshots.map(({ version }) => version), remainingWindows })}\n`);
+        }
         if (truncated) console.error('⚠ 병합 PR 400개 상한: 목록이 잘렸을 수 있다');
+        if (stopReason !== undefined) console.error(`⚠ 병합 PR 조회 시간 상한 도달: 부분 결과 ${prs.length} · 남은 판 ${snapshots.map(({ version }) => version).join(' · ')} · 미조회 UTC 창 ${remainingWindows.length}(${remainingWindows.slice(0, 3).join(' · ')}${remainingWindows.length > 3 ? ' …' : ''})`);
       } catch (error) {
         console.error(`⛔ ${error instanceof Error ? error.message : String(error)}`);
         process.exitCode = 1;
@@ -972,7 +1005,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
       const data = noteDispatchSkip(version, id, reason, opts.expectedTitle, opts.by);
       if (json) console.log(JSON.stringify(data)); else console.log(`✅ ${id} 건너뜀 근거 확인`);
     });
-  const evidence = checklist.command('evidence').description('칸의 PR·커밋 근거');
+  const evidence = checklist.commands.find((command) => command.name() === 'evidence')!;
   withContext(evidence.command('add <id> <ref>').description('근거 참조 추가')).action((id: string, ref: string, _opts: unknown, cmd: Command) => {
       const { version, json } = context(cmd);
       if (!mayWrite(cmd)) return;
@@ -1278,7 +1311,7 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
           const gate = plan.gatePlan.mode === 'not-run' ? 'gate 실행 없음'
             : plan.gatePlan.mode === 'partial' ? `부분 gate 계획 ${plan.partial.requested && plan.partial.applied ? `${plan.partial.files}파일` : '미상'}`
               : `전체 gate${plan.gatePlan.reason ? ` (${plan.gatePlan.reason})` : ''}`;
-          log(`· 재개 preflight 통과 · ${plan.version} · ${plan.fromNode}부터 · tip ${plan.tip.to.slice(0, 12)}${plan.tip.changed ? ` (기록 tip ${plan.tip.from.slice(0, 12)}에서 이동)` : ''} · ${gate} · 시도 ${plan.nextAttempt}/${plan.attemptLimit} · 실행·원장 변경 없음`);
+          log(`· 재개 preflight 통과 · ${plan.version} · ${plan.fromNode}부터 · tip ${plan.tip.to.slice(0, 12)}${plan.tip.changed ? ` (기록 tip ${plan.tip.from.slice(0, 12)}에서 이동)` : ''} · ${gate} · ${plan.priorCountKnown ? `시도 ${plan.nextAttempt}` : `새 원장 기록 ${plan.nextAttempt} (이전 횟수 미측정)`} · 실행·원장 변경 없음`);
           return plan;
         }
         const result = await resumeReleaseRun(resumeOptions, { onSource: log });
@@ -1368,7 +1401,11 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
             log(`· 리허설 ${stamp.version} ${stamp.step} · ${stamp.summary} · stage claim 해제 · 다음 tick 재시도`);
         }
         return result;
-      }, (result) => result.status !== 'failed' && !result.notificationFailures && !result.stamps?.some((stamp) => !['ok', 'superseded'].includes(stamp.outcome)));
+      // Recovery results carry no tick fields; the widened view keeps the same runtime verdict (main's tsc touch-clean).
+      }, (raw) => {
+        const result = raw as { status?: string; notificationFailures?: number; stamps?: readonly { outcome: string }[] };
+        return result.status !== 'failed' && !result.notificationFailures && !result.stamps?.some((stamp) => !['ok', 'superseded'].includes(stamp.outcome));
+      });
     });
   release.command('auto-start')
     .description('판 일정의 컷 창에서 릴리스 시작을 미리 본다 · --apply 로 release run --if-ready 실행')
@@ -1377,20 +1414,32 @@ export function registerReleaseCommands(program: Command, releaseRunDeps: Unatte
     .option('--json', '결과 한 줄 JSON(stdout)')
     .action(async (o: { windowMinutes: string; apply?: boolean; json?: boolean }) => {
       await jsonAction(o.json, async (log) => {
+        // Same authority as `release run`'s refusal: graph-run ledger, then a live force marker, then a run.lock whose
+        // pid is alive — the same liveness releaseReadiness refuses on, so the reason line can name the lock's startedAt.
+        const activeRun = (version: string, ledgerRoot: string) => {
+          const live = findActiveReleaseRun(version, ledgerRoot) ?? readActiveForceReleaseRun(version, ledgerRoot);
+          if (live) return live;
+          const lock = readReleaseRunLock(version, ledgerRoot);
+          return lock?.pid !== undefined && Number.isSafeInteger(lock.pid) && lock.pid > 0 && isPidAlive(lock.pid)
+            ? { runId: 'pending', pid: lock.pid, startedAt: lock.startedAt ?? 'unknown' } : undefined;
+        };
         const result = await autoStartScheduledRelease({
-          windowMinutes: Number(o.windowMinutes), apply: o.apply, ledgerRoot: scheduleLedgerRoot(),
+          windowMinutes: Number(o.windowMinutes), apply: o.apply, ledgerRoot: scheduleLedgerRoot(), activeRun,
           readiness: (version, ledgerRoot, now) => releaseReadiness(version, { ledgerRoot, now: () => now, checklist: releaseRunDeps.checklist }),
           launch: async (version, launchOptions) => {
             const ran = await runAction({ version, ifReady: true, publishAt: launchOptions?.publishAt, json: false }, log);
             if (ran && typeof ran === 'object' && ran.deferred) return ran;
+            // A run that appeared between readiness and launch is the same refusal, with its identity.
+            if (ran === false && activeRun(version, scheduleLedgerRoot())) return { deferred: true, reason: 'already-running' };
             if (ran !== true) throw new Error(`release run 미시작 또는 실패: ${version}`);
           },
         });
         if (result.status === 'planned') log(`· 미리 보기 ${result.version} · 컷 ${result.cutAt} · 실행하려면 --apply`);
         else if (result.status === 'started') log(`▶ 릴리스 시작 ${result.version} · 컷 ${result.cutAt}${result.publishAt ? ` · 발행 ${result.publishAt}` : ''}`);
         else if (result.status === 'skipped') log(`· 릴리스 연기 ${result.version} · ${result.reason}`);
+        else if (result.status === 'already-running') console.error(`⛔ 릴리스 이미 실행 중 ${result.version} · runId=${result.runId} pid=${result.pid} startedAt=${result.startedAt} · auto-start 거부`);
         else log('· 선택할 컷 없음');
         return result;
-      }, () => true);
+      }, (result) => result.status !== 'already-running');
     });
 }

package/src/cli/release-single-flight.ts

@@ -16,7 +16,7 @@ export class ReleaseRunClaimConflict extends Error {
   constructor() { super('release run claim already exists'); }
 }
 
-function isPidAlive(pid: number): boolean {
+export function isPidAlive(pid: number): boolean {
   try { process.kill(pid, 0); return true; }
   catch (error) {
     if ((error as NodeJS.ErrnoException).code === 'ESRCH') return false;

package/src/cli/self-update.ts

@@ -10,6 +10,15 @@ import { getUserConfig } from '../user-config.js';
 import { planEdgeRail, type EdgeRailInput, type EdgeRailPlan } from './self-update-canary.js';
 import { loadRunLedger } from '../self-implement/run-ledger.js';
 
+function selfUpdateOutputTail(output: string): string {
+  const lines = output.split(/\r?\n/).filter((line) => line.trim()).slice(-40);
+  return Array.from(lines.join('\n')).slice(-20_000).join('');
+}
+
+function selfUpdateReasonTail(tail: string): string {
+  return Array.from(tail).slice(-4_000).join('');
+}
+
 export interface SelfUpdateOptions {
   from?: string;
   restart?: boolean;
@@ -1241,25 +1250,34 @@ export async function runSelfUpdate(options: SelfUpdateOptions = {}, deps: SelfU
       try {
         const build = run('bun', ['bin/elanous.mjs', 'nexus', 'build'], checkout, { timeout: 15 * 60_000 });
         ok = build.status === 0;
-        tail = (build.stderr?.trim() || build.stdout?.trim() || '').split(/\r?\n/).filter((line) => line.trim()).at(-1)?.trim().slice(0, 500) ?? '';
+        const output = build.stderr?.trim() || build.stdout?.trim() || '';
+        tail = ok ? output.split(/\r?\n/).filter((line) => line.trim()).at(-1)?.trim().slice(0, 500) ?? '' : selfUpdateOutputTail(output);
       } catch (error) {
-        tail = String(error).split(/\r?\n/).at(-1)?.trim().slice(0, 500) ?? '';
+        tail = selfUpdateOutputTail(String(error));
       }
       const ms = Date.now() - started;
       try {
         debug.log('self-update', 'pwa-build', { ok, commit, ms });
         debug.log('self-update', 'pwa-build-tail', { commit, tail: tail || '출력 없음' });
+        if (!ok) debug.log('self-update', 'build-failed', { stage: 'pwa-build', commit, tail: tail || '출력 없음' });
       } catch { /* 관측 실패가 갱신을 막지 않는다 */ }
-      if (!ok) return emit({ exitCode: 1, installedVersion: null, decision, restarted: false, reason: `PWA 빌드 실패: ${tail || '출력 없음'}` });
+      if (!ok) return emit({ exitCode: 1, installedVersion: null, decision, restarted: false, reason: `PWA 빌드 실패: ${selfUpdateReasonTail(tail) || '출력 없음'}` });
       pwaBuild = { pwaBuiltCommit: commit, pwaBuiltAt: new Date().toISOString() };
     }
     let install: ReturnType<NonNullable<SelfUpdateDeps['run']>>;
+    let installTail = '';
     try {
       install = run('bash', [join(checkout, 'scripts/install.sh'), '--no-modify-path'], checkout);
+      if (install.status !== 0) installTail = selfUpdateOutputTail(install.stderr?.trim() || install.stdout?.trim() || '');
     } catch (error) {
-      return emit({ exitCode: 1, installedVersion: null, decision, restarted: false, reason: `설치 실패: ${String(error)}` });
+      installTail = selfUpdateOutputTail(String(error));
+      try { debug.log('self-update', 'build-failed', { stage: 'install', commit: head.stdout.trim().slice(0, 12), tail: installTail || '출력 없음' }); } catch { /* 관측 실패가 갱신을 막지 않는다 */ }
+      return emit({ exitCode: 1, installedVersion: null, decision, restarted: false, reason: `설치 실패: ${selfUpdateReasonTail(installTail) || '출력 없음'}` });
+    }
+    if (install.status !== 0) {
+      try { debug.log('self-update', 'build-failed', { stage: 'install', commit: head.stdout.trim().slice(0, 12), tail: installTail || '출력 없음' }); } catch { /* 관측 실패가 갱신을 막지 않는다 */ }
+      return emit({ exitCode: 1, installedVersion: null, decision, restarted: false, reason: `설치 실패: ${selfUpdateReasonTail(installTail) || '출력 없음'}` });
     }
-    if (install.status !== 0) return emit({ exitCode: 1, installedVersion: null, decision, restarted: false, reason: `설치 실패: ${install.stderr}` });
     let installedVersion: string;
     try {
       installedVersion = (deps.installedVersion ?? (() => basename(readlinkSync(join(homedir(), '.local/share/elanous/current')))))();

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

@@ -1,12 +1,12 @@
 import type { Command } from 'commander';
 import { Database } from 'bun:sqlite';
 import { redactSecretText } from '../debug/log.js';
-import { openSurfaceEventsDb, querySurfaceUtterances, surfaceEventsDbPath, type SurfaceEventRow } from '../domains/surface-events.js';
+import { classifySurfaceUtteranceOrigin, countSurfaceUtterancesByOrigin, openSurfaceEventsDb, querySurfaceUtterances, surfaceEventsDbPath, type SurfaceEventRow } from '../domains/surface-events.js';
 import { injectUtterance, type UtteranceInput } from '../domains/self-awareness.js';
 import { writeStdoutJson } from './stdout-json.js';
 
 const PAGE_SIZE = 50;
-type UtteranceOrigin = 'human' | 'agent' | 'unknown';
+type UtteranceOrigin = 'human' | 'agent' | 'test-fixture' | 'unknown';
 
 function refsOf(raw: string | null): Record<string, unknown> {
   if (!raw) return {};
@@ -33,21 +33,15 @@ function isAutomatic(row: SurfaceEventRow): boolean {
   return false;
 }
 
+/** 도메인 원천 분류(사람/시험 fixture/외부 CLI agent/elanous 자기)를 CLI 표기로 접는다.
+ *  시험 fixture 는 사람과 같은 서피스에 기록되지만 사람 표본이 아니다 — 별도 값으로 노출한다. */
 function originOf(row: SurfaceEventRow): UtteranceOrigin {
-  if (row.direction !== 'inbound') return 'unknown';
-  const refs = refsOf(row.refs);
-  if (refs.utteranceOrigin === 'human' || refs.utteranceOrigin === 'agent') return refs.utteranceOrigin;
-  const explicit = refs.origin;
-  if (typeof explicit === 'string') {
-    if (/^(?:human|user|tui|pwa|telegram|discord|cli)$/i.test(explicit)) return 'human';
-    if (/^(?:claude-code|codex|gemini|agent|external:)/i.test(explicit)) return 'agent';
+  switch (classifySurfaceUtteranceOrigin(row)) {
+    case 'human': return 'human';
+    case 'test-fixture': return 'test-fixture';
+    case 'external-cli-agent': case 'elanous-self': return 'agent';
+    default: return 'unknown';
   }
-  // recordInboundTurn marks its recorder as elanous-self; on chat Q&A the speaker is the human.
-  if (row.kind === 'qna' && /^(?:telegram|discord)$/i.test(row.surface)) return 'human';
-  if (explicit === 'elanous-self') return 'agent';
-  if (/^ext:/i.test(row.surface)) return 'agent';
-  if (/^(?:cli|tui|pwa|telegram|discord|ipad|watch)$/i.test(row.surface)) return 'human';
-  return 'unknown';
 }
 
 function utteranceText(row: SurfaceEventRow): { text: string; extract: 'direct' | 'qna' | 'ambiguous' | 'summary'; truncated: boolean; truncationEvidence: 'cap-reached' | 'over-cap' | null; possibleLoss: boolean } {
@@ -101,7 +95,9 @@ export function collectSelfUtterances(opts: SelfUtterancesOptions, db: ReturnTyp
   });
   const total = utterances.length;
   const start = (page - 1) * PAGE_SIZE;
-  return { source: 'surface_events.events (read-only)', filters: { from, to, surface: opts.surface ?? null, origin: opts.origin ?? null, automatic: 'excluded' }, counts: { matched: total, excludedAutomatic, excludedByOrigin, excludedUnextractable, ambiguous, truncated, capReached, possibleLoss }, page: { number: page, size: PAGE_SIZE, total, hasNext: start + PAGE_SIZE < total }, utterances: utterances.slice(start, start + PAGE_SIZE) };
+  // ⭐ 원천별 수를 «명시»한다 — 사람 원천 0 을 사람 표본으로 오인하지 않게(시험 fixture·외부 CLI agent 분리).
+  const originCounts = countSurfaceUtterancesByOrigin(db, { from, to, ...(opts.surface ? { surface: opts.surface } : {}) });
+  return { source: 'surface_events.events (read-only)', filters: { from, to, surface: opts.surface ?? null, origin: opts.origin ?? null, automatic: 'excluded' }, originCounts, humanSample: originCounts.human === 0 ? 'absent' : 'present', counts: { matched: total, excludedAutomatic, excludedByOrigin, excludedUnextractable, ambiguous, truncated, capReached, possibleLoss }, page: { number: page, size: PAGE_SIZE, total, hasNext: start + PAGE_SIZE < total }, utterances: utterances.slice(start, start + PAGE_SIZE) };
 }
 
 export function recordSelfUtterance(input: UtteranceInput & { utteranceOrigin?: 'human' | 'agent' }, db?: Database): { eventId: string } {
@@ -131,6 +127,7 @@ export function registerSelfUtterancesCommand(selfCmd: Command): void {
         if (opts.json) { await writeStdoutJson(JSON.stringify(result, null, 2) + '\n'); return; }
         console.log(`source=${result.source} matched=${result.counts.matched} excludedAutomatic=${result.counts.excludedAutomatic} excludedByOrigin=${result.counts.excludedByOrigin} excludedUnextractable=${result.counts.excludedUnextractable} page=${result.page.number} size=${result.page.size} hasNext=${result.page.hasNext}`);
         console.log(`filters=${JSON.stringify(result.filters)}`);
+        console.log(`origin-counts human=${result.originCounts.human} test-fixture=${result.originCounts.testFixture} external-cli-agent=${result.originCounts.externalCliAgent} elanous-self=${result.originCounts.elanousSelf} unknown=${result.originCounts.unknown} human-sample=${result.humanSample}`);
         for (const item of result.utterances) console.log(JSON.stringify(item));
         console.log(`ambiguous=${result.counts.ambiguous} truncated=${result.counts.truncated} cap-reached=${result.counts.capReached} possibleLoss=${result.counts.possibleLoss}`);
       } finally { db.close(); }

package/src/cli/tasks-card-show.ts

@@ -0,0 +1,162 @@
+import { debug } from '../debug/log.js';
+import { cardPrNumber, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, readTaskAgentState, readTaskCard, shellQuote, taskAgentStatePath as taskStatePathDefault, taskCardLabelContext, type TaskCard } from '../task-agent/task-hand.js';
+import { RUN_TAG_KEYS, runIdentityFieldText, runPriorityClass } from '../task-agent/run-identity.js';
+import { readCardSalvageBranch, refreshCardRunBinding } from '../task-agent/card-evidence.js';
+import { captureReviewResults } from '../task-agent/review-result-capture.js';
+import type { TasksCliDeps } from './tasks-cli.js';
+import { registerTaskAgentSink } from './tasks-read-cli.js';
+
+/**
+ * CLI-ENTRY-LAZY — `tasks show ta-…`(TASK-AGENT 과제 카드) 상세. `tasks-read-cli.ts` 가 카드 id 일 때만 싣는다.
+ */
+
+/** HARNESS-PARENT-ON-MSB1 — 카드가 원격 부모면 그 런 원장(⊕ Pod 자식)을 HQ 거울로 당긴다. 실패는 관측만(«없음»으로 읽히지 않게). */
+export async function mirrorRemoteCardLedger(cardId: string, deps: TasksCliDeps): Promise<void> {
+  let card: TaskCard | undefined;
+  try { card = readTaskCard(cardId, deps.taskStatePath); } catch { return; }
+  if (!card?.parentHost || !card.runId) return;
+  try {
+    if (deps.remoteLedgerMirror) { deps.remoteLedgerMirror(card); return; }
+    const { mirrorRemoteRunLedgers } = await import('../task-agent/parent-host.js');
+    const { effectiveInstanceRoot } = await import('../instance/resolve.js');
+    mirrorRemoteRunLedgers(card.parentHost, card.runId, effectiveInstanceRoot(), deps.cardRunEvidence?.ssh);
+  } catch (error) {
+    try { debug.log('task-agent', 'remote-ledger-mirror-failed', { card: cardId, host: card.parentHost.host, runId: card.runId, error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+  }
+}
+
+function moveLine(card: TaskCard): string {
+  const move = nextMoveFor(card);
+  return `${move.kind}${move.command ? ` — elanous ${move.command.map(shellQuote).join(' ')}` : ''} (${move.reason})`;
+}
+
+export function headLine(text: string): string {
+  const first = text.split('\n')[0]!.trim();
+  return first.length > 100 ? `${first.slice(0, 100)}…` : first;
+}
+
+/** 런 연결 한 줄 — 런 id 가 없으면 없다(옛 카드 · shadow). */
+function runLinkLine(card: TaskCard): string[] {
+  if (!card.runId) return [];
+  const number = cardPrNumber(card);
+  const url = typeof card.pr === 'object' ? card.pr.url : undefined;
+  const pr = number !== undefined ? `#${number}${url ? ` ${url}` : ''}` : '-';
+  return [`런: ${card.runId} · 골: ${card.goalId ?? '-'} · PR: ${pr}${card.runChildId ? ` · 자식 런: ${card.runChildId}` : ''}`];
+}
+
+/** RUN-IDENTITY-TAGS — 신분 한 줄 + Pod 라벨 한 줄(원장 정본 2줄 렌더 · 신분 없는 카드는 «미기록»으로 적고 기본값 정책을 밝힌다). */
+export function cardIdentityLines(card: TaskCard): string[] {
+  const identity = card.identity;
+  const { labels } = taskCardLabelContext({ id: card.id });
+  // 경계: Pod 에 실제로 붙는 라벨은 카드 id 하나뿐이다 — 신분 값은 Pod 라벨에 아직 안 실린다(RUN-IDENTITY-ADMIT 몫). 화면도 그렇게 말한다.
+  const podLine = `Pod 라벨 ${Object.entries(labels).map(([key, value]) => `${key}=${value}`).join(' ')} (신분 값은 Pod 라벨 미탑재 — RUN-IDENTITY-ADMIT)`;
+  if (!identity) return [`신분 미기록 — 원장에 identity 없음 · 승인·선점은 기본 class=${runPriorityClass(identity)} 로 읽는다`, podLine];
+  // ⛔ 모르는 칸을 기본값으로 보이지 않는다 — 원장에 없는 칸은 «미기록»으로 적는다(확인된 칸만 값으로).
+  const identityText = RUN_TAG_KEYS.map((key) => `${key}=${runIdentityFieldText(identity, key)}`).join(' · ');
+  const originParts = [identity.origin?.checklistId, identity.origin?.version, identity.origin?.seat, identity.origin?.launcher].filter((part) => part !== undefined);
+  return [
+    `신분 ${identityText}${originParts.length > 0 ? ` — 출생 ${originParts.join(' · ')}` : ''}`,
+    podLine,
+  ];
+}
+
+function taskCardLines(card: TaskCard): string[] {
+  return [
+    [card.id, card.status, card.seat ?? '-', card.checklistId ?? '-', card.createdAt, card.text].join('\t'),
+    ...cardIdentityLines(card),
+    ...(card.targetPaths !== undefined ? [`대상 경로: ${card.targetPaths.length ? card.targetPaths.join(' · ') : '(유효한 경로 없음)'}`] : []),
+    ...(card.mission ? [`미션: ${card.mission} · after: ${card.after?.length ? card.after.join(', ') : '-'}`] : []),
+    ...runLinkLine(card),
+    ...liveMoveLines(card),
+    `다음 수: ${moveLine(card)}`,
+  ];
+}
+
+/** TA-LIVE-MOVE-CARD-HISTORY — 카드 history 의 live-move 줄(실행·그림자)을 한 줄씩. 없으면 없다(옛 카드 그대로). */
+function liveMoveLines(card: TaskCard): string[] {
+  return (card.history ?? []).filter((item) => item.event === LIVE_MOVE_HISTORY_EVENT || item.event === LIVE_MOVE_RESULT_EVENT).map((item) => item.event === LIVE_MOVE_RESULT_EVENT ? [
+    // TA-REVIEW-RESULT-CAPTURE — 회수한 리뷰 결과(또는 «결과 없음») 줄.
+    `결과: ${item.at}`, `${item.kind ?? '?'}`, `PR ${item.pr !== undefined ? `#${item.pr}` : '-'}${item.head ? ` head ${item.head.slice(0, 12)}` : ''}`,
+    `verdict=${item.verdict ?? '—'} reviewed=${item.reviewed ?? '—'} must-fix=${item.mustFix ?? '—'} route=${item.reviewRoute ?? '—'}`,
+    `효과: ${item.effect ?? 'unknown'}`, (item.detail ?? '').replace(/\r\n|\r|\n/g, (match) => (match === '\r' ? '\\r' : '\\n')),
+  ].join(' · ') : [
+    `수: ${item.at}`, `${item.kind ?? '?'} ${item.executorResult ?? '?'}`, `executed=${item.executed === true} ok=${item.ok === undefined ? '—' : item.ok}`,
+    `PR ${item.pr !== undefined ? `#${item.pr}` : '-'}${item.head ? ` head ${item.head.slice(0, 12)}` : ''}`,
+    `효과: ${item.effect ?? 'unknown'}`, (item.detail ?? '').replace(/\r\n|\r|\n/g, (match) => (match === '\r' ? '\\r' : '\\n')),
+  ].join(' · '));
+}
+
+/** 미션 카드 — 머리 한 줄 ⊕ 조각 한 줄씩(상태·다음 수·선행) ⊕ 간선 한 줄씩. */
+function missionLines(mission: TaskCard, pieces: TaskCard[]): string[] {
+  const edges = pieces.flatMap((piece) => (piece.after ?? []).map((before) => `간선: ${before} -> ${piece.id}`));
+  return [
+    [mission.id, 'mission', mission.seat ?? '-', mission.checklistId ?? '-', mission.createdAt, `조각 ${pieces.length} · 간선 ${edges.length} · 출처 ${mission.splitSource ?? '-'}`, headLine(mission.text)].join('\t'),
+    ...pieces.map((piece) => [`조각: ${piece.id}`, piece.status, nextMoveFor(piece).kind, `after: ${piece.after?.length ? piece.after.join(',') : '-'}`, headLine(piece.text),
+      ...(piece.runId ? [`런: ${piece.runId}${cardPrNumber(piece) !== undefined ? ` · PR #${cardPrNumber(piece)}` : ''}`] : [])].join('\t')),
+    ...edges,
+    ...(mission.greenProposal ? [`green 제안: ${mission.greenProposal.at} · 칸 ${mission.greenProposal.checklistId ?? '-'} · 근거 ${Object.entries(mission.greenProposal.evidence).map(([id, ref]) => `${id}=${ref}`).join(', ')}`] : []),
+  ];
+}
+
+/** `tasks show <ta-…>` — 카드 ⊕ 런 근거 묶기 ⊕ 다음 수. 출력·종료 코드는 `out`·`process.exitCode` 로만 낸다. */
+export async function showTaskCard(id: string, opts: { json?: boolean }, deps: TasksCliDeps, out: (line: string) => void): Promise<void> {
+  await registerTaskAgentSink(deps.registerSink);
+  let card: TaskCard | undefined;
+  try {
+    card = readTaskCard(id, deps.taskStatePath);
+    // 런 id 가 있으면 원장에서 골 id · PR 을 묶는다(찾았을 때만 적는다 · 실패는 그대로 보인다).
+    const bindable = card?.pieces ? card.pieces : card ? [card.id] : [];
+    for (const cardId of bindable) {
+      // HARNESS-PARENT-ON-MSB1: 원격 부모 런은 원장이 그 호스트에 있다 — HQ 거울로 먼저 당긴다(읽기 전용).
+      await mirrorRemoteCardLedger(cardId, deps);
+      // shadow 는 묶을 카드가 있을 때만 싣는다 — 없는 카드·TOX 상세 조회는 이 클러스터를 안 싣는다(CLI-ENTRY-LAZY).
+      const { replayRemoteCardMoves } = await import('../task-agent/shadow.js');
+      try { await replayRemoteCardMoves(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
+        try { debug.log('task-agent', 'card-binding-replay-failed', { card: cardId, reason: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+      }
+      try { await refreshCardRunBinding(cardId, deps.taskStatePath ?? taskStatePathDefault(), deps.cardRunEvidence ?? {}); } catch (error) {
+        // 근거 없음으로 보인다 — 원장 부재와 갈리게 실패는 남긴다.
+        try { debug.log('task-agent', 'card-bind-failed', { card: cardId, via: 'show', error: error instanceof Error ? error.message : String(error) }); } catch { /* fail-soft */ }
+      }
+      // TA-REVIEW-RESULT-CAPTURE — 떼어 띄운 live review 의 결과 파일을 이 카드 history 로 회수한다(대기 중인 요청이 있을 때만 쓴다 · 던지지 않는다).
+      captureReviewResults(deps.taskStatePath ?? taskStatePathDefault(), { cardIds: [cardId], ...(deps.reviewResultNow ? { now: deps.reviewResultNow } : {}) });
+    }
+    if (card) card = readTaskCard(id, deps.taskStatePath);
+  } catch (error) {
+    out(error instanceof Error ? error.message : '과제 카드 읽기 실패');
+    process.exitCode = 1;
+    return;
+  }
+  if (!card) { out(`과제 카드 없음: ${id}`); process.exitCode = 1; return; }
+  if (card.pieces) {
+    let all: Record<string, TaskCard>;
+    try { all = readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(deps.taskStatePath ?? taskStatePathDefault()).tasks ?? {}; } catch (error) {
+      out(error instanceof Error ? error.message : '과제 카드 읽기 실패');
+      process.exitCode = 1;
+      return;
+    }
+    const pieces = card.pieces.map((pieceId) => all[pieceId]).filter((piece): piece is TaskCard => piece !== undefined);
+    const missingPieces = card.pieces.filter((pieceId) => !all[pieceId]);
+    if (opts.json) {
+      out(JSON.stringify({ card, nextMove: nextMoveFor(card), pieces: pieces.map((piece) => ({ card: piece, nextMove: nextMoveFor(piece) })), missingPieces }));
+      if (missingPieces.length) process.exitCode = 1;
+    }
+    else {
+      for (const line of missionLines(card, pieces)) out(line);
+      for (const missing of missingPieces) { out(`조각 카드 없음: ${missing} — 선후 기록이 불완전하다`); process.exitCode = 1; }
+    }
+    return;
+  }
+  // DRAFT-NOT-ARCHIVE: 멈춘 런이 draft PR 대신 남긴 수확 가지(원장 `salvaged`). 못 읽었으면 «못 읽음»(⛔ 없음 아님).
+  let salvage: Awaited<ReturnType<typeof readCardSalvageBranch>> = { salvageBranch: null };
+  try { salvage = await readCardSalvageBranch(card, deps.cardRunEvidence ?? {}); }
+  catch (error) { salvage = { salvageBranch: null, readErrors: [error instanceof Error ? error.message : String(error)] }; }
+  const salvageUnread = !salvage.salvageBranch && !!salvage.readErrors?.length;
+  if (opts.json) out(JSON.stringify({ card, nextMove: nextMoveFor(card), salvageBranch: salvage.salvageBranch, ...(salvageUnread ? { salvageBranchUnread: true } : {}) }));
+  else {
+    for (const line of taskCardLines(card)) out(line);
+    if (card.parentHost) out(`부모 호스트: ${card.parentHost.host}${card.parentHost.pid ? ` (pid ${card.parentHost.pid})` : ''} · PR 까지만 — 병합은 HQ${card.parentHost.log ? ` · 로그 ${card.parentHost.host}:${card.parentHost.log}` : ''}`);
+    if (salvage.salvageBranch) out(`수확 가지: ${salvage.salvageBranch} (draft PR 대신)`);
+    else if (salvageUnread) out('수확 가지: 못 읽음(원장 읽기 실패)');
+  }
+}