elanous 0.2.32 → 0.2.34

package/scripts/release-loop/gate-partial.ts

@@ -9,7 +9,7 @@ import { existsSync, linkSync, mkdirSync, readFileSync, rmSync, writeFileSync }
 import { randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { dirname, join } from 'node:path';
-import { CODE_FILE, type ClosureVerdict } from './gate-closure';
+import { CODE_FILE, TRACEABLE_RELEASE_JSON, type ClosureVerdict } from './gate-closure';
 
 export interface PartialPlan {
   /** A verified docs-only append carries the completed, clean cut without starting a test Pod. */
@@ -137,13 +137,13 @@ export function planPartialRegate(input: { version: string; priorCommit: string;
   const source = input.changedFiles.filter((file) => !TEST_FILE.test(file) && !isInert(file));
   const list = (files: string[]) => `${files.slice(0, 5).join(', ')}${files.length > 5 ? ` (+${files.length - 5})` : ''}`;
   // Only code is followed through the closure: a changed fixture, JSON, lockfile, config or script is a full gate.
-  const notCode = source.filter((file) => !CODE_FILE.test(file));
+  const notCode = source.filter((file) => !CODE_FILE.test(file) && file !== TRACEABLE_RELEASE_JSON);
   if (source.length && (!input.closure || notCode.length)) return { ok: false, reason: `non-test change → full gate: ${list(notCode.length ? notCode : source)}` };
   let reaching: string[] = [];
   let closure: { reached: number; opaque: number } | undefined;
   if (source.length) {
     let verdict: ClosureVerdict;
-    try { verdict = input.closure!(input.changedFiles.filter((file) => CODE_FILE.test(file))); }
+    try { verdict = input.closure!(input.changedFiles.filter((file) => CODE_FILE.test(file) || file === TRACEABLE_RELEASE_JSON)); }
     catch (error) { return { ok: false, reason: `import closure unreadable → full gate: ${String(error instanceof Error ? error.message : error).slice(0, 200)}` }; }
     if (!verdict.ok) return { ok: false, reason: verdict.reason };
     const unsafe = verdict.tests.filter((file) => !TEST_FILE.test(file) || file.split('/').includes('..'));

package/scripts/release-loop/gate-radius-shadow.ts

@@ -0,0 +1,138 @@
+/** Observation only: compare a proposed import radius with the full gate that actually ran. */
+import { randomUUID } from 'node:crypto';
+import { existsSync, linkSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { changedFilesBetween, planPartialRegate, testFileOfId } from './gate-partial';
+import { gitClosureTree, testsReachingChanged } from './gate-closure';
+import { SPAWN_SYNC_MAX_BUFFER } from '../../src/util/spawn-sync-output.js';
+
+const SHA = /^[0-9a-f]{40}$/i;
+const VERSION = /^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/;
+const TEST = /\.test\.(?:tsx?|jsx?|mts|cts)$/;
+const BUMP_FILES = new Set(['package.json', 'server.json', 'integrations/acp-registry/elanous/agent.json', 'bun.lock']);
+
+export interface GateRadiusShadowPlan {
+  schema: 1;
+  version: string;
+  priorCommit: string | null;
+  forCommit: string;
+  proposed: 'partial' | 'full';
+  files: string[];
+  totalTests: number | null;
+  reason: string;
+}
+
+export interface GateRadiusShadowRecord {
+  plan: GateRadiusShadowPlan;
+  actual: { commit: string; outcome: 'ok' | 'regression' | 'error'; cutRc: number | null; introduced: string[];
+    cutFailures: string[]; cutErrors: string[]; missedIntroduced: string[]; fullSweep: boolean;
+    comparison: 'complete' | 'unmeasured' };
+  recordedAt: string;
+}
+
+function blob(repo: string, commit: string, file: string): unknown {
+  const run = spawnSync('git', ['show', `${commit}:${file}`], { cwd: repo, encoding: 'utf8', maxBuffer: SPAWN_SYNC_MAX_BUFFER });
+  if (run.status !== 0 || run.error) throw new Error(`unreadable release blob ${file}`);
+  return JSON.parse(run.stdout);
+}
+
+/** Remove only the fields version-node itself changes; any other JSON difference leaves a full shadow plan. */
+function versionOnlyBumps(repo: string, from: string, to: string, version: string, changed: readonly string[]): string[] {
+  if (!changed.includes('package.json')) return [];
+  const prior = blob(repo, from, 'package.json') as Record<string, unknown>;
+  const next = blob(repo, to, 'package.json') as Record<string, unknown>;
+  if (typeof prior.version !== 'string' || prior.version === version || next.version !== version) return [];
+  const inert: string[] = [];
+  for (const file of changed.filter((name) => BUMP_FILES.has(name))) {
+    const left = blob(repo, from, file) as Record<string, any>;
+    const right = blob(repo, to, file) as Record<string, any>;
+    const normalize = (row: Record<string, any>, expected: string): boolean => {
+      if (file === 'package.json') { if (row.version !== expected) return false; row.version = '<version>'; }
+      else if (file === 'server.json') {
+        if (row.version !== expected || row.packages?.[0]?.version !== expected) return false;
+        row.version = '<version>'; row.packages[0].version = '<version>';
+      } else if (file.endsWith('/agent.json')) {
+        if (row.version !== expected || row.distribution?.npx?.package !== `elanous@${expected}`) return false;
+        row.version = '<version>'; row.distribution.npx.package = 'elanous@<version>';
+      } else {
+        if (row.workspaces?.['']?.version !== expected) return false;
+        row.workspaces[''].version = '<version>';
+      }
+      return true;
+    };
+    if (normalize(left, prior.version) && normalize(right, version) && JSON.stringify(left) === JSON.stringify(right)) inert.push(file);
+  }
+  return inert;
+}
+
+export function planGateRadiusShadow(input: { repo: string; ledgerRoot: string; version: string;
+  baselineVersion: string; forCommit: string; instanceRoot?: string; expectedBaselineCommit?: string }): GateRadiusShadowPlan {
+  const { repo, ledgerRoot, version, baselineVersion, forCommit } = input;
+  const full = (reason: string, priorCommit: string | null = null, totalTests: number | null = null): GateRadiusShadowPlan =>
+    ({ schema: 1, version, priorCommit, forCommit, proposed: 'full', files: [], totalTests, reason });
+  if (!VERSION.test(version) || !VERSION.test(baselineVersion) || !SHA.test(forCommit)) return full('invalid identity');
+  try {
+    const priorDir = join(ledgerRoot, 'release', baselineVersion);
+    const verdict = JSON.parse(readFileSync(join(priorDir, 'gate-verdict.json'), 'utf8')) as { commit?: string; outcome?: string };
+    const failures = JSON.parse(readFileSync(join(priorDir, 'gate-failures.json'), 'utf8')) as
+      { commit?: string; failures?: string[]; errors?: string[] };
+    const priorCommit = verdict.commit;
+    const manifestPaths = [...new Set([ledgerRoot, input.instanceRoot].filter((root): root is string => !!root))]
+      .map((root) => join(root, 'release', baselineVersion, 'release.json')).filter(existsSync);
+    if (!manifestPaths.length) return full('prior release manifest absent', priorCommit ?? null);
+    const manifestCommits = manifestPaths.map((path) =>
+      (JSON.parse(readFileSync(path, 'utf8')) as { sourceCommit?: unknown }).sourceCommit);
+    if (manifestCommits.some((commit) => typeof commit !== 'string' || !SHA.test(commit) || commit !== priorCommit)
+      || (input.expectedBaselineCommit && input.expectedBaselineCommit !== priorCommit))
+      return full('prior gate commit differs from release source', priorCommit ?? null);
+    if (!priorCommit || !SHA.test(priorCommit) || failures.commit !== priorCommit || verdict.outcome !== 'ok'
+      || !Array.isArray(failures.failures) || !Array.isArray(failures.errors ?? []))
+      return full('prior gate evidence absent or not clean', priorCommit ?? null);
+    const tree = gitClosureTree(repo, forCommit);
+    const tests = tree.files.filter((file) => TEST.test(file));
+    const changed = changedFilesBetween(repo, priorCommit, forCommit);
+    const bump = versionOnlyBumps(repo, priorCommit, forCommit, version, changed);
+    const effective = changed.filter((file) => !bump.includes(file));
+    if (!effective.length && bump.length) {
+      const rerun = [...new Set([...failures.failures, ...(failures.errors ?? [])].map(testFileOfId))].sort();
+      if (rerun.some((file) => !tests.includes(file))) return full('prior failure file absent at cut', priorCommit, tests.length);
+      return { schema: 1, version, priorCommit, forCommit, proposed: 'partial', files: rerun,
+        totalTests: tests.length, reason: 'version-only candidate' };
+    }
+    const result = planPartialRegate({ version, priorCommit, forCommit, changedFiles: effective,
+      priorFailures: failures.failures, priorErrors: failures.errors ?? [],
+      existsAtTip: (file) => tree.files.includes(file),
+      closure: (code) => testsReachingChanged(tree, code, tests) });
+    if (!result.ok) return full(result.reason, priorCommit, tests.length);
+    // Shadow only: this proposal is never passed to writePartialPlan/readPartialPlan or the sweep selector.
+    return { schema: 1, version, priorCommit, forCommit, proposed: 'partial', files: result.plan.files,
+      totalTests: tests.length, reason: result.plan.kind === 'carry' ? 'zero-file candidate' : 'import radius candidate' };
+  } catch (error) { return full(`shadow evidence unreadable: ${String(error)}`); }
+}
+
+/** Append beside the gate verdict; a shadow write never changes a release decision. */
+export function writeGateRadiusShadow(root: string, record: GateRadiusShadowRecord): string {
+  const { plan, actual } = record;
+  if (!VERSION.test(plan.version) || !SHA.test(plan.forCommit) || actual.commit !== plan.forCommit
+    || !['ok', 'regression', 'error'].includes(actual.outcome)) throw new Error('invalid gate radius shadow');
+  const path = join(root, 'release', plan.version, `gate-radius-shadow-${plan.forCommit}-${randomUUID()}.json`);
+  mkdirSync(dirname(path), { recursive: true });
+  const temp = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+    linkSync(temp, path);
+  } finally { rmSync(temp, { force: true }); }
+  return path;
+}
+
+export function shadowActual(input: { plan: GateRadiusShadowPlan; outcome: 'ok' | 'regression' | 'error';
+  introduced: readonly string[]; cutFailures: readonly string[]; cutErrors: readonly string[]; cutRc: number | null;
+  fullSweep: boolean }): GateRadiusShadowRecord['actual'] {
+  const selected = new Set(input.plan.files);
+  const missedIntroduced = input.plan.proposed === 'partial' && input.fullSweep
+    ? input.introduced.filter((id) => { try { return !selected.has(testFileOfId(id)); } catch { return true; } }) : [];
+  return { commit: input.plan.forCommit, outcome: input.outcome, cutRc: input.cutRc, introduced: [...input.introduced],
+    cutFailures: [...input.cutFailures], cutErrors: [...input.cutErrors], missedIntroduced, fullSweep: input.fullSweep,
+    comparison: input.fullSweep ? 'complete' : 'unmeasured' };
+}

package/scripts/release-loop/gate-traffic-mode.ts

@@ -0,0 +1,128 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { debug } from '../../src/debug/log.js';
+
+type TrafficBoard = Record<string, unknown> & { global: string };
+type PatchResult = { changed: true; previous: string; warning?: string } | { changed: false; current: string };
+
+const defaultTrafficPath = () => join(homedir(), 'elanous-hq', 'seat-state', 'OP', 'traffic.json');
+const trafficPath = (env: NodeJS.ProcessEnv) => env.ELANOUS_TRAFFIC_SIGNAL || defaultTrafficPath();
+
+function releaseGateContext(env: NodeJS.ProcessEnv): boolean {
+  const source = env.ELANOUS_GRAPH_CONTEXT;
+  if (!source) return false;
+  try {
+    const raw = JSON.parse(source.trimStart().startsWith('{') ? source : readFileSync(source, 'utf8')) as Record<string, unknown>;
+    return raw.graphId === 'release-loop' && raw.nodeId === 'gate';
+  } catch {
+    return false;
+  }
+}
+
+function withTrafficLock<T>(path: string, action: () => T): T {
+  const lock = `${path}.lock.d`;
+  const deadline = Date.now() + 10_000;
+  for (let attempt = 1; attempt <= 100; attempt++) {
+    try { mkdirSync(lock); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+      try {
+        const stat = statSync(lock).mtimeMs;
+        const owner = Number(readFileSync(join(lock, 'pid'), 'utf8').trim());
+        if (Date.now() - stat > 60_000 && Number.isInteger(owner) && owner > 0) {
+          try { process.kill(owner, 0); }
+          catch (probeError) {
+            if ((probeError as NodeJS.ErrnoException).code === 'ESRCH'
+              && Number(readFileSync(join(lock, 'pid'), 'utf8').trim()) === owner) {
+              try { renameSync(lock, `${lock}.stale.${process.pid}.${attempt}`); } catch { /* owner may have released it */ }
+            }
+          }
+        }
+      } catch { /* unknown owner and unreadable locks are never reaped */ }
+      if (attempt === 100 || Date.now() >= deadline) throw new Error(`traffic lock timeout: ${lock}`);
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+      continue;
+    }
+    try {
+      writeFileSync(join(lock, 'pid'), `${process.pid}\n`);
+      return action();
+    } finally {
+      rmSync(join(lock, 'pid'), { force: true });
+      try { rmdirSync(lock); } catch { /* another writer replaced the lock directory */ }
+    }
+  }
+  throw new Error(`traffic lock timeout: ${lock}`);
+}
+
+function patchGlobal(path: string, next: string, reason: string, onlyIf?: string): PatchResult {
+  return withTrafficLock(path, () => {
+    if (!existsSync(path)) throw new Error(`traffic board missing: ${path}`);
+    const board = JSON.parse(readFileSync(path, 'utf8')) as TrafficBoard;
+    if (!board || typeof board !== 'object' || Array.isArray(board) || typeof board.global !== 'string') {
+      throw new Error(`invalid traffic board: ${path}`);
+    }
+    if (onlyIf !== undefined && board.global !== onlyIf) return { changed: false, current: board.global };
+    const updated: TrafficBoard = { ...board, global: next, reason, updatedAt: new Date().toISOString() };
+    const at = new Date();
+    const stamp = [at.getMonth() + 1, at.getDate(), at.getHours(), at.getMinutes(), at.getSeconds()].map(value => String(value).padStart(2, '0')).join('');
+    const suffix = `bak-${stamp}-${randomUUID().slice(0, 8)}-global-${next}`;
+    const backup = `${path}.${suffix}`;
+    const temp = `${path}.tmp.${process.pid}.${randomUUID()}`;
+    const payload = `${JSON.stringify(updated)}\n`;
+    writeFileSync(backup, readFileSync(path));
+    writeFileSync(temp, payload, { mode: statSync(path).mode & 0o777 });
+    try { renameSync(temp, path); }
+    finally { rmSync(temp, { force: true }); }
+    try {
+      const verify = JSON.parse(readFileSync(path, 'utf8')) as TrafficBoard;
+      if (verify.global !== next) return { changed: true, previous: board.global, warning: `traffic verification mismatch: ${path}` };
+    } catch (error) {
+      // rename already committed the requested mode; keep the lease so the caller still attempts cleanup.
+      return { changed: true, previous: board.global, warning: `traffic verification failed: ${String(error)}` };
+    }
+    return { changed: true, previous: board.global };
+  });
+}
+
+/** Hold dispatcher traffic at gate only for the release-loop's gate node, then restore conditionally. */
+export async function runWithReleaseGateTraffic<T>(env: NodeJS.ProcessEnv, run: () => Promise<T>): Promise<T> {
+  if (!releaseGateContext(env)) return run();
+  const path = trafficPath(env);
+  let started: PatchResult;
+  try { started = patchGlobal(path, 'gate', 'release gate running', 'green'); }
+  catch (error) {
+    debug.log('release-loop.gate', 'traffic gate set failed', { path, error: String(error) }, { level: 'warn' });
+    return run(); // The traffic board is advisory; it must not block publication.
+  }
+  if (!started.changed) return run(); // Existing gate/yellow (or any operator change) belongs to its owner.
+  if (started.warning) debug.log('release-loop.gate', 'traffic gate verification failed', { path, error: started.warning }, { level: 'warn' });
+  let restoreResult: Promise<void> | undefined;
+  const restoreOnce = () => restoreResult ??= Promise.resolve().then(() => {
+    try {
+      const restored = patchGlobal(path, started.previous, 'release gate finished', 'gate');
+      if (!restored.changed) debug.log('release-loop.gate', 'traffic restore skipped', { path, current: restored.current }, { level: 'warn' });
+      else if (restored.warning) debug.log('release-loop.gate', 'traffic restore verification failed', { path, error: restored.warning }, { level: 'warn' });
+    } catch (error) {
+      debug.log('release-loop.gate', 'traffic restore failed', { path, error: String(error) }, { level: 'warn' });
+    }
+  });
+  const interrupt = (signal: NodeJS.Signals) => {
+    void restoreOnce().finally(() => {
+      process.removeListener(signal, signal === 'SIGINT' ? onSigint : onSigterm);
+      process.kill(process.pid, signal);
+    });
+  };
+  const onSigint = () => interrupt('SIGINT');
+  const onSigterm = () => interrupt('SIGTERM');
+  process.once('SIGINT', onSigint);
+  process.once('SIGTERM', onSigterm);
+  try {
+    return await run();
+  } finally {
+    process.removeListener('SIGINT', onSigint);
+    process.removeListener('SIGTERM', onSigterm);
+    await restoreOnce();
+  }
+}

package/scripts/release-loop/gate-triage-node.ts

@@ -120,7 +120,7 @@ export function gateTriageShadowFromContext(context: GraphContext, evidence?: Ga
         && item.files.every((file: unknown) => typeof file === 'string') && typeof item.reason === 'string')))
     || (value.loadFlaky !== undefined && (!Array.isArray(value.loadFlaky)
       || !value.loadFlaky.every((item) => typeof item === 'string')))
-    || !['ok', 'regression', 'error'].includes(String(value.outcome))) {
+    || !['ok', 'regression', 'fail', 'error'].includes(String(value.outcome))) {
     throw new Error('gate output is missing or malformed');
   }
   const input = context.input.gateTriageEvidence;
@@ -140,7 +140,10 @@ export function gateTriageShadowFromContext(context: GraphContext, evidence?: Ga
       && item.failureIds.every((id: unknown) => typeof id === 'string'))
       ? { priorDecisions: supplied.priorDecisions as GateTriageEvidence['priorDecisions'] } : {}),
   };
