elanous 0.2.25 → 0.2.27

package/src/release-loop/feature-store.ts

@@ -36,7 +36,7 @@ const walWait = new Int32Array(new SharedArrayBuffer(4));
 const SCHEMA_COLUMNS: Record<string, readonly string[]> = {
   imported_versions: ['json_hash', 'imported_at'],
   events: ['reason', 'generation'],
-  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs'],
+  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs', 'dispatch_kind'],
   release_schedules: ['freeze_from', 'freeze_until', 'publish_at'],
 };
 function schemaCurrent(db: Database): boolean {
@@ -81,7 +81,7 @@ function open(root = releaseLedgerRoot()): Database {
       if (!eventColumns.some((column) => column.name === 'generation')) db.exec('ALTER TABLE events ADD COLUMN generation INTEGER');
       db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
       const assignmentColumns = db.query('PRAGMA table_info(assignments)').all() as Array<{ name: string }>;
-      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT'], ['accelerator', 'INTEGER'], ['refs', 'TEXT']] as const) {
+      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT'], ['accelerator', 'INTEGER'], ['refs', 'TEXT'], ['dispatch_kind', 'TEXT']] as const) {
         if (!assignmentColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE assignments ADD COLUMN ${name} ${sql}`);
       }
       const scheduleColumns = db.query('PRAGMA table_info(release_schedules)').all() as Array<{ name: string }>;
@@ -178,12 +178,13 @@ function evidenceRefs(db: Database, version: string, id: string): string[] {
   return (db.query('SELECT ref FROM evidence WHERE feature_id = ? AND version = ? ORDER BY rowid').all(id, version) as Array<{ ref: string }>).map((row) => row.ref);
 }
 function items(db: Database, version: string): ChecklistItem[] {
-  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.accelerator, a.refs, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
+  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.dispatch_kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.accelerator, a.refs, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
     FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.version = ? ORDER BY a.rowid`).all(version) as Array<Record<string, string | number | null>>;
   return rows.map((r) => {
     const evidence = [r.evidence, ...evidenceRefs(db, version, r.id as string)].filter((value) => value !== null).join('\n');
     return { id: r.id as string, title: r.title as string, status: r.status as ChecklistItem['status'],
       ...(r.owner !== null ? { owner: r.owner as string } : {}), ...(r.kind !== null ? { kind: r.kind as ChecklistItem['kind'] } : {}),
+      ...(r.dispatch_kind !== null ? { dispatchKind: r.dispatch_kind as ChecklistItem['dispatchKind'] } : {}),
       ...(r.priority !== null ? { priority: r.priority as ChecklistItem['priority'] } : {}), ...(r.predecessors !== null ? { predecessors: JSON.parse(r.predecessors as string) as string[] } : {}),
       ...(r.deadline_version !== null ? { deadlineVersion: r.deadline_version as string } : {}),
       ...(r.ceo_minutes !== null ? { ceoMinutes: r.ceo_minutes as number } : {}), ...(r.ceo_date !== null ? { ceoDate: r.ceo_date as string } : {}),
@@ -202,9 +203,9 @@ function putItem(db: Database, version: string, item: ChecklistItem): void {
   if (!feature) db.query('INSERT INTO features (id, title, owner, kind, created_at) VALUES (?, ?, ?, ?, ?)').run(item.id, item.title, item.owner ?? null, item.kind ?? null, item.updatedAt);
   // features.owner/kind follow the latest assignment so details() and the checklist never disagree after a set.
   else if (item.owner !== undefined || item.kind !== undefined) db.query('UPDATE features SET owner = COALESCE(?, owner), kind = COALESCE(?, kind) WHERE id = ?').run(item.owner ?? null, item.kind ?? null, item.id);
-  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, accelerator=excluded.accelerator, refs=excluded.refs, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
+  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, dispatch_kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, dispatch_kind=excluded.dispatch_kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, accelerator=excluded.accelerator, refs=excluded.refs, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.dispatchKind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
 }
 function jsonHash(contents: string | Buffer): string { return createHash('sha256').update(contents).digest('hex'); }
 
@@ -245,8 +246,8 @@ function importOnDb(db: Database, version: string): boolean {
       // Keep a legacy per-version title until an explicit retitle unifies the feature identity.
       if (!existing) putItem(db, version, item);
       else {
-        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
+        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, dispatch_kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.dispatchKind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
       }
     }
     for (const entry of data.history) record(db, version, entry);
@@ -273,7 +274,7 @@ function importOnDb(db: Database, version: string): boolean {
       record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: null, to: item, released: data.released, dev: data.dev });
       continue;
     }
-    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const;
+    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'dispatchKind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const;
     const baseEvidence = (db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(item.id, version) as { evidence: string | null }).evidence ?? undefined;
     const preserveRefs = item.evidence === baseEvidence || item.evidence === current.evidence;
     const differs = fields.some((field) => field === 'evidence'

package/src/seat-loop/seat-loop.ts

@@ -85,7 +85,7 @@ export type SeatDeps = {
   /** Release schedules (version · cutAt) — a version is open while its cut is still ahead. Default reads the release ledger; unreadable ⇒ no checklist candidates (fail closed). */
   schedules?: () => Array<{ version: string; cutAt: string; landBy?: string | null }>;
   /** Checklist items of one version — default reads the release ledger DB (checklist.json is only a legacy import source since REL5b). */
-  checklistItems?: (version: string) => Array<{ id: string; title: string; status: string; owner?: string | null; disposition?: string; evidence?: string }>;
+  checklistItems?: (version: string) => Array<{ id: string; title: string; status: string; owner?: string | null; disposition?: string; evidence?: string; dispatchKind?: string }>;
   /** Optional injected traffic/handoff snapshots; defaults read the OP files. */
   trafficSignal?: TrafficSignalRead;
   handedCells?: ReadonlySet<string>;
@@ -588,6 +588,10 @@ export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}, ledger
     }
     for (const item of items) {
       if (item.owner === seat && (item.status === 'yellow' || item.status === 'red')) {
+        if (item.dispatchKind && item.dispatchKind !== 'code') {
+          debug.log('seat.loop', 'skip-non-code-cell', { id: item.id, version, dispatchKind: item.dispatchKind });
+          continue;
+        }
         if (signal?.hold?.includes(item.id)) {
           debug.log('seat.loop', 'skip-signal-cell', { id: item.id, why: 'hold' });
           continue;

package/src/self-dev/draft-sweep.ts

@@ -33,7 +33,7 @@ export interface DraftSweepAdapters {
   /** Undefined means liveness could not be established. */
   listLiveBranches(repository: string): Promise<ReadonlySet<string> | undefined>;
   setLabels(repository: string, number: number, change: { add: string; remove: readonly string[] }): Promise<void>;
-  closeDraft(repository: string, number: number, comment: string): Promise<void>;
+  closeDraft(repository: string, number: number): Promise<void>;
   /** Resolve the latest claim comment owner; a failed lookup must not authorize a close. */
   getClaimOwner?(repository: string, number: number): Promise<string | undefined>;
   /** Current owner, accounting for a later claim release; only draft metrics need this distinction. */
@@ -478,6 +478,23 @@ const label = (action: 'mark-stalled' | 'close', name?: string): string => {
 const runningLabel = label('mark-stalled');
 const stalledLabel = label('close', 'stalled');
 const supersededLabel = label('close', 'superseded');
+
+/** Keep repository labels bounded; the complete reason and PR number live in the closed event. */
+export function sweptReasonLabel(reason: string): string {
+  const kinds = ['superseded-by', 'duplicate-of-open', 'claim-expired', 'stale-unobserved',
+    'harvest-expired', 'stale-ended-run'] as const;
+  const kind = kinds.find((name) => reason === name || reason.startsWith(`${name} `)) ?? 'other';
+  return `elanous:swept:${kind}`;
+}
+
+async function closeSweptDraft(adapters: Pick<DraftSweepAdapters, 'setLabels' | 'closeDraft'>,
+  repository: string, number: number, reason: string, onLabelApplied?: () => void): Promise<void> {
+  await adapters.setLabels(repository, number, { add: sweptReasonLabel(reason), remove: [] });
+  onLabelApplied?.();
+  await adapters.closeDraft(repository, number);
+  try { debug.log('self-dev.draft-sweep', 'closed', { pr: number, reason }); } catch { /* fail-soft */ }
+}
+
 const approvalLabel = PR_LABELS.find((entry) => entry.axis === 'state' && entry.sweep.action === 'none')?.name;
 const keepLabel = PR_LABELS.find((entry) => entry.sweep.action === 'exclude')?.name;
 const benchLabel = PR_LABELS.find((entry) => entry.name === 'elanous:bench')!.name;
@@ -572,8 +589,7 @@ export async function supersedeDraftsOnMerge(input: {
       try {
         // Label first: a failed label write must never strand a closed, unlabelled PR outside open-draft sweeps.
         if (!draft.labels.includes(supersededLabel)) await adapters.setLabels(repository, draft.number, { add: supersededLabel, remove });
-        await adapters.closeDraft(repository, draft.number,
-          `Draft sweep: superseded-by #${merged.number} (https://github.com/${repository}/pull/${merged.number}). Branch preserved.`);
+        await closeSweptDraft(adapters, repository, draft.number, decision.reason);
         closed.push(draft.number);
       } catch (failure) {
         kept.push(draft.number);
@@ -975,8 +991,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
                 });
                 labelsChanged = true;
               }
-              await adapters.closeDraft(repository, draft.number,
-                `Draft sweep: ${reason} (https://github.com/${repository}/pull/${lineageNewer.number}). Branch preserved.`);
+              await closeSweptDraft(adapters, repository, draft.number, reason, () => { labelsChanged = true; });
               entry.applied = true;
             } catch (error) {
               if (labelsChanged) entry.partialApplied = true;
@@ -1035,11 +1050,10 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
       if (!apply || action !== 'close') continue;
       let labelsChanged = false;
       try {
-        const owner = await adapters.getClaimOwner?.(repository, draft.number) ?? '미상';
+        await adapters.getClaimOwner?.(repository, draft.number);
         await adapters.setLabels(repository, draft.number, { add: stalledLabel, remove: [runningLabel] });
         labelsChanged = true;
-        await adapters.closeDraft(repository, draft.number,
-          `Draft sweep: 처리 중 표식이 ${CLAIM_IDLE_HOURS}시간 갱신 없음 — ${runStatus === 'self-implement.result final' ? 'self-implement.result final · 남은 워크트리는 live 아님' : '런·워크트리 없음'} · 주인 ${owner}. Closed as stalled. Branch preserved; reopen to restore.`);
+        await closeSweptDraft(adapters, repository, draft.number, entry.reason, () => { labelsChanged = true; });
         entry.applied = true;
       } catch (error) {
         if (labelsChanged) entry.partialApplied = true;
@@ -1085,12 +1099,7 @@ export async function runDraftSweep({ repository, adapters, apply = false, now =
         labelsChanged = true;
       }
       if (action === 'close') {
-        await adapters.closeDraft(repository, draft.number, decision.reason === 'stale-unobserved'
-          ? `Draft sweep: run unobserved — no run record reachable here, no host worktree for this branch, idle ≥${STALLED_DRAFT_HOURS}h. Closed as stalled. Branch preserved; reopen to restore.`
-          : decision.reason === 'harvest-expired'
-          ? `Draft sweep: harvest-expired — 종단이 수확 대상으로 표시한 뒤 ${STALLED_DRAFT_HOURS}h 동안 수확 없음. Branch preserved; reopen to restore.`
-          : `Draft sweep: ${decision.reason}${decision.reason.startsWith('superseded-by #')
-            ? ` (https://github.com/${repository}/pull/${decision.reason.slice('superseded-by #'.length).match(/^\d+/)![0]})` : ''}. Branch preserved.`);
+        await closeSweptDraft(adapters, repository, draft.number, reason, () => { labelsChanged = true; });
       }
       entry.applied = labelsChanged || action === 'close';
     } catch (error) {

package/src/self-dev/orchestrate.ts

@@ -23,6 +23,7 @@ import { parentUnlandedProgressLine } from './run-supervisor.js';
 import { mkdirSync, openSync, writeFileSync, closeSync, renameSync, unlinkSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { goalPathFromArgv, launchRegistryDir, removeLaunchBinding, writeLaunchBinding } from '../harness/launch-registry.js';
+import { psProcessStartMs } from '../harness/harness-stop.js';
 import { adoptRunCard } from '../task-agent/run-adopt.js';
 import { availableParallelism, cpus } from 'node:os';
 import { selfDevRunsDir } from './run-store.js';
@@ -912,12 +913,15 @@ async function deleteLabelledJobs(runId: string, selectedTargets: readonly { con
  *  take minutes before that, and a stop in that window found «no process» (10-01 · three runs). */
 export function writeRunPidRecord(runId: string, runsDir: string = selfDevRunsDir(), registryDir: string | null = launchRegistryDir()): string {
   const pidPath = join(runsDir, runId, 'pid.json');
+  // The observer reads `ps -o lstart=`, whose precision is one second. Record that same
+  // process birth value when available so a launch near a second boundary still matches.
+  const startedAt = psProcessStartMs(process.pid) ?? Date.now() - Math.floor(process.uptime() * 1000);
   mkdirSync(join(runsDir, runId), { recursive: true });
   const temporary = `${pidPath}.${process.pid}.${randomUUID()}.tmp`;
   const fd = openSync(temporary, 'wx', 0o600);
   try {
     try {
-      writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt: Date.now() - Math.floor(process.uptime() * 1000), argv0: process.argv0 }));
+      writeFileSync(fd, JSON.stringify({ pid: process.pid, startedAt, argv0: process.argv0 }));
     } finally { closeSync(fd); }
     renameSync(temporary, pidPath);
   } catch (error) { unlinkSync(temporary); throw error; }
@@ -925,7 +929,7 @@ export function writeRunPidRecord(runId: string, runsDir: string = selfDevRunsDi
   if (registryDir !== null) {
     const cwd = process.cwd();
     const goalPath = goalPathFromArgv(process.argv, cwd);
-    writeLaunchBinding(runId, { pid: process.pid, startedAt: Date.now() - Math.floor(process.uptime() * 1000), argv0: process.argv0,
+    writeLaunchBinding(runId, { pid: process.pid, startedAt, argv0: process.argv0,
       cwd, ...(goalPath ? { goalPath } : {}), runsDir: resolve(runsDir),
       ...(process.env.ELANOUS_POD_NAME ? { podName: process.env.ELANOUS_POD_NAME } : {}),
       ...(process.env.ELANOUS_TASK_CARD_ID ? { taskCardId: process.env.ELANOUS_TASK_CARD_ID } : {}) }, registryDir);

package/src/self-dev/run-supervisor.ts

@@ -9,7 +9,8 @@ import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
 import { debug } from '../debug/log.js';
 import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
 import { routeSupervisorVerdict } from './supervisor-verdict-edges.js';
-import { recordTaskAgentShadowMove, type TaskAgentShadowInput } from '../task-agent/shadow.js';
+import { recordTaskAgentShadowMove, runCardFor, type TaskAgentShadowInput } from '../task-agent/shadow.js';
+import { cardPrNumber, taskAgentStatePath } from '../task-agent/task-hand.js';
 
 export interface SupervisorRound {
   round: number;
@@ -641,6 +642,12 @@ export interface SuperviseRunOptions {
    * `false` 면 끈다. 던져도 런의 결말은 바뀌지 않는다(fail-soft).
    */
   taskAgentShadow?: ((input: TaskAgentShadowInput) => unknown) | false;
+  /** TA-LAND-AFTER-REVIEW — false disables the hook; function replaces only the final rejudge for isolated tests. */
+  taskAgentRejudge?: ((cardId: string, statePath: string) => Promise<unknown>) | false;
+  /** Test-only external I/O for the real completion rejudge. The decision and shadow gate remain production code. */
+  taskAgentRejudgeExternal?: Parameters<typeof import('../task-agent/rejudge-on-head.js').rejudgeAsyncResultCard>[2];
+  /** Isolated state ledger for the terminal rejudge test; production uses the active instance. */
+  taskAgentStatePath?: string;
   observeDeliverables?: () => Promise<{
     readonly deployFindings: ReadonlyMap<string, { target: string; findings?: readonly DeployVerifyFinding[] | readonly unknown[] }>;
     readonly unmeasured: readonly unknown[];
@@ -658,6 +665,23 @@ function resolveSupervisorStopStorage(runStore: SuperviseRunOptions['runStore'])
   return { path: selfDevRunsDir(), source: 'process-default' };
 }
 
+/** The supervisor's terminal hook, limited to a uniquely run-bound TA land card. */
+export async function rejudgeTerminalTaskCard(runId: string | null, deps: {
+  statePath?: string;
+  env?: NodeJS.ProcessEnv;
+  rejudgeCard?: (cardId: string, statePath: string) => Promise<unknown>;
+  external?: Parameters<typeof import('../task-agent/rejudge-on-head.js').rejudgeAsyncResultCard>[2];
+} = {}): Promise<void> {
+  const statePath = deps.statePath ?? taskAgentStatePath();
+  const card = runCardFor(runId, { statePath, ...(deps.env ? { env: deps.env } : {}) });
+  if (!card || card.status !== 'launched' || card.taLand !== true || cardPrNumber(card) === undefined) return;
+  const { rejudgeAsyncResultCard } = await import('../task-agent/rejudge-on-head.js');
+  const result = await (deps.rejudgeCard ?? ((id, path) => rejudgeAsyncResultCard(id, path, deps.external)))(card.id, statePath);
+  const { requireSuccessfulRejudge } = await import('../task-agent/rejudge-on-head.js');
+  requireSuccessfulRejudge(result);
+  try { debug.log('task-agent', 'terminal-rejudge', { runId, card: card.id }); } catch { /* fail-soft */ }
+}
+
 export async function superviseRun(opts: SuperviseRunOptions): Promise<SupervisorJobResult[]> {
   let results = [...opts.initial];
   let history: SupervisorRound[] = [];
@@ -808,6 +832,16 @@ export async function superviseRun(opts: SuperviseRunOptions): Promise<Superviso
         } catch (error) {
           try { debug.log('task-agent', 'shadow-move-failed', { runId, stopReason: decision.stopReason, error: String(error) }); } catch { /* fail-open */ }
         }
+        if (opts.taskAgentRejudge !== false) {
+          const rejudgeOptions = { ...(opts.taskAgentStatePath ? { statePath: opts.taskAgentStatePath } : {}), ...(opts.taskAgentRejudge ? { rejudgeCard: opts.taskAgentRejudge } : {}), ...(opts.taskAgentRejudgeExternal ? { external: opts.taskAgentRejudgeExternal } : {}) };
+          try { await rejudgeTerminalTaskCard(runId, rejudgeOptions); }
+          catch (error) {
+            try { await rejudgeTerminalTaskCard(runId, rejudgeOptions); }
+            catch (retryError) {
+              try { debug.log('task-agent', 'terminal-rejudge-failed', { runId, stopReason: decision.stopReason, error: String(retryError), firstError: String(error), attempts: 2 }); } catch { /* fail-open */ }
+            }
+          }
+        }
       }
       return results;
     }

package/src/self-implement/goal-author.ts

@@ -51,6 +51,9 @@ import { hasGoalStepCodeName } from './goal-step-code-name.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
 import { parseReleaseNoteSection } from '../release-loop/release-note.js';
 import { declaredNewFilePaths } from './goal-new-paths.js';
+import { classifyGoalCommandExecution, type GoalCommandExecutionResult } from './goal-command-execution.js';
+export { classifyGoalCommandExecution } from './goal-command-execution.js';
+export type { GoalCommandExecutionKind, GoalCommandExecutionResult, GoalCommandExecutionClassification } from './goal-command-execution.js';
 
 // ⭐ `situation`/`complication` 은 **선택**이다 — 안 오면 `scqaNarrative` 가 종전 문면을 쓴다.
 //   ⛔ 필수로 만들지 않는다: 그러면 인핸싱이 폴백으로 떨어진 저작(LLM 실패·`disabled`)이 전부 죽는다.
@@ -439,33 +442,6 @@ export function canonicalStructureFinding(
   return finding;
 }
 
-export type GoalCommandExecutionKind = 'success' | 'missing-command' | 'argument-problem' | 'execution-failure';
-
-export interface GoalCommandExecutionResult {
-  readonly status: number | null;
-  readonly stderr: string;
-}
-
-export interface GoalCommandExecutionClassification {
-  readonly kind: GoalCommandExecutionKind;
-  readonly log: string;
-}
-
-/** Classifies an already-observed Commander result without executing a command. */
-export function classifyGoalCommandExecution(result: GoalCommandExecutionResult): GoalCommandExecutionClassification {
-  // A clean exit is authoritative: stderr text from a successful command is not a failure signal.
-  if (result.status === 0) return { kind: 'success', log: 'command completed successfully' };
-
-  const stderr = result.stderr;
-  if (stderr.includes('unknown command') || stderr.includes('unknown option')) {
-    return { kind: 'missing-command', log: 'command is not recognized; this may be not yet implemented rather than a defect' };
-  }
-  if (stderr.includes('missing required argument') || stderr.includes('required option')) {
-    return { kind: 'argument-problem', log: 'command requires a missing argument or option' };
-  }
-  return { kind: 'execution-failure', log: `command execution failed with code ${String(result.status)}` };
-}
-
 /** Optional repository-bounded source reader. Legacy null means the referenced path is missing. */
 export interface GoalFileLintDeps {
   readReferencedFile?: (repositoryRelativePath: string) => string | null | ReferencedFileReadResult;

package/src/self-implement/goal-command-execution.ts

@@ -0,0 +1,26 @@
+export type GoalCommandExecutionKind = 'success' | 'missing-command' | 'argument-problem' | 'execution-failure';
+
+export interface GoalCommandExecutionResult {
+  readonly status: number | null;
+  readonly stderr: string;
+}
+
+export interface GoalCommandExecutionClassification {
+  readonly kind: GoalCommandExecutionKind;
+  readonly log: string;
+}
+
+/** Classifies an already-observed Commander result without executing a command. */
+export function classifyGoalCommandExecution(result: GoalCommandExecutionResult): GoalCommandExecutionClassification {
+  // A clean exit is authoritative: stderr text from a successful command is not a failure signal.
+  if (result.status === 0) return { kind: 'success', log: 'command completed successfully' };
+
+  const stderr = result.stderr;
+  if (stderr.includes('unknown command') || stderr.includes('unknown option')) {
+    return { kind: 'missing-command', log: 'command is not recognized; this may be not yet implemented rather than a defect' };
+  }
+  if (stderr.includes('missing required argument') || stderr.includes('required option')) {
+    return { kind: 'argument-problem', log: 'command requires a missing argument or option' };
+  }
+  return { kind: 'execution-failure', log: `command execution failed with code ${String(result.status)}` };
+}

package/src/self-implement/orchestrator.ts

@@ -3647,7 +3647,8 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   try {
     // 10-05 PODPROVIDER: record which child provider this run uses — «default» when the launch named none.
     const launch = opts.launch ?? resolveLaunchStamp();
-    const origin = { ...runOriginData(), childProvider: opts.childLlm?.provider ?? 'default', ...(opts.childLlm?.model ? { childModel: opts.childLlm.model } : {}), launch };
+    const origin = { ...runOriginData(), childProvider: opts.childLlm?.provider ?? 'default', ...(opts.childLlm?.model ? { childModel: opts.childLlm.model } : {}),
+      ...(process.env.ELANOUS_TASK_CARD_ID ? { taskCardId: process.env.ELANOUS_TASK_CARD_ID } : {}), launch };
     (opts.seams.writeRunLedger ?? appendRunLedgerEntry)({
       timestamp: new Date().toISOString(), runId, event: 'run-origin', data: origin,
       ...(opts.goalId ? { goalId: opts.goalId } : {}), ...shardIdentity,

package/src/self-implement/pwa-import-graph.ts

@@ -1,5 +1,7 @@
-import { readdirSync, readFileSync } from 'node:fs';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { dirname, join, relative, resolve, sep } from 'node:path';
+import ts from 'typescript';
+import { debug } from '../debug/log.js';
 
 type GraphFiles = {
   readFile?: (path: string) => string;
@@ -24,6 +26,16 @@ function sourceFiles(cwd: string): string[] {
   return files;
 }
 
+const IMPORT_SPECIFIER = /\b(?:import|export)\s+(?:[^;'"]*?\s+from\s*)?['"](\.[^'"]+)['"]|\bimport\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
+
+/** Repo-relative file candidates a relative import specifier (already joined to its importer's directory) can resolve to. */
+function importCandidates(base: string): string[] {
+  return /\.js$/.test(base)
+    // A real .js file wins over a same-named .ts source (the actual resolution order).
+    ? [base, base.replace(/\.js$/, '.ts'), base.replace(/\.js$/, '.tsx'), `${base.slice(0, -3)}/index.ts`, `${base.slice(0, -3)}/index.tsx`, `${base.slice(0, -3)}/index.js`]
+    : /\.tsx?$/.test(base) ? [base] : [base + '.ts', base + '.tsx', base + '.js', base + '/index.ts', base + '/index.tsx', base + '/index.js'];
+}
+
 /** PWA source entrypoints and the transitive relative imports they resolve inside repository src/. */
 export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFileSync(path, 'utf8'), listFiles = sourceFiles }: GraphFiles = {}): Set<string> {
   const root = resolve(cwd);
@@ -33,7 +45,6 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
   // Start from everything apps/pwa/tsconfig.json `include`s — its `src/**/*.ts(x)` also matches *.test.* files, and the Next
   // build type-checks them. Excluding tests hid the real entry (tool-result-chain.test.ts → src/nexus/api/meta-api → most of src).
   const queue = [...available].filter((file) => /^apps\/pwa\/src\/.*\.tsx?$/.test(file));
-  const imports = /\b(?:import|export)\s+(?:[^;'"]*?\s+from\s*)?['"](\.[^'"]+)['"]|\bimport\s*\(\s*['"](\.[^'"]+)['"]\s*\)/g;
   while (queue.length) {
     const file = queue.pop()!;
     if (visited.has(file)) continue;
@@ -42,16 +53,13 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
     let content: string;
     try { content = readFile(join(root, file)); }
     catch { continue; }
-    for (const match of content.matchAll(imports)) {
+    for (const match of content.matchAll(IMPORT_SPECIFIER)) {
       const specifier = match[1] ?? match[2];
       if (!specifier) continue;
       const target = resolve(root, dirname(file), specifier);
       const base = relative(root, target).split(sep).join('/');
       if (!base.startsWith('src/')) continue;
-      const candidates = /\.js$/.test(base)
-        // A real .js file wins over a same-named .ts source (the actual resolution order).
-        ? [base, base.replace(/\.js$/, '.ts'), base.replace(/\.js$/, '.tsx'), `${base.slice(0, -3)}/index.ts`, `${base.slice(0, -3)}/index.tsx`, `${base.slice(0, -3)}/index.js`]
-        : /\.tsx?$/.test(base) ? [base] : [base + '.ts', base + '.tsx', base + '.js', base + '/index.ts', base + '/index.tsx', base + '/index.js'];
+      const candidates = importCandidates(base);
       const resolved = candidates.find((candidate) => available.has(candidate));
       if (resolved) {
         if (!visited.has(resolved)) queue.push(resolved);
@@ -63,3 +71,182 @@ export function pwaReachableSrcFiles(cwd: string, { readFile = (path) => readFil
   }
   return reached;
 }
+
+export type AffectedRoots = { roots: Set<string>; failure?: undefined } | { roots?: undefined; failure: string };
+
+function astImportSpecifiers(source: ts.SourceFile): { imports: string[]; ignoredDynamic: number; failure?: string } {
+  const parseError = (source as ts.SourceFile & { parseDiagnostics?: readonly ts.Diagnostic[] }).parseDiagnostics?.[0];
+  if (parseError) return { imports: [], ignoredDynamic: 0, failure: `${source.fileName} AST 파싱 실패: ${ts.flattenDiagnosticMessageText(parseError.messageText, ' ')}` };
+  const imports: string[] = [];
+  let ignoredDynamic = 0;
+  const literal = (node: ts.Node | undefined): string | undefined => node && (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) ? node.text : undefined;
+  const visit = (node: ts.Node): void => {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const specifier = literal(node.moduleSpecifier);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference)) {
+      const specifier = literal(node.moduleReference.expression);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isImportTypeNode(node) && ts.isLiteralTypeNode(node.argument)) {
+      const specifier = literal(node.argument.literal);
+      if (specifier) imports.push(specifier);
+    } else if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword
+      || (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {
+      const specifier = literal(node.arguments[0]);
+      if (specifier) imports.push(specifier);
+      else ignoredDynamic += 1;
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return { imports, ignoredDynamic };
+}
+
+function reExportSpecifiers(source: ts.SourceFile): string[] {
+  const importedLocals = new Map<string, string>();
+  for (const statement of source.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const from = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (clause?.name) importedLocals.set(clause.name.text, from);
+    const bindings = clause?.namedBindings;
+    if (bindings && ts.isNamespaceImport(bindings)) importedLocals.set(bindings.name.text, from);
+    if (bindings && ts.isNamedImports(bindings)) {
+      for (const element of bindings.elements) importedLocals.set(element.name.text, from);
+    }
+  }
+  const specifiers: string[] = [];
+  for (const statement of source.statements) {
+    if (ts.isExportDeclaration(statement)) {
+      if (statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) specifiers.push(statement.moduleSpecifier.text);
+      else if (statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        for (const element of statement.exportClause.elements) {
+          const from = importedLocals.get((element.propertyName ?? element.name).text);
+          if (from) specifiers.push(from);
+        }
+      }
+    } else if (ts.isExportAssignment(statement) && ts.isIdentifier(statement.expression)) {
+      const from = importedLocals.get(statement.expression.text);
+      if (from) specifiers.push(from);
+    }
+  }
+  return specifiers;
+}
+
+/** Declarations visible without an import edge must enter every scoped program. */
+function suppliesAmbientTypes(source: ts.SourceFile): boolean {
+  if (source.fileName.endsWith('.d.ts') || !ts.isExternalModule(source)) return true;
+  const visit = (node: ts.Node): boolean => {
+    if (ts.isModuleDeclaration(node) && (node.name.text === 'global' || ts.isStringLiteral(node.name))) return true;
+    return ts.forEachChild(node, visit) ?? false;
+  };
+  return visit(source);
+}
+
+function gateTypeScriptSources(cwd: string): string[] {
+  const files: string[] = [];
+  const walk = (dir: string): void => {
+    // A partial directory walk is not a valid affected-root measurement: an
+    // unreadable subtree may contain the only importer of a changed file.
+    const entries = readdirSync(join(cwd, dir), { withFileTypes: true });
+    for (const entry of entries) {
+      const path = `${dir}/${entry.name}`;
+      if (entry.isDirectory() && entry.name !== 'node_modules' && !entry.name.startsWith('.')) walk(path);
+      else if (entry.isFile() && /\.ts$/.test(path)) files.push(path);
+    }
+  };
+  for (const root of ['src', 'scripts', 'test']) {
+    // An optional include glob may match no directory in a fixture. Only a
+    // confirmed ENOENT is empty; permission/I/O errors must fail closed.
+    try { statSync(join(cwd, root)); }
+    catch (cause) {
+      if ((cause as NodeJS.ErrnoException).code === 'ENOENT') continue;
+      throw cause;
+    }
+    walk(root);
+  }
+  return files;
+}
+
+/**
+ * Changed .ts files plus the listed files that import one of them directly (one reverse-import step).
+ * Every changed file and every listed file must be readable — an unreadable file could be a hidden importer, so the
+ * result is a failure the caller turns into a full-program run, never a smaller root set.
+ */
+export function reverseImportAffectedRoots(cwd: string, changed: ReadonlySet<string>, { readFile = (path) => readFileSync(path, 'utf8'), listFiles = gateTypeScriptSources }: GraphFiles = {}): AffectedRoots {
+  const root = resolve(cwd);
+  const normalize = (file: string): string => file.replaceAll('\\', '/').replace(/^\.\//, '');
+  const read = (file: string): string | { failure: string } => {
+    try { return readFile(join(root, file)); }
+    catch (cause) { return { failure: `${file} 을 읽지 못했다: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+  };
+  let listed: string[];
+  try { listed = listFiles(cwd).map(normalize); }
+  catch (cause) { return { failure: `소스 목록을 읽지 못했다: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+  const available = new Set(listed);
+  const targets = new Set([...changed].map(normalize));
+  for (const file of targets) {
+    const content = read(file);
+    if (typeof content !== 'string') return content;
+  }
+  const importsByFile = new Map<string, Set<string>>();
+  const barrelsByTarget = new Map<string, Set<string>>();
+  const ambientRoots = new Set<string>();
+  let ignoredDynamic = 0;
+  const resolveImport = (file: string, specifier: string): { target?: string; ignored?: true; unresolved?: true } => {
+    if (!specifier.startsWith('.')) return { ignored: true };
+    const base = relative(root, resolve(root, dirname(file), specifier)).split(sep).join('/');
+    // The gate's tsconfig includes these roots. A relative import outside them
+    // cannot lead back to a changed gate source; asset imports are not TS
+    // source edges either.
+    if (!/^(?:src|scripts|test)\//.test(base) || /\.(?:css|json|svg|png|jpg|jpeg|webp|wasm)$/.test(base)) return { ignored: true };
+    const target = importCandidates(base).find((candidate) => available.has(candidate));
+    return target ? { target } : { unresolved: true };
+  };
+  for (const file of listed) {
+    const content = read(file);
+    if (typeof content !== 'string') return content;
+    let source: ts.SourceFile;
+    try { source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true); }
+    catch (cause) { return { failure: `${file} AST 파싱 실패: ${cause instanceof Error ? cause.message : String(cause)}` }; }
+    const scanned = astImportSpecifiers(source);
+    if (scanned.failure) return { failure: scanned.failure };
+    if (suppliesAmbientTypes(source)) ambientRoots.add(file);
+    ignoredDynamic += scanned.ignoredDynamic;
+    const imports = new Set<string>();
+    for (const specifier of scanned.imports) {
+      if (!specifier.startsWith('.')) continue;
+      const resolved = resolveImport(file, specifier);
+      if (resolved.unresolved) return { failure: `${file} 의 리터럴 import ${specifier} 해석 실패` };
+      if (resolved.target) imports.add(resolved.target);
+    }
+    importsByFile.set(file, imports);
+    for (const specifier of reExportSpecifiers(source)) {
+      const resolved = resolveImport(file, specifier);
+      if (resolved.unresolved) return { failure: `${file} 의 리터럴 re-export ${specifier} 해석 실패` };
+      if (!resolved.target) continue;
+      const barrels = barrelsByTarget.get(resolved.target) ?? new Set<string>();
+      barrels.add(file);
+      barrelsByTarget.set(resolved.target, barrels);
+    }
+  }
+  if (ignoredDynamic) debug.log('typecheck.gate', 'nonliteral-import-ignored', { count: ignoredDynamic });
+  // A changed export can break an importer through any number of re-export
+  // barrels. Walk that chain to a fixed point, then include direct importers
+  // of each barrel. The visited set also terminates circular barrels.
+  const exported = new Set(targets);
+  const queue = [...targets];
+  while (queue.length) {
+    const target = queue.pop()!;
+    for (const barrel of barrelsByTarget.get(target) ?? []) {
+      if (exported.has(barrel)) continue;
+      exported.add(barrel);
+      queue.push(barrel);
+    }
+  }
+  const roots = new Set([...exported, ...ambientRoots]);
+  for (const [file, imports] of importsByFile) {
+    if ([...imports].some((target) => exported.has(target))) roots.add(file);
+  }
+  return { roots };
+}