elanous 0.2.16 → 0.2.17

package/src/cli/self-update.ts

@@ -5,6 +5,10 @@ import { spawnSync } from 'node:child_process';
 import { decideRestartNeeded, type RestartNeededResult } from './nexus-restart-needed.js';
 import { debug } from '../debug/log.js';
 import { envLiteral } from '../platform/env-literal.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+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';
 
 export interface SelfUpdateOptions {
   from?: string;
@@ -22,6 +26,14 @@ export interface SelfUpdateOptions {
   dev?: boolean;
   /** install.json 의 이전 versionDir 로 current 를 되돌린다. 이전이 없으면 거부. */
   rollback?: boolean;
+  /** Canary rollout action; legacy --auto on|off|status is handled by the CLI scheduler. */
+  auto?: boolean;
+  dryRun?: boolean;
+  seat?: string;
+  quietWindow?: boolean;
+  failureRate?: EdgeRailInput['failureRate'];
+  /** Unique ID of an independently successful canary run; no id means no new run. */
+  canaryRunId?: string;
 }
 
 export interface SelfUpdateDeps {
@@ -30,6 +42,8 @@ export interface SelfUpdateDeps {
   decide?: (opts: { to: string; cwd: string; out: { log: (s: string) => void; error: (s: string) => void } }) => Promise<RestartNeededResult>;
   run?: (command: string, args: string[], cwd: string, options?: { timeout?: number }) => { status: number | null; stderr: string; stdout?: string };
   installedVersion?: () => string;
+  /** 캐너리 시작 «뒤»에 시작해 `completed` 로 끝난 런인가(주입 안 하면 런 원장 `canaryRunSucceededInLedger`). */
+  canaryRunSucceeded?: (runId: string, sinceIso: string) => boolean;
   /** 재시작 뒤 데몬이 이 커밋으로 떴나(주입 안 하면 `/v1/health` 를 최대 90초 폴링). */
   verifyRestart?: (expectedCommit: string) => Promise<VerifyRestartResult>;
   /** 판 목록(이름) — 되돌릴 판 찾기. */
@@ -58,6 +72,13 @@ export interface SelfUpdateDeps {
   packageVersion?: (checkout: string) => string;
   /** 재시작을 실제로 호출해도 되는지. NODE_ENV=test · ELANOUS_TEST_HOME 이면 기본 false. */
   allowLiveRestart?: boolean;
+  /** Automatic edge-rail inputs; injected in tests, never a service registration. */
+  now?: () => Date;
+  stateDir?: string;
+  edgeRailConfig?: () => Pick<EdgeRailInput, 'canaryOkRuns' | 'failureMultiplier' | 'minSamples'>;
+  installEdgeRail?: (options: SelfUpdateOptions, deps: SelfUpdateDeps) => Promise<SelfUpdateResult>;
+  rollbackEdgeRail?: (deps: Pick<SelfUpdateDeps, 'installRoot'>) => ReturnType<typeof rollbackDevInstall>;
+  restartEdgeRail?: () => Promise<boolean>;
 }
 
 export interface SelfUpdateResult {
@@ -87,6 +108,10 @@ export interface SelfUpdateResult {
   relay?: RelayUpdateOutcome;
   /** 텔레그램 러너(`com.elanous.telegram` · `elanous-telegram.service`) 판정 — 🆕 2026-09-25. */
   telegramRunner?: RelayUpdateOutcome;
+  edgeRail?: EdgeRailPlan;
+  missingFixes?: string;
+  /** 실패율 측정 원천이 없으면 자동 되돌림이 판단되지 않는다 — 측정 원천은 다음 조각(EDGE-RAIL2 범위 밖). */
+  autoRollback?: 'active' | 'inactive-no-failure-rate';
 }
 
 export interface RelayUpdateOutcome {
@@ -628,12 +653,186 @@ function readInstallSource(cliRoot: string, exists: (path: string) => boolean, r
   }
 }
 
+/** Output only; never uses a title to decide whether to install. */
+export function missingFixCommitTitles(checkout: string, installed: string, main: string, git: NonNullable<SelfUpdateDeps['git']>): string {
+  if (!/^[a-f0-9]{12,40}$/i.test(installed) || !/^[a-f0-9]{12,40}$/i.test(main)) return 'main 엔 있고 운영엔 없는 수리: 판정 불가';
+  const result = git(checkout, ['log', '--format=%s', '--no-merges', `${installed}..${main}`]);
+  if (result.status !== 0) return 'main 엔 있고 운영엔 없는 수리: 판정 불가';
+  const titles = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => /\bfix(?:es|ed)?\b|(?:^|[(:])fix[:)]/i.test(line))
+    .map((line) => line.replace(/[\r\n\t]+/g, ' ').slice(0, 160)).slice(0, 10);
+  return `main 엔 있고 운영엔 없는 수리: ${titles.length ? titles.join(' · ') : '없음'}`;
+}
+
+interface EdgeRailState { canary: NonNullable<EdgeRailInput['canary']>; mainCommit: string; lastRunId?: string; countedRunIds?: string[]; failureRate?: NonNullable<EdgeRailInput['failureRate']>; promoted?: boolean; rolledBack?: boolean }
+
+function saveEdgeRailState(file: string, state: EdgeRailState): void {
+  mkdirSync(dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`);
+  renameSync(tmp, file);
+}
+
+/** 런 원장에서: `start` 가 캐너리 시작 이후이고 마지막 `run-status` 가 `completed` 인 런만 참. 못 읽으면 거짓. */
+export function canaryRunSucceededInLedger(runId: string, sinceIso: string, dir?: string): boolean {
+  try {
+    const entries = (dir ? loadRunLedger(runId, dir) : loadRunLedger(runId)) ?? [];
+    const started = Date.parse(entries.find((entry) => entry.event === 'start')?.timestamp ?? '');
+    const last = entries.filter((entry) => entry.event === 'run-status').at(-1);
+    return Number.isFinite(started) && started >= Date.parse(sinceIso) && last?.data.runStatus === 'completed';
+  } catch { return false; }
+}
+
+async function restartEdgeRail(deps: SelfUpdateDeps, checkout: string): Promise<boolean> {
+  if (deps.restartEdgeRail) return deps.restartEdgeRail();
+  if (deps.allowLiveRestart === false || (deps.allowLiveRestart !== true && liveRestartBlocked())) return false;
+  const os = deps.os ?? platform();
+  const command = os === 'darwin' ? 'launchctl' : os === 'linux' ? 'systemctl' : null;
+  if (!command) return false;
+  const args = os === 'darwin' ? ['kickstart', '-k', `gui/${deps.uid ?? process.getuid?.() ?? userInfo().uid}/com.elanous.nexus`] : ['--user', 'restart', 'elanous-nexus'];
+  return (deps.run ?? execute)(command, args, checkout).status === 0;
+}
+
+export async function runEdgeRailUpdate(options: SelfUpdateOptions, deps: SelfUpdateDeps = {}): Promise<SelfUpdateResult> {
+  const out = deps.out ?? console;
+  const root = deps.installRoot ?? defaultInstallRoot();
+  const record = readInstallRecord(root);
+  const checkout = resolve(options.from ?? record?.source ?? deps.cliRoot ?? resolve(import.meta.dir, '../..'));
+  const stateFile = join(deps.stateDir ?? elanousStateRoot(), 'self-update-edge-rail.json');
+  const git = deps.git ?? ((cwd: string, args: string[]) => execute('git', args, cwd));
+  const fail = (reason: string): SelfUpdateResult => {
+    const result: SelfUpdateResult = { exitCode: 2, installedVersion: null, decision: null, restarted: false, reason };
+    out.log(options.json ? JSON.stringify(result) : `self-update --auto: hold — ${reason}`);
+    return result;
+  };
+  if (options.dev || options.rollback || options.version || options.restart) return fail('--auto cannot combine with --dev, --rollback, --version or --restart');
+  if (options.seat !== 'OP' && options.seat !== 'TC' && options.seat !== 'MK' && options.seat !== 'UX') return fail('--auto requires a known --seat (OP|TC|MK|UX)');
+  if (!record?.commit) return fail('installed commit unknown');
+  const currentName = versionDirName(record.versionDir);
+  if (!currentName || !installEntryExists(root, currentName)) return fail('installed entry missing');
+  try {
+    if (readlinkSync(join(root, 'current')) !== record.versionDir) return fail('current does not match installed record');
+  } catch { return fail('current is not a version link'); }
+  if (!options.from && (!record.source || /^(?:https?:|file:)/.test(record.source))) return fail('local checkout source unknown — use --from');
+  if (!existsSync(join(checkout, 'scripts', 'install.sh'))) return fail('checkout installer missing');
+  const verifiedRoot = git(checkout, ['rev-parse', '--show-toplevel']);
+  try {
+    if (verifiedRoot.status !== 0 || !verifiedRoot.stdout.trim() || realpathSync(verifiedRoot.stdout.trim()) !== realpathSync(checkout)) return fail('checkout git root mismatch');
+  } catch { return fail('checkout git root mismatch'); }
+  const head = git(checkout, ['rev-parse', '--verify', 'main']);
+  if (head.status !== 0 || !/^[a-f0-9]{12,40}$/i.test(head.stdout.trim())) return fail('main commit unknown');
+  if (!options.dryRun) {
+    const tracked = git(checkout, ['diff', '--quiet', 'HEAD', '--']);
+    const working = git(checkout, ['rev-parse', '--verify', 'HEAD']);
+    if (tracked.status !== 0 || working.status !== 0 || working.stdout.trim() !== head.stdout.trim()) return fail('main is not the clean checkout HEAD');
+    const untracked = git(checkout, ['ls-files', '--others', '--exclude-standard']);
+    if (untracked.status !== 0 || untracked.stdout.trim()) return fail('checkout contains untracked files');
+  }
+  let state: EdgeRailState | null = null;
+  if (existsSync(stateFile)) {
+    try {
+      const value: unknown = JSON.parse(readFileSync(stateFile, 'utf8'));
+      if (value && typeof value === 'object' && 'canary' in value && 'mainCommit' in value) state = value as EdgeRailState;
+      else return fail('invalid edge-rail state');
+    } catch { return fail('invalid edge-rail state'); }
+  }
+  const mainCommit = head.stdout.trim();
+  const config = deps.edgeRailConfig?.() ?? getUserConfig().harness?.edgeRail ?? {};
+  const canary = state?.mainCommit === mainCommit ? state.canary : null;
+  const observed = (deps.now ?? (() => new Date()))();
+  if (!options.dryRun && canary && canary.okRuns < (config.canaryOkRuns ?? 3) && options.seat === 'OP' && (record.commit.startsWith(mainCommit) || mainCommit.startsWith(record.commit))
+    && !options.failureRate && options.canaryRunId?.trim() && options.canaryRunId !== state?.lastRunId
+    // 같은 런을 두 번 세지 않고, 캐너리 시작 뒤 «성공으로 끝난» 런만 센다(임의·과거·실패 id 로 승격을 열지 못하게).
+    && !(state?.countedRunIds ?? []).includes(options.canaryRunId.trim())
+    && (deps.canaryRunSucceeded ?? canaryRunSucceededInLedger)(options.canaryRunId.trim(), canary.startedAt)
+    && Number.isFinite(observed.getTime()) && observed.getTime() >= Date.parse(canary.startedAt)) {
+    const health = await (deps.verifyRestart ?? defaultVerifyRestart)(mainCommit);
+    if (health.ok && health.daemonSha && (health.daemonSha.startsWith(mainCommit) || mainCommit.startsWith(health.daemonSha)) && state) {
+      state = { ...state, canary: { ...canary, okRuns: canary.okRuns + 1 }, lastRunId: options.canaryRunId, countedRunIds: [...(state.countedRunIds ?? []), options.canaryRunId.trim()] };
+      saveEdgeRailState(stateFile, state);
+    }
+  }
+  const input: EdgeRailInput = {
+    // 설정에서는 세 수치만 받는다 — 여분 키가 판단 입력(seat·failureRate·canary…)을 덮지 못하게.
+    ...(config.canaryOkRuns !== undefined ? { canaryOkRuns: config.canaryOkRuns } : {}),
+    ...(config.failureMultiplier !== undefined ? { failureMultiplier: config.failureMultiplier } : {}),
+    ...(config.minSamples !== undefined ? { minSamples: config.minSamples } : {}),
+    now: observed, mainCommit, installed: record.commit, seat: options.seat,
+    canary: state?.mainCommit === mainCommit ? state.canary : null,
+    failureRate: options.failureRate ?? (state?.mainCommit === mainCommit ? state.failureRate : null) ?? null,
+    quietWindow: options.quietWindow === true, promoted: state?.mainCommit === mainCommit ? state.promoted : false,
+  };
+  // 이 main 은 이미 되돌렸다 — 새 main 이 올 때까지 다시 깔거나 승격하지 않는다.
+  const plan = state?.mainCommit === mainCommit && state.rolledBack
+    ? { decision: 'hold' as const, reason: 'this main was rolled back; waiting for a new main' }
+    : planEdgeRail(input);
+  const fixes = missingFixCommitTitles(checkout, record.commit, mainCommit, git);
+  if (!options.dryRun) try { debug.log('self-update.edge-rail', 'plan', { decision: plan.decision, reason: plan.reason, seat: options.seat, mainCommit, installed: record.commit, fixes }); } catch { /* log sink optional */ }
+  const emit = (result: SelfUpdateResult): SelfUpdateResult => {
+    const autoRollback = input.failureRate ? 'active' as const : 'inactive-no-failure-rate' as const;
+    const merged = { ...result, edgeRail: plan, missingFixes: fixes, autoRollback };
+    out.log(options.json ? JSON.stringify(merged) : `self-update --auto: ${plan.decision} — ${plan.reason} · ${fixes}${autoRollback === 'active' ? '' : ' · 자동 되돌림 비활성 — 실패율 측정 원천 없음'}`);
+    return merged;
+  };
+  if (options.dryRun || plan.decision === 'hold' || plan.decision === 'wait-quiet') return emit({ exitCode: 0, installedVersion: null, decision: null, restarted: false, reason: plan.reason });
+  if (plan.decision === 'rollback' && (!record.previous || !versionDirName(record.previous))) return emit({ exitCode: 2, installedVersion: null, decision: null, restarted: false, reason: 'no previous version for rollback' });
+  if (plan.decision === 'rollback' && !deps.restartEdgeRail && liveRestartBlocked()) return emit({ exitCode: 2, installedVersion: null, decision: null, restarted: false, reason: 'live restart blocked' });
+  if (plan.decision === 'rollback') {
+    const rolled = (deps.rollbackEdgeRail ?? rollbackDevInstall)(deps);
+    if (!rolled.ok) return emit({ exitCode: 2, installedVersion: null, decision: null, restarted: false, reason: rolled.reason });
+    // 되돌린 main 은 표시해 둔다 — 캐너리 OK 수가 남아 있어도 다음 실행이 다시 승격하지 못하게.
+    if (state?.mainCommit === mainCommit) saveEdgeRailState(stateFile, { ...state, promoted: false, rolledBack: true });
+    else saveEdgeRailState(stateFile, { mainCommit, canary: { seat: 'OP', okRuns: 0, startedAt: input.now.toISOString() }, rolledBack: true });
+    const restarted = await restartEdgeRail(deps, checkout);
+    const health = restarted ? await (deps.verifyRestart ?? defaultVerifyRestart)(rolled.record.commit ?? '') : null;
+    const confirmed = !!(health?.ok && health.daemonSha && rolled.record.commit
+      && (health.daemonSha.startsWith(rolled.record.commit) || rolled.record.commit.startsWith(health.daemonSha)));
+    return emit({ exitCode: confirmed ? 0 : 1, installedVersion: rolled.versionName, decision: null, restarted, current: `versions/${rolled.versionName}`, reason: confirmed ? plan.reason : `${plan.reason}; rollback health not confirmed` });
+  }
+  if (!deps.restartEdgeRail && liveRestartBlocked()) return emit({ exitCode: 2, installedVersion: null, decision: null, restarted: false, reason: 'live restart blocked' });
+  const installer = deps.installEdgeRail ?? ((next: SelfUpdateOptions, injected: SelfUpdateDeps) => runUpdateForInstallation(next, { cliRoot: injected.cliRoot, checkout: injected }));
+  // The existing --from dev installer checks entry existence and restores current even when install.sh fails after relinking.
+  const installed = await installer({ from: checkout, dev: true, restart: false }, { ...deps, notice: () => {}, out: { log: () => {}, error: () => {} } });
+  if (installed.exitCode !== 0) return emit(installed);
+  const nextRecord = readInstallRecord(root);
+  const nextName = versionDirName(nextRecord?.versionDir);
+  let currentLink = '';
+  try { currentLink = readlinkSync(join(root, 'current')); } catch { /* no valid installed current */ }
+  if (!nextName || !installEntryExists(root, nextName) || nextRecord?.commit !== mainCommit || currentLink !== nextRecord.versionDir) {
+    const rolled = record.versionDir && nextRecord?.previous === record.versionDir ? (deps.rollbackEdgeRail ?? rollbackDevInstall)(deps) : null;
+    return emit({ ...installed, exitCode: 1, reason: `installed entry/commit not confirmed${rolled?.ok ? '; previous build restored' : '; rollback not confirmed'}` });
+  }
+  const restarted = await restartEdgeRail(deps, checkout);
+  // 설치한 판이 재시작·건강에서 실패해 되돌렸으면 같은 main 을 다시 깔지 않게 표시한다.
+  const markRolledBack = (): void => saveEdgeRailState(stateFile, { mainCommit, canary: { seat: 'OP', okRuns: 0, startedAt: input.now.toISOString() }, rolledBack: true });
+  if (!restarted) {
+    const rolled = record.versionDir && readInstallRecord(root)?.previous === record.versionDir
+      ? (deps.rollbackEdgeRail ?? rollbackDevInstall)(deps) : null;
+    if (rolled?.ok) markRolledBack();
+    return emit({ ...installed, exitCode: 1, restarted: false, reason: `${plan.reason}; restart not confirmed${rolled?.ok ? '; previous build restored' : '; rollback not confirmed'}` });
+  }
+  const verified = await (deps.verifyRestart ?? defaultVerifyRestart)(mainCommit);
+  if (!verified.ok || !verified.daemonSha || !(verified.daemonSha.startsWith(mainCommit) || mainCommit.startsWith(verified.daemonSha))) {
+    const rolled = record.versionDir && readInstallRecord(root)?.previous === record.versionDir
+      ? (deps.rollbackEdgeRail ?? rollbackDevInstall)(deps) : null;
+    if (rolled?.ok) { markRolledBack(); await restartEdgeRail(deps, checkout); }
+    return emit({ ...installed, exitCode: 1, restarted: true, reason: `${plan.reason}; restarted build health not confirmed${rolled?.ok ? '; previous build restored' : '; rollback not confirmed'}` });
+  }
+  if (plan.decision === 'canary-install') {
+    const next: EdgeRailState = { mainCommit, canary: { seat: 'OP', okRuns: 0, startedAt: input.now.toISOString() }, ...(options.failureRate ? { failureRate: options.failureRate } : {}) };
+    saveEdgeRailState(stateFile, next);
+  } else if (state?.mainCommit === mainCommit && plan.decision === 'promote-all') {
+    saveEdgeRailState(stateFile, { ...state, promoted: true });
+  }
+  return emit({ ...installed, restarted: true });
+}
+
 /** Route an installed CLI by where it was installed from: a release URL → release installer, a local checkout → git update. */
 export async function runUpdateForInstallation(
   options: SelfUpdateOptions = {},
   deps: { cliRoot?: string; exists?: (path: string) => boolean; readText?: (path: string) => string; release?: ReleaseUpdateDeps; checkout?: SelfUpdateDeps } = {},
 ): Promise<SelfUpdateResult> {
   const cliRoot = resolve(deps.cliRoot ?? resolve(import.meta.dir, '../..'));
+  if (options.auto) return runEdgeRailUpdate(options, { cliRoot, ...deps.checkout });
   const exists = deps.exists ?? existsSync;
   const holder = resolve(cliRoot, '..', '..');
   const parent = resolve(holder, '..');
@@ -726,7 +925,7 @@ export async function runSelfUpdate(options: SelfUpdateOptions = {}, deps: SelfU
 
     if (options.dev) {
       try {
-        const installed = installDevBuild(checkout, head.stdout.trim(), { ...deps, runInstaller: () => run('bash', [join(checkout, 'scripts/install.sh'), '--no-modify-path'], checkout) });
+        const installed = installDevBuild(checkout, head.stdout.trim(), { ...deps, runInstaller: () => run('bash', [join(checkout, 'scripts/install.sh'), '--no-modify-path', ...(deps.installRoot ? ['--prefix', deps.installRoot] : [])], checkout) });
         return emit({
           exitCode: 0,
           installedVersion: installed.versionName,

package/src/context-card/index.ts

@@ -0,0 +1,45 @@
+/** A rebuildable view of the ledger and code, never an authoritative record. */
+export interface ContextCard {
+  readonly id: string;
+  readonly kind: 'task' | 'goal' | 'run' | 'pr' | 'cell' | 'doc';
+  readonly conclusion: string;
+  readonly why: string;
+  readonly verdict: string;
+  readonly remaining: readonly string[];
+  readonly pointers: readonly string[];
+  readonly source: string;
+  readonly updatedAt: string;
+  readonly supersedes?: string;
+}
+
+/** Serialized code points, including JSON escaping; callers may supply a smaller screen budget. */
+export const CONTEXT_CARD_SCREEN_CHARS = 1_600;
+const length = (text: string): number => [...text].length;
+
+/** Preserve the decision and provenance; fold only the two expandable lists. Never mutate the card. */
+export function serializeContextCard(card: ContextCard, maxChars = CONTEXT_CARD_SCREEN_CHARS): string {
+  if (!Number.isSafeInteger(maxChars) || maxChars < 1) throw new RangeError('maxChars must be a positive safe integer');
+  if (/[\r\n\u2028\u2029]/u.test(card.conclusion)) throw new Error('conclusion must be one line');
+  const remaining = [...card.remaining];
+  const pointers = [...card.pointers];
+  const render = () => JSON.stringify({
+    id: card.id, kind: card.kind, conclusion: card.conclusion, why: card.why,
+    verdict: card.verdict, remaining: remaining.length < card.remaining.length
+      ? [...remaining, `외 ${card.remaining.length - remaining.length}개`] : remaining,
+    pointers: pointers.length < card.pointers.length
+      ? [...pointers, `외 ${card.pointers.length - pointers.length}개`] : pointers,
+    source: card.source, updatedAt: card.updatedAt,
+    ...(card.supersedes === undefined ? {} : { supersedes: card.supersedes }),
+  });
+  let text = render();
+  while (length(text) > maxChars && (remaining.length || pointers.length)) {
+    // Remove the larger last entry first, then break ties by preferring remaining.
+    const remainingCost = remaining.length ? length(JSON.stringify(remaining.at(-1))) : -1;
+    const pointerCost = pointers.length ? length(JSON.stringify(pointers.at(-1))) : -1;
+    if (remainingCost >= pointerCost) remaining.pop();
+    else pointers.pop();
+    text = render();
+  }
+  if (length(text) > maxChars) throw new RangeError('card core and omission counts exceed maxChars');
+  return text;
+}

package/src/context-card/task.ts

@@ -0,0 +1,76 @@
+import type { RunLedgerEntry } from '../self-implement/run-ledger.js';
+import type { ContextCard } from './index.js';
+
+/** An injected, read-only view of the JSONL run ledger. No writer or store mutation is available. */
+export interface TaskLedgerReader {
+  readRuns(): readonly { readonly runId: string; readonly entries: readonly RunLedgerEntry[] }[];
+  /** Returns the verbatim original ask from the goal document named by start.goalFile. */
+  readOriginalAsk?(goalFile: string): string | null;
+  /** Returns must-fix text from the review artifact named by reviewed.artifactPath. */
+  readReviewMustFix?(artifactPath: string): readonly string[] | null;
+}
+
+export interface TaskContextCard extends ContextCard {
+  readonly kind: 'task';
+  readonly originalAsk: string;
+  readonly authoredGoal: { readonly path: string; readonly sha256: string } | null;
+  readonly runIds: readonly string[];
+  readonly mustFix: readonly string[];
+  readonly decisionCards: readonly string[];
+  readonly nextAction: string;
+}
+
+const text = (value: unknown): string | null => typeof value === 'string' && value.trim() ? value : null;
+const strings = (value: unknown): string[] | null => Array.isArray(value) && value.every((item) => typeof item === 'string') ? [...value] : null;
+
+/** Produce a task card from source events, not from the previous card or wall-clock time. */
+export function buildTaskCard(taskId: string, reader: TaskLedgerReader): TaskContextCard {
+  const runs = reader.readRuns().filter((run) => run.entries.some((entry) => entry.event === 'start' && entry.goalId === taskId))
+    .map((run) => ({ runId: run.runId, entries: run.entries.filter((entry) => entry.runId === run.runId && (entry.goalId === undefined || entry.goalId === taskId)) }))
+    .sort((a, b) => a.runId < b.runId ? -1 : a.runId > b.runId ? 1 : 0);
+  if (!runs.length) throw new Error(`no run-ledger start for task: ${taskId}`);
+  const events = runs.flatMap(({ entries }) => entries).sort((a, b) =>
+    (a.timestamp ?? '').localeCompare(b.timestamp ?? '') || a.runId.localeCompare(b.runId));
+  const start = events.find((event) => event.event === 'start')!;
+  const goalFile = text(start.data.goalFile);
+  const originalAsk = text(start.data.originalAsk)
+    ?? (goalFile ? reader.readOriginalAsk?.(goalFile) ?? null : null);
+  if (!originalAsk) throw new Error(`original ask unavailable for task: ${taskId}`);
+
+  const authored = [...events].reverse().find((event) => event.event === 'goal-authored'
+    && text(event.data.path) !== null && /^[a-f0-9]{64}$/i.test(text(event.data.sha256) ?? ''));
+  const authoredGoal = authored ? { path: text(authored.data.path)!, sha256: text(authored.data.sha256)! } : null;
+  const reviews = events.filter((event) => event.event === 'reviewed' && event.data.reviewed === true);
+  const review = reviews.at(-1);
+  const artifactPath = review ? text(review.data.artifactPath) : null;
+  const mustFix = review
+    ? strings(review.data.mustFix) ?? (artifactPath ? reader.readReviewMustFix?.(artifactPath) ?? null : null)
+    : [];
+  if (mustFix === null && review?.data.mustFix !== 0) throw new Error(`review must-fix unavailable for task: ${taskId}`);
+  const findings = mustFix ?? [];
+  const decisionCards = events.filter((event) => event.event === 'decision-card')
+    .flatMap((event) => {
+      const cardId = text(event.data.cardId);
+      return cardId ? [cardId] : [];
+    });
+  const nextAction = [...events].reverse().map((event) => text(event.data.nextAction)).find((value): value is string => value !== null)
+    ?? findings[0] ?? null;
+  if (!nextAction) throw new Error(`next action unavailable for task: ${taskId}`);
+  const updatedAt = events.at(-1)?.timestamp;
+  if (!updatedAt) throw new Error(`timestamp unavailable for task: ${taskId}`);
+  const pointers = [
+    ...(goalFile ? [goalFile] : []),
+    ...(authoredGoal ? [`${authoredGoal.path}#sha256=${authoredGoal.sha256}`] : []),
+    ...runs.map(({ runId }) => `run:${runId}`),
+    ...(artifactPath ? [artifactPath] : []),
+    ...decisionCards,
+  ];
+  return {
+    id: `task:${taskId}`, kind: 'task', conclusion: nextAction,
+    why: findings.length ? `최근 리뷰 must-fix ${findings.length}개` : '원문과 런 원장에 따른 다음 행동',
+    verdict: text(review?.data.verdict) ?? '리뷰 판정 없음',
+    remaining: [...findings], pointers,
+    source: `run-ledger:${runs.map(({ runId }) => runId).join(',')}`, updatedAt,
+    originalAsk, authoredGoal, runIds: runs.map(({ runId }) => runId), mustFix: [...findings], decisionCards, nextAction,
+  };
+}

package/src/dashboard/slash-runtime/dashboard-handlers.ts

@@ -2442,6 +2442,8 @@ export function buildDashboardSlashRegistry(nowDeps?: ContextNowDeps): SlashComm
         cwd: () => process.cwd(),
         now: () => Date.now(),
         isInteractive: () => ctx.surfaceUx !== undefined,
+        selfResolveClarification: (await import('../../self-implement/goal-author-clarification.js')).defaultGoalAuthorSelfResolve,
+        writeGoalDocument: (await import('../../self-implement/goal-document-write.js')).writeGoalDocumentAtomic,
         buildPreflightDeps: askIo.buildAskPreflightDeps,
         priorBlockSamples: () => askIo.priorBlockSamplesFrom(rows),
         recentAuthoringSamples: () => askIo.recentAuthoringSamplesFrom(rows),

package/src/decisions/decision-ledger.ts

@@ -93,7 +93,16 @@ function validate(input: RaiseInput, historical = false): RaiseInput {
   const c = scqaField(input.scqa.c, 'c');
   const q = input.scqa.q?.trim() ? scqaField(input.scqa.q, 'q') : undefined;
   const a = input.scqa.a?.trim() ? scqaField(input.scqa.a, 'a') : undefined;
-  if (q && q === c) throw new Error('SCQA Q repeats C — leave Q empty');
+  if (q && q === c && input.raisedBy.agent !== 'seat-loop') throw new Error('SCQA Q repeats C — leave Q empty');
+  if (input.raisedBy.agent === 'seat-loop') {
+    if (!q || !a || !input.pendingQuestion?.trim()) throw new Error('seat-loop cards require --q, --a and --pending-question');
+    if ('skipped' in input.recommendation && !(['money', 'security', 'secret'].includes(input.category)
+      || (['publish', 'irreversible'].includes(input.category)
+        && /공개|게시|발행|출시|publish|release/i.test(`${title} ${input.pendingQuestion} ${input.recommendation.reason}`)
+        && /되돌릴 수 없|철회 불가|복구 불가|irreversib|cannot (?:undo|retract)/i.test(`${input.pendingQuestion} ${input.recommendation.reason}`)))) {
+      throw new Error('seat-loop recommendation may only be skipped for money, security or irreversible publication');
+    }
+  }
   if (!Array.isArray(input.options) || (input.options.length < 2 && !(historical && input.options.length === 0))) throw new Error('at least two options required');
   const options = input.options.map(o => ({ key: single(o.key, 'option key'), label: safe(single(o.label, 'option label')), consequence: safe(single(o.consequence, 'option consequence')) }));
   if (options.some(o => !/^[a-z]$/.test(o.key)) || new Set(options.map(o => o.key)).size !== options.length) throw new Error('option keys must be unique lowercase letters');