-  return classifyGateShadow(value as unknown as GateResult, observed);
+  // The graph adapter maps a measured gate regression to `fail` for edge routing.
+  // Restore the gate verdict before classifying the shadow; keep the context untouched.
+  const gate = value.outcome === 'fail' ? { ...value, outcome: 'regression' } : value;
+  return classifyGateShadow(gate as unknown as GateResult, observed);
 }
 
 export function logGateTriageShadow(result: GateTriageShadow, version: string): void {

package/scripts/release-loop/known-issues-0.2.33-approved.json

@@ -0,0 +1,194 @@
+[
+  {
+    "id": "scripts/botlab/bot-routine.test.ts > bot routine dry-run delivery fence > 단계 목록 뒤 관문을 평가·기록하지만 단계를 실행하거나 배달하지 않는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 사용자 영향은 bot routine dry-run 루틴 사용 금지. 격리 시험은 검증되지 않았으며 0.2.34에서 복원·재검증한다."
+  },
+  {
+    "id": "scripts/botlab/bot-routine.test.ts > bot routine mailbox > prints and records unread messages, marks them read, then does not repeat them",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 사용자 영향은 bot routine dry-run 루틴 사용 금지. 격리 시험은 검증되지 않았으며 0.2.34에서 복원·재검증한다."
+  },
+  {
+    "id": "scripts/botlab/bot-routine.test.ts > bot routine production delivery fence > 신원을 «모르면» 관문을 안 걸고 그 사실을 관측에 남긴다 — ⛔ 지어낸 신원으로 걸지 않는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 사용자 영향은 bot routine dry-run 루틴 사용 금지. 격리 시험은 검증되지 않았으며 0.2.34에서 복원·재검증한다."
+  },
+  {
+    "id": "scripts/graph-contract-flow.test.ts > graph-contract-flow > keeps every target runner declaration equal to its consumed no-producer implement-loop inputs",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > config set llm.provider — provider별 자격증명 동기화 > rotation은 env보다 우선해 저장하고 출력은 키 값을 노출하지 않는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > config set llm.provider — provider별 자격증명 동기화 > rotation이 없으면 provider 환경변수 키를 저장한다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > config set llm.provider — provider별 자격증명 동기화 > 같은 provider는 자격증명을 갱신하거나 설정 파일을 다시 쓰지 않는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > config set llm.provider — provider별 자격증명 동기화 > 자격증명 없음은 경고와 기존 키 유지를, keyless와 다른 경로는 무경고 키 유지를 보장한다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > provider codex status — 실물 산출 > 우주·임계·신호 나이를 «값으로» 낸다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > 배포 엔트리 bin/elanous.mjs > release checklist 중복 칸과 없는 칸은 두 줄의 사용자 오류만 stderr로 낸다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli/logs-model-input.test.ts > logs model-input baseline > registered logs model-input reports observations emitted to an isolated log store in JSON and text",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > conatusNativePortEnabled: flag=true → true",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_backtest(flag true): backtest TS 포트 렌더 · {script,output,note} shape",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_backtest(flag true·factor): factorResearch TS 포트 · script=factor_research.py",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_signals(flag true·factor): factorResearch TS 포트",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_signals(flag true·screen): reportMd TS 포트 · {kind,report,note}",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_signals(flag true·trend): computeTrend/render TS 포트(db 없음 → fallback 문자열)",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/intake-plane/check.test.ts > actual repository CLI surfaces include migrated commands without losing index surfaces",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/loops/orchestrator/overlap.test.ts > CLI --json keeps stdout parseable while retaining the summary on stderr; text mode ends in summary",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/loops/orchestrator/tick.test.ts > COORD-HA × ORCH-TA-HAND: a live hand uses the per-tick cap; L2 never hands",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/loops/orchestrator/tick.test.ts > ORCH-TA-HAND: an injected mode still honors the configured cell filter; shadow-before-placement then live launches; a seat-delegated cell stays on the seat path",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/nexus/api/graphs-api.test.ts > GET /v1/graphs reads real YAML, retains labelled research branches and denies anonymous or write requests",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/onboarding/web-first.test.ts > real CLI does not print a link when health responds with an error",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/onboarding/web-first.test.ts > real CLI honors explicit webFirst=false without probing health or issuing a link",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-authority.test.ts > 2026-09-26 설정 졸업 — 선언은 항상 실행 권위 > 대응 스펙이 없으면 던지지 않고 null로 남겨 빈 선언 손실과 구별한다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-authority.test.ts > 2026-09-26 설정 졸업 — 선언은 항상 실행 권위 > 원장 칸 — 기존 권위 칸, 템플릿 이슈 내용, 선택된 스펙의 버려진 선언 필드를 함께 싣는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-overlay-yaml.test.ts > RFC §5 3단계 — 오버레이 적용 (⛔ 얹은 «결과»를 다시 검사한다) > ⭐ 노드를 «추가»할 수 있다 — 다이나믹 대응의 핵심",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-overlay-yaml.test.ts > RFC §5 3단계 — 오버레이 적용 (⛔ 얹은 «결과»를 다시 검사한다) > 예산 조정이 «실제로» 먹는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-overlay-yaml.test.ts > RFC §5 4단계 — 선택 (⛔ 「안 얹혔다」의 이유가 «넷»이다) > ⭐ 선택 → 적용이 «이어진다» — 예산이 실제로 바뀐다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-templates.test.ts > RFC §5 3단계 — 템플릿 둘째(research-loop) > ⛔ 두 템플릿의 «차이»가 gate 하나임을 값으로 고정한다 — 그것이 승격이 바꾸는 전부다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-templates.test.ts > RFC §5 3단계 — 템플릿 둘째(research-loop) > ⭐ research-loop 은 gate 를 «안 갖고» merge 는 «갖는다» — 산출이 남아야 하기 때문이다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-templates.test.ts > RFC §5 3단계 — 템플릿 둘째(research-loop) > 기존 템플릿은 기존 네 종류 그대로이며 타입은 파서의 확장된 종류를 재내보낸다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-templates.test.ts > ⭐ 실행 경로가 «YAML 을 지나는가» (RFC §5 배선) > 선언의 출처와 경고 수가 YAML 적재 상태를 말한다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/skills/claude-package-commands.test.ts > buildSkillIndex — includeClaudePackageCommands wiring > 키를 켜면 command 항목이 들어가고 기존 스킬은 이름·설명이 그대로다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/steward/observation-graph.test.ts > spawned steward graph and node scripts store decision rows in isolated logs.db for CLI lookup",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/tool-runtime/elanous-skills-list-runtime.test.ts > dispatchElanousSkillsList · shared HOME discovery > earlier custom root wins a duplicate skill name over shared root",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/tool-runtime/elanous-skills-list-runtime.test.ts > dispatchElanousSkillsList · 다중 루트(user-config skills.dirs) > config.skills.dirs=[a,b] → 두 dir 의 skill 을 모두 열거",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/tool-runtime/elanous-skills-list-runtime.test.ts > dispatchElanousSkillsList · 다중 루트(user-config skills.dirs) > ★ partial-error 표면화 — 일부 root 부재면 error 로 노출(config 은폐 방지)",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/tool-runtime/elanous-skills-list-runtime.test.ts > dispatchElanousSkillsList · 다중 루트(user-config skills.dirs) > ★ 기본 root = user-config skill dir·격리 fixture 노출(CI 안전·비-.elanous·정밀 일치)",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/config-unification-audit.test.ts > Phase 6 · XDG_CONFIG_HOME deprecation warning > XDG_CONFIG_HOME set → one-time warning to stderr",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/document-loop-graph.test.ts > document-loop YAML graph > loads as the distinct document graph with document-specific nodes",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/graph-visit-budget.test.ts > research-loop 실행 경로가 예산 7 을 관측으로 넘긴다 > ⭐ 운영 런치 오버레이(research-wide-launch · investigate 예산 12)가 얹히면 같은 걸음이 예산 «안»이다 — 운영의 「0」은 이 오버레이 몫이다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/plan-mode/auto-worktree.test.ts > dispatchEnterPlanMode + plan.autoWorktree=true with a real git repo > creates a worktree, flips SWD, returns path + branch",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/plan-mode/auto-worktree.test.ts > dispatchEnterPlanMode + plan.autoWorktree=true, cwd not a git repo > soft-fails; plan mode still active; output carries the skip notice",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/test-home-state-write-audit.test.ts > test home/state write inventory contract > reviewed baseline home/state writers have complete inventory rows",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/voice-streaming-stt-singleton.test.ts > daemon streaming STT singleton > keeps an explicit config choice even when that id is unusable",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/voice-tts-providers.test.ts > TTS provider availability and unpaid default > keeps an explicit config choice even when that id is unusable",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/mss/logging/log-store-stale-opener.test.ts > log-store ⓑ 수호자: 설치 sha 보다 옛 판으로 logs.db 를 연 프로세스 > 시뮬레이트된 옛 판 오프너가 경보 관측에 잡힌다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 옛 판 오프너 경보가 지연되거나 누락될 수 있다. 0.2.34에서 독립 fixture와 Linux Pod 실물 검증 후 복원한다."
+  }
+]