elanous 0.2.25 → 0.2.27

package/src/cli/seat-cli.ts

@@ -0,0 +1,121 @@
+import type { Command } from 'commander';
+import { existsSync, lstatSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, relative, sep } from 'node:path';
+import { redactSecretText } from '../debug/log.js';
+import { defaultMsgStorePath, readUnreadCount } from '../msg/msg-store.js';
+
+export const SEAT_ROLES = ['OP', 'TC', 'MK', 'UX'] as const;
+export type SeatRole = typeof SEAT_ROLES[number];
+
+const MAX_FIELD = 160;
+const MAX_ROWS = 12;
+const clean = (value: unknown): string => redactSecretText(String(value ?? '').replace(/[\r\n\t]+/g, ' ').trim()).slice(0, MAX_FIELD);
+const safeObject = (value: unknown, keys: readonly string[]): Record<string, string> => {
+  const source = value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+  return Object.fromEntries(keys.filter(key => source[key] !== undefined && source[key] !== null).map(key => [key, clean(source[key])]));
+};
+
+function isRegularSeatPath(home: string, root: string, path: string): boolean {
+  const suffix = relative(root, path);
+  if (!suffix || suffix === '..' || suffix.startsWith(`..${sep}`) || suffix.startsWith(sep)) return false;
+  if (!lstatSync(home).isDirectory()) return false;
+  let parent = home;
+  for (const part of relative(home, dirname(path)).split(sep).filter(Boolean)) {
+    parent = join(parent, part);
+    if (!lstatSync(parent).isDirectory()) return false;
+  }
+  return lstatSync(path).isFile();
+}
+
+function metadata(home: string, root: string, path: string, kind: 'markdown' | 'tsv' | 'memory'): { source: string; updated: string; rows: string[]; reason?: string } {
+  if (!existsSync(path)) return { source: path, updated: '미상', rows: [], reason: '미관측: 파일 없음' };
+  try {
+    if (!isRegularSeatPath(home, root, path)) return { source: path, updated: '미상', rows: [], reason: '미관측: 일반 경로가 아님' };
+    const updated = statSync(path).mtime.toISOString();
+    const text = readFileSync(path, 'utf8').slice(0, 256_000);
+    let rows: string[] = [];
+    if (kind === 'tsv') {
+      const headers = (text.split(/\r?\n/, 1)[0] ?? '').split('\t');
+      const allowed = kind === 'tsv' && path.endsWith('harvest-claims.tsv') ? ['pr', 'claimer', 'at', 'status'] : ['at', 'what', 'then'];
+      const indexes = allowed.map(key => headers.indexOf(key));
+      rows = text.split(/\r?\n/).slice(1).filter(Boolean).slice(0, MAX_ROWS).map(line => {
+        const cells = line.split('\t');
+        return allowed.map((key, i) => indexes[i] < 0 ? '' : `${key}=${clean(cells[indexes[i]])}`).filter(Boolean).join(' · ');
+      }).filter(Boolean);
+    } else if (kind === 'memory') {
+      rows = text.split(/\r?\n/).filter(line => /^#{1,6}\s/.test(line)).slice(0, MAX_ROWS).map(line => clean(line.replace(/^#+\s*/, '')));
+    } else {
+      rows = text.split(/\r?\n/).filter(line => (/^#{1,6}\s/.test(line) || /^(?:[-*]\s*)?(?:from|발신|시각|at)\s*[:：]/i.test(line)) && !/[`$;|<>]/.test(line)).slice(0, MAX_ROWS).map(line => {
+        const from = line.match(/^(?:[-*]\s*)?(?:from|발신)\s*[:：]\s*(OP|TC|MK|UX)\b/i);
+        if (/^(?:[-*]\s*)?(?:from|발신)\s*[:：]/i.test(line)) return from ? `From: ${from[1]!.toUpperCase()}` : '';
+        return clean(line.replace(/^#{1,6}\s*/, ''));
+      }).filter(Boolean);
+    }
+    return { source: path, updated, rows, ...(rows.length ? {} : { reason: '미관측: 허용된 메타데이터 없음' }) };
+  } catch {
+    return { source: path, updated: '미상', rows: [], reason: '미관측: 읽기 실패' };
+  }
+}
+
+function contextFacts(snapshot: unknown): string[] {
+  const root = snapshot !== null && typeof snapshot === 'object' && !Array.isArray(snapshot) ? snapshot as Record<string, unknown> : {};
+  const facts: string[] = [];
+  const sourceFacts = Array.isArray(root.facts) ? root.facts as unknown[] : [];
+  for (const item of sourceFacts.slice(0, MAX_ROWS)) {
+    const value = item !== null && typeof item === 'object' && !Array.isArray(item) ? item as Record<string, unknown> : {};
+    const keys = value.kind === 'cell' ? ['id', 'status', 'owner', 'version', 'source']
+      : value.kind === 'seat' ? ['seat', 'at', 'status', 'id', 'source']
+      : value.kind === 'run' ? ['phase', 'elapsed', 'source'] : [];
+    const values = safeObject(value, keys);
+    if (Object.keys(values).length) facts.push(`${clean(value.kind)}: ${Object.entries(values).map(([k, v]) => `${k}=${v}`).join(' · ')}`);
+  }
+  const sourceEvents = Array.isArray(root.events) ? root.events as unknown[] : [];
+  for (const item of sourceEvents.slice(0, MAX_ROWS)) {
+    const values = safeObject(item, ['at', 'kind', 'source', 'summary']);
+    if (Object.keys(values).length) facts.push(`event: ${Object.entries(values).map(([k, v]) => `${k}=${v}`).join(' · ')}`);
+  }
+  return facts.slice(0, MAX_ROWS);
+}
+
+export function renderSeatBootCard(seat: SeatRole, sections: ReadonlyArray<{ title: string; source: string; updated: string; rows: readonly string[]; reason?: string }>, facts: readonly string[], contextUpdated = '미상'): string {
+  const out = [`# ${seat} 자리 부팅 카드`, '', '## 현재 구조화 관측', '출처: elanous://context-now', `갱신: ${clean(contextUpdated)}`, ...(facts.length ? facts.map(row => `- ${clean(row)}`) : ['- 미관측: contextNow 구조화 facts/events 없음'])];
+  for (const section of sections) out.push('', `## ${section.title}`, `출처: ${clean(section.source)}`, `갱신: ${clean(section.updated)}`, ...(section.rows.length ? section.rows.map(row => `- ${clean(row)}`) : [`- ${clean(section.reason ?? '미관측')}`]));
+  return out.join('\n');
+}
+
+export function registerSeatBootCommands(command: Command, options: { home?: () => string; contextNow?: () => unknown; msgPath?: () => string } = {}): void {
+  command.command('boot <seat>').description('현재 자리 카드 — 허용된 메타데이터만 읽기 전용 표시')
+    .action(async (rawSeat: string) => {
+      const seat = rawSeat.toUpperCase();
+      if (!(SEAT_ROLES as readonly string[]).includes(seat)) { console.error(`seat boot: unknown seat ${rawSeat} (OP|TC|MK|UX)`); process.exitCode = 2; return; }
+      const home = options.home?.() ?? homedir();
+      const root = join(home, 'elanous-hq', 'seat-state');
+      let facts: string[] = [];
+      let contextUpdated = '미상';
+      try {
+        const snapshot = options.contextNow ? options.contextNow() : await (async () => {
+          const mod = await import('../context-bus/context-now.js');
+          return (mod.contextNow as unknown as (options: { audience: string }) => unknown)({ audience: 'operator' });
+        })();
+        const context = snapshot !== null && typeof snapshot === 'object' ? snapshot as Record<string, unknown> : {};
+        contextUpdated = typeof context.at === 'string' ? clean(context.at) : '시각 미관측';
+        facts = contextFacts(snapshot);
+      } catch { facts = []; contextUpdated = '미관측: contextNow 조회 실패'; }
+      const seatDir = join(root, seat);
+      const msgPath = options.msgPath?.() ?? defaultMsgStorePath();
+      let unread: number | null = null;
+      try { unread = readUnreadCount(seat, msgPath); }
+      catch { /* unavailable is not a measured zero */ }
+      const sections = [
+        { title: 'msg 원장', source: msgPath, updated: unread === null ? '미상' : new Date().toISOString(), rows: [`안 읽은 msg ${unread ?? '미관측'} (${seat})`] },
+        { title: 'HANDOFF', ...metadata(home, root, join(seatDir, 'HANDOFF.md'), 'markdown') },
+        { title: 'inbox', ...metadata(home, root, join(seatDir, 'inbox.md'), 'markdown') },
+        { title: '수확 주장', ...metadata(home, root, join(seatDir, 'harvest-claims.tsv'), 'tsv') },
+        { title: '예약', ...metadata(home, root, join(seatDir, 'scheduled.tsv'), 'tsv') },
+        { title: '공통 메모리 색인', ...metadata(home, root, join(root, 'memory', 'MEMORY.md'), 'memory') },
+      ];
+      console.log(renderSeatBootCard(seat as SeatRole, sections, facts, contextUpdated));
+    });
+}
+

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

@@ -0,0 +1,140 @@
+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 { injectUtterance, type UtteranceInput } from '../domains/self-awareness.js';
+import { writeStdoutJson } from './stdout-json.js';
+
+const PAGE_SIZE = 50;
+type UtteranceOrigin = 'human' | 'agent' | 'unknown';
+
+function refsOf(raw: string | null): Record<string, unknown> {
+  if (!raw) return {};
+  try {
+    const value: unknown = JSON.parse(raw);
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {};
+  } catch { return {}; }
+}
+
+function redact(value: string): string {
+  return redactSecretText(value)
+    .replace(/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, '[REDACTED_EMAIL]')
+    .replace(/(https?:\/\/[^\s?#]+)\?[^\s#]*/gi, '$1?[REDACTED_QUERY]');
+}
+
+function isAutomatic(row: SurfaceEventRow): boolean {
+  const refs = refsOf(row.refs);
+  if (row.surface === 'coord:channel' || row.surface === 'coord:seat' || refs.origin === 'coord:channel') return true;
+  const seatSource = typeof refs.origin === 'string' && /^(?:seat|seat-notice|notification|wake|coord:seat)$/i.test(refs.origin);
+  if (seatSource) return true;
+  if (refs.origin === 'observer' || refs.origin === 'observer-generated' || /observer-generated/i.test(row.tags ?? '')) return true;
+  if (row.kind === 'qna' && /^(?:telegram|discord)$/i.test(row.surface)) return false;
+  if (refs.origin === 'human' || refs.origin === 'user') return false;
+  return false;
+}
+
+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';
+  }
+  // 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 } {
+  if (row.kind !== 'qna') return { text: row.text, extract: 'direct', truncated: false, truncationEvidence: null, possibleLoss: false };
+  const firstAnswer = row.text.startsWith('Q: ') ? row.text.indexOf('\nA: ', 3) : -1;
+  if (firstAnswer >= 0) {
+    const ambiguous = row.text.indexOf('\nQ: ', 3) >= 0 || row.text.indexOf('\nA: ', firstAnswer + 4) >= 0;
+    return { text: row.text.slice(3, firstAnswer), extract: ambiguous ? 'ambiguous' : 'qna', truncated: false, truncationEvidence: null, possibleLoss: ambiguous };
+  }
+  const summary = row.summary ?? '';
+  return { text: summary.slice(0, 150), extract: 'summary', truncated: summary.length > 150, truncationEvidence: summary.length > 150 ? 'over-cap' : summary.length === 150 ? 'cap-reached' : null, possibleLoss: false };
+}
+
+function validDate(value: string, name: string): string {
+  const date = new Date(value);
+  if (!value || !Number.isFinite(date.getTime()) || !/^\d{4}-\d\d-\d\d(?:T.*)?$/.test(value)) throw new Error(`--${name} must be a valid ISO date/time`);
+  return date.toISOString();
+}
+
+interface SelfUtterancesOptions {
+  from: string; to: string; surface?: string; origin?: UtteranceOrigin; page?: string; json?: boolean;
+}
+
+export function collectSelfUtterances(opts: SelfUtterancesOptions, db: ReturnType<typeof openSurfaceEventsDb>) {
+  const from = validDate(opts.from, 'from');
+  const to = validDate(opts.to, 'to');
+  if (from >= to) throw new Error('--from must be earlier than --to');
+  const page = opts.page === undefined ? 1 : Number(opts.page);
+  if (!Number.isSafeInteger(page) || page < 1) throw new Error('--page must be a positive integer');
+  const rows = querySurfaceUtterances(db, { from, to, ...(opts.surface ? { surface: opts.surface } : {}) });
+  let excludedAutomatic = 0;
+  let excludedByOrigin = 0;
+  let ambiguous = 0;
+  let truncated = 0;
+  let capReached = 0;
+  let possibleLoss = 0;
+  let excludedUnextractable = 0;
+  const utterances = rows.flatMap((row) => {
+    if (isAutomatic(row)) { excludedAutomatic += 1; return []; }
+    const origin = originOf(row);
+    if (opts.origin && origin !== opts.origin) { excludedByOrigin += 1; return []; }
+    const refs = refsOf(row.refs);
+    const cwd = typeof refs.cwd === 'string' && refs.cwd.length > 0 && !/[\u0000-\u001f\u007f]/.test(refs.cwd) ? redact(refs.cwd) : null;
+    const extracted = utteranceText(row);
+    if (row.kind === 'qna' && extracted.text.trim() === '') { excludedUnextractable += 1; return []; }
+    if (extracted.extract === 'ambiguous') ambiguous += 1;
+    if (extracted.truncated) truncated += 1;
+    if (extracted.truncationEvidence === 'cap-reached') capReached += 1;
+    if (extracted.possibleLoss) possibleLoss += 1;
+    return [{ id: redact(row.id), ts: redact(row.ts), surface: redact(row.surface), session: row.session_id ? redact(row.session_id) : null, cwd, origin, source: typeof refs.origin === 'string' ? redact(refs.origin) : 'unrecorded', text: redact(extracted.text), extract: extracted.extract, truncated: extracted.truncated, truncationEvidence: extracted.truncationEvidence, possibleLoss: extracted.possibleLoss }];
+  });
+  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) };
+}
+
+export function recordSelfUtterance(input: UtteranceInput & { utteranceOrigin?: 'human' | 'agent' }, db?: Database): { eventId: string } {
+  const store = db ?? openSurfaceEventsDb();
+  try {
+    const result = injectUtterance(input, store);
+    if (input.utteranceOrigin === 'human') {
+      store.prepare("UPDATE events SET refs = json_set(refs, '$.utteranceOrigin', 'human') WHERE id = ?").run(result.eventId);
+    }
+    return result;
+  } finally { if (!db) store.close(); }
+}
+
+export function registerSelfUtterancesCommand(selfCmd: Command): void {
+  selfCmd.command('utterances').description('Read paginated original utterances from surface_events (read-only)')
+    .requiredOption('--from <ISO>', 'Inclusive ISO date/time')
+    .requiredOption('--to <ISO>', 'Exclusive ISO date/time')
+    .option('--surface <surface>', 'Filter by surface')
+    .option('--origin <origin>', 'Filter by known origin: human|agent')
+    .option('--page <page>', 'One-based page number', '1')
+    .option('--json', 'Emit JSON')
+    .action(async (opts: SelfUtterancesOptions) => {
+      if (opts.origin && opts.origin !== 'human' && opts.origin !== 'agent') throw new Error('--origin must be human or agent');
+      const db = new Database(surfaceEventsDbPath(), { readonly: true });
+      try {
+        const result = collectSelfUtterances(opts, db);
+        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)}`);
+        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(); }
+    });
+}
+
+export { PAGE_SIZE };

package/src/cli/tasks-cli.ts

@@ -1,17 +1,22 @@
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { loadRunLedger as loadRunLedgerSync } from '../self-implement/run-ledger.js';
+import { goalRunDbPath, loadGoalRunQuery } from '../self-implement/goal-run-store.js';
+import { loadGoalAskRecords } from '../self-implement/goal-ask-store.js';
 import { join, resolve } from 'node:path';
 import { InvalidArgumentError, Option, type Command } from 'commander';
 import { debug } from '../debug/log.js';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { readNexusRuntime } from '../nexus/runtime.js';
 import { checklistDevVersion } from '../release-loop/checklist.js';
+import { assignedVersions, releasedVersion, validateVersion } from '../release-loop/feature-store.js';
+import { compareVersions } from '../directives/version-at.js';
 import { cardsBoard, countBoardTasks, INTERNAL_PACK_PROJECT, mergeBoards, releasePackBoard, type BoardNode } from '../task-agent/board.js';
 import type { Task } from '../task-orchestrator/types.js';
-import { cardPrNumber, CLOSED_BY_HAND_EVENT, closeTaskCard, COMPLETION_KINDS, handTask, updateTaskCard, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, resolveHandText, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TA_LAND_ENV, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
+import { cardPrNumber, CLOSED_BY_HAND_EVENT, closeTaskCard, COMPLETION_KINDS, handTask, updateTaskCard, LIVE_MOVE_HISTORY_EVENT, LIVE_MOVE_RESULT_EVENT, nextMoveFor, resolveHandText, readTaskAgentState, readTaskCard, taskAgentStatePath as taskStatePathDefault, shellQuote, TASK_CARD_PREFIX, TASK_SEATS, type CompletionKind, type TaskCard, type TaskLaunchContext, type TaskLaunchReceipt, type TaskLauncher, type TaskSeat } from '../task-agent/task-hand.js';
 import { readCardSalvageBranch, recordWiringLiveVerified, refreshCardRunBinding, type CardRunEvidenceDeps } from '../task-agent/card-evidence.js';
 import { captureReviewResults } from '../task-agent/review-result-capture.js';
+import { replayRemoteCardMoves } from '../task-agent/shadow.js';
 import { HAND_MOVE_KINDS, recordHandMove } from '../task-agent/live-move-history.js';
 import { advanceMission, handMission, MissionAdvanceError, openMissionIds, recordPieceRef, type AdvanceMissionResult, type MissionDecompose, type PieceEvidenceReader } from '../task-agent/mission.js';
 import { formatSevenVerbLive, formatTaskAgentCover, measureSevenVerbLive, measureTaskAgentCover, type CoverRow, type SevenVerbLive, type TaskAgentCoverInput } from '../task-agent/cover.js';
@@ -38,7 +43,9 @@ export interface TasksCliDeps {
   /** `task advance` 의 착지 근거 읽기(시험 주입). 기본 = `predecessorState`(gh · 런 원장). */
   pieceEvidence?: PieceEvidenceReader;
   /** `task board` 의 내부 팩 어댑터(시험 주입). 기본 = 현재 판(`checklistDevVersion()`)의 `releasePackBoard` — 읽기만. */
-  releaseBoard?: () => BoardNode[];
+  releaseBoard?: (version?: string) => BoardNode[];
+  /** `tasks hand --checklist` 판 목록(시험 주입). 기본은 발행 전 체크리스트가 있는 판 전부. */
+  releaseVersions?: () => string[];
   /** `tasks show`·`advance` 의 런 근거 읽기(시험 주입) — 기본 = 런 원장(이 우주 ⊕ 연합) ⊕ 호스트 logs 의 Pod job-finished. */
   cardRunEvidence?: CardRunEvidenceDeps;
   /** `tasks live-verified` 가 적는 런 원장 디렉터리(시험 주입). 기본 = `runLedgerDir()`. */
@@ -54,10 +61,16 @@ export interface TasksCliDeps {
   coverLogs?: (query: LogQuery) => LogStoreRow[] | CoverLogRead;
   /** `tasks cover --by-card` 카드 원장 읽기 seam(읽기 전용). 플래그가 있을 때만 부른다. 기본 = TA 카드 원장(task-agent-actions.json). null = 못 읽음. */
   coverCards?: () => CoverCardRow[] | null | Promise<CoverCardRow[] | null>;
+  /** Read-only authored goal provenance; null means the authoring ledger could not be read. */
+  coverGoalAsks?: () => { authorRunId: string; goalId: string; createdAt: string }[] | null;
+  /** Read-only terminal goal records; null means the goal ledger could not be read. */
+  coverGoalRuns?: () => { goalId: string; outcome: string; stage?: string; startedAt: string; completedAt?: string }[] | null;
   /** TA-REJUDGE-ON-HEAD — `tasks rejudge` 의 판단 의존(시험 주입 · 기본 = 설정 liveMoves ⊕ 실물 gh·리뷰·재게이트·land). */
   rejudge?: Partial<import('../task-agent/rejudge-on-head.js').RejudgeDeps>;
   /** TA-REJUDGE-ON-HEAD — `tasks regate-run` 의 재게이트(시험 주입 · 기본 `runHostRegate`). */
   hostRegate?: (input: import('../self-implement/host-regate.js').HostRegateInput) => Promise<import('../self-implement/host-regate.js').HostRegateResult>;
+  /** Isolated regate-run tests can disable the asynchronous completion callback explicitly. */
+  regateCompletion?: false;
 }
 
 /** `<조각id>=<값>` 반복 인자. */
@@ -152,8 +165,8 @@ async function tryRemoteParent(args: string[], cwd: string | undefined, context:
     try { debug.log('task-agent', 'parent-host-fallback', { host: target.host, runId: context.runId, gaps, facts }); } catch { /* fail-soft */ }
     notice(`[parent-host] ${target.host} 로 못 띄움 — ${multi ? '다음 호스트 또는 로컬 발사로 간다' : '로컬 발사로 간다'}: ${gaps.join(' · ')}`);
   };
-  if (cwd || context.env[TA_LAND_ENV] === '1') {
-    failed(targets[0]!, [cwd ? 'project-target-is-local' : 'ta-land-needs-local-parent']);
+  if (cwd) {
+    failed(targets[0]!, ['project-target-is-local']);
     return null;
   }
   let launchHoldActive = false;
@@ -502,6 +515,7 @@ export function readTaskAgentCover(
   window: { sinceMs?: number; untilMs?: number } = {},
   query: NonNullable<TasksCliDeps['coverLogs']> = queryCoverLogs,
   taskCards?: readonly { id: string }[] | null,
+  goalReaders: Pick<TasksCliDeps, 'coverGoalAsks' | 'coverGoalRuns'> = {},
 ): { rows: CoverRow[]; sevenVerbs: SevenVerbLive; limitReached: boolean; unreadableStores: number } {
   let unreadableStores = 0;
   const read = (category: 'task-agent' | 'pr.land', event: 'action' | 'step'): { rows: LogStoreRow[]; limitReached: boolean } | null => {
@@ -517,16 +531,51 @@ export function readTaskAgentCover(
   const actions = actionRead?.rows ?? null;
   const lands = landRead?.rows ?? null;
   const truncated = { taskAgentActions: actionRead?.limitReached === true, allLands: landRead?.limitReached === true };
+  const inWindow = (value: string): boolean => {
+    const time = Date.parse(value);
+    return Number.isFinite(time) && (window.sinceMs === undefined || time >= window.sinceMs) && (window.untilMs === undefined || time <= window.untilMs);
+  };
+  let goalAsks: ReturnType<NonNullable<TasksCliDeps['coverGoalAsks']>> = null;
+  let goalRuns: ReturnType<NonNullable<TasksCliDeps['coverGoalRuns']>> = null;
+  let goalAsksTruncated = false;
+  let goalRunsTruncated = false;
+  try {
+    if (goalReaders.coverGoalAsks) goalAsks = goalReaders.coverGoalAsks();
+    else {
+      const asks = loadGoalAskRecords({ limit: COVER_QUERY_LIMIT }, goalRunDbPath());
+      goalAsksTruncated = asks.length >= COVER_QUERY_LIMIT;
+      goalAsks = asks;
+    }
+  } catch { goalAsks = null; }
+  try {
+    if (goalReaders.coverGoalRuns) goalRuns = goalReaders.coverGoalRuns();
+    else {
+      const runs = loadGoalRunQuery({ limit: COVER_QUERY_LIMIT }, goalRunDbPath());
+      goalRunsTruncated = runs?.truncated ?? false;
+      goalRuns = runs?.records.map(({ goalId, record }) => ({
+        goalId, outcome: record.outcome, stage: record.stage, startedAt: record.startedAt ?? '', completedAt: record.completedAt,
+      })) ?? null;
+    }
+  } catch { goalRuns = null; }
+  const authoredGoalIds = new Set(goalAsks?.map((ask) => ask.goalId) ?? []);
   const input: TaskAgentCoverInput = {
     taskAgentActions: actions === null ? null : coverEvents(actions, 'task-agent', 'action', (data) =>
       typeof data.kind === 'string' && typeof data.result === 'string'
         ? { kind: data.kind as NonNullable<TaskAgentCoverInput['taskAgentActions']>[number]['kind'], result: data.result, ...(typeof data.taskId === 'string' ? { taskId: data.taskId } : {}) } : null),
     allLands: lands === null ? null : coverEvents(lands, 'pr.land', 'step', (data) =>
       typeof data.step === 'string' && typeof data.ok === 'boolean' ? { step: data.step, ok: data.ok } : null),
-    truncated,
+    truncated: { ...truncated, goalAsks: goalAsksTruncated, goalRuns: goalRunsTruncated },
+    // Authoring may start before this window; completion is the event being counted.
+    goalAsks,
+    goalRuns: goalRuns && (window.sinceMs !== undefined || window.untilMs !== undefined)
+      ? goalRuns.some((run) => authoredGoalIds.has(run.goalId)
+          && run.stage === 'merged' && (run.outcome === 'completed' || run.outcome === 'merged')
+          && !Number.isFinite(Date.parse(run.completedAt ?? '')))
+        ? null : goalRuns.filter((run) => inWindow(run.completedAt ?? ''))
+      : goalRuns,
     ...(taskCards === undefined ? {} : { taskCards }),
   };
-  return { rows: measureTaskAgentCover(input), sevenVerbs: measureSevenVerbLive(input), limitReached: truncated.taskAgentActions || truncated.allLands, unreadableStores };
+  return { rows: measureTaskAgentCover(input), sevenVerbs: measureSevenVerbLive(input), limitReached: truncated.taskAgentActions || truncated.allLands || goalAsksTruncated || goalRunsTruncated, unreadableStores };
 }
 
 export function registerTasksCommands(program: Command, deps: TasksCliDeps = {}): void {
@@ -568,7 +617,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           }
           taskCards = coverCardsInWindow(cards, { sinceMs, untilMs });
         }
-        const { rows, sevenVerbs, limitReached, unreadableStores } = readTaskAgentCover({ sinceMs, untilMs }, deps.coverLogs, taskCards);
+        const { rows, sevenVerbs, limitReached, unreadableStores } = readTaskAgentCover({ sinceMs, untilMs }, deps.coverLogs, taskCards, deps);
         const limitWarning = limitReached ? `조회 상한 ${COVER_QUERY_LIMIT} 도달 — 더 오래된 사건이 있을 수 있다(절단된 수를 전체로 읽지 말 것)` : null;
         const storeWarning = unreadableStores > 0 ? `logs.db ${unreadableStores}개를 못 읽었다 — 그 우주의 사건은 수에 없다(«없다»로 읽지 말 것)` : null;
         if (opts.json) out(JSON.stringify({ rows, sevenVerbs, limitReached, unreadableStores, ...(limitWarning ? { warning: limitWarning } : {}), ...(storeWarning ? { storeWarning } : {}) }));
@@ -624,6 +673,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .description('TASK-AGENT 에 과제 한 줄을 넘긴다 — 카드를 적고 첫 수(harness say --substrate pod --merge-by-host)를 고른다 · 기본 shadow(발사 0) · `--mission` 이면 조각 카드 ⊕ 선후로 쪼개 선행 없는 조각만 넘긴다')
     .addOption(new Option('--seat <seat>', `과제 자리 (${TASK_SEATS.join('|')})`).choices([...TASK_SEATS]))
     .option('--checklist <cellId>', '릴리스 체크리스트 칸 id')
+    .option('--version <version>', '체크리스트 판 고정(생략하면 발행 전 판을 가까운 순서로 탐색)')
     .addOption(new Option('--completion <kind>', `종결 종류 (${COMPLETION_KINDS.join('|')} · 기본 code-pr = PR 병합)`).choices([...COMPLETION_KINDS]))
     .option('--mission <text>', '미션 문면 — 조각(`- …`·`① …`·`1. …` ⊕ `after: 1`)으로 나열돼 있으면 결정론, 아니면 분해기로 쪼갠다')
     .option('--project <id>', '프로젝트 id — --target 과 함께')
@@ -635,7 +685,72 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
     .option('--child-llm <provider/model>', 'TASKS-HAND-CHILD-LLM — 구현 자식 LLM(예: grok/grok-4.7) → 발사 인자 --child-llm-provider <provider> --child-llm-model <model> · «첫» `/` 에서만 가른다(모델 id 의 `/` 는 보존) · openrouter 는 모델 id 가 openrouter/ 접두를 포함하므로 전체를 모델로(openrouter/z-ai/glm-5.3 → --child-llm-model openrouter/z-ai/glm-5.3) · 카드 childLlm · 안 주면 명령·카드 무변경')
     .option('--child-llm-effort <level>', '구현 자식 추론 노력 → 발사 인자 --child-llm-effort(검증은 하니스 · --child-llm 과 함께)')
     .option('--json', 'JSON 출력')
-    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; taLand?: boolean; childLlm?: string; childLlmEffort?: string; json?: boolean }) => {
+    .action(async (text: string | undefined, opts: { seat?: TaskSeat; checklist?: string; version?: string; completion?: CompletionKind; mission?: string; project?: string; target?: string; goal?: string; milestone?: string; live?: boolean; taLand?: boolean; childLlm?: string; childLlmEffort?: string; json?: boolean }) => {
+      const suppliedText = text !== undefined;
+      if (opts.version !== undefined && opts.checklist === undefined) {
+        out('--version 은 --checklist 와 함께 준다');
+        process.exitCode = 1;
+        return;
+      }
+      if (opts.checklist !== undefined) {
+        const findTitle = (nodes: BoardNode[]): string | undefined => {
+          for (const node of nodes) {
+            if (node.level === 'task' && node.id === opts.checklist) return node.title;
+            const nested = node.children ? findTitle(node.children) : undefined;
+            if (nested !== undefined) return nested;
+          }
+          return undefined;
+        };
+        if (opts.version !== undefined) {
+          try { validateVersion(opts.version); }
+          catch (error) {
+            out(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+            return;
+          }
+        }
+        const versions = opts.version !== undefined ? [opts.version]
+          : [checklistDevVersion(), ...(deps.releaseVersions?.() ?? (deps.releaseBoard ? [] : (() => {
+            const released = releasedVersion();
+            return assignedVersions().filter((version) => !released || compareVersions(version, released) > 0);
+          })()))];
+        const current = checklistDevVersion();
+        const orderedVersions = [...new Set(versions)].sort((a, b) => {
+          if (a === current) return -1;
+          if (b === current) return 1;
+          const aFuture = compareVersions(a, current) > 0;
+          const bFuture = compareVersions(b, current) > 0;
+          if (aFuture !== bFuture) return aFuture ? -1 : 1;
+          return aFuture ? compareVersions(a, b) : compareVersions(b, a);
+        });
+        const matches: Array<{ version: string; title: string }> = [];
+        for (const version of orderedVersions) {
+          try {
+            const title = findTitle((deps.releaseBoard ?? releasePackBoard)(version));
+            if (title !== undefined) matches.push({ version, title });
+          } catch (error) {
+            if (opts.version !== undefined) {
+              out(`체크리스트 판 읽기 실패: ${version}`);
+              process.exitCode = 1;
+              return;
+            }
+            console.error(`⚠ 체크리스트 판 ${version} 읽기 실패 — 다른 판 계속 조회: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        const title = matches[0]?.title;
+        if (title === undefined) {
+          out(`체크리스트 칸 없음: ${opts.checklist}`);
+          process.exitCode = 1;
+          return;
+        }
+        if (matches.length > 1) console.error(`⚠ 체크리스트 칸 ${opts.checklist} 중복: ${matches.map((match) => match.version).join(', ')} — 가장 가까운 판 ${matches[0]!.version} 선택 (--version 으로 고정 가능)`);
+        if (opts.mission === undefined && text === undefined) text = title;
+      }
+      if (opts.checklist !== undefined && opts.mission === undefined && suppliedText && !text!.split(/\r?\n/, 1)[0]!.startsWith('대상 경로:')) {
+        out('칸 문면을 쓰려면 문면 인자를 빼라');
+        process.exitCode = 1;
+        return;
+      }
       await registerTaskAgentSink(deps.registerSink);
       if ((text === undefined) === (opts.mission === undefined)) {
         out('과제 한 줄 «또는» --mission <문면> 중 하나만 준다');
@@ -712,7 +827,7 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           out(`${result.card.id}\t${result.mode}\t${result.launched ? 'launched' : 'not launched'}`);
           out(`elanous ${result.move.command!.map(shellQuote).join(' ')}`);
           if (result.cwd) out(`(cwd: ${result.cwd})`);
-          if (result.card.taLand) out('(ta-land — 발사 env ELANOUS_TA_LAND=1 · 로컬 부모 · taskAgent.liveMoves 에 propose-land 가 있으면 병합은 TASK-AGENT 몫, 없으면 종전대로 호스트 병합)');
+          if (result.card.taLand) out('(ta-land — 발사 env ELANOUS_TA_LAND=1 · 원격 또는 로컬 부모 · taskAgent.liveMoves 에 propose-land 가 있으면 병합은 TASK-AGENT 몫, 없으면 종전대로 호스트 병합)');
           if (!result.launched) out('(shadow — 띄우지 않았다 · 띄우려면 --live)');
         }
       } catch (error) {
@@ -961,6 +1076,9 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
           for (const cardId of bindable) {
             // HARNESS-PARENT-ON-MSB1: 원격 부모 런은 원장이 그 호스트에 있다 — HQ 거울로 먼저 당긴다(읽기 전용).
             await mirrorRemoteCardLedger(cardId, deps);
+            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 */ }
@@ -1040,6 +1158,10 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       const liveMoves = deps.rejudge?.liveMoves ?? await configuredTaskAgentLiveMoves();
       const all = [];
       for (const cardId of ids) {
+        await mirrorRemoteCardLedger(cardId, deps);
+        try { await replayRemoteCardMoves(cardId, statePath, 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 */ }
+        }
         let outcomes: Awaited<ReturnType<typeof rejudgeCardOnHead>>;
         try { outcomes = await rejudgeCardOnHead(cardId, { ...deps.rejudge, liveMoves, live: { ...deps.rejudge?.live, statePath } }); } catch (error) {
           // 카드 하나의 예외가 --all 의 나머지 카드 판단을 멈추지 않게 — 사유를 남기고 다음 카드로.
@@ -1073,6 +1195,14 @@ export function registerTasksCommands(program: Command, deps: TasksCliDeps = {})
       try { debug.log('task-agent', 'regate-run', { card: opts.card, ...record, failures: result.failures.slice(0, 3) }); } catch { /* fail-soft */ }
       mkdir(dir(opts.out), { recursive: true });
       write(opts.out, JSON.stringify(record));
+      if (deps.regateCompletion !== false) {
+        try {
+          const { rejudgeCompletedTaskRegate } = await import('../task-agent/rejudge-on-head.js');
+          await rejudgeCompletedTaskRegate(opts.card, pr, opts.head, opts.out, deps.taskStatePath ?? taskStatePathDefault(), undefined, deps.rejudge);
+        } catch (error) {
+          try { debug.log('task-agent', 'regate-completion-rejudge-failed', { card: opts.card, pr, head: opts.head, reason: String(error).slice(-300) }, { level: 'warn' }); } catch { /* fail-soft */ }
+        }
+      }
       if (!result.passed) process.exitCode = 1;
     });
 

package/src/context-card/cell.ts

@@ -0,0 +1,40 @@
+import type { ContextCard } from './index.js';
+
+export interface CellCardItem {
+  readonly id: string;
+  readonly title: string;
+  readonly status: string;
+  readonly owner?: string | null;
+  readonly disposition?: string;
+  readonly evidence?: string;
+}
+
+const POINTER_PATTERN = /#\d+|run-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/giu;
+
+function extractPointers(text: string): string[] {
+  return [...text.matchAll(POINTER_PATTERN)].map(([pointer]) => pointer);
+}
+
+/** Build a compact checklist-cell card; evidence is used only to derive stable source pointers. */
+export function buildCellCard(version: string, item: CellCardItem, asOf: string): ContextCard {
+  const pointers = [...new Set([
+    ...extractPointers(item.evidence ?? ''),
+    ...extractPointers(item.title),
+    `checklist:${version}/${item.id}`,
+  ])];
+  const reasons = [
+    item.owner ? `담당 ${item.owner}` : undefined,
+    item.disposition ? `처분 ${item.disposition}` : undefined,
+  ].filter((value): value is string => value !== undefined);
+  return {
+    id: `cell:${version}/${item.id}`,
+    kind: 'cell',
+    conclusion: (item.title.split(/[\r\n\u2028\u2029]/u, 1)[0] ?? '').trim(),
+    why: reasons.join(' · '),
+    verdict: item.status,
+    remaining: [],
+    pointers,
+    source: `release-checklist:${version}`,
+    updatedAt: asOf,
+  };
+}

package/src/dashboard/boot-timing.ts

@@ -0,0 +1,35 @@
+import { debug } from '../debug/log.js';
+
+export interface BootTimer {
+  begin(): void;
+  phase(name: string): void;
+  done(): void;
+}
+
+export function createBootTimer(now: () => number = performance.now): BootTimer {
+  const startedAt = now();
+  let phaseStartedAt = startedAt;
+  let lastPhase: string | undefined;
+  let slowest: { phase: string; ms: number } | undefined;
+  let completed = false;
+
+  return {
+    begin(): void {
+      phaseStartedAt = now();
+    },
+    phase(name: string): void {
+      const current = now();
+      const ms = current - phaseStartedAt;
+      phaseStartedAt = current;
+      lastPhase = name;
+      if (!slowest || ms > slowest.ms) slowest = { phase: name, ms };
+      try { debug.log('tui.boot', 'phase', { phase: name, ms }); } catch { /* logging must not block startup */ }
+    },
+    done(): void {
+      if (completed) return;
+      completed = true;
+      const totalMs = now() - startedAt;
+      try { debug.log('tui.boot', 'summary', { totalMs, slowest: slowest ?? (lastPhase ? { phase: lastPhase, ms: totalMs } : null) }); } catch { /* logging must not block startup */ }
+    },
+  };
+}