elanous 0.2.41 → 0.2.43

package/scripts/release-loop/resume-release.ts

@@ -22,6 +22,7 @@ import { reserveReleaseResumeAttempt } from './resume-cap.js';
 import { cutReleaseBranch } from './cut-branch.js';
 import { releaseLoopConfig } from './unattended-release.js';
 import { trafficOptionsFromConfig } from './traffic-transition.js';
+import type { GateAutohealDecision } from './gate-autoheal.js';
 
 const GRAPH = join(import.meta.dir, '../../graphs/release/release-loop.yaml');
 
@@ -67,9 +68,36 @@ export interface ResumeReleaseOptions {
 export interface ResumeReleasePlan {
   runId: string; version: string; fromNode: string; commandRoot: string; tip: TipRefresh;
   partial: PartialOutcome; gatePlan: { mode: 'not-run' | 'partial' | 'full'; reason?: string };
+  /** Most recent failed gate's autoheal recommendation, carried into the resume plan for the caller. */
+  autoheal?: GateAutohealDecision;
+  autohealReroute?: string;
   nextAttempt: number; priorCountKnown: boolean; preflight: 'passed';
 }
 
+function priorGateAutoheal(run: GraphRunState): GateAutohealDecision | undefined {
+  const gate = lastJsonObject(run.nodes.find((node) => node.nodeId === 'gate')?.output);
+  const value = gate?.autoheal;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const candidate = value as Partial<GateAutohealDecision>;
+  if (!['reroute-shard', 'retry-shard', 'partial-resume', 'host-switch', 'hitl'].includes(String(candidate.action))) return undefined;
+  if (!['shard-pod-death', 'timeout', 'host-down', 'interference', 'true-regression', 'environment'].includes(String(candidate.cause))) return undefined;
+  if (typeof candidate.signature !== 'string' || typeof candidate.reason !== 'string'
+    || typeof candidate.shardElapsedMs !== 'number' || typeof candidate.overallElapsedMs !== 'number') return undefined;
+  return candidate as GateAutohealDecision;
+}
+
+function automaticReroute(run: GraphRunState, autoheal: GateAutohealDecision | undefined, tipChanged: boolean, from: string): string | undefined {
+  if (!autoheal || tipChanged || from !== 'gate' || typeof (run.input as Record<string, unknown> | undefined)?.gatePodPool !== 'string'
+    || (autoheal.action !== 'retry-shard' && autoheal.action !== 'reroute-shard' && autoheal.action !== 'host-switch')) return undefined;
+  const key = autoheal.shardKey;
+  if (autoheal?.action === 'host-switch') return 'auto';
+  if (typeof key === 'string' && /^pod-\d+$/.test(key)) return key;
+  if (typeof key === 'string' && /^\d+$/.test(key)) return `pod-${key}`;
+  const gate = lastJsonObject(run.nodes.find((node) => node.nodeId === 'gate')?.output);
+  const stalled = gate?.stalledShards;
+  return Array.isArray(stalled) && stalled.length > 0 ? 'auto' : undefined;
+}
+
 /** CLI entry files: a production file that only names one (help text, a goal's command line) does not run it. */
 const CLI_ENTRIES = ['bin/elanous.mjs', 'src/index.ts'] as const;
 /** The gate's own test-file set (gate-node sweep: `git ls-files '*.test.*'` filtered by this). */
@@ -428,6 +456,42 @@ function preparePartial(tip: TipRefresh, opts: { from: string; partial?: boolean
     const saved = JSON.parse(readFileSync(tip.statePath, 'utf8')) as GraphRunState;
     const gateRecord = saved.nodes.find((node) => node.nodeId === 'gate');
     const previousGate = gateRecord ? lastJsonObject(gateRecord.output) as Record<string, unknown> | undefined : undefined;
+    // `loadFlaky` is also a partial-resume cause, but it is emitted separately from
+    // shard-only interference. Carry both sets into the same affected-file recheck.
+    const interference = [...new Set([
+      ...(Array.isArray(previousGate?.interferenceErrors) ? previousGate.interferenceErrors : []),
+      ...(Array.isArray(previousGate?.loadFlaky) ? previousGate.loadFlaky : []),
+    ])];
+    if (previousGate?.outcome === 'error' && previousGate.commit === tip.to && previousGate.autoheal
+      && typeof previousGate.autoheal === 'object' && (previousGate.autoheal as { action?: unknown }).action === 'partial-resume') {
+      if (!Array.isArray(interference) || !interference.length || !interference.every((id) => typeof id === 'string'))
+        return fallback('partial-resume has no complete interference error record');
+      let closure: ClosureTree;
+      try { closure = (deps.closureTree ?? ((commit: string) => gitClosureTree(deps.repo ?? process.cwd(), commit)))(tip.to); }
+      catch (error) { return fallback(`tip tree unreadable: ${String(error instanceof Error ? error.message : error).slice(0, 200)}`); }
+      const tracked = new Set(closure.files);
+      const planned = planSameCommitRecheck({ version: tip.version, measuredCommit: tip.to, forCommit: tip.to,
+        failures: [], errors: interference as string[], existsAtCommit: (file) => tracked.has(file) });
+      if (!planned.ok) return fallback(planned.reason);
+      // The gate consumer only executes same-cut partial work for the stalled-only recheck shape.
+      // Interference files are likewise unmeasured, so mark exactly this set as the recheck boundary.
+      const partialFailures = previousGate.partialFailures as { failures?: unknown; errors?: unknown } | undefined;
+      if (!Array.isArray(partialFailures?.failures) || !partialFailures.failures.every((id) => typeof id === 'string')
+        || !Array.isArray(partialFailures.errors) || !partialFailures.errors.every((id) => typeof id === 'string'))
+        return fallback('partial-resume has no complete prior failure record');
+      let priorFailures: string[];
+      let priorErrors: string[];
+      try {
+        const affected = new Set(planned.plan.files);
+        priorFailures = (partialFailures.failures as string[]).filter((id) => !affected.has(testFileOfId(id)));
+        priorErrors = (partialFailures.errors as string[]).filter((id) => !affected.has(testFileOfId(id)));
+      } catch { return fallback('partial-resume prior failure record is malformed'); }
+      const recheckPlan = { ...planned.plan, priorFailures, priorErrors, stalledFiles: planned.plan.files };
+      const path = dryRun ? undefined : writeRecheckPlan(root, recheckPlan);
+      debug.log('release-loop.resume', 'interference-recheck-planned', { version: tip.version, commit: tip.to,
+        remeasureFileCount: recheckPlan.files.length, fallbackReason: null, ...(path ? { path } : {}), dryRun });
+      return { requested: true, applied: true, files: recheckPlan.files.length, priorCommit: tip.to, ...(auto ? { auto: true as const } : {}) };
+    }
     const stalled = previousGate?.stalledShards;
     const summary = previousGate?.partialSummary as { pass?: unknown; fail?: unknown; errors?: unknown; ran?: unknown; files?: unknown } | undefined;
     const measured = previousGate?.partialFailures as { failures?: unknown; errors?: unknown } | undefined;
@@ -600,19 +664,25 @@ async function planResumeReleaseRunLocked(opts: ResumeReleaseOptions, deps: Resu
     waiverCommit = recorded;
   }
   const tip = refreshReleaseBranchTipInternal(opts.runId, deps, opts.from, waiverCommit, true);
+  const fromIndex = savedRun.path.indexOf(opts.from);
+  const gateIndex = savedRun.path.indexOf('gate');
+  const gateWillRun = fromIndex >= 0 && gateIndex >= fromIndex;
   if (opts.rerouteShard !== undefined && tip.changed) throw new Error('shard reroute requires the original cut head; moved tip needs a full re-gate');
   verifyResumeRecipePin(opts.commandRoot ?? process.cwd(), savedRun.graphSnapshot, tip.version);
   const commandRoot = verifyReleaseCommandRoot(opts.commandRoot ?? process.cwd(), tip.to, deps.git);
   verifyResumePreflight(savedRun, opts, deps, tip.version, tip.from, tip.to, commandRoot);
-  const partial = preparePartial(tip, opts.rerouteShard !== undefined ? { ...opts, partial: false } : opts, deps, true);
-  const fromIndex = savedRun.path.indexOf(opts.from);
-  const gateIndex = savedRun.path.indexOf('gate');
-  const gateWillRun = fromIndex >= 0 && gateIndex >= fromIndex;
+  const autoheal = gateWillRun ? priorGateAutoheal(savedRun) : undefined;
+  const autoReroute = opts.rerouteShard === undefined ? automaticReroute(savedRun, autoheal, tip.changed, opts.from) : undefined;
+  const automaticShardReroute = autoReroute ? releaseResumeGateShardReroute(savedRun, { from: opts.from, shard: autoReroute }) : undefined;
+  const effectiveOpts = automaticShardReroute ? { ...opts, rerouteShard: automaticShardReroute.set.gateRerouteShard } : opts;
+  const partial = preparePartial(tip, effectiveOpts.rerouteShard !== undefined ? { ...effectiveOpts, partial: false } : effectiveOpts, deps, true);
   const gatePlan = !gateWillRun ? { mode: 'not-run' as const }
     : partial.requested && partial.applied ? { mode: 'partial' as const }
       : { mode: 'full' as const, reason: partial.requested ? partial.reason : opts.partial === false ? 'partial recheck disabled' : 'no partial plan applies' };
+  if (autoheal) debug.log('release-loop.resume', 'gate-autoheal-plan', { runId: opts.runId, version: tip.version, appliedReroute: automaticShardReroute?.set.gateRerouteShard ?? null, ...autoheal });
   return { runId: opts.runId, version: tip.version, fromNode: opts.from, commandRoot, tip, partial,
-    gatePlan, nextAttempt: attempt.attempt, priorCountKnown: attempt.priorCountKnown, preflight: 'passed' };
+    gatePlan, ...(autoheal ? { autoheal } : {}), ...(automaticShardReroute ? { autohealReroute: automaticShardReroute.set.gateRerouteShard } : {}),
+    nextAttempt: attempt.attempt, priorCountKnown: attempt.priorCountKnown, preflight: 'passed' };
 }
 
 async function resumeReleaseRunLocked(opts: ResumeReleaseOptions, deps: ResumeReleaseDeps): Promise<{ tip: TipRefresh; partial: PartialOutcome; state: GraphRunState }> {
@@ -667,7 +737,12 @@ async function resumeReleaseRunLocked(opts: ResumeReleaseOptions, deps: ResumeRe
   const commandRoot = verifyReleaseCommandRoot(opts.commandRoot ?? process.cwd(), previewTip.to, deps.git);
   verifyResumePreflight(savedRun, opts, deps, previewTip.version, previewTip.from, previewTip.to, commandRoot);
   const tip = refreshReleaseBranchTipInternal(opts.runId, deps, opts.from, waiverCommit, false, previewTip.to);
-  const partial = preparePartial(tip, shardReroute ? { ...opts, partial: false } : opts, deps);
+  const autoheal = priorGateAutoheal(savedRun);
+  const autoReroute = !shardReroute ? automaticReroute(savedRun, autoheal, tip.changed, opts.from) : undefined;
+  const automaticShardReroute = autoReroute ? releaseResumeGateShardReroute(savedRun, { from: opts.from, shard: autoReroute }) : undefined;
+  const partial = preparePartial(tip, shardReroute || automaticShardReroute
+    ? { ...opts, rerouteShard: (shardReroute ?? automaticShardReroute)!.set.gateRerouteShard, partial: false } : opts, deps);
+  if (autoheal) debug.log('release-loop.resume', 'gate-autoheal-plan', { runId: opts.runId, version: tip.version, appliedReroute: automaticShardReroute?.set.gateRerouteShard ?? null, ...autoheal });
   // A failed preflight does not consume an observed release resume attempt.
   const attempt = reserveReleaseResumeAttempt(savedRun, deps.root!, { now: deps.now });
   debug.log('release-loop.resume', 'attempt', { runId: opts.runId, attempt: attempt.attempt,
@@ -682,8 +757,8 @@ async function resumeReleaseRunLocked(opts: ResumeReleaseOptions, deps: ResumeRe
     ...(acceptedRegressions ? { releaseAcceptedRegressions: { requested: opts.acceptedRegressions!, acceptedRegressions } } : {}),
     ...(gateExecutor ? { releaseGateExecutor: { executor: gateExecutor.set.gateExecutor, ...(opts.gateHost !== undefined ? { host: opts.gateHost } : {}) } } : {}),
     ...(gatePodPool ? { releaseGatePodPool: gatePodPool.set.gatePodPool } : {}),
-    ...(shardReroute ? { releaseGateShardReroute: { shard: shardReroute.set.gateRerouteShard,
-      ...(shardReroute.set.gateShardHost ? { host: shardReroute.set.gateShardHost } : {}),
+    ...(shardReroute || automaticShardReroute ? { releaseGateShardReroute: { shard: (shardReroute ?? automaticShardReroute)!.set.gateRerouteShard,
+      ...((shardReroute ?? automaticShardReroute)!.set.gateShardHost ? { host: (shardReroute ?? automaticShardReroute)!.set.gateShardHost } : {}),
       ...(opts.shardOs ? { os: opts.shardOs } : {}) } } : {}),
     deps: { root: deps.root, ...(deps.runBash ? { runBash: deps.runBash } : {}) } });
   return { tip, partial, state };

package/scripts/release-loop/unattended-release.ts

@@ -15,6 +15,7 @@ import { releaseRunUniverse } from './release-universe.js';
 import { baseVersion, isStableVersion, nextPrereleaseVersion, type PrereleaseKind } from './release-version.js';
 import { publishAtError } from './publish-at.js';
 import { checkGateExecutorChoice, type GateExecutor } from './gate-executor.js';
+import { readReleaseGateRehearsal, readReleaseOpsPolicy, selectReleaseGateMethod } from './gate-method.js';
 
 const VERSION = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)$/;
 const GRAPH = join(import.meta.dir, '../../graphs/release/release-loop.yaml');
@@ -55,6 +56,8 @@ export interface ReleaseRunInput extends ReleaseLoopConfig {
   gatePodPool?: string;
   /** GATE-HOST-EXECUTOR — absent = pod (today's input, byte-identical); `host` sweeps on `gateRemote`. */
   gateExecutor?: GateExecutor;
+  /** RELEASE-POLICY-PACK — gate source/image identity follows the selected cut commit. */
+  gateImagePin?: 'cut-commit';
   forceFreeze?: boolean;
   publishAt?: string;
   /** RELEASE-BRANCH: version-release cuts release/<v> from main HEAD and bumps only the branch. */
@@ -65,6 +68,7 @@ export interface UnattendedReleaseDeps {
   ledgerRoot?: string;
   config?: ReleaseLoopConfig;
   configPath?: string;
+  policyPath?: string;
   graph?: (path: string, options: { input: ReleaseRunInput; pinChildUniverse?: boolean; deps?: { root?: string } }) => Promise<GraphRunState>;
   checklist?: (version: string) => Pick<ReturnType<typeof cutChecklistGate>, 'ok' | 'red' | 'undecided' | 'blocked'>;
   freezeRoot?: string;
@@ -125,20 +129,27 @@ export interface GateExecutorRequest { executor?: string; host?: string }
 export function buildReleaseRunInput(version: string, deps: UnattendedReleaseDeps = {}, cutCommit?: string, gate: GateExecutorRequest = {}): ReleaseRunInput {
   const config = deps.config ?? releaseLoopConfig(deps.configPath);
   if (gate.executor === undefined && gate.host !== undefined) throw new Error('--gate-host requires --gate-executor host');
-  const choice = gate.executor === undefined ? undefined
-    : checkGateExecutorChoice(gate.executor, gate.executor === 'host' ? gate.host ?? config.gateRemote : gate.host);
-  const pool = config.gatePodPool;
-  const hasPool = typeof pool === 'string' && !!pool.trim();
-  // The pod executor (the default) stays fail-closed on a missing pool; an explicit host executor does not need one.
-  if (choice?.executor !== 'host' && !hasPool) throw new Error('release.loop.gatePodPool is required before graph execution');
   const previousVersion = latestPublishedPreviousVersion(baseVersion(version), deps.ledgerRoot);
+  const rehearsal = readReleaseGateRehearsal(deps.ledgerRoot ?? releaseLedgerRoot(), previousVersion);
+  const method = selectReleaseGateMethod({ policy: readReleaseOpsPolicy(deps.policyPath), targetVersion: baseVersion(version),
+    configuredPool: config.gatePodPool, rehearsal });
+  debug.log('release.run', 'gate-method-selected', { version, previousVersion, ...method });
+  const requested = gate.executor === undefined ? undefined
+    : checkGateExecutorChoice(gate.executor, gate.executor === 'host' ? gate.host ?? config.gateRemote : gate.host);
+  if (requested && requested.executor !== method.executor) {
+    debug.log('release.run', 'gate-method-override-rejected', { version, requested: requested.executor, selected: method.executor, decision: method.decision });
+    throw new Error(`gate executor ${requested.executor} conflicts with release policy ${method.executor}`);
+  }
+  if (method.executor === 'pod' && !method.pool) throw new Error('release.loop.gatePodPool is required by release ops policy');
   return {
     ...config,
     version, previousVersion,
     ...(cutCommit !== undefined ? { cutCommit } : {}),
-    ...(hasPool ? { gatePodPool: pool.trim() } : {}),
-    ...(choice ? { gateExecutor: choice.executor } : {}),
-    ...(choice?.host ? { gateRemote: choice.host } : {}),
+    ...(method.executor === 'pod' ? { gatePodPool: method.pool } : {}),
+    gateExecutor: method.executor,
+    gateImagePin: method.imagePin,
+    // A future policy may select host; only then can its validated host request reach this input.
+    ...(requested?.host ? { gateRemote: requested.host } : {}),
   };
 }
 

package/scripts/rhythm/daily.ts

@@ -5,7 +5,7 @@ import { Database } from 'bun:sqlite';
 import { dirname, join } from 'node:path';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
 import { listSchedules } from '../../src/release-loop/release-schedule.js';
-import { devVersion, listChecklist } from '../../src/release-loop/checklist.js';
+import { checklistDevVersion, devVersion, listChecklist } from '../../src/release-loop/checklist.js';
 import { DecisionLedger } from '../../src/decisions/decision-ledger.js';
 import { selectProact1Lite, type ProactSignals } from '../../src/decisions/proact1-lite.js';
 import { trafficTick, seatOfTree } from '../../src/loops/orchestrator/traffic.js';
@@ -21,6 +21,7 @@ import { BriefItemsLedger } from '../../src/briefing/brief-items.js';
 import { debug } from '../../src/debug/log.js';
 import { retroBriefingLines } from '../../src/retro/daily.js';
 import { dispatchCooAdmin } from '../../src/domains/coo-admin-tool.js';
+import { runLinearProgressSync, type ProgressSyncResult } from './linear-progress-sync.js';
 
 export type Section<T> = { status: 'ok'; value: T } | { status: 'unreadable'; reason: string };
 export type Landing = { title: string; seat: string; mergedAt: string; prNumber?: number };
@@ -542,6 +543,7 @@ export type DailyDeps = { now?: () => Date; root?: string; vaultRoot?: string |
   target?: { chatId: number; botToken: string };
   send?: (request: DailySendRequest) => DailySendConfirmation | null; receipt?: (key: string) => DeliveryReceipt;
   recordDelivery?: (text: string, kind: 'ops-report') => void;
+  linearProgressSync?: typeof runLinearProgressSync;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
   proactSignals?: () => Promise<ProactSignals>;
   proactPreviouslySuggested?: ReadonlySet<string>;
@@ -593,6 +595,8 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
     let sendError: string | null = null;
     let recordError: string | null = null;
     let newsState: string | null = null;
+    let linearProgress: ProgressSyncResult | undefined;
+    let linearProgressError: string | null = null;
     let enabled = deps.sendEnabled === true;
     if (deps.sendEnabled === undefined && options.stage === 'deliver' && !options.dryRun) {
       try { enabled = record(record(record(getUserConfig().raw.loops).rhythm).daily).send === true; }
@@ -613,11 +617,39 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
       deliveryState = delivery.deliveryState;
       if (resolved) newsState = sendNewsAfterReview(delivery, file, markdown, resolved, deps);
     }
+    if (options.stage === 'deliver' && !options.dryRun) {
+      try {
+        const dailyConfig = record(record(record(getUserConfig().raw.loops).rhythm).daily);
+        if (dailyConfig.linearProgressSync === true) {
+          const allowIssueIdentifiers = Array.isArray(dailyConfig.linearProgressIssueAllowlist)
+            ? dailyConfig.linearProgressIssueAllowlist.filter((value): value is string => typeof value === 'string') : [];
+          if (!allowIssueIdentifiers.length) {
+            linearProgressError = 'issue allowlist missing; no Linear comments sent';
+            if (deps.log) deps.log('loop.rhythm-daily', 'linear-progress-config-blocked', { reason: 'issue-allowlist-missing' });
+            else loopEvent('rhythm-daily', 'linear-progress-config-blocked', { reason: 'issue-allowlist-missing' });
+          } else {
+            linearProgress = await (deps.linearProgressSync ?? runLinearProgressSync)({ version: checklistDevVersion(devVersion()), now, root: deps.root,
+              apply: true, allowIssueIdentifiers,
+              log: (event, data) => deps.log ? deps.log('loop.rhythm-daily.linear-progress', event, data)
+                : loopEvent('rhythm-daily.linear-progress', event, data) });
+            if (linearProgress.failures.length) {
+              linearProgressError = `${linearProgress.failures.length} Linear summary failure(s); see loop.rhythm-daily.linear-progress logs`;
+            }
+          }
+        }
+      } catch (error) {
+        linearProgressError = shortReason(reasonOf(error));
+        if (deps.log) deps.log('loop.rhythm-daily', 'linear-progress-failed', { reason: linearProgressError });
+        else loopEvent('rhythm-daily', 'linear-progress-failed', { reason: linearProgressError });
+      }
+    }
     tick.sent = sent;
-    const status = vault.vaultFatal || Object.values(sections).includes('unreadable') ? 'degraded'
+    if (linearProgress) tick.linearProgress = linearProgress;
+    if (linearProgressError) tick.linearProgressError = linearProgressError;
+    const status = vault.vaultFatal || Object.values(sections).includes('unreadable') || !!linearProgressError ? 'degraded'
       : deliveryState === 'pending' ? 'pending'
       : ['sent', 'already-sent', 'receipt-sent'].includes(deliveryState) ? 'ok' : 'degraded';
-    const deliveryLine = `${options.stage} ${status} · target=${target} · ${deliveryState} · sent=${sent} · chars=${chars} · receipt=${receiptKey}${recordError ? ` · ${recordError}` : ''}${newsState ? ` · news=${newsState}` : ''}`;
+    const deliveryLine = `${options.stage} ${status} · target=${target} · ${deliveryState} · sent=${sent} · chars=${chars} · receipt=${receiptKey}${recordError ? ` · ${recordError}` : ''}${newsState ? ` · news=${newsState}` : ''}${linearProgressError ? ` · linear=${linearProgressError}` : ''}`;
     if (options.stage === 'deliver') {
       Object.assign(tick, { status, deliveryState, target, chars, receiptKey, deliveryLine, recordError });
       if (!options.dryRun) {
@@ -625,7 +657,7 @@ export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; st
         else loopEvent('rhythm-daily', 'tick', tick);
       }
     }
-    return { file, markdown, header, risks, sections, sent, ...vault, sendError, recordError, status, deliveryState, deliveryLine,
+    return { file, markdown, header, risks, sections, sent, ...vault, sendError, recordError, status, deliveryState, deliveryLine, linearProgress, linearProgressError,
       draftCloseSummary: undefined };
   }
   const safe = async <T>(fetch: () => Promise<T>): Promise<Section<T>> => {

package/scripts/rhythm/linear-progress-sync.ts

@@ -0,0 +1,298 @@
+import { createHash } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { getSecretAsync } from '../../src/nexus/config/secrets/index.js';
+import { commentLinearIssue } from '../../src/connectors/linear.js';
+import { listChecklist, type Checklist, type ChecklistItem } from '../../src/release-loop/checklist.js';
+import { DecisionLedger, type DecisionEntry } from '../../src/decisions/decision-ledger.js';
+import { effectiveInstanceRoot } from '../../src/instance/resolve.js';
+import { debug } from '../../src/debug/log.js';
+import { acquireLockAsync } from '../../src/storage/file-lock.js';
+
+export type ProgressIssue = {
+  id: string; identifier: string; title: string; url: string; description: string; state: string;
+};
+export type ProgressLink = { issue: ProgressIssue; cells: ChecklistItem[]; decisions: DecisionEntry[]; sources: Array<{ cellId: string; field: string }> };
+export type ProgressPreview = { identifier: string; body: string; sources: Array<{ cellId: string; field: string }> };
+export type ProgressSyncResult = {
+  day: string; candidates: ProgressPreview[]; posted: string[]; alreadyPresent: string[];
+  skipped: string[]; failures: Array<{ identifier: string; reason: string }>;
+};
+
+const kstDay = (date: Date) => new Date(date.getTime() + 9 * 3_600_000).toISOString().slice(0, 10);
+const escapeRegExp = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+function exactReference(source: string, token: string): boolean {
+  return new RegExp(`(^|[^A-Z0-9_-])${escapeRegExp(token)}($|[^A-Z0-9_-])`).test(source);
+}
+
+function declaredIssueRefs(source: string): string[] {
+  const refs: string[] = [];
+  for (const declaration of source.matchAll(/\blinear-ref\s*[:=]\s*([^\r\n]+)/gi)) {
+    refs.push(...[...(declaration[1] ?? '').matchAll(/\b[A-Z]{2,8}-\d+\b/g)].map(match => match[0]!));
+  }
+  return [...new Set(refs)];
+}
+
+/** Only `linear-ref:` declarations in checklist fields and exact checklist IDs in issue descriptions create a link. */
+export function resolveExplicitProgressLinks(issues: readonly ProgressIssue[], checklist: Checklist, decisions: readonly DecisionEntry[] = []): ProgressLink[] {
+  const links: ProgressLink[] = [];
+  for (const issue of issues) {
+    const cells = new Map<string, ChecklistItem>();
+    const sources: Array<{ cellId: string; field: string }> = [];
+    for (const cell of checklist.items) {
+      const declared: Array<[string, string]> = [
+        ['title', cell.title], ['evidence', cell.evidence ?? ''], ['refs', (cell.refs ?? []).join('\n')],
+      ];
+      for (const [field, value] of declared) {
+        if (declaredIssueRefs(value).includes(issue.identifier)) {
+          cells.set(cell.id, cell);
+          sources.push({ cellId: cell.id, field: `checklist.${field}` });
+        }
+      }
+      if (exactReference(issue.description, cell.id)) {
+        cells.set(cell.id, cell);
+        sources.push({ cellId: cell.id, field: 'issue.description' });
+      }
+    }
+    const linkedDecisions = decisions.filter(decision => decision.refs?.some(ref => ref === issue.identifier || ref === issue.url));
+    for (const decision of linkedDecisions) sources.push({ cellId: decision.id, field: 'decision.refs' });
+    if (cells.size || linkedDecisions.length) links.push({ issue, cells: [...cells.values()], decisions: linkedDecisions, sources });
+  }
+  return links;
+}
+
+function changedStatuses(checklist: Checklist, cellIds: ReadonlySet<string>, day: string): Array<{ id: string; from: string; to: string }> {
+  return checklist.history.flatMap(entry => {
+    if (!cellIds.has(entry.id) || entry.field !== 'status' || !entry.at || kstDay(new Date(entry.at)) !== day) return [];
+    return [{ id: entry.id, from: String(entry.from ?? 'unknown'), to: String(entry.to ?? 'unknown') }];
+  });
+}
+
+export function renderProgressPreview(link: ProgressLink, checklist: Checklist, day: string): ProgressPreview {
+  const ids = new Set(link.cells.map(cell => cell.id));
+  const transitions = changedStatuses(checklist, ids, day);
+  const statusLines = link.cells.map(cell => {
+    const evidence = cell.evidence ?? '';
+    const simulated = cell.status === 'green' && /green\(sim\)/i.test(evidence);
+    const e4Pending = simulated && /(?:설치본|installed)(?: CLI)?[^\n.]{0,24}E4[^\n.]{0,24}(?:미완|incomplete|not complete|not done)/i.test(evidence);
+    return `- 연결 칸: ${cell.id} — ${simulated ? `green(sim)${e4Pending ? ' · 설치본 E4 미완' : ''}` : cell.status}`;
+  });
+  const transitionLines = transitions.map(change => `- 오늘 상태 변화: ${change.id} ${change.from} → ${change.to}`);
+  const decisionLines = link.decisions.filter(decision => {
+    const timestamp = decision.decidedAt ?? decision.withdrawnAt ?? decision.raisedAt;
+    return !!timestamp && kstDay(new Date(timestamp)) === day;
+  })
+    .map(decision => `- 연결 결정: ${decision.id} — ${decision.status}`);
+  const landedPrs = [...new Set(link.cells.flatMap(cell => {
+    const text = cell.evidence ?? '';
+    return [...text.matchAll(/\bPR\s*#(\d+)\b[^\n]{0,120}\bmerged\b/gi)].map(match => `#${match[1]}`);
+  }))];
+  const nextCell = link.cells.find(cell => cell.status !== 'green' && cell.status !== 'done');
+  const simulatedCell = link.cells.find(cell => cell.status === 'green' && /green\(sim\)/i.test(cell.evidence ?? ''));
+  const simulatedEvidence = simulatedCell?.evidence ?? '';
+  const simulatedE4Pending = !!simulatedCell && /(?:설치본|installed)(?: CLI)?[^\n.]{0,24}E4[^\n.]{0,24}(?:미완|incomplete|not complete|not done)/i.test(simulatedEvidence);
+  const next = nextCell ? `연결 칸 ${nextCell.id}의 남은 완료 경계 진행`
+    : simulatedCell ? `연결 칸 ${simulatedCell.id}의 ${simulatedE4Pending ? '설치본 E4 실물 증거 확보' : '설치본 실물 증거 확인'}` : '연결된 칸은 현재 green/done';
+  const body = [
+    `${day} 진행 요약`,
+    `- 상태: ${link.issue.state} — ${link.issue.url}`,
+    ...statusLines,
+    ...transitionLines,
+    ...decisionLines,
+    ...(landedPrs.length ? [`- 연결 착지 PR: ${landedPrs.join(', ')}`] : []),
+    `- 다음: ${next}`,
+    `<!-- elanous-linear-progress:${day}:${link.issue.identifier} -->`,
+  ].join('\n');
+  return { identifier: link.issue.identifier, body, sources: link.sources };
+}
+
+async function fetchTeamIssues(apiKey: string, teamKey: string): Promise<ProgressIssue[]> {
+  const query = `query LinearProgressIssues($teamKey: String!, $after: String) {
+    issues(filter: { team: { key: { eq: $teamKey } } }, first: 100, after: $after) {
+      nodes { id identifier title url description state { name } }
+      pageInfo { hasNextPage endCursor }
+    }
+  }`;
+  const issues: ProgressIssue[] = [];
+  const cursors = new Set<string>();
+  let after: string | null = null;
+  do {
+    const response = await fetch('https://api.linear.app/graphql', {
+      method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query, variables: { teamKey, after } }),
+    });
+    if (!response.ok) throw new Error(`Linear GraphQL HTTP ${response.status}`);
+    const result = await response.json() as { errors?: unknown[]; data?: { issues?: { nodes?: Array<Record<string, unknown>>; pageInfo?: { hasNextPage: boolean; endCursor: string | null } } } };
+    const page = result.data?.issues;
+    if (result.errors?.length || !Array.isArray(page?.nodes)) throw new Error(`Linear ${teamKey} issue query failed`);
+    for (const node of page.nodes) {
+      if (typeof node.id !== 'string' || typeof node.identifier !== 'string' || typeof node.title !== 'string' || typeof node.url !== 'string') continue;
+      const state = node.state && typeof node.state === 'object' ? (node.state as { name?: unknown }).name : undefined;
+      issues.push({ id: node.id, identifier: node.identifier, title: node.title, url: node.url,
+        description: typeof node.description === 'string' ? node.description : '', state: typeof state === 'string' ? state : 'unknown' });
+    }
+    const info = page.pageInfo;
+    if (info?.hasNextPage && (!info.endCursor || cursors.has(info.endCursor))) throw new Error(`Linear ${teamKey} cursor missing or repeated`);
+    after = info?.hasNextPage ? info.endCursor : null;
+    if (after) cursors.add(after);
+  } while (after);
+  return issues;
+}
+
+async function fetchAllowlistedIssue(apiKey: string, identifier: string): Promise<ProgressIssue | null> {
+  const query = `query LinearAllowlistedProgressIssue($identifier: String!) {
+    issue(id: $identifier) { id identifier title url description state { name } }
+  }`;
+  const response = await fetch('https://api.linear.app/graphql', {
+    method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+    body: JSON.stringify({ query, variables: { identifier } }),
+  });
+  if (!response.ok) throw new Error(`Linear ${identifier} lookup HTTP ${response.status}`);
+  const result = await response.json() as { errors?: unknown[]; data?: { issue?: Record<string, unknown> | null } };
+  const node = result.data?.issue;
+  if (result.errors?.length) throw new Error(`Linear ${identifier} lookup failed`);
+  if (!node || typeof node.id !== 'string' || typeof node.identifier !== 'string' || typeof node.title !== 'string' || typeof node.url !== 'string') return null;
+  const state = node.state && typeof node.state === 'object' ? (node.state as { name?: unknown }).name : undefined;
+  return { id: node.id, identifier: node.identifier, title: node.title, url: node.url,
+    description: typeof node.description === 'string' ? node.description : '', state: typeof state === 'string' ? state : 'unknown' };
+}
+
+async function countMarker(apiKey: string, issueId: string, marker: string): Promise<number> {
+  const query = `query LinearProgressComments($id: String!, $after: String) {
+    issue(id: $id) { comments(first: 100, after: $after) { nodes { body } pageInfo { hasNextPage endCursor } } }
+  }`;
+  const cursors = new Set<string>();
+  let after: string | null = null;
+  let count = 0;
+  do {
+    const response = await fetch('https://api.linear.app/graphql', {
+      method: 'POST', headers: { Authorization: apiKey, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ query, variables: { id: issueId, after } }),
+    });
+    if (!response.ok) throw new Error(`Linear comment lookup HTTP ${response.status}`);
+    const result = await response.json() as { errors?: unknown[]; data?: { issue?: { comments?: { nodes?: Array<{ body?: unknown }>; pageInfo?: { hasNextPage: boolean; endCursor: string | null } } } } };
+    const comments = result.data?.issue?.comments;
+    if (result.errors?.length || !Array.isArray(comments?.nodes)) throw new Error('Linear comment lookup failed');
+    count += comments.nodes.filter(comment => typeof comment.body === 'string' && comment.body.includes(marker)).length;
+    const info = comments.pageInfo;
+    if (info?.hasNextPage && (!info.endCursor || cursors.has(info.endCursor))) throw new Error('Linear comment cursor missing or repeated');
+    after = info?.hasNextPage ? info.endCursor : null;
+    if (after) cursors.add(after);
+  } while (after);
+  return count;
+}
+
+export async function runLinearProgressSync(options: {
+  version: string; now?: Date; root?: string; apply?: boolean;
+  allowIssueIdentifiers?: readonly string[];
+  checklist?: Checklist; issues?: readonly ProgressIssue[]; decisions?: readonly DecisionEntry[];
+  getApiKey?: (id: string) => Promise<string | undefined>;
+  countMarker?: (issue: ProgressIssue, marker: string) => Promise<number>;
+  postComment?: (issue: ProgressIssue, body: string) => Promise<void>;
+  log?: (event: string, data: Record<string, unknown>) => void;
+}): Promise<ProgressSyncResult> {
+  const now = options.now ?? new Date();
+  const day = kstDay(now);
+  const root = options.root ?? effectiveInstanceRoot();
+  const checklist = options.checklist ?? listChecklist(options.version, root);
+  const decisions = options.decisions ?? new DecisionLedger({ stateDir: root }).list({ status: 'all' });
+  const apiKey = (options.getApiKey ?? getSecretAsync)('connector.linear.apiKey');
+  const resolvedKey = await apiKey;
+  if (!resolvedKey) throw new Error('connector.linear.apiKey missing');
+  const allowedIdentifiers = [...new Set(options.allowIssueIdentifiers ?? [])];
+  const lookupFailures: Array<{ identifier: string; reason: string }> = [];
+  let issues: ProgressIssue[];
+  if (options.issues) issues = [...options.issues];
+  else if (options.apply) {
+    const lookups = await Promise.all(allowedIdentifiers.map(async identifier => {
+      try {
+        const issue = await fetchAllowlistedIssue(resolvedKey, identifier);
+        if (!issue) lookupFailures.push({ identifier, reason: 'allowlisted issue not found' });
+        return issue;
+      } catch (error) {
+        lookupFailures.push({ identifier, reason: (error instanceof Error ? error.message : String(error)).slice(0, 200) });
+        return null;
+      }
+    }));
+    issues = lookups.filter((issue): issue is ProgressIssue => issue !== null);
+  } else issues = (await Promise.all(['ELA', 'DEMO'].map(key => fetchTeamIssues(resolvedKey, key)))).flat();
+  const links = resolveExplicitProgressLinks(issues, checklist, decisions);
+  const previews = links.map(link => renderProgressPreview(link, checklist, day));
+  const linkedIdentifiers = new Set(links.map(link => link.issue.identifier));
+  const fetchedIdentifiers = new Set(issues.map(issue => issue.identifier));
+  const lookupFailureIdentifiers = new Set(lookupFailures.map(failure => failure.identifier));
+  const missingApproved = options.apply ? allowedIdentifiers.filter(identifier => !fetchedIdentifiers.has(identifier) && !lookupFailureIdentifiers.has(identifier))
+    .map(identifier => ({ identifier, reason: 'allowlisted issue not found' })) : [];
+  const unlinkedApproved = options.apply ? allowedIdentifiers.filter(identifier => issues.some(issue => issue.identifier === identifier) && !linkedIdentifiers.has(identifier))
+    .map(identifier => ({ identifier, reason: 'allowlisted issue has no explicit checklist/decision link' })) : [];
+  const unresolvedApproved = [...lookupFailures, ...missingApproved, ...unlinkedApproved];
+  const result: ProgressSyncResult = { day, candidates: previews, posted: [], alreadyPresent: [], skipped: [], failures: unresolvedApproved };
+  const log = (event: string, data: Record<string, unknown>) => {
+    const enriched = { day, ...data };
+    if (options.log) options.log(event, enriched);
+    else debug.log('loop.rhythm-daily.linear-progress', event, enriched);
+  };
+  const check = options.countMarker ?? ((issue: ProgressIssue, marker: string) => countMarker(resolvedKey, issue.id, marker));
+  const post = options.postComment ?? ((issue: ProgressIssue, body: string) => commentLinearIssue({ apiKey: resolvedKey, issueId: issue.id, body }));
+  for (const failure of unresolvedApproved) log('approved-issue-unresolved', failure);
+  for (const preview of previews) {
+    const issue = links.find(link => link.issue.identifier === preview.identifier)!.issue;
+    const marker = `<!-- elanous-linear-progress:${day}:${issue.identifier} -->`;
+    let release: (() => void) | undefined;
+    let stillHeld: (() => boolean) | undefined;
+    try {
+      if (options.apply && !options.allowIssueIdentifiers?.includes(issue.identifier)) {
+        result.skipped.push(issue.identifier);
+        log('not-approved', { identifier: issue.identifier, sources: preview.sources });
+        continue;
+      }
+      if (options.apply) {
+        const lockDir = join(root, 'rhythm', 'linear-progress-sync');
+        mkdirSync(lockDir, { recursive: true, mode: 0o700 });
+        const lockName = createHash('sha256').update(`${day}:${issue.id}`).digest('hex');
+        const lock = await acquireLockAsync(join(lockDir, `${lockName}.lock`), { staleMs: 120_000, maxTries: 240 });
+        release = lock.release;
+        stillHeld = lock.stillHeld;
+        if (!stillHeld()) throw new Error('Linear progress lock lost before marker check');
+      }
+      const existing = await check(issue, marker);
+      if (existing > 1) {
+        result.failures.push({ identifier: issue.identifier, reason: `duplicate-marker-count=${existing}` });
+        log('duplicate-marker', { identifier: issue.identifier, markerCount: existing, sources: preview.sources });
+        continue;
+      }
+      if (existing === 1) {
+        result.alreadyPresent.push(issue.identifier);
+        log('already-present', { identifier: issue.identifier, markerCount: 1, sources: preview.sources });
+        continue;
+      }
+      if (!options.apply) {
+        result.skipped.push(issue.identifier);
+        log('dry-run', { identifier: issue.identifier, markerCount: 0, sources: preview.sources });
+        continue;
+      }
+      if (!release || !stillHeld?.()) throw new Error('Linear progress write lock unavailable or lost');
+      await post(issue, preview.body);
+      const verified = await check(issue, marker);
+      if (verified !== 1) throw new Error(`post-verification-marker-count=${verified}`);
+      result.posted.push(issue.identifier);
+      log('posted', { identifier: issue.identifier, markerCount: verified, sources: preview.sources });
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      result.failures.push({ identifier: issue.identifier, reason: reason.slice(0, 200) });
+      log('failed', { identifier: issue.identifier, reason: reason.slice(0, 200), sources: preview.sources });
+    } finally {
+      release?.();
+    }
+  }
+  return result;
+}
+
+if (import.meta.main) {
+  const version = process.argv.find((arg, index) => process.argv[index - 1] === '--version');
+  if (!version) throw new Error('--version required');
+  if (process.argv.includes('--apply')) throw new Error('live posting requires the approved scheduled daily path');
+  const result = await runLinearProgressSync({ version, apply: false });
+  console.log(JSON.stringify(result));
+}

package/scripts/ux-sim.ts

@@ -20,10 +20,11 @@
 //   bun scripts/ux-sim.ts --fault sqlite-busy # 결함 주입: 실제 SQLite 잠금 → 로그 배치 버퍼·복구
 //   bun scripts/ux-sim.ts emit child-error-long --json # 사건 주입(L0): 격리 우주 원장에 주입 줄 → 소비자 목록
 //
-// ⛔ 이 CLI 는 «실제 위젯 render()» 를 부른다 — 흉내 렌더러가 아니다.
+// catalog list/show 는 재사용 장치의 참조를 보여 준다. 선언된 TUI 장면은 실제 위젯 render() 를 부른다 — 흉내 렌더러가 아니다.
 import { simRenderLogFrame } from '../src/ux-sim/render-frame.js';
 import { simTypeaheadState, type TurnPhase, type TurnSimSpec } from '../src/ux-sim/turn-states.js';
 import { renderTurnTypeaheadQueueRow, renderTurnTypeaheadEcho } from '../src/chat/turn-typeahead.js';
+import { loadMockScenarioCatalog, renderMockScenarioDetails, renderMockScenarioList } from '../src/ux-sim/mock-scenario-catalog.js';
 
 const PHASES: TurnPhase[] = [
   'idle', 'thinking', 'streaming', 'streaming-with-subagents', 'harness-child', 'interrupted',
@@ -31,6 +32,22 @@ const PHASES: TurnPhase[] = [
 
 const argv = process.argv.slice(2);
 
+if (argv[0] === 'list') {
+  if (argv.length !== 1) { console.error('usage: bun scripts/ux-sim.ts list'); process.exit(2); }
+  console.log(renderMockScenarioList(loadMockScenarioCatalog()).join('\n'));
+  process.exit(0);
+}
+if (argv[0] === 'show') {
+  if (argv.length !== 2) { console.error('usage: bun scripts/ux-sim.ts show <MS-id>'); process.exit(2); }
+  try {
+    console.log(renderMockScenarioDetails(loadMockScenarioCatalog(), argv[1]!).join('\n'));
+    process.exit(0);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(2);
+  }
+}
+
 // ── 사건 주입 «이벤트 몽키» (SIM-EVENT-MONKEY · L0) — 자기 플래그를 가진 하위 명령 ──
 //   bun scripts/ux-sim.ts emit <kind> [--run <id>] [--variant allowed|refused] [--state-dir <dir>] [--json]
 //   bun scripts/ux-sim.ts emit --list