elanous 0.2.42 → 0.2.44

package/src/user-config.ts

@@ -187,6 +187,8 @@ export interface LLMConfig {
   apiKey?: string;
   model?: string;
   baseUrl?: string;
+  /** Host that owns Codex OAuth refresh authority. Defaults to the HQ's mbp host. */
+  codexTokenOwnerHost?: string;
   /** Override the text stream idle watchdog in milliseconds. Omitted keeps provider/family defaults. */
   streamIdleTimeoutMs?: number;
   /** OpenRouter 설정 한 곳(두 골이 같은 키를 쓴다):
@@ -1177,6 +1179,8 @@ export interface SelfImplementToolConfig {
   goalRecordInDoc: boolean;
   /** Controls the persistent grounding loop used while authoring goals; absent preserves it. */
   goalAuthorPersistentGrounding?: boolean;
+  /** Explicit opt-in for the one-shot Terra medium goal-author reviewer precheck; absent/off preserves legacy authoring. */
+  goalAuthorReviewerPrecheck?: boolean;
   /** Uses the Fabric decomposer for SelfOrchestrate requests that omit `fabric_decompose`. */
   fabricDecompose: boolean;
   /** Normalized SelfOrchestrate goal count that automatically selects Fabric; null disables auto-selection. */
@@ -1294,7 +1298,7 @@ const TOOLS_DEFAULTS: ToolsConfig = {
   selfOrchestrate: {},
   nativeStructure: { enabled: false },
   // 대표 결정(2026-07-26): 오토 선호 — 기본 ON.
-  selfImplement: { worktreeRoot: join(homedir(), '.elanous', 'worktrees'), childInstanceMode: 'isolated', prApprovalDelivery: 'terminal' as const, observeOnly: false, goalRecordInDoc: true, fabricDecompose: false, fabricDecomposeAutoPathThreshold: 5, autoOpenPr: true, supervisor: { reasonRepair: false }, autoStop: { enabled: true, minRung: 2 }, autoAssist: { enabled: true, minRung: 2 }, screenStallTermination: { enabled: true, minRung: 2 }, reworkBudget: { shadowStop: false, maxRounds: 3 }, decompositionShadow: { enabled: false }, clarificationEscalation: { enabled: false } },
+  selfImplement: { worktreeRoot: join(homedir(), '.elanous', 'worktrees'), childInstanceMode: 'isolated', prApprovalDelivery: 'terminal' as const, observeOnly: false, goalRecordInDoc: true, goalAuthorReviewerPrecheck: false, fabricDecompose: false, fabricDecomposeAutoPathThreshold: 5, autoOpenPr: true, supervisor: { reasonRepair: false }, autoStop: { enabled: true, minRung: 2 }, autoAssist: { enabled: true, minRung: 2 }, screenStallTermination: { enabled: true, minRung: 2 }, reworkBudget: { shadowStop: false, maxRounds: 3 }, decompositionShadow: { enabled: false }, clarificationEscalation: { enabled: false } },
 };
 
 // ── Debug ────────────────────────────────────────────────────────────
@@ -2664,6 +2668,7 @@ function parseToolsConfig(raw: unknown): ToolsConfig {
   const goalAuthorPersistentGrounding = typeof selfImplRaw.goalAuthorPersistentGrounding === 'boolean'
     ? selfImplRaw.goalAuthorPersistentGrounding
     : undefined;
+  const goalAuthorReviewerPrecheck = selfImplRaw.goalAuthorReviewerPrecheck === true;
   const fabricDecompose = selfImplRaw.fabricDecompose === true;
   const fabricDecomposeAutoPathThresholdRaw = selfImplRaw.fabricDecomposeAutoPathThreshold;
   const fabricDecomposeAutoPathThreshold = fabricDecomposeAutoPathThresholdRaw === null
@@ -2813,7 +2818,7 @@ function parseToolsConfig(raw: unknown): ToolsConfig {
     runDevHarness,
     selfOrchestrate,
     nativeStructure,
-    selfImplement: { worktreeRoot, childInstanceMode, prApprovalDelivery, observeOnly, goalRecordInDoc, goalAuthorPersistentGrounding, fabricDecompose, fabricDecomposeAutoPathThreshold, autoOpenPr, supervisor, draftOnStop, salvageRetention, autoStop, autoAssist, screenStallTermination, reworkBudget, decompositionShadow, clarificationEscalation, ...(childLlm ? { childLlm } : {}), ...(escalateChild && Object.keys(escalateChild).length ? { escalateChild } : {}), ...(selfImplRaw.podChildDefault !== undefined ? { podChildDefault: selfImplRaw.podChildDefault } : {}), ...(runTtlHours !== undefined ? { runTtlHours } : {}), ...(draftSweepCloseCap !== undefined ? { draftSweepCloseCap } : {}), ...(runTtl ? { runTtl } : {}), ...(autoheal ? { autoheal } : {}) },
+    selfImplement: { worktreeRoot, childInstanceMode, prApprovalDelivery, observeOnly, goalRecordInDoc, goalAuthorPersistentGrounding, goalAuthorReviewerPrecheck, fabricDecompose, fabricDecomposeAutoPathThreshold, autoOpenPr, supervisor, draftOnStop, salvageRetention, autoStop, autoAssist, screenStallTermination, reworkBudget, decompositionShadow, clarificationEscalation, ...(childLlm ? { childLlm } : {}), ...(escalateChild && Object.keys(escalateChild).length ? { escalateChild } : {}), ...(selfImplRaw.podChildDefault !== undefined ? { podChildDefault: selfImplRaw.podChildDefault } : {}), ...(runTtlHours !== undefined ? { runTtlHours } : {}), ...(draftSweepCloseCap !== undefined ? { draftSweepCloseCap } : {}), ...(runTtl ? { runTtl } : {}), ...(autoheal ? { autoheal } : {}) },
   };
 }
 
@@ -3948,8 +3953,8 @@ export interface UserConfig {
   nexus?: { demoMode?: boolean };
   /** Execution-phase HITL answer deadline; absent means 30 minutes. */
   hitl?: { executionDeadlineMinutes?: number };
-  /** Deferred (quiet-hours) outbound queue. `deferredMaxAttempts`: failed flushes before an item is quarantined; absent = env ELANOUS_OUTBOUND_DEFERRED_MAX_ATTEMPTS, else 5. */
-  outbound?: { deferredMaxAttempts?: number };
+  /** Outbound notifications. quietHours is `off` or `HH:MM-HH:MM` KST; absent keeps 00:00-06:30. */
+  outbound?: { deferredMaxAttempts?: number; quietHours?: 'off' | string };
   coo?: { linearProject?: string };
   decisions?: { linearProjection: { enabled: boolean }; requireCrossCheck: boolean;
     crossCheckNeighbor: Record<EventSeat, EventSeat>; crossCheckWaitMinutes: number };
@@ -5032,6 +5037,21 @@ export function parseHqConfig(raw: unknown): HqConfig | undefined {
   return Object.keys(out).length ? out : undefined;
 }
 
+function parseOutboundConfig(raw: unknown): UserConfig['outbound'] {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return undefined;
+  const outbound = raw as Record<string, unknown>;
+  const attempts = outbound.deferredMaxAttempts;
+  const quietHours = outbound.quietHours;
+  const validQuietHours = quietHours === 'off'
+    || (typeof quietHours === 'string'
+      && /^(?:[01]\d|2[0-3]):[0-5]\d-(?:[01]\d|2[0-3]):[0-5]\d$/.test(quietHours)
+      && quietHours.slice(0, 5) !== quietHours.slice(6));
+  const result: NonNullable<UserConfig['outbound']> = {};
+  if (Number.isSafeInteger(attempts) && (attempts as number) > 0) result.deferredMaxAttempts = attempts as number;
+  if (validQuietHours) result.quietHours = quietHours as 'off' | string;
+  return Object.keys(result).length ? result : undefined;
+}
+
 export function buildUserConfig(path: string = defaultPath()): UserConfig {
   if (!existsSync(path)) return defaultConfigWithRuntimeProvider();
   let raw: unknown;
@@ -5156,6 +5176,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
   const tuiRaw = rawObj.tui && typeof rawObj.tui === 'object' && !Array.isArray(rawObj.tui) ? rawObj.tui as Record<string, unknown> : {};
   const gateRemoteConfig = parseGateRemoteConfig(rawObj.gateRemote);
   const projects = parseProjectsConfig(rawObj.projects);
+  const outboundConfig = parseOutboundConfig(rawObj.outbound);
   return {
     tui: {
       sidetab: tuiRaw.sidetab === 'off' || tuiRaw.sidetab === 'open' ? tuiRaw.sidetab : 'collapsed',
@@ -5330,6 +5351,9 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
         };
       })(),
       model: resolveRuntimeLlmModel(baseProvider, selectedProvider, str(llm.model), escalationProvider || undefined),
+      codexTokenOwnerHost: typeof llm.codexTokenOwnerHost === 'string'
+        && /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(llm.codexTokenOwnerHost.trim())
+        ? llm.codexTokenOwnerHost.trim() : undefined,
       streamIdleTimeoutMs: positiveFiniteNumber(llm.streamIdleTimeoutMs),
       openrouter: (() => {
         const router = llm.openrouter;
@@ -5954,11 +5978,7 @@ export function buildUserConfig(path: string = defaultPath()): UserConfig {
       && typeof (rawObj.hitl as Record<string, unknown>).executionDeadlineMinutes === 'number'
       ? { hitl: { executionDeadlineMinutes: (rawObj.hitl as { executionDeadlineMinutes: number }).executionDeadlineMinutes } }
       : {}),
-    ...(rawObj.outbound && typeof rawObj.outbound === 'object' && !Array.isArray(rawObj.outbound)
-      && Number.isSafeInteger((rawObj.outbound as Record<string, unknown>).deferredMaxAttempts)
-      && ((rawObj.outbound as { deferredMaxAttempts: number }).deferredMaxAttempts) > 0
-      ? { outbound: { deferredMaxAttempts: (rawObj.outbound as { deferredMaxAttempts: number }).deferredMaxAttempts } }
-      : {}),
+    ...(outboundConfig ? { outbound: outboundConfig } : {}),
     ...(parseHqConfig(rawObj.hq) ? { hq: parseHqConfig(rawObj.hq)! } : {}),
     ...(gateRemoteConfig ? { gateRemote: gateRemoteConfig } : {}),
     cli: { helpRole: parseCliHelpRole(rawObj.cli) },
@@ -6527,6 +6547,9 @@ export function saveUserConfig(
     },
   };
   const rawRest = { ...(cfg.raw ?? {}) };
+  const rawOutbound = rawRest.outbound && typeof rawRest.outbound === 'object' && !Array.isArray(rawRest.outbound)
+    ? rawRest.outbound as Record<string, unknown> : undefined;
+  delete rawRest.outbound;
   const rawTui = rawRest.tui && typeof rawRest.tui === 'object' && !Array.isArray(rawRest.tui)
     ? rawRest.tui as Record<string, unknown> : {};
   // projects: raw entries are kept verbatim — an invalid entry loaded from disk is preserved, not blocked (its error
@@ -6680,6 +6703,7 @@ export function saveUserConfig(
       // picks up capability fallback 'medium' → user thinks fix
       // regressed).
       reasoningLevel: cfg.llm.reasoningLevel,
+      codexTokenOwnerHost: cfg.llm.codexTokenOwnerHost,
       codexReasoning: cfg.llm.codexReasoning,
       goalLoop: cfg.llm.goalLoop,
       memoryJudge: cfg.llm.memoryJudge,
@@ -6974,6 +6998,7 @@ export function saveUserConfig(
     // M1-2b: sparse — emit only when explicitly set. Keeps Path-A-only
     // users' file clean (no empty modelTier:{} blobs).
     ...(cfg.modelTier ? { modelTier: parseModelTierConfig(cfg.modelTier) } : {}),
+    ...((cfg.outbound || rawOutbound) ? { outbound: stripUndef({ ...rawOutbound, ...cfg.outbound }) } : {}),
     ...(cfg.sessionFabric ? { sessionFabric: cfg.sessionFabric } : {}),
     ...(cfg.nextFluent ? { nextFluent: cfg.nextFluent } : {}),
     ...(cfg.taste ? { taste: cfg.taste } : {}),

package/src/user-intent/types.ts

@@ -3,8 +3,8 @@
 // PLAN: 내부 문서 `PLAN-user-intent-logging-2026-05-12` §2
 // MANUAL: 내부 문서 `MANUAL-user-intent-logging-2026-05-12`
 //
-// Single shape for every user-intent signal across the 7 surfaces
-// (tui · pwa · ios · watch · airpods · discord · telegram) and 7
+// Single shape for every user-intent signal across the 8 surfaces
+// (tui · ask · pwa · ios · watch · airpods · discord · telegram) and 7
 // layers (utterance · gesture · selection · navigation · ambient ·
 // device_state · system). Patcher (Y3) consumes the JSONL stream as
 // raw input; KGS card conversion happens in the Patcher, not here.
@@ -21,6 +21,7 @@
 export type UserIntentSurface =
   | 'unknown'
   | 'tui'
+  | 'ask'
   | 'pwa'
   | 'ios'
   | 'watch'
@@ -29,7 +30,7 @@ export type UserIntentSurface =
   | 'telegram';
 
 export const USER_INTENT_SURFACES: readonly UserIntentSurface[] = [
-  'unknown', 'tui', 'pwa', 'ios', 'watch', 'airpods', 'discord', 'telegram',
+  'unknown', 'tui', 'ask', 'pwa', 'ios', 'watch', 'airpods', 'discord', 'telegram',
 ];
 
 export type UserIntentLayer =

package/src/ux-sim/browser-hand.ts

@@ -0,0 +1,165 @@
+// BrowserHand 시뮬레이션 — 페이지·Linear 네트워크 경계만 대역하고 생산 coordinator와 browser-act를 부른다.
+import {
+  dispatchBrowserHand,
+  type BrowserHandArgs,
+  type BrowserHandDeps,
+  type BrowserHandRepairNode,
+  type BrowserHandResult,
+} from '../tool-runtime/browser-hand-runtime.js';
+import { performBrowserAction, type BrowserActionDeps, type BrowserActionResult } from '../harness/browser-act.js';
+import type { CdpClient, CdpEventListener } from '../browser-cdp/client.js';
+
+export type BrowserHandScenario = 'attach' | 'paywall-fallback' | 'selection-roundtrip';
+
+export interface BrowserHandSimulationResult {
+  scenario: BrowserHandScenario;
+  runId: string;
+  observedRunId: string | null;
+  observedBrowserActionRunIds: readonly (string | null)[];
+  result: BrowserHandResult;
+  pageReads: readonly string[];
+  browserActions: readonly string[];
+  repairNodes: readonly BrowserHandRepairNode[];
+  linear: {
+    uploads: readonly { filename: string; contentType: string; bytes: number }[];
+    attachments: readonly { issueId: string; title: string; url: string }[];
+    comments: readonly { issueId: string; body: string }[];
+  };
+}
+
+const ISSUE_ID = 'c0ffee00-0000-4000-8000-000000000001';
+const PERSONA = {
+  personaId: 'ux-sim-browser-hand',
+  displayName: 'UX simulation browser',
+  actionHosts: ['ir.example.test', 'archive.example.test'],
+};
+const PRIMARY_URL = 'https://ir.example.test/filing';
+const ALTERNATE_URL = 'https://archive.example.test/filing';
+const CAPTURE_REF = 'ux-sim://browser-hand/capture.png';
+
+function fakeCdp(): CdpClient {
+  let lifecycleListener: CdpEventListener | undefined;
+  return {
+    port: 0,
+    pid: 0,
+    get isAlive() { return true; },
+    on(method, listener) {
+      if (method === 'Page.lifecycleEvent') lifecycleListener = listener;
+      return () => { lifecycleListener = undefined; };
+    },
+    async navigate() {
+      queueMicrotask(() => lifecycleListener?.({
+        method: 'Page.lifecycleEvent',
+        params: { name: 'load', frameId: 'ux-sim-frame', loaderId: 'ux-sim-loader' },
+      }));
+      return { frameId: 'ux-sim-frame', loaderId: 'ux-sim-loader' };
+    },
+    async screenshot() { return Buffer.from([137, 80, 78, 71]); },
+    async evaluate() { throw new Error('unexpected page evaluation; execute seam supplies click coordinates'); },
+    async setScriptExecutionDisabled(value) {
+      // Canary: BrowserHand must not disable page scripts; fail loudly if that production behavior is introduced.
+      if (value) throw new Error('BrowserHand simulation must not disable page scripts');
+    },
+    async close() {},
+  };
+}
+
+/** Run the real BrowserHand coordinator and performBrowserAction with only browser and Linear I/O faked. */
+export async function simBrowserHand(scenario: BrowserHandScenario, linearSubtaskId = ISSUE_ID, runId = 'run-ux-sim-browser-hand'): Promise<BrowserHandSimulationResult> {
+  let observedRunId: string | null = null;
+  const observedBrowserActionRunIds: Array<string | null> = [];
+  const pageReads: string[] = [];
+  const browserActions: string[] = [];
+  const repairNodes: BrowserHandRepairNode[] = [];
+  const uploads: Array<{ filename: string; contentType: string; bytes: number }> = [];
+  const attachments: Array<{ issueId: string; title: string; url: string }> = [];
+  const comments: Array<{ issueId: string; body: string }> = [];
+
+  const args: BrowserHandArgs = {
+    url: PRIMARY_URL,
+    target: 'body',
+    armed: true,
+    linearSubtaskId,
+    persona: PERSONA.personaId,
+    ...(scenario === 'paywall-fallback' ? { alternateUrl: ALTERNATE_URL } : {}),
+    ...(scenario === 'selection-roundtrip'
+      ? { includeThisToo: true, selection: { text: 'Revenue rose 12%', tab: 'Q3 filing' } }
+      : {}),
+  };
+
+  const browserAct = async (request: Parameters<typeof performBrowserAction>[0], deps?: BrowserActionDeps): Promise<BrowserActionResult> => {
+    browserActions.push(request.url);
+    return performBrowserAction(request, {
+      ...deps,
+      connect: async () => fakeCdp(),
+      // `performBrowserAction` uses this injected click boundary, so the fake page's evaluate must stay unused.
+      execute: async () => ({ x: 41, y: 73 }),
+      loadWaitTimeoutMs: 20,
+      captureTimeoutMs: 20,
+      reclaimOpenedTabs: false,
+      saveAttachment: async () => ({
+        ok: true,
+        entry: {
+          id: 'ux-sim-browser-hand-capture',
+          path: CAPTURE_REF,
+          filename: 'capture.png',
+          mediaType: 'image/png',
+          size: 4,
+          createdAt: 0,
+        },
+      }),
+    });
+  };
+
+  const deps: BrowserHandDeps = {
+    browserAct,
+    confirmHuman: async () => true,
+    resolvePersona: async () => PERSONA,
+    readPageText: async url => {
+      pageReads.push(url);
+      return scenario === 'paywall-fallback' && url === PRIMARY_URL
+        ? 'Subscribe to continue'
+        : 'Public filing content';
+    },
+    browserActDeps: {
+      getRunId: () => { observedRunId = runId; return runId; },
+      observe(event, data) {
+        if (event === 'repair-node') repairNodes.push(data as BrowserHandRepairNode);
+        if (event === 'executed') {
+          const row = data as { runId?: unknown };
+          observedBrowserActionRunIds.push(typeof row.runId === 'string' ? row.runId : null);
+        }
+      },
+    },
+    getApiKey: async () => 'ux-sim-fake-linear-key',
+    readCapture: async path => {
+      if (path !== CAPTURE_REF) throw new Error(`unexpected simulated capture ref: ${path}`);
+      return Buffer.from([137, 80, 78, 71]);
+    },
+    upload: async input => {
+      uploads.push({ filename: input.filename, contentType: input.contentType, bytes: input.body.byteLength });
+      return 'https://uploads.example.test/browser-hand.png';
+    },
+    attach: async input => {
+      attachments.push({ issueId: input.issueId, title: input.title, url: input.url });
+      return 'ux-sim-attachment-1';
+    },
+    reflectSelection: async input => {
+      comments.push(input);
+      return true;
+    },
+  };
+  const result = await dispatchBrowserHand(args, undefined, deps);
+
+  return {
+    scenario,
+    runId,
+    observedRunId,
+    observedBrowserActionRunIds,
+    result,
+    pageReads,
+    browserActions,
+    repairNodes,
+    linear: { uploads, attachments, comments },
+  };
+}

package/src/ux-sim/draft-inventory-builder.ts

@@ -0,0 +1,199 @@
+import {
+  assessDraftTriage,
+  decideDraft,
+  draftClaimState,
+  type DraftDecision,
+  type DraftTriageAssessmentInput,
+  type DraftTriageInput,
+  type DraftTriageNextAction,
+  type DraftTriagePr,
+} from '../self-dev/draft-triage-rules.js';
+
+export type DraftInventoryScenario =
+  | 'merged-twin'
+  | 'duplicate-open'
+  | 'harvest-reference'
+  | 'all-files-landed'
+  | 'protected-label'
+  | 'running'
+  | 'stale'
+  | 'harvestable';
+
+export interface DraftInventoryCase {
+  scenario: DraftInventoryScenario;
+  input: DraftTriageInput;
+  expected: DraftDecision['action'];
+  assessmentInput: DraftTriageAssessmentInput;
+  expectedAssessment: DraftTriageNextAction;
+}
+
+const fixedNow = Date.parse('2026-10-26T00:00:00.000Z');
+const iso = (offsetMs: number): string => new Date(fixedNow + offsetMs).toISOString();
+const CASE_AGE_HOURS = 60;
+const CASE_AGE_MS = CASE_AGE_HOURS * 60 * 60_000;
+
+function makeCase(scenario: DraftInventoryScenario, index: number): DraftInventoryCase {
+  const number = 10_000 + index;
+  const title = `Draft inventory ${scenario} ${index}`;
+  const branchStem = `inventory-${scenario}-${index}`;
+  const cell = 'MOCK-DRAFT-INVENTORY';
+  const body = `골: ${branchStem}\n칸: ${cell}\n카드: mock-draft-${scenario}-${index}`;
+  const createdAt = iso(-72 * 60 * 60_000);
+  const latestCommitAt = iso(-CASE_AGE_MS);
+  const fileChangedAt = iso(-70 * 60 * 60_000);
+  const labels = ['elanous:from-ux'];
+  const draft: DraftTriagePr = {
+    number,
+    title,
+    branch: `self-impl/${branchStem}-a1b2c3d4-r1`,
+    body,
+    createdAt,
+    latestCommitAt,
+    updatedAt: iso(-30 * 60_000),
+    changedFiles: ['src/example.ts'],
+    latestFileChanges: { 'src/example.ts': fileChangedAt },
+    labels,
+  };
+  const input: DraftTriageInput = {
+    draft,
+    now: new Date(fixedNow),
+    runStatus: 'self-implement.result final',
+    mergedTwins: [],
+    openDrafts: [],
+    ageHours: CASE_AGE_HOURS,
+    liveBranches: new Set<string>(),
+  };
+  const assessmentInput: DraftTriageAssessmentInput = {
+    draft,
+    now: new Date(fixedNow),
+    runStatus: 'completed',
+  };
+  let expected: DraftDecision['action'] = 'keep';
+  let expectedAssessment: DraftTriageNextAction = 'human';
+
+  switch (scenario) {
+    case 'merged-twin':
+      input.mergedTwins = [{ number: number + 50_000, title: 'merged twin', branch: 'main', body }];
+      assessmentInput.replacement = { number: number + 50_000, evidence: 'same verified goal was merged' };
+      expected = 'close';
+      expectedAssessment = 'close-b';
+      break;
+    case 'duplicate-open':
+      input.openDrafts = [{
+        number: number + 50_000,
+        title,
+        branch: `self-impl/${branchStem}-d4e5f6a7-r2`,
+        body,
+        createdAt: iso(-60 * 60 * 60_000),
+      }];
+      assessmentInput.replacement = { number: number + 50_000, evidence: 'newer same-card draft supersedes this draft' };
+      expected = 'close';
+      expectedAssessment = 'close-b';
+      break;
+    case 'harvest-reference':
+      input.mergedTwins = [{
+        number: number + 50_000,
+        title: 'harvested replacement',
+        branch: 'main',
+        body: `수확 완료 (수확 #${number})`,
+      }];
+      expected = 'close';
+      break;
+    case 'all-files-landed':
+      input.mergedTwins = [{
+        number: number + 50_000,
+        title: 'later landed file',
+        branch: `self-impl/${branchStem}-b2c3d4e5-r2`,
+        body,
+        changedFiles: ['src/example.ts'],
+        mergedAt: iso(-69 * 60 * 60_000),
+      }];
+      assessmentInput.replacement = { number: number + 50_000, evidence: 'all changed files landed in the replacement' };
+      expected = 'close';
+      expectedAssessment = 'close-b';
+      break;
+    case 'protected-label':
+      draft.labels = [...labels, 'elanous:keep'];
+      expected = 'keep';
+      break;
+    case 'running':
+      draft.labels = [...labels, 'elanous:running'];
+      input.runStatus = 'running';
+      input.liveBranches = new Set([draft.branch]);
+      assessmentInput.runStatus = 'running';
+      expected = 'keep';
+      break;
+    case 'stale':
+      input.runStatus = undefined;
+      assessmentInput.ownerConfirmed = true;
+      expected = 'close';
+      expectedAssessment = 'close-c';
+      break;
+    case 'harvestable':
+      draft.labels = [...labels, 'elanous:harvestable'];
+      draft.body = `${body}\n수확보류: harvest-deferred`;
+      input.runStatus = 'failed';
+      assessmentInput.runStatus = 'failed';
+      assessmentInput.gate = 'pass';
+      assessmentInput.review = 'approved';
+      expected = 'keep';
+      expectedAssessment = 'harvest';
+      break;
+  }
+
+  return { scenario, input, expected, assessmentInput, expectedAssessment };
+}
+
+/** Deterministic synthetic inventory; both production draft triage functions run for every case. */
+export function buildDraftInventory(count = 200): DraftInventoryCase[] {
+  if (!Number.isInteger(count) || count < 0) throw new RangeError('count must be a non-negative integer');
+  const scenarios: readonly DraftInventoryScenario[] = [
+    'merged-twin', 'duplicate-open', 'harvest-reference', 'all-files-landed',
+    'protected-label', 'running', 'stale', 'harvestable',
+  ];
+  return Array.from({ length: count }, (_, index) => makeCase(scenarios[index % scenarios.length]!, index));
+}
+
+export function assessDraftInventory(cases = buildDraftInventory()): {
+  total: number;
+  byScenario: Record<DraftInventoryScenario, number>;
+  byAction: Record<'close' | 'keep', number>;
+  triageByAction: Record<DraftTriageNextAction, number>;
+  mismatches: string[];
+  protectedOrRunningClosed: number;
+} {
+  const byScenario: Record<DraftInventoryScenario, number> = {
+    'merged-twin': 0,
+    'duplicate-open': 0,
+    'harvest-reference': 0,
+    'all-files-landed': 0,
+    'protected-label': 0,
+    running: 0,
+    stale: 0,
+    harvestable: 0,
+  };
+  const byAction = { close: 0, keep: 0 };
+  const triageByAction: Record<DraftTriageNextAction, number> = {
+    'close-a': 0, 'close-b': 0, 'close-c': 0, harvest: 0, human: 0,
+  };
+  const mismatches: string[] = [];
+  let protectedOrRunningClosed = 0;
+  cases.forEach((item, index) => {
+    byScenario[item.scenario] += 1;
+    const decision = decideDraft(item.input);
+    byAction[decision.action] += 1;
+    if (decision.action !== item.expected) mismatches.push(`${index}:${item.scenario}:decideDraft expected=${item.expected} actual=${decision.action}`);
+
+    const assessment = assessDraftTriage(item.assessmentInput);
+    triageByAction[assessment.nextAction] += 1;
+    if (assessment.nextAction !== item.expectedAssessment) mismatches.push(`${index}:${item.scenario}:assessDraftTriage expected=${item.expectedAssessment} actual=${assessment.nextAction}`);
+
+    if ((item.scenario === 'protected-label' || item.scenario === 'running') && decision.action === 'close') {
+      protectedOrRunningClosed += 1;
+    }
+    if (item.scenario === 'running' && draftClaimState({ labels: item.input.draft.labels ?? [], updatedAt: item.input.draft.updatedAt }, new Date(fixedNow)) !== 'claimed') {
+      mismatches.push(`${index}:running:draftClaimState expected=claimed`);
+    }
+  });
+  return { total: cases.length, byScenario, byAction, triageByAction, mismatches, protectedOrRunningClosed };
+}

package/src/ux-sim/fake-browser-page.ts

@@ -0,0 +1,81 @@
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { BrowserHandDeps } from '../tool-runtime/browser-hand-runtime.js';
+import type { BrowserActionDeps } from '../harness/browser-act.js';
+import type { CdpClient, CdpEventListener } from '../browser-cdp/client.js';
+
+export interface FakeBrowserPageOptions {
+  pages: Record<string, string>;
+  artifactDir: string;
+  approved?: boolean;
+}
+
+/** Fake only the external page/CDP boundary; the coordinator and browser-act remain real. */
+export function createFakeBrowserPage(options: FakeBrowserPageOptions) {
+  const visits: string[] = [];
+  const inspections: string[] = [];
+  const clicks: Array<{ url: string; target: string }> = [];
+  const confirmations: Array<{ url: string; target: string }> = [];
+  let currentUrl = '';
+  let pendingTarget = '';
+  let listener: CdpEventListener | undefined;
+  mkdirSync(options.artifactDir, { recursive: true });
+
+  const client: CdpClient = {
+    port: 0,
+    pid: 0,
+    get isAlive() { return true; },
+    on(method, next) {
+      if (method === 'Page.lifecycleEvent') listener = next;
+      return () => { listener = undefined; };
+    },
+    async navigate(url) {
+      if (!listener) throw new Error('fake browser page requires Page.lifecycleEvent subscription before navigate');
+      const lifecycleListener = listener;
+      currentUrl = url;
+      visits.push(url);
+      const navigation = { frameId: 'fake-frame', loaderId: `fake-loader-${visits.length}` };
+      queueMicrotask(() => lifecycleListener({ method: 'Page.lifecycleEvent', params: { name: 'load', ...navigation } }));
+      return navigation;
+    },
+    async screenshot() { return Buffer.from('fake page screenshot'); },
+    async evaluate(expression) {
+      if (expression === 'location.href') return currentUrl;
+      if (expression.includes('document.querySelector(')) {
+        const selector = expression.match(/document\.querySelector\(("(?:[^"\\]|\\.)*")\)/)?.[1];
+        pendingTarget = selector ? JSON.parse(selector) as string : 'unknown-target';
+        return { x: 10, y: 10, kind: 'navigation', href: currentUrl, text: pendingTarget };
+      }
+      throw new Error(`fake page does not implement CDP evaluate expression: ${expression.slice(0, 80)}`);
+    },
+    async setScriptExecutionDisabled() {},
+    async click() { clicks.push({ url: currentUrl, target: pendingTarget }); },
+    async close() {},
+  };
+
+  const browserActionDeps: BrowserActionDeps = {
+    connect: async () => client,
+    loadWaitTimeoutMs: 100,
+    captureTimeoutMs: 100,
+    reclaimOpenedTabs: false,
+    saveAttachment: async (blob, filename) => {
+      const path = join(options.artifactDir, filename);
+      const png = Buffer.from(await blob.arrayBuffer());
+      writeFileSync(path, png);
+      return {
+        ok: true,
+        entry: { id: 'fake-capture', path, filename, mediaType: 'image/png', size: png.length, createdAt: 0 },
+      };
+    },
+  };
+
+  const deps: BrowserHandDeps = {
+    confirmHuman: async input => { confirmations.push(input); return options.approved ?? true; },
+    resolvePersona: async id => ({ personaId: id, displayName: 'UX sim page', actionHosts: Object.keys(options.pages).map(url => new URL(url).hostname) }),
+    readPageText: async url => { inspections.push(url); return options.pages[url]; },
+    browserActDeps: browserActionDeps,
+    getApiKey: async () => 'fake-linear-key',
+  };
+
+  return { deps, visits, inspections, clicks, confirmations };
+}

package/src/ux-sim/fake-linear-device.ts

@@ -0,0 +1,31 @@
+import type { BrowserHandDeps } from '../tool-runtime/browser-hand-runtime.js';
+
+interface FakeLinearAttachment {
+  issueId: string;
+  title: string;
+  url: string;
+}
+
+/** Fake Linear's network API while preserving the production coordinator's calls. */
+export function createFakeLinearDevice() {
+  const uploads: Array<{ filename: string; contentType: string; body: Buffer }> = [];
+  const attachments: FakeLinearAttachment[] = [];
+  const comments: Array<{ issueId: string; body: string }> = [];
+
+  const deps: Pick<BrowserHandDeps, 'upload' | 'attach' | 'reflectSelection'> = {
+    upload: async input => {
+      uploads.push({ filename: input.filename, contentType: input.contentType, body: Buffer.from(input.body) });
+      return `https://linear-sim.invalid/files/${uploads.length}`;
+    },
+    attach: async input => {
+      attachments.push({ issueId: input.issueId, title: input.title, url: input.url });
+      return `linear-attachment-${attachments.length}`;
+    },
+    reflectSelection: async input => {
+      comments.push(input);
+      return true;
+    },
+  };
+
+  return { deps, uploads, attachments, comments };
+}