elanous 0.2.42 → 0.2.44

package/scripts/release-loop/render-warm-control-manifest.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { DEFAULT_CONTROL_PORT } from '../../src/control-plane/server.js';
+
+const args = process.argv.slice(2);
+const imageIndex = args.indexOf('--image');
+const namespaceIndex = args.indexOf('--namespace');
+const image = imageIndex >= 0 ? args[imageIndex + 1] : undefined;
+const namespace = namespaceIndex >= 0 ? args[namespaceIndex + 1] : undefined;
+if (args.length !== 4 || imageIndex < 0 || namespaceIndex < 0 || imageIndex === namespaceIndex
+  || !image || !namespace || !/^[a-z0-9](?:[-a-z0-9]{0,61}[a-z0-9])?$/.test(namespace)
+  || !/^[a-z0-9][a-z0-9.-]*(?::[0-9]+)?\/[a-zA-Z0-9._/-]+@sha256:[a-f0-9]{64}$/.test(image)) {
+  process.stderr.write('usage: bun scripts/release-loop/render-warm-control-manifest.ts --image <repository@sha256:digest> --namespace <namespace>\n');
+  process.exitCode = 2;
+} else {
+  const template = readFileSync(join(import.meta.dir, '../../docker/warm-control/control.yaml.tmpl'), 'utf8');
+  if (!template.includes('{{CONTROL_IMAGE}}') || !template.includes('{{NAMESPACE}}') || !template.includes('{{CONTROL_PORT}}'))
+    throw new Error('warm control manifest placeholder missing');
+  process.stdout.write(template.replaceAll('{{CONTROL_IMAGE}}', image)
+    .replaceAll('{{NAMESPACE}}', namespace).replaceAll('{{CONTROL_PORT}}', String(DEFAULT_CONTROL_PORT)));
+}

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

