elanous 0.2.9 → 0.2.10

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

@@ -0,0 +1,231 @@
+import { execFile } from 'node:child_process';
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs';
+import { Database } from 'bun:sqlite';
+import { dirname, join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { TRACK_AGENT_FORBIDDEN_ACTION_REGEX, universeLaunch } from '../autopilot/track-agent.js';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
+import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
+import { listChecklist } from '../release-loop/checklist.js';
+import { readSchedules } from '../release-loop/feature-store.js';
+
+// `kind`/`createdAt` are the V3 shadow-compare keys (내부 문서 `METHOD-v3-shadow-compare-2026-10-02` · MK 10-02 18:54).
+export type SeatItem = { source: 'request' | 'checklist'; kind?: 'request' | 'cell'; id: string; title: string; text: string; version?: string; queuedAt?: string; createdAt?: string };
+export type SeatInputs = { requests: SeatItem[]; checklist: SeatItem[]; role: string };
+// V3 ledger row: `ts` · `item.id` · `item.kind` · `item.createdAt` · `action` (door or skipped-*) · `reason` (forbidden word for a decision).
+export type SeatAction = 'decision' | 'harness' | 'skipped-budget' | 'skipped-empty';
+export type SeatEntry = { seat: string; ts?: string; at: string; status: 'shadow' | 'attempting' | 'outcome-unknown' | 'launched' | 'hitl' | 'skipped-budget' | 'skipped-empty'; item?: SeatItem; action?: SeatAction; reason?: string; runId?: string };
+export type SeatLoopResult = SeatEntry | { seat: string; status: 'skipped-off' };
+export type SeatDeps = {
+  root?: string;
+  repo?: string;
+  config?: SeatLoopConfig;
+  now?: () => Date;
+  read?: (path: string) => string;
+  run?: (args: string[]) => Promise<string>;
+  append?: (path: string, entry: SeatEntry) => void;
+  versions?: () => string[];
+  /** 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 }>;
+  ledgerFiles?: (directory: string) => string[];
+  lockContended?: () => void;
+};
+
+const repoRoot = resolve(import.meta.dir, '../..');
+const exec = promisify(execFile);
+const defaultRead = (path: string): string => {
+  try { return readFileSync(path, 'utf8'); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return ''; throw error; }
+};
+const defaultRun = async (args: string[]): Promise<string> => {
+  const { argv, env } = universeLaunch(args);
+  const { stdout } = await exec('bun', argv, {
+    cwd: repoRoot, env, encoding: 'utf8',
+    timeout: args[0] === 'harness' && args[1] === 'say' ? 3_600_000 : 120_000, maxBuffer: 4 * 1024 * 1024,
+  });
+  return stdout;
+};
+const defaultAppend = (path: string, entry: SeatEntry): void => {
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(entry)}\n`, { mode: 0o600 });
+};
+const observe = (event: string, data: Record<string, unknown>): void => {
+  try { debug.log('seat.loop', event, data); } catch { /* logging cannot change execution */ }
+};
+
+// SQLite's OS lock survives the awaited external call and is released if the process exits.
+async function withSeatLock<T>(directory: string, action: () => Promise<T>, contended?: () => void): Promise<T> {
+  mkdirSync(directory, { recursive: true });
+  const path = join(directory, '.once.mutex.sqlite');
+  const db = new Database(path, { create: true, strict: true });
+  try {
+    chmodSync(path, 0o600);
+    const deadline = Date.now() + 120_000;
+    let signalled = false;
+    while (true) {
+      try { db.exec('BEGIN IMMEDIATE'); break; }
+      catch (error) {
+        if ((error as { code?: string }).code !== 'SQLITE_BUSY' || Date.now() >= deadline) throw error;
+        if (!signalled) { contended?.(); signalled = true; }
+        await new Promise((done) => setTimeout(done, 25));
+      }
+    }
+    try { return await action(); }
+    finally { db.exec('ROLLBACK'); }
+  } finally { db.close(); }
+}
+
+export function seatDay(now: Date): string {
+  return new Intl.DateTimeFormat('en-CA', { timeZone: 'Asia/Seoul', year: 'numeric', month: '2-digit', day: '2-digit' }).format(now);
+}
+
+export function seatLedgerPath(seat: string, root: string, now: Date): string {
+  return join(root, 'seat-loop', seat, `${seatDay(now)}.jsonl`);
+}
+
+function rows(text: string): Record<string, unknown>[] {
+  return text.split('\n').filter(Boolean).map((line) => JSON.parse(line) as Record<string, unknown>);
+}
+
+function versionOrder(a: string, b: string): number {
+  const aa = a.split('.').map(Number), bb = b.split('.').map(Number);
+  return (aa[0]! - bb[0]!) || (aa[1]! - bb[1]!) || (aa[2]! - bb[2]!);
+}
+
+export async function gatherSeatInputs(seat: string, deps: SeatDeps = {}): Promise<SeatInputs> {
+  const read = deps.read ?? defaultRead;
+  const root = deps.root ?? effectiveInstanceRoot();
+  const requests = new Map<string, Record<string, unknown>>();
+  for (const row of rows(read(join(root, 'seat-requests', 'requests.jsonl')))) {
+    if (typeof row.key === 'string') requests.set(row.key, row);
+  }
+  const pending = [...requests.values()]
+    .filter((row) => row.seat === seat && (row.status === 'pending' || row.status === 'queued') && typeof row.text === 'string')
+    .map((row) => ({ source: 'request' as const, kind: 'request' as const, id: String(row.key), title: String(row.text), text: String(row.text), queuedAt: String(row.queuedAt ?? ''), createdAt: String(row.queuedAt ?? '') }))
+    .sort((a, b) => a.queuedAt.localeCompare(b.queuedAt) || a.id.localeCompare(b.id));
+  const releaseRoot = deps.root ?? releaseLedgerRoot();
+  const versions = deps.versions ?? (() => {
+    const dir = join(releaseRoot, 'release');
+    const fromDirs = existsSync(dir) ? readdirSync(dir).filter((v) => /^\d+\.\d+\.\d+$/.test(v)) : [];
+    let fromSchedule: string[] = [];
+    try { fromSchedule = readSchedules().map((row) => row.version); } catch { /* ledger unreadable — directories only */ }
+    return [...new Set([...fromDirs, ...fromSchedule])].filter((v) => /^\d+\.\d+\.\d+$/.test(v));
+  });
+  const itemsOf = deps.checklistItems ?? ((version: string) => listChecklist(version).items);
+  const checklist: SeatItem[] = [];
+  for (const version of versions().sort(versionOrder)) {
+    let items: ReturnType<typeof itemsOf>;
+    try { items = itemsOf(version); } catch (error) {
+      debug.log('seat.loop', 'checklist-unreadable', { seat, version, error: String(error).slice(0, 200) });
+      continue;
+    }
+    for (const item of items) {
+      if (item.owner === seat && (item.status === 'yellow' || item.status === 'red')) {
+        checklist.push({ source: 'checklist', kind: 'cell', version, id: item.id, title: item.title, text: item.title });
+      }
+    }
+  }
+  checklist.sort((a, b) => versionOrder(a.version!, b.version!) || a.id.localeCompare(b.id));
+  return { requests: pending, checklist, role: read(join(deps.repo ?? repoRoot, 'docs', 'roles', `${seat}.md`)).slice(0, 4_000) };
+}
+
+function itemKey(item: SeatItem): string { return `${item.source}:${item.version ?? ''}:${item.id}`; }
+
+// In shadow mode a shadowed item counts as handled, so a rehearsal day walks the queue like the seat would.
+export function pickNext(inputs: SeatInputs, ledger: readonly SeatEntry[], opts: { shadow?: boolean } = {}): SeatItem | null {
+  const handled = new Set(ledger.filter((entry) => entry.status === 'launched' || entry.status === 'hitl' || entry.status === 'attempting' || entry.status === 'outcome-unknown' || (opts.shadow === true && entry.status === 'shadow'))
+    .filter((entry): entry is SeatEntry & { item: SeatItem } => !!entry.item && !!entry.item.source && typeof entry.item.id === 'string').map((entry) => itemKey(entry.item)));
+  return [...inputs.requests, ...inputs.checklist].find((item) => !handled.has(itemKey(item))) ?? null;
+}
+
+export function planAction(item: SeatItem, seat?: string): { kind: 'decision' | 'harness'; text: string; reason?: string } {
+  const hit = `${item.id}\n${item.title}\n${item.text}`.match(TRACK_AGENT_FORBIDDEN_ACTION_REGEX);
+  const kind = hit ? 'decision' : 'harness';
+  return { kind, text: seat && kind === 'harness' ? seatTaskText(seat, item) : `${item.id} ${item.title}`, ...(hit ? { reason: hit[0] } : {}) };
+}
+
+// The launched sentence names the seat, the source and the release so same-named items stay distinct.
+export function seatTaskText(seat: string, item: SeatItem): string {
+  const where = item.source === 'checklist' ? `${item.version ?? '?'} 체크리스트 칸 ${item.id}` : `자리 요청 ${item.id}`;
+  return `[${seat} 자리 · ${where} · 역할 docs/roles/${seat}.md] ${item.title.replace(/[\r\n]+/g, ' ')}`;
+}
+
+export async function runSeatLoopOnce(seat: string, deps: SeatDeps = {}): Promise<SeatLoopResult> {
+  if (!/^(?:MK|OP|TC|UX)$/.test(seat)) throw new Error(`unknown seat: ${seat}`);
+  const config = deps.config ?? getUserConfig().loops?.seat ?? { mode: 'off' };
+  if (config.mode === 'off' || !(config.seats ?? ['MK']).includes(seat)) {
+    observe('skipped-off', { seat });
+    return { seat, status: 'skipped-off' };
+  }
+  const now = (deps.now ?? (() => new Date()))();
+  const path = seatLedgerPath(seat, deps.root ?? effectiveInstanceRoot(), now);
+  const directory = dirname(path);
+  return withSeatLock(directory, async () => {
+  const files = deps.ledgerFiles?.(directory) ?? (existsSync(directory) ? readdirSync(directory) : []);
+  const ledger = files.filter((name) => /^\d{4}-\d{2}-\d{2}\.jsonl$/.test(name) && name <= `${seatDay(now)}.jsonl`)
+    .flatMap((name) => rows((deps.read ?? defaultRead)(join(directory, name))) as SeatEntry[]);
+  const inputs = await gatherSeatInputs(seat, deps);
+  const item = pickNext(inputs, ledger, { shadow: config.mode === 'shadow' });
+  if (item) observe('picked', { seat, item, date: seatDay(now) });
+  const planned = item ? planAction(item, seat) : undefined;
+  const entry: SeatEntry = { seat, ts: now.toISOString(), at: now.toISOString(), status: item ? 'shadow' : 'skipped-empty',
+    ...(item ? { item, action: planned!.kind, ...(planned!.reason ? { reason: planned!.reason } : {}) } : { action: 'skipped-empty' as const }) };
+  const append = deps.append ?? defaultAppend;
+  if (config.mode === 'shadow' || !item) {
+    append(path, entry);
+    if (config.mode === 'shadow') observe('shadow', { seat, item, status: entry.status });
+    return entry;
+  }
+  const run = deps.run ?? defaultRun;
+  let outcome: string | undefined;
+  try { outcome = (JSON.parse(await run(['harness', 'budget', '--json'])) as { outcome?: string }).outcome; }
+  catch { /* failed budget observation is never permission to launch */ }
+  if (outcome !== 'proceed' && outcome !== 'next-provider') {
+    entry.status = 'skipped-budget';
+    entry.action = 'skipped-budget';
+    delete entry.reason;
+    append(path, entry);
+    observe('skipped-budget', { seat, item, outcome: outcome ?? 'unavailable' });
+    return entry;
+  }
+  const action = planned!;
+  // Persist the intent before crossing the process boundary: an unreturned call may already have acted.
+  append(path, { ...entry, status: 'attempting' });
+  try {
+    if (action.kind === 'decision') {
+      const title = `${seat}: ${action.text.replace(/[\r\n]+/g, ' ')}`;
+      const raised = await run(['decisions', 'raise', '--title', title, '--category', 'other',
+        '--s', `${seat} 배정 항목: ${action.text.replace(/[\r\n]+/g, ' ')}\n역할: ${inputs.role}`, '--c', '자동 실행 금지 문면에 해당하여 사람 결정이 필요하다',
+        '--option', 'a=사람 승인:승인 후 별도로 집행', '--option', 'b=보류:집행하지 않음',
+        '--skip-recommend', '금지 문면은 자동으로 권고하지 않는다', '--agent', 'seat-loop', '--json']);
+      const decision: unknown = JSON.parse(raised.trim());
+      if (!decision || typeof decision !== 'object' || typeof (decision as { id?: unknown }).id !== 'string') {
+        throw new Error('decisions raise returned no decision id');
+      }
+      entry.status = 'hitl';
+      append(path, entry);
+      observe('hitl', { seat, item });
+      return entry;
+    }
+    const output = await run(['harness', 'say', action.text, '--substrate', 'pod', '--pod-pool', config.podPool ?? 'pool-node-b@node-b:8', '--base', 'main', '--json']);
+    const results: unknown = JSON.parse(output.trim());
+    if (!Array.isArray(results) || results.length === 0 || results.some((result) =>
+      !result || typeof result !== 'object' || (result as { status?: unknown }).status !== 'done')) {
+      throw new Error('harness say did not complete successfully');
+    }
+    const runId = (results[0] as { runId?: unknown }).runId;
+    if (typeof runId !== 'string' || !/^run-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(runId)) {
+      throw new Error('harness say output has no runId');
+    }
+    entry.status = 'launched';
+    entry.runId = runId;
+    append(path, entry);
+    observe('launched', { seat, item, runId });
+    return entry;
+  } catch (error) {
+    append(path, { ...entry, status: 'outcome-unknown' });
+    throw error;
+  }
+  }, deps.lockContended);
+}

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