@@ -17,7 +17,7 @@ import { changedFilesBetween, clearPartialPlan, collectExecutedPodShardImages, p
 import { gateAssignableTestsAtCommit, gateEnvFingerprint } from './gate-baseline-receipt.js';
 import { readGateShardManifest, readGateShardResult } from './gate-shard-receipts.js';
 import { gitClosureTree, testsReachingChanged, TRACEABLE_RELEASE_JSON, type ClosureTree } from './gate-closure.js';
-import { assertReleaseResumeApprovalBoundary, releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseResumeGatePodPool, releaseResumeGateShardReroute, releaseResumeWaiver, type AcceptedRegression } from './resume.js';
+import { assertReleaseResumeApprovalBoundary, releaseFanOutForkIndex, releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseResumeGatePodPool, releaseResumeGateShardReroute, releaseResumeWaiver, type AcceptedRegression } from './resume.js';
 import { reserveReleaseResumeAttempt } from './resume-cap.js';
 import { cutReleaseBranch } from './cut-branch.js';
 import { releaseLoopConfig } from './unattended-release.js';
@@ -138,8 +138,9 @@ function refreshReleaseBranchTipInternal(runId: string, deps: ResumeReleaseDeps,
   const state = JSON.parse(readFileSync(statePath, 'utf8')) as GraphRunState;
   if (state.graphId !== 'release-loop' || state.runId !== runId) throw new Error(`run identity mismatch: ${statePath}`);
   if (state.status !== 'failed') throw new Error(`release run ${runId} is ${state.status} — only a failed run is resumed`);
-  const restartAt = from === undefined ? -1 : state.path.indexOf(from);
-  if (from !== undefined && (restartAt < 0 || state.path.lastIndexOf(from) !== restartAt)) throw new Error(`--from ${from} is not a node on the saved path of ${runId}`);
+  const branchFork = from === undefined || state.path.includes(from) ? undefined : releaseFanOutForkIndex(state, from);
+  const restartAt = from === undefined ? -1 : state.path.indexOf(from) >= 0 ? state.path.indexOf(from) : branchFork ?? -1;
+  if (from !== undefined && (restartAt < 0 || (branchFork === undefined && state.path.lastIndexOf(from) !== restartAt))) throw new Error(`--from ${from} is not a node on the saved path of ${runId}`);
   const index = state.nodes.findIndex((node) => node.nodeId === 'version-release');
   const record = index >= 0 ? state.nodes[index]! : undefined;
   const output = record ? lastJsonObject(record.output) : undefined;
@@ -490,7 +491,7 @@ function preparePartial(tip: TipRefresh, opts: { from: string; partial?: boolean
       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 } : {}) };
+      return { requested: true, applied: true, files: recheckPlan.files.length, plannedFiles: recheckPlan.files, 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;
@@ -664,7 +665,7 @@ 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 fromIndex = savedRun.path.indexOf(opts.from) >= 0 ? savedRun.path.indexOf(opts.from) : releaseFanOutForkIndex(savedRun, opts.from) ?? -1;
   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');
@@ -929,8 +930,9 @@ async function recoverReleaseRunLocked(opts: RecoverReleaseOptions, deps: Recove
   if (fromNode === 'version-release') {
     throw new Error(`--from version-release would cut again — recover at a later node; ${branch} was not moved`);
   }
-  const restartAt = savedRun.path.indexOf(fromNode);
-  if (restartAt < 0 || savedRun.path.lastIndexOf(fromNode) !== restartAt) {
+  const branchFork = savedRun.path.includes(fromNode) ? undefined : releaseFanOutForkIndex(savedRun, fromNode);
+  const restartAt = savedRun.path.indexOf(fromNode) >= 0 ? savedRun.path.indexOf(fromNode) : branchFork ?? -1;
+  if (restartAt < 0 || (branchFork === undefined && savedRun.path.lastIndexOf(fromNode) !== restartAt)) {
     throw new Error(`--from ${fromNode} is not a node on the saved path of ${opts.runId}; ${branch} was not moved`);
   }
   const consumers = ['export-check', 'gate'].map((node) => savedRun.path.indexOf(node)).filter((index) => index >= 0);

package/scripts/release-loop/resume.ts

@@ -5,13 +5,22 @@ import { checkGateExecutorChoice, type GateExecutor } from './gate-executor.js';
 
 export interface AcceptedRegression { id: string; note: string }
 
+/** Return the saved fork-node index when --from names a failed fan-out branch rather than a parent-path node. */
+export function releaseFanOutForkIndex(state: GraphRunState, branchId: string): number | undefined {
+  const matches = Object.values(state.fanOuts ?? {}).filter((fanout) => fanout.branches[branchId]?.status === 'failed');
+  if (matches.length !== 1) return undefined;
+  const fork = matches[0]!.from;
+  const index = state.path.indexOf(fork);
+  return index >= 0 && state.path.lastIndexOf(fork) === index ? index : undefined;
+}
+
 /** Match the graph runner's approval boundary before release resume performs tip refresh or writes an attempt. */
 export function assertReleaseResumeApprovalBoundary(state: GraphRunState, from: string): void {
   if (!Array.isArray(state.path)) return;
-  const start = state.path.indexOf(from);
-  if (start < 0 || state.path.lastIndexOf(from) !== start) {
-    return;
-  }
+  const pathStart = state.path.indexOf(from);
+  const branchStart = pathStart < 0 ? releaseFanOutForkIndex(state, from) : undefined;
+  const start = pathStart >= 0 ? pathStart : branchStart;
+  if (start === undefined || start < 0 || (pathStart >= 0 && state.path.lastIndexOf(from) !== start)) return;
   for (let index = 0; index < state.nodes.length; index++) {
     const record = state.nodes[index]!;
     if (typeof record.decidedAt !== 'string') continue;

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/release-loop/warm-control-forward.ts

@@ -0,0 +1,178 @@
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+import { debug } from '../../src/debug/log.js';
+
+export interface WarmControlForwardOptions {
+  context: string;
+  namespace: string;
+  service: string;
+  remotePort: number;
+  kubectl?: string;
+  startupTimeoutMs?: number;
+}
+
+export interface WarmControlForward {
+  url: string;
+  stop(): Promise<void>;
+}
+
+/** A single-flight startup cache owned by one gate-run lifecycle. A rejected start
+ * is shared by that run's shards, while a later run gets a fresh instance and retries. */
+export function createRunScopedWarmControlForward(start: () => Promise<WarmControlForward>): {
+  ensure(): Promise<WarmControlForward>;
+  stop(): Promise<void>;
+} {
+  let starting: Promise<WarmControlForward> | null = null;
+  return {
+    ensure() {
+      starting ??= start();
+      return starting;
+    },
+    async stop() {
+      const pending = starting;
+      starting = null;
+      const forward = pending ? await pending.catch(() => null) : null;
+      if (forward) await forward.stop();
+    },
+  };
+}
+
+type ForwardExit = { code: number | null; signal: NodeJS.Signals | null };
+
+function exitWithin(exited: Promise<ForwardExit>, timeoutMs: number): Promise<ForwardExit | null> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  return Promise.race([exited, new Promise<null>(resolve => { timer = setTimeout(() => resolve(null), timeoutMs); })])
+    .finally(() => { if (timer) clearTimeout(timer); });
+}
+
+function ephemeralLoopbackPort(): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      if (!address || typeof address === 'string') {
+        server.close();
+        reject(new Error('warm control forward could not reserve a loopback port'));
+        return;
+      }
+      server.close(error => error ? reject(error) : resolve(address.port));
+    });
+  });
+}
+
+function cleanKubectlEnv(): NodeJS.ProcessEnv {
+  // Port-forward carries control credentials and task payloads; never route the tunnel through ambient proxies.
+  const env = { ...process.env };
+  for (const key of ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy', 'ALL_PROXY', 'all_proxy']) delete env[key];
+  return env;
+}
+
+/** Start a run-owned, loopback-only tunnel. No remote interface is ever bound. */
+async function startWarmControlPortForwardAt(options: WarmControlForwardOptions, localPort: number): Promise<WarmControlForward> {
+  const child = spawn(options.kubectl ?? 'kubectl', [
+    '--context', options.context, '-n', options.namespace, 'port-forward',
+    '--address', '127.0.0.1', `service/${options.service}`, `${localPort}:${options.remotePort}`,
+  ], { detached: true, stdio: ['ignore', 'pipe', 'pipe'], env: cleanKubectlEnv() });
+  let stdout = '';
+  let stderr = '';
+  let stopRequested = false;
+  let failStartup: ((error: Error) => void) | undefined;
+  const startedAt = Date.now();
+  const stopGroup = (signal: NodeJS.Signals) => {
+    if (child.pid) {
+      try { process.kill(-child.pid, signal); } catch { child.kill(signal); }
+    } else child.kill(signal);
+  };
+  const exited = new Promise<ForwardExit>(resolve => {
+    child.once('close', (code, signal) => resolve({ code, signal }));
+    child.once('error', () => resolve({ code: null, signal: null }));
+  });
+  child.stderr?.on('data', chunk => {
+    stderr = `${stderr}${String(chunk)}`.slice(-8192);
+    if (/address already in use/i.test(stderr)) failStartup?.(new Error('warm control local port was claimed before kubectl bound it'));
+  });
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      let settled = false;
+      const timer = setTimeout(() => finish(new Error('warm control port-forward startup timed out')), options.startupTimeoutMs ?? 15_000);
+      const ready = (chunk: Buffer | string) => {
+        if (new RegExp(`Forwarding from 127\\.0\\.0\\.1:${localPort} -> ${options.remotePort}`).test(stdout)) finish();
+      };
+      const capture = (chunk: Buffer | string) => { stdout = `${stdout}${String(chunk)}`.slice(-8192); };
+      const finish = (error?: Error) => {
+        if (settled) return;
+        settled = true;
+        failStartup = undefined;
+        clearTimeout(timer);
+        child.stdout?.off('data', ready);
+        if (error) reject(error); else resolve();
+      };
+      failStartup = finish;
+      child.stdout?.on('data', capture);
+      child.stdout?.on('data', ready);
+      void exited.then(({ code, signal }) => finish(new Error(`warm control port-forward exited before ready (code=${code}, signal=${signal})`)));
+      child.once('error', error => finish(error));
+    });
+  } catch (error) {
+    stopRequested = true;
+    if (child.exitCode === null && child.signalCode === null) stopGroup('SIGTERM');
+    let final = await exitWithin(exited, 2_000);
+    if (final === null) {
+      stopGroup('SIGKILL');
+      final = await exitWithin(exited, 2_000);
+    }
+    debug.log('pod.warm.control-forward', 'start-failed', { context: options.context, namespace: options.namespace,
+      service: options.service, localPort, elapsedMs: Date.now() - startedAt,
+      reason: error instanceof Error ? error.message : String(error), stderr: stderr.slice(-1000), orphaned: final === null },
+    { level: final === null ? 'error' : 'warn' });
+    if (final === null) debug.log('pod.warm.control-forward', 'orphan-detected', { context: options.context,
+      namespace: options.namespace, service: options.service, localHost: '127.0.0.1', localPort }, { level: 'error' });
+    throw error;
+  }
+  void exited.then(result => {
+    if (!stopRequested) debug.log('pod.warm.control-forward', 'exited-unexpectedly', {
+      context: options.context, namespace: options.namespace, service: options.service,
+      localHost: '127.0.0.1', localPort, exitCode: result.code, exitSignal: result.signal,
+    }, { level: 'error' });
+  });
+  debug.log('pod.warm.control-forward', 'started', { context: options.context, namespace: options.namespace,
+    service: options.service, localHost: '127.0.0.1', localPort, remotePort: options.remotePort });
+
+  return {
+    url: `http://127.0.0.1:${localPort}/`,
+    async stop() {
+      if (stopRequested) return;
+      stopRequested = true;
+      if (child.exitCode === null && child.signalCode === null) stopGroup('SIGTERM');
+      const result = await exitWithin(exited, 2_000);
+      if (result === null) stopGroup('SIGKILL');
+      const final = result ?? await exitWithin(exited, 2_000);
+      const orphaned = final === null;
+      debug.log('pod.warm.control-forward', orphaned ? 'orphan-detected' : 'stopped', {
+        context: options.context, namespace: options.namespace, service: options.service,
+        localHost: '127.0.0.1', localPort, remotePort: options.remotePort,
+        elapsedMs: Date.now() - startedAt, exitCode: final?.code ?? null, exitSignal: final?.signal ?? null,
+      }, { level: orphaned ? 'error' : 'info' });
+      if (orphaned) throw new Error('warm control port-forward process survived gate cleanup');
+    },
+  };
+}
+
+export async function startWarmControlPortForward(options: WarmControlForwardOptions): Promise<WarmControlForward> {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(options.context)
+    || !/^[a-z0-9](?:[-a-z0-9]{0,61}[a-z0-9])?$/.test(options.namespace)
+    || !/^[a-z0-9](?:[-a-z0-9]{0,61}[a-z0-9])?$/.test(options.service)
+    || !Number.isSafeInteger(options.remotePort) || options.remotePort < 1 || options.remotePort > 65535)
+    throw new Error('invalid warm control forward target');
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const localPort = await ephemeralLoopbackPort();
+    try { return await startWarmControlPortForwardAt(options, localPort); }
+    catch (error) {
+      if (attempt === 0 && error instanceof Error && /local port was claimed/i.test(error.message)) continue;
+      throw error;
+    }
+  }
+  throw new Error('warm control port-forward could not claim a loopback port');
+}

package/scripts/retro-cycle.ts

@@ -21,6 +21,11 @@ import { aggregateMissionRetros } from '../src/autopilot/mission-retrospect.js';
 import { recordAutonomousActionSafe } from '../src/domains/autonomy-log.js';
 import { sendOutbound } from '../src/domains/outbound-alert.js';
 import { unknownCronFlag } from '../src/domains/cron-flag-contract.js';
+import { debug } from '../src/debug/log.js';
+import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js';
+import { finishRetroCycleRun } from '../src/domains/retro-cycle-observation.js';
+import { readRunExits } from '../src/harness/harness-incidents.js';
+import { doctorVisitIncidentRoot, readDoctorVisits } from '../src/self-implement/doctor-visit.js';
 
 // ⛔⭐ 거부는 «맨 앞»이다 — 이 파일은 모듈 최상위에서 argv 를 읽으므로 그 뒤면 늦다.
 //   ⛔ 그리고 «한 줄»로 낸다 — 최상위 throw 는 스택 트레이스를 흘리고, 크론 로그에서 그것은 잡음이다.
@@ -32,6 +37,10 @@ const pIdx = process.argv.indexOf('--period');
 const period = (pIdx >= 0 ? process.argv[pIdx + 1] : 'weekly') as RetroPeriod;
 if (!['weekly', 'monthly', 'quarterly', 'annual'].includes(period)) { console.error(`잘못된 period: ${period}`); process.exit(1); }
 