@@ -0,0 +1,64 @@
+import { execFile } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { getUserConfig, type SeatLoopConfig } from '../user-config.js';
+import { seatDay, seatLedgerPath, type SeatEntry } from './seat-loop.js';
+
+export type SeatReportDeps = {
+  root?: string;
+  repo?: string;
+  now?: () => Date;
+  read?: (path: string) => string;
+  config?: SeatLoopConfig;
+  post?: boolean;
+  send?: (body: string, seat: string, pr: number) => Promise<void> | void;
+};
+export type SeatReportResult = { seat: string; date: string; body: string; posted: boolean };
+const repoRoot = resolve(import.meta.dir, '../..');
+const exec = promisify(execFile);
+
+async function defaultSend(body: string, seat: string, pr: number, repo: string): Promise<void> {
+  const dir = mkdtempSync(join(tmpdir(), 'seat-report-'));
+  try {
+    const file = join(dir, 'body.md');
+    writeFileSync(file, body);
+    await exec('bash', [join(repo, 'scripts', 'coord-post.sh'), file], {
+      cwd: repo, env: { ...process.env, COORD_ID: seat, CH_PR: String(pr) }, timeout: 30_000,
+    });
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
+export async function seatReport(seat: string, deps: SeatReportDeps = {}): Promise<SeatReportResult> {
+  if (!/^(?:MK|OP|TC|UX)$/.test(seat)) throw new Error(`unknown seat: ${seat}`);
+  const now = (deps.now ?? (() => new Date()))();
+  const date = seatDay(now);
+  let raw = '';
+  try { raw = (deps.read ?? ((path) => readFileSync(path, 'utf8')))(seatLedgerPath(seat, deps.root ?? effectiveInstanceRoot(), now)); }
+  catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error; }
+  const entries = raw.split('\n').filter(Boolean).map((line) => JSON.parse(line) as SeatEntry);
+  // One line per item, its last state wins: an `attempting` row followed by `launched` is not «unconfirmed».
+  const latest = new Map<string, SeatEntry>();
+  for (const entry of entries) {
+    const key = entry.item ? `${entry.item.source}:${entry.item.version ?? ''}:${entry.item.id}` : `none:${entry.status}`;
+    latest.delete(key);
+    latest.set(key, entry);
+  }
+  const detail = [...latest.values()].map((entry) => {
+    const label = entry.item ? `${entry.item.version ? `${entry.item.version} ` : ''}${entry.item.id} ${entry.item.title}`.replace(/\s+/g, ' ').trim() : '배정 없음';
+    if (entry.status === 'launched') return `발사 ${label} (${entry.runId ?? 'runId 없음'})`;
+    if (entry.status === 'hitl') return `결정 상정 ${label}`;
+    if (entry.status === 'shadow') return `shadow ${label}`;
+    if (entry.status === 'attempting' || entry.status === 'outcome-unknown') return `결과 확인 필요 ${entry.status} ${label}`;
+    return `건너뜀 ${entry.status} ${label}`;
+  });
+  const body = `**[${seat}]** {{TS}} → 보고 ${date}: ${detail.join(' · ') || '원장 기록 없음'}`;
+  const pr = (deps.config ?? getUserConfig().loops?.seat)?.reportPr;
+  const posted = deps.post === true && pr !== undefined;
+  if (posted) await (deps.send ?? ((text, id, number) => defaultSend(text, id, number, deps.repo ?? repoRoot)))(body, seat, pr);
+  try { debug.log('seat.loop', 'reported', { seat, date, entries: entries.length, posted }); } catch { /* observation is fail-soft */ }
+  return { seat, date, body, posted };
+}

package/src/self-dev/decompose.ts

@@ -156,6 +156,8 @@ interface SelfDevSubtaskGradeRationale {
 }
 
 export interface SelfDevDecompositionObservation extends SelfDevDecompositionMeta {
+  /** Number of registration-only goals folded into their dependency. */
+  foldedRegistration: number;
   /** Number of retained subtasks whose original feature text grades `too_large`. */
   tooLargeSubtaskCount: number;
   /** Number of retained subtasks whose original feature text grades `too_small`. */
@@ -250,7 +252,7 @@ function observeDecomposerSelection(selection: SelfDevDecomposerSelection, obser
 }
 
 function applyGoalDefaultsAndHotPaths(goals: SelfDevGoal[], defaults: { base?: string; autoMerge?: boolean }): SelfDevGoal[] {
-  return pruneDanglingDependencies(goals.map((goal) => {
+  return goals.map((goal) => {
     const hotPaths = [...new Set([...(goal.hotPaths ?? []), ...inferHotPaths(goal.feature ?? '')])];
     return {
       ...goal,
@@ -258,7 +260,55 @@ function applyGoalDefaultsAndHotPaths(goals: SelfDevGoal[], defaults: { base?: s
       ...(defaults.base !== undefined ? { base: defaults.base } : {}),
       ...(defaults.autoMerge !== undefined ? { autoMerge: defaults.autoMerge } : {}),
     };
-  }));
+  });
+}
+
+const REGISTRATION_FILES = new Set([
+  'src/nexus/api/http-server.ts',
+  'src/index.ts',
+  'src/telegram-commands.ts',
+]);
+
+function isRegistrationFile(path: string): boolean {
+  return REGISTRATION_FILES.has(path) || /^graphs\/(?:[^/]+\/)*[^/]+\.yaml$/.test(path);
+}
+
+/** Fold only registration-only goals into their one retained dependency. */
+export function foldRegistrationOnlyGoals(goals: SelfDevGoal[]): SelfDevGoal[] {
+  let remaining = [...goals];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const registration of remaining) {
+      const files = registration.hotPaths ?? [];
+      if (files.length === 0 || !files.every(isRegistrationFile) || registration.dependsOn?.length !== 1) continue;
+      const dependencyId = registration.dependsOn[0];
+      const targetIndex = remaining.findIndex((goal) => goal.id === dependencyId && goal !== registration);
+      if (targetIndex < 0) continue;
+      const target = remaining[targetIndex]!;
+      remaining = remaining.filter((goal) => goal !== registration).map((goal) => {
+        if (goal === target) {
+          const dependsOn = goal.dependsOn?.filter((id) => id !== registration.id && id !== goal.id);
+          const { dependsOn: _old, ...rest } = goal;
+          return {
+            ...rest,
+            ...(dependsOn?.length ? { dependsOn } : {}),
+            feature: `${goal.feature}\nAlso register: ${registration.feature}`,
+            hotPaths: [...new Set([...(goal.hotPaths ?? []), ...files])],
+          };
+        }
+        if (!goal.dependsOn?.includes(registration.id!)) return goal;
+        const dependsOn = [...new Set(goal.dependsOn.map((id) => id === registration.id ? target.id! : id))]
+          .filter((id) => id !== goal.id);
+        const { dependsOn: _old, ...rest } = goal;
+        return dependsOn.length ? { ...rest, dependsOn } : rest;
+      });
+      debug.log('self-dev.decompose', 'fold-registration', { from: registration.id, into: target.id, files });
+      changed = true;
+      break;
+    }
+  }
+  return remaining;
 }
 
 function observeDecomposition(
@@ -267,12 +317,14 @@ function observeDecomposition(
   arcClassification?: { arcs: SelfDevArc[]; hintDeviation?: { requested: number; actual: number } },
   observationContext: SelfDevDecompositionObservationContext = {},
   pathGroundingOptions?: DecomposePathGroundingOptions,
+  foldedRegistration = 0,
 ): SelfDevDecomposition {
   const retainedSubtasks = decomposition.outcome === 'decomposed' ? goals : [];
   const gradedSubtasks = retainedSubtasks.map(gradeRetainedSubtask);
   const tooLargeSubtaskCount = gradedSubtasks.filter(({ grade }) => grade.verdict === 'too_large').length;
   const observation: SelfDevDecompositionObservation & { goalId: string | null; runId: string | null } = {
     ...decomposition,
+    foldedRegistration,
     tooLargeSubtaskCount,
     tooSmallSubtaskCount: gradedSubtasks.filter(({ grade }) => grade.verdict === 'too_small').length,
     hasMultipleTooLargeSubtasks: tooLargeSubtaskCount >= 2,
@@ -467,14 +519,15 @@ async function finalizeDecomposition(
   decomposition: SelfDevDecompositionMeta,
   opts: SelfDevDecomposeOptions,
   arcHint: number | undefined,
+  foldedRegistration = 0,
 ): Promise<SelfDevDecomposition> {
-  if (arcHint === undefined || goals.length === 0) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+  if (arcHint === undefined || goals.length === 0) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
   try {
     const arcLlm = opts.arcLlm ?? opts.llm ?? (await defaultDecomposeLlm(opts.model));
     const tasks = goals.map((goal) => ({ id: goal.id ?? '', title: goal.feature ?? '', description: goal.feature, dependsOn: goal.dependsOn }));
     const grouping = parseSelfDevArcGrouping(await arcLlm(buildSelfDevArcClassifyPrompt(feature, tasks, arcHint)));
     const classification = grouping ? deriveSelfDevArcsFromGrouping(tasks, grouping, arcHint) : null;
-    if (!classification) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+    if (!classification) return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
     const arcByTask = new Map(classification.arcs.flatMap((arc) => arc.taskIds.map((taskId) => [taskId, arc])));
     const taskIdsForArc = new Map(classification.arcs.map((arc) => [arc.id, arc.taskIds]));
     const orderedGoals = goals.map((goal) => {
@@ -482,9 +535,9 @@ async function finalizeDecomposition(
       const dependsOn = [...new Set([...(goal.dependsOn ?? []), ...arcDependencies])].filter((id) => id !== goal.id);
       return dependsOn.length ? { ...goal, dependsOn } : goal;
     });
-    return observeDecomposition(pruneDanglingDependencies(orderedGoals), decomposition, classification, opts.observation, opts.pathGrounding);
+    return observeDecomposition(pruneDanglingDependencies(orderedGoals), decomposition, classification, opts.observation, opts.pathGrounding, foldedRegistration);
   } catch {
-    return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding);
+    return observeDecomposition(goals, decomposition, undefined, opts.observation, opts.pathGrounding, foldedRegistration);
   }
 }
 
@@ -514,17 +567,18 @@ export async function decomposeSelfDevGoal(
     }
     observeDecomposerSelection('fabric', opts.observation);
     const actualTaskCount = result.goals.length;
-    const goals = actualTaskCount > 0
+    const prepared = actualTaskCount > 0
       ? applyGoalDefaultsAndHotPaths(result.goals.slice(0, hardMaxTasks), defaults)
       : [single];
-    return finalizeDecomposition(feature, goals, {
+    const goals = foldRegistrationOnlyGoals(prepared);
+    return finalizeDecomposition(feature, pruneDanglingDependencies(goals), {
       recommendedMaxTasks: maxTasks,
       actualTaskCount,
       truncatedAtHardMax: actualTaskCount > hardMaxTasks,
       exceededRecommendedMax: actualTaskCount > maxTasks,
       outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed',
       omittedGoalCount: result.omittedGoalCount,
-    }, opts, actualTaskCount > 0 ? arcHint : undefined);
+    }, opts, actualTaskCount > 0 ? arcHint : undefined, prepared.length - goals.length);
   }
 
   observeDecomposerSelection('default', opts.observation);
@@ -539,8 +593,9 @@ export async function decomposeSelfDevGoal(
   const actualTaskCount = rawSubtasks.length;
   const decomposition: SelfDevDecompositionMeta = { recommendedMaxTasks: maxTasks, actualTaskCount, truncatedAtHardMax: actualTaskCount > hardMaxTasks, exceededRecommendedMax: actualTaskCount > maxTasks, outcome: actualTaskCount === 0 ? 'single-no-subtasks' : 'decomposed' };
   const parsedGoals = parseSelfDevDecomposition(JSON.stringify({ subtasks: rawSubtasks.slice(0, hardMaxTasks) }), defaults);
-  const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(parsedGoals) : [single];
-  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined);
+  const foldedGoals = foldRegistrationOnlyGoals(parsedGoals);
+  const goals = parsedGoals.length > 0 ? pruneDanglingDependencies(foldedGoals) : [single];
+  return finalizeDecomposition(feature, goals, decomposition, opts, parsedGoals.length > 0 ? arcHint : undefined, parsedGoals.length - foldedGoals.length);
 }
 
 /** Default LLM seam — lazy `streamLLM` wire (kept out of the test path). */

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

@@ -111,6 +111,8 @@ function runPath(runId: string, dir: string): string {
   return path;
 }
 
+const loggedAbsentCheckpoints = new Set<string>();
+
 function loadSelfDevRunFromPath(path: string): SelfDevRunState | null {
   const runId = path.slice(path.lastIndexOf(sep) + 1, -'.json'.length);
   try {
@@ -118,7 +120,14 @@ function loadSelfDevRunFromPath(path: string): SelfDevRunState | null {
     if (o && typeof o.runId === 'string' && Array.isArray(o.results)) return o;
     try { debug.log('self-dev.run-store', 'read-failed', { runId, reason: 'invalid checkpoint shape' }); } catch { /* preserve fail-soft reads */ }
   } catch (error) {
-    try { debug.log('self-dev.run-store', 'read-failed', { runId, reason: String(error) }); } catch { /* preserve fail-soft reads */ }
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      if (!loggedAbsentCheckpoints.has(runId)) {
+        loggedAbsentCheckpoints.add(runId);
+        try { debug.log('self-dev.run-store', 'checkpoint-absent', { runId }); } catch { /* preserve fail-soft reads */ }
+      }
+    } else {
+      try { debug.log('self-dev.run-store', 'read-failed', { runId, reason: String(error) }); } catch { /* preserve fail-soft reads */ }
+    }
   }
   return null;
 }

package/src/self-implement/execution-clarification.ts

@@ -0,0 +1,115 @@
+import { randomUUID } from 'node:crypto';
+
+import { createPendingQuestion, writePendingQuestion } from '../ask-user-question/pending-questions.js';
+import { createFileAskUserQuestionResolver } from '../ask-user-question/tool.js';
+import { debug } from '../debug/log.js';
+import {
+  decideAndObserveClarification,
+  defaultClarificationBudget,
+  toAskUserQuestionRequest,
+  type ClarificationCandidate,
+  type ClarificationContext,
+} from '../hitl/clarification-policy.js';
+import { getUserConfig } from '../user-config.js';
+import { appendRunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
+
+export interface ExecutionClarificationContext {
+  runId: string;
+  budget?: ClarificationContext['budget'];
+  pendingQuestionCount?: number;
+  config?: { hitl?: { executionDeadlineMinutes?: number } };
+}
+
+export type ExecutionClarificationResult =
+  | { choice: string; by: 'assumed' | 'owner' | 'auto-recommended' }
+  | { deferred: true }
+  | { parked: true; reason: 'critical-unanswered'; questionId: string };
+
+export interface ExecutionClarificationDeps {
+  now?: () => number;
+  createId?: () => string;
+  resolver?: typeof createFileAskUserQuestionResolver;
+  resolverDeps?: Parameters<typeof createFileAskUserQuestionResolver>[1];
+  writeRunLedger?: RunLedgerWriter;
+}
+
+/** A single execution-phase decision; the file resolver owns the pending/answer lifecycle. */
+export async function askAtExecution(
+  candidate: ClarificationCandidate,
+  ctx: ExecutionClarificationContext,
+  deps: ExecutionClarificationDeps = {},
+): Promise<ExecutionClarificationResult> {
+  const recommended = candidate.options.filter(option => option.recommended);
+  if (candidate.options.length < 2 || candidate.options.length > 4 || recommended.length !== 1
+    || new Set(candidate.options.map(option => option.label)).size !== candidate.options.length) {
+    throw new Error('Execution clarification requires 2–4 distinct options and exactly one recommendation.');
+  }
+  const observe = (event: 'assumed' | 'asked' | 'answered' | 'auto-recommended' | 'parked', questionId?: string): void => {
+    try {
+      debug.log('hitl.execution', event, { runId: ctx.runId, questionId, impact: candidate.impact });
+    } catch { /* Logging must not decide the user's choice. */ }
+  };
+  const record = (event: 'assumed' | 'auto-recommended' | 'parked', data: Record<string, unknown>): void => {
+    (deps.writeRunLedger ?? appendRunLedgerEntry)({
+      timestamp: new Date((deps.now ?? Date.now)()).toISOString(),
+      runId: ctx.runId,
+      event,
+      data: { impact: candidate.impact, ...data },
+    });
+  };
+  const decision = decideAndObserveClarification(candidate, {
+    phase: 'execution',
+    budget: ctx.budget ?? defaultClarificationBudget('execution'),
+    pendingQuestionCount: ctx.pendingQuestionCount,
+  }, { consumer: 'self-implement-execution' });
+  if (decision.action === 'defer') return { deferred: true };
+  if (decision.action === 'assume') {
+    record('assumed', { choice: recommended[0]!.label, assumption: decision.assumption });
+    observe('assumed');
+    return { choice: recommended[0]!.label, by: 'assumed' };
+  }
+
+  const request = toAskUserQuestionRequest(decision);
+  if (!request) throw new Error('Execution clarification policy approved a question without a valid wire request.');
+  const configured = ctx.config === undefined
+    ? getUserConfig().hitl?.executionDeadlineMinutes
+    : ctx.config.hitl?.executionDeadlineMinutes;
+  const minutes = configured === undefined ? 30 : configured;
+  if (!Number.isSafeInteger(minutes) || minutes < 1 || minutes > 35_791) {
+    throw new Error('hitl.executionDeadlineMinutes must be a positive integer within the resolver timer limit.');
+  }
+  const questionId = (deps.createId ?? (() => `execution:${ctx.runId}:${randomUUID()}`))();
+  let expired = false;
+  let written = false;
+  const resolver = (deps.resolver ?? createFileAskUserQuestionResolver)(minutes * 60_000, {
+    ...deps.resolverDeps,
+    observe: (state, data) => {
+      if (state === 'answer-missing') expired = true;
+      deps.resolverDeps?.observe?.(state, data);
+    },
+    createId: () => questionId,
+    write: (pending) => {
+      const question = createPendingQuestion(questionId, { ...request, runId: ctx.runId }, undefined,
+        { now: () => new Date((deps.now ?? Date.now)()) },
+        { surface: 'file', delivery: 'file', expiresAt: pending.expiresAt });
+      (deps.resolverDeps?.write ?? writePendingQuestion)(question);
+      written = true;
+      observe('asked', questionId);
+    },
+  });
+  const answer = await resolver({ ...request, runId: ctx.runId });
+  const chosen = answer.answers[candidate.id];
+  if (written && !expired && !answer.cancelled && typeof chosen === 'string' && candidate.options.some(option => option.label === chosen)) {
+    observe('answered', questionId);
+    return { choice: chosen, by: 'owner' };
+  }
+  if (!written || !expired) throw new Error('Execution clarification was cancelled or could not read its answer before expiry.');
+  if (candidate.impact === 'critical') {
+    record('parked', { questionId, reason: 'critical-unanswered' });
+    observe('parked', questionId);
+    return { parked: true, reason: 'critical-unanswered', questionId };
+  }
+  record('auto-recommended', { questionId, choice: recommended[0]!.label, by: 'auto-recommended' });
+  observe('auto-recommended', questionId);
+  return { choice: recommended[0]!.label, by: 'auto-recommended' };
+}

package/src/self-implement/gate-cli.ts

@@ -7,6 +7,7 @@ import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
 import { runAndroidUnitTestGate } from '../../scripts/ci-android-unit-tests.js';
 import { runIosUnitTestGate } from '../../scripts/ci-ios-unit-tests.js';
+import { runPwaBuildGate } from '../../scripts/ci-pwa-build-gate.js';
 import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-gate.js';
 import { parseReviewDepthFromFilesJson } from '../agent-mission/review-depth.js';
 import { buildGateBaselineReport, calculateGateTestCountChange, formatGateBaselineNote, formatGateTestCountNote, isGateTestFile, runGateBaseline, type BaselineProcessResult, type BaselineProcessStatus, type GateTestFailure } from './gate-baseline.js';
@@ -83,6 +84,7 @@ interface SelfGateCliDeps {
   runAndroidGate?: (out: GateOutput) => number;
   /** iOS 순수-로직 시험 게이트 심(시험 주입용). */
   runIosGate?: (out: GateOutput) => number;
+  runPwaGate?: (out: GateOutput) => number;
   listPrWorktrees?: (cwd: string) => PrWorktreeListEntry[] | { lookupFailed: string };
   inspectWorktreeDirtiness?: (path: string) => { dirty: boolean } | { lookupFailed: string };
 }
@@ -619,11 +621,12 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   const androidPassed = runAdditionalGate('android-gate', deps.runAndroidGate ?? runAndroidUnitTestGate, selection.files, cwd, lines);
   // 🍎 iOS 축 — 안드로이드와 «같은 자리»에 둔다(skipTestStep 앞). Swift 만 바뀐 PR 도 여기서 조기 리턴한다.
   const iosPassed = runAdditionalGate('ios-gate', deps.runIosGate ?? runIosUnitTestGate, selection.files, cwd, lines);
+  const pwaPassed = runAdditionalGate('pwa-gate', deps.runPwaGate ?? runPwaBuildGate, selection.files, cwd, lines);
 
   if (scope.skipTestStep) {
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: androidPassed && iosPassed && policyPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
+    return { exitCode: androidPassed && iosPassed && pwaPassed && policyPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
   }
 
   const test = (deps.runTests ?? ((dir, files) => (deps.runCommand ?? defaultRunCommand)('bun', ['test', ...files], dir)))(cwd, testFiles);
@@ -632,7 +635,7 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
     lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, `tests: pass (${testFiles.length} files)`));
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: policyPassed && androidPassed && iosPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
+    return { exitCode: policyPassed && androidPassed && iosPassed && pwaPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
   }
 
   if (worktreeLog.includes('deterministic environment setup failed')) lines.push(worktreeLog);
@@ -653,6 +656,6 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   });
   lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, formatGateBaselineNote(report, unrunImporterTotal ?? 0)));
   const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
-  const exitCode = !androidPassed || !iosPassed || !policyPassed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
+  const exitCode = !androidPassed || !iosPassed || !pwaPassed || !policyPassed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
   return { exitCode, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
 }