+// This scheduled script runs outside the daemon; attach its debug events to
+// this instance's logs.db so the lifecycle observations remain queryable.
+await registerStandaloneLogSink('retro');
+
 const REPORT_DIR = join(homedir(), '.elanous/conatus/reflections');
 const LOG = join(homedir(), '.elanous/conatus/retro_cycle.log');
 const log = (m: string): void => { try { appendFileSync(LOG, `${new Date().toISOString()} ${m}\n`); } catch { /* */ } };
@@ -114,6 +123,14 @@ const report = await runRetroCycle({
   // C3 (2026-07-18) — 미션 회고(C1 안착·C2 피드백) 집계를 주간 리포트에 합류(비파괴 opt-in).
   retro: { backtest: backtestAgg, regime: regimeAgg, surface: surfaceAgg, missions: (from, to) => aggregateMissionRetros(from, to) },
   candidates,
+  featureSignals: () => {
+    const incidents = readRunExits(doctorVisitIncidentRoot())
+      .map((row) => ({ runId: row.runId, symptom: row.reason, at: row.at, source: 'incident' as const }));
+    const visits = readDoctorVisits()
+      .filter((row) => !!row.timestamp)
+      .map((row) => ({ runId: row.runId, symptom: row.symptom, at: row.timestamp!, source: 'doctor-visit' as const }));
+    return [...incidents, ...visits];
+  },
   // LLM 정성 서사(fail-soft) — provider 없으면 정량 base 그대로.
   narrate: narrateRetro,
   writeReport: (filename, md) => {
@@ -127,15 +144,20 @@ const report = await runRetroCycle({
   notify: (t) => { log(`[HITL] ${t.replace(/\n/g, ' ')}`); if (!process.argv.includes('--collect-only')) try { sendOutbound(t, 'ops-alert'); } catch { /* fail-soft */ } },
 }, period);
 
-log(`retro ${period}: report=${report.reportPath} · 제안=${report.hasProposal ? report.proposalId : '없음'}`);
+log(`retro ${period}: report=${report.reportPath} · 리밸런싱=${report.hasProposal ? report.proposalId : '없음'} · 반복 증상 제안=${report.featureProposals.length}`);
 
 // Autopilot P0.2 — 자율행동(회고 루프) 회상 로깅. 리밸런싱 제안은 HITL 승인 대기(자율집행 아님).
-recordAutonomousActionSafe({
-  loop: 'retro',
-  action: `${period} 회고 리포트 발행`,
-  rationale: '기간 성과 집계(백테스트·국면·발송) → 리밸런싱 제안(HITL 승인 대기)',
-  outcome: report.hasProposal ? `리밸런싱 제안 ${report.proposalId}(승인 대기)` : '제안 없음',
-  refs: { reportPath: report.reportPath },
+const runId = finishRetroCycleRun(report, {
+  recordAction: ({ runId: actionRunId, reportPath }) => {
+    recordAutonomousActionSafe({
+      loop: 'retro',
+      action: `${period} 회고 리포트 발행`,
+      rationale: '기간 성과 집계(백테스트·국면·발송) → 리밸런싱 제안(HITL 승인 대기)',
+      outcome: report.hasProposal ? `리밸런싱 제안 ${report.proposalId}(승인 대기)` : '제안 없음',
+      refs: { runId: actionRunId, reportPath },
+    });
+  },
+  log: (category, event, data) => debug.log(category, event, data),
 });
 
-console.log(JSON.stringify(report, null, 2));
+console.log(JSON.stringify({ ...report, runId }, null, 2));

package/scripts/rhythm/daily.ts

@@ -1,11 +1,12 @@
 #!/usr/bin/env bun
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 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 +22,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 };
@@ -536,12 +538,14 @@ function sendNewsAfterReview(delivery: DeliveryResult, file: string, markdown: s
 }
 
 export type DailyDeps = { now?: () => Date; root?: string; vaultRoot?: string | null; sendEnabled?: boolean; repoRoot?: string; repoName?: string;
+  runId?: string;
   landings?: (now: Date) => Promise<Landing[]>; release?: () => Promise<Release>; loops?: () => Promise<Loop[]>;
   grid?: () => Promise<Seat[]>; decisions?: () => Promise<Pending[]>; news?: () => Promise<News[]>;
   cooAdmin?: (now: Date) => Promise<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>;
@@ -567,6 +571,7 @@ function copyToVault(markdown: string, now: Date, deps: DailyDeps): { vaultError
 
 export async function runDaily(options: { dryRun?: boolean; noNews?: boolean; stage?: 'collect' | 'compose' | 'deliver' } = {}, deps: DailyDeps = {}) {
   const now = (deps.now ?? (() => new Date()))();
+  const runId = deps.runId ?? randomUUID();
   const receiptKey = `RHYTHM-DAILY:${kstDay(now)}`;
   if (options.stage === 'compose' || options.stage === 'deliver') {
     const file = join(deps.root ?? effectiveInstanceRoot(), 'rhythm', 'daily', `${kstDay(now)}.md`);
@@ -593,6 +598,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 +620,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, runId,
+              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 +660,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>> => {