elanous 0.2.37 → 0.2.40

package/graphs/release/release-loop.yaml

@@ -12,6 +12,7 @@ dry_run_await_approval: true
 terminal_nodes: [done, failed]
 nodes:
   - { node_id: version-release, kind: git, recipe: 'cmd:version-release', max_visits: 1 }
+  - { node_id: traffic-cut-start, kind: gate, recipe: 'cmd:traffic-cut-start', max_visits: 1 }
   - { node_id: cutoff, kind: judge, recipe: 'cmd:cutoff', max_visits: 1 }
   - { node_id: checklist-gate, kind: gate, recipe: 'cmd:checklist-gate', max_visits: 1 }
   # cmd:docs dispatches by graph node ID: bounded prefetch before gate, TUI join after upgrade, docs write after both.
@@ -39,6 +40,7 @@ nodes:
   - { node_id: approve-publish, kind: hitl, recipe: 'approval:publish', max_visits: 1 }
   - { node_id: publish, kind: git, recipe: 'cmd:publish-command', max_visits: 1, notify: { on: [ok, fail] } }
   - { node_id: npm-publish, kind: git, recipe: 'cmd:npm-publish', max_visits: 1 }
+  - { node_id: traffic-npm-published, kind: gate, recipe: 'cmd:traffic-npm-published', max_visits: 1 }
   - { node_id: docs-land, kind: git, recipe: 'cmd:docs-land', max_visits: 1 }
   - { node_id: verify, kind: gate, recipe: 'cmd:verify', max_visits: 1, notify: { on: [ok, fail] } }
   - { node_id: traffic-verify-complete, kind: gate, recipe: 'cmd:traffic-verify-complete', max_visits: 1 }
@@ -47,35 +49,40 @@ nodes:
   - { node_id: ops-upgrade, kind: agent, recipe: 'cmd:ops-upgrade', max_visits: 1 }
   - { node_id: version-dev-bump, kind: git, recipe: 'cmd:version-dev-bump', max_visits: 1 }
   - { node_id: version-dev-bump-after-failure, kind: git, recipe: 'cmd:version-dev-bump', max_visits: 1 }
+  - { node_id: traffic-failed-restore, kind: gate, recipe: 'cmd:traffic-failed-restore', max_visits: 1 }
   - { node_id: done, kind: gate, max_visits: 1 }
   - { node_id: failed, kind: gate, max_visits: 1 }
 edges:
-  - { from: version-release, on: outcome, map: { ok: cutoff, fail: failed, error: failed } }
-  - { from: cutoff, on: outcome, map: { ok: checklist-gate, fail: failed, error: failed } }
-  - { from: checklist-gate, on: outcome, map: { ok: export-check, fail: failed, error: failed } }
-  - { from: export-check, on: outcome, map: { ok: prefetch, fail: failed, error: failed } }
+  - { from: version-release, on: outcome, map: { ok: traffic-cut-start, fail: failed, error: failed } }
+  # Advisory traffic writes report failure to OP; release steps still proceed on fail/error.
+  - { from: traffic-cut-start, on: outcome, map: { ok: cutoff, fail: cutoff, error: cutoff } }
+  - { from: cutoff, on: outcome, map: { ok: checklist-gate, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: checklist-gate, on: outcome, map: { ok: export-check, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: export-check, on: outcome, map: { ok: prefetch, fail: traffic-failed-restore, error: traffic-failed-restore } }
   # Prefetch never gates: even a crashed prefetch node is a cache miss — the late nodes take their original paths.
   - { from: prefetch, on: outcome, map: { ok: gate, fail: gate, error: gate } }
   - { from: gate, on: outcome, map: { ok: traffic-gate-passed, fail: gate-triage, error: gate-triage } }
   # Warning-only: the transition result stays truthful; every outcome continues to the next release node.
   - { from: traffic-gate-passed, on: outcome, map: { ok: mac-smoke, fail: mac-smoke, error: mac-smoke } }
-  - { from: gate-triage, on: outcome, map: { ok: failed, fail: failed, error: failed } }
+  - { from: gate-triage, on: outcome, map: { ok: traffic-failed-restore, fail: traffic-failed-restore, error: traffic-failed-restore } }
   # Warning-only: a macOS failure or unmeasured run never blocks publishing — auto-approve shows it as a warning row.
   - { from: mac-smoke, on: outcome, map: { ok: pwa, fail: pwa, error: pwa } }
-  - { from: pwa, on: outcome, map: { ok: prepare, fail: failed, error: failed } }
-  - { from: prepare, on: outcome, map: { ok: upgrade, fail: failed, error: failed } }
-  - { from: upgrade, on: outcome, map: { ok: tui, fail: failed, error: failed } }
-  - { from: tui, on: outcome, map: { ok: docs, fail: failed, error: failed } }
-  - { from: docs, on: outcome, map: { ok: known-issues, fail: failed, error: failed } }
-  - { from: known-issues, on: outcome, map: { ok: notes-check, fail: failed, error: failed } }
+  - { from: pwa, on: outcome, map: { ok: prepare, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: prepare, on: outcome, map: { ok: upgrade, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: upgrade, on: outcome, map: { ok: tui, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: tui, on: outcome, map: { ok: docs, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: docs, on: outcome, map: { ok: known-issues, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: known-issues, on: outcome, map: { ok: notes-check, fail: traffic-failed-restore, error: traffic-failed-restore } }
   # RELEASE-GRAPH-SELFHEAL: fail/error re-enter notes-check through one repair; publish still requires a passing recheck.
   - { from: notes-check, on: outcome, map: { ok: auto-approve, fail: notes-repair, error: notes-repair } }
-  - { from: notes-repair, on: outcome, map: { ok: notes-recheck, fail: failed, error: failed } }
-  - { from: notes-recheck, on: outcome, map: { ok: auto-approve, fail: failed, error: failed } }
+  - { from: notes-repair, on: outcome, map: { ok: notes-recheck, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: notes-recheck, on: outcome, map: { ok: auto-approve, fail: traffic-failed-restore, error: traffic-failed-restore } }
   - { from: auto-approve, on: outcome, map: { ok: publish, fail: approve-publish, error: approve-publish } }
-  - { from: approve-publish, on: outcome, map: { ok: publish, fail: failed } }
-  - { from: publish, on: outcome, map: { ok: npm-publish, fail: failed, error: failed } }
-  - { from: npm-publish, on: outcome, map: { ok: docs-land, fail: failed, error: failed } }
+  - { from: approve-publish, on: outcome, map: { ok: publish, fail: traffic-failed-restore } }
+  - { from: publish, on: outcome, map: { ok: npm-publish, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: npm-publish, on: outcome, map: { ok: traffic-npm-published, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  # Publication already happened; a traffic write failure must not skip docs-land.
+  - { from: traffic-npm-published, on: outcome, map: { ok: docs-land, fail: docs-land, error: docs-land } }
   # RELEASE-DEVBUMP-ALWAYS: after a successful publish every fail/error routes through version-dev-bump —
   # a published release always hands main to its own next -dev, then still finishes failed.
   - { from: docs-land, on: outcome, map: { ok: verify, fail: version-dev-bump-after-failure, error: version-dev-bump-after-failure } }
@@ -85,5 +92,6 @@ edges:
   - { from: vault-note, on: outcome, map: { ok: release-story, fail: release-story, error: release-story } }
   - { from: release-story, on: outcome, map: { ok: ops-upgrade, fail: ops-upgrade, error: ops-upgrade } }
   - { from: ops-upgrade, on: outcome, map: { ok: version-dev-bump, fail: version-dev-bump, error: version-dev-bump } }
-  - { from: version-dev-bump, on: outcome, map: { ok: done, fail: failed, error: failed } }
-  - { from: version-dev-bump-after-failure, on: outcome, map: { ok: failed, fail: failed, error: failed } }
+  - { from: version-dev-bump, on: outcome, map: { ok: done, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: version-dev-bump-after-failure, on: outcome, map: { ok: traffic-failed-restore, fail: traffic-failed-restore, error: traffic-failed-restore } }
+  - { from: traffic-failed-restore, on: outcome, map: { ok: failed, fail: failed, error: failed } }

package/graphs/video/explainer-line.yaml

@@ -6,6 +6,8 @@ graph_id: explainer-line
 version: 1
 entry_node: script
 terminal_nodes: [delivered, needs-human, blocked, unobserved]
+# ⭐ 요청 동작 — 3분 영상: 이 라인이 만드는 영상 계획의 목표 총 길이는 180초다(지속 필드 target_seconds · 단위 초).
+target_seconds: 180
 nodes:
   - node_id: script
     kind: agent
@@ -55,4 +57,5 @@ edges:
   # check/snapshot failures are layout faults → rebuild; a wrong-length render is a timing fault → rebuild too.
   - { from: render, on: outcome, map: { ok: qc, check-fail: build, render-mismatch: build, unmeasurable: unobserved } }
   # speech ≠ script → re-voice that line; loudness off → rebuild (mix lives in the composition); public release is a human call.
-  - { from: qc, on: outcome, map: { pass: delivered, vo-mismatch: vo, loudness: build, public: needs-human, unmeasurable: unobserved } }
+  # narration past the target_seconds(180) plan is a timing fault → rebuild too.
+  - { from: qc, on: outcome, map: { pass: delivered, vo-mismatch: vo, loudness: build, too-long: build, public: needs-human, unmeasurable: unobserved } }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elanous",
   "mcpName": "io.github.ElanvitalAI/elanous",
-  "version": "0.2.37",
+  "version": "0.2.40",
   "description": "Self-healing coding harness where eyes, hands, and memory all turn on one sentence — it authors its own goals, implements them in isolated worktrees, and reviews its own work.",
   "license": "Apache-2.0",
   "author": "Elanvital AI",

package/scripts/ask-op-inbox-once.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+/** Drain the coordinator inbox once without running the orchestrator graph. */
+import { runCoordinatorInboxOnce, type InboxOnceOptions } from '../src/loops/orchestrator/inbox-once.js';
+
+export function runAskOpInboxCli(options: InboxOnceOptions = {}) {
+  return runCoordinatorInboxOnce(options);
+}
+
+if (import.meta.main) {
+  try {
+    const result = await runAskOpInboxCli();
+    console.log(JSON.stringify(result));
+  } catch (error) {
+    console.error(`coordinator inbox: ${error instanceof Error ? error.message : String(error)}`);
+    process.exitCode = 1;
+  }
+}

package/scripts/brand/check.ts

@@ -104,9 +104,8 @@ function isEnglishDocument(content: string, file: string, scope: Scope): boolean
   return /\b[A-Za-z]{2,}(?:\s+[A-Za-z]{2,}){2,}\b/.test(body);
 }
 
-function findInFile(file: string, rules: Rule[], scope: Scope): Finding[] {
+function findInContent(file: string, content: string, rules: Rule[], scope: Scope): Finding[] {
   const findings: Finding[] = [];
-  const content = readFileSync(file, 'utf8');
   const html = ['.html', '.htm'].includes(extname(file).toLowerCase());
   const englishDocument = isEnglishDocument(content, file, scope);
   const markdown = ['.md', '.mdx'].includes(extname(file).toLowerCase());
@@ -144,14 +143,24 @@ function findInFile(file: string, rules: Rule[], scope: Scope): Finding[] {
   return findings;
 }
 
+function applicableRules(scope: Scope, rulesPath: string): Rule[] {
+  return loadRules(rulesPath).filter((rule) => scope === 'any' || rule.scope.includes('any') || rule.scope.includes(scope));
+}
+
+/** Scan in-memory text (for example a PR body) with the same rules as file scans. */
+export function checkBrandText(text: string, label: string, scope: Scope = 'public-docs', rulesPath = defaultRules): Finding[] {
+  if (!existsSync(rulesPath)) throw new Error(BRAND_RULES_UNMEASURED);
+  return findInContent(label, text, applicableRules(scope, rulesPath), scope);
+}
+
 export function checkBrand(scope: Scope, paths: string[], rulesPath = defaultRules): { files: number; findings: Finding[]; rules: number; missing: boolean; message?: string } {
   if (!existsSync(rulesPath)) {
     debug.log('brand.check', 'run', { scope, files: 0, findings: 0, rules: 0, missing: true, message: BRAND_RULES_UNMEASURED });
     return { files: 0, findings: [], rules: 0, missing: true, message: BRAND_RULES_UNMEASURED };
   }
-  const applicable = loadRules(rulesPath).filter((rule) => scope === 'any' || rule.scope.includes('any') || rule.scope.includes(scope));
+  const applicable = applicableRules(scope, rulesPath);
   const files = filesAt(paths);
-  const findings = files.flatMap((file) => findInFile(file, applicable, scope));
+  const findings = files.flatMap((file) => findInContent(file, readFileSync(file, 'utf8'), applicable, scope));
   debug.log('brand.check', 'run', { scope, files: files.length, findings: findings.length, rules: applicable.length });
   return { files: files.length, findings, rules: applicable.length, missing: false };
 }

package/scripts/dead-code/report.ts

@@ -0,0 +1,169 @@
+#!/usr/bin/env bun
+/** Conservative multi-entrypoint reachability inventory. This command NEVER deletes files. */
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import ts from 'typescript';
+
+export interface RootGroup { name: string; roots: string[]; configuration?: string }
+export interface ModuleGap { importer: string; specifier: string; kind: 'unresolved' | 'dynamic' }
+export interface GroupResult { name: string; roots: string[]; reachable: string[]; gaps: ModuleGap[] }
+export interface ReachabilityReport {
+  schemaVersion: 1;
+  trackedFiles: number;
+  groups: GroupResult[];
+  unionReachable: string[];
+  unknownKeep: string[];
+  unresolved: ModuleGap[];
+  dynamic: ModuleGap[];
+  /** Never interpreted as safe-to-delete: configuration/runtime loaders cannot be exhaustively statically enumerated. */
+  unclassifiedKeep: string[];
+  overlaps: Record<string, string[]>;
+  deletions: 0;
+}
+
+const moduleFile = (p: string) => /\.[cm]?[jt]sx?$/.test(p);
+const testFile = (p: string) => /(?:^|\/)(?:__tests__|__fixtures__|test|tests|fixtures)\//.test(p) || /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(p);
+const normalized = (p: string) => p.replaceAll('\\', '/');
+const sorted = (items: Iterable<string>) => [...new Set(items)].sort();
+
+export function trackedModules(root: string): string[] {
+  return execFileSync('git', ['ls-files', '-z', '--cached'], { cwd: root, maxBuffer: 16 * 1024 * 1024 })
+    .toString().split('\0').filter(moduleFile).filter(Boolean).map(normalized).sort();
+}
+
+function loadOptions(config: string | undefined, root: string): ts.CompilerOptions {
+  if (!config || !existsSync(join(root, config))) return { moduleResolution: ts.ModuleResolutionKind.Bundler, module: ts.ModuleKind.ESNext, allowJs: true };
+  const filename = join(root, config);
+  const source = ts.readConfigFile(filename, ts.sys.readFile);
+  if (source.error) throw new Error(ts.flattenDiagnosticMessageText(source.error.messageText, '\n'));
+  const parsed = ts.parseJsonConfigFileContent(source.config, ts.sys, dirname(filename), undefined, filename);
+  if (parsed.errors.length) throw new Error(parsed.errors.map(e => ts.flattenDiagnosticMessageText(e.messageText, '\n')).join('\n'));
+  return parsed.options;
+}
+
+export function inventoryRoots(root: string, files: readonly string[]): RootGroup[] {
+  const groups: RootGroup[] = [
+    { name: 'cli', roots: ['bin/elanous.mjs', 'src/index.ts', 'src/light-cli.ts'], configuration: 'tsconfig.json' },
+    { name: 'scripts', roots: files.filter(p => p.startsWith('scripts/') && !testFile(p)), configuration: 'tsconfig.json' },
+    { name: 'pwa', roots: files.filter(p => /^apps\/pwa\/src\/(app\/(?:.*\/)?(?:page|layout|route|loading|error|not-found|template|default)|middleware|instrumentation)\.[jt]sx?$/.test(p)), configuration: 'apps/pwa/tsconfig.json' },
+    { name: 'desktop', roots: ['apps/desktop/src/main.ts'], configuration: 'apps/desktop/tsconfig.json' },
+  ];
+  for (const app of sorted(files.filter(p => /^apps\/[^/]+\/src\/(?:main|index)\.[jt]sx?$/.test(p)))) {
+    if (app.startsWith('apps/desktop/') || app.startsWith('apps/pwa/')) continue;
+    groups.push({ name: `app:${app.split('/')[1]}`, roots: [app], configuration: `apps/${app.split('/')[1]}/tsconfig.json` });
+  }
+  // Manifest-declared paths are roots even when no TS import refers to them.
+  const manifests = execFileSync('git', ['ls-files', '-z', '--', 'plugins/*/plugin.json', 'plugins/*/manifest.json'], { cwd: root }).toString().split('\0').filter(Boolean);
+  const plugins: string[] = [];
+  for (const path of manifests) {
+    const manifest = JSON.parse(readFileSync(join(root, path), 'utf8')) as { entry?: string; main?: string };
+    const declared = manifest.entry ?? manifest.main;
+    if (!declared) continue;
+    const entry = normalized(join(dirname(path), declared));
+    // Missing manifest entries remain roots and become explicit unresolved/unknown gaps.
+    plugins.push(entry);
+  }
+  groups.push({ name: 'plugins', roots: sorted(plugins), configuration: 'tsconfig.json' });
+  // Runtime loaders and independently launched ACP boot are not necessarily in the CLI's import graph.
+  groups.push({ name: 'runtime', roots: ['src/boot/acp-server.ts', 'src/plugin-declarative/discovery.ts', 'src/self-implement/graph-catalog.ts', 'src/graph-runner/runner.ts'], configuration: 'tsconfig.json' });
+  return groups;
+}
+
+export function analyzeReachability(root: string, files: readonly string[], groups: readonly RootGroup[]): ReachabilityReport {
+  const tracked = new Set(files.map(normalized));
+  const cache = new Map<string, ts.SourceFile>();
+  const results: GroupResult[] = [];
+  const unknown = new Set<string>();
+  for (const group of groups) {
+    const options = loadOptions(group.configuration, root);
+    const reachable = new Set<string>();
+    const gaps: ModuleGap[] = [];
+    const queue = [...group.roots];
+    const host = ts.createCompilerHost(options, true);
+    const moduleCache = ts.createModuleResolutionCache(root, s => s, options);
+    while (queue.length) {
+      const path = queue.pop()!;
+      if (reachable.has(path)) continue;
+      if (!tracked.has(path)) {
+        gaps.push({ importer: `(root:${group.name})`, specifier: path, kind: 'unresolved' });
+        unknown.add(path);
+        continue;
+      }
+      reachable.add(path);
+      const absolute = join(root, path);
+      let source = cache.get(path);
+      if (!source) {
+        source = ts.createSourceFile(absolute, readFileSync(absolute, 'utf8'), ts.ScriptTarget.Latest, true, path.endsWith('x') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+        cache.set(path, source);
+      }
+      const inspect = (specifier: ts.Expression) => {
+        if (!ts.isStringLiteralLike(specifier)) {
+          gaps.push({ importer: path, specifier: specifier.getText(source), kind: 'dynamic' }); unknown.add(path); return;
+        }
+        const text = specifier.text;
+        const resolved = ts.resolveModuleName(text, absolute, options, host, moduleCache).resolvedModule?.resolvedFileName;
+        const name = resolved ? normalized(relative(root, resolved)) : '';
+        if (name && tracked.has(name)) queue.push(name);
+        else if (text.startsWith('.') || text.startsWith('/') || text.startsWith('@/')) {
+          gaps.push({ importer: path, specifier: text, kind: 'unresolved' }); unknown.add(path);
+        }
+        // External packages are outside the tracked-source deletion domain.
+      };
+      const walk = (node: ts.Node) => {
+        if ((ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) && node.moduleSpecifier) inspect(node.moduleSpecifier);
+        else if (ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference) && node.moduleReference.expression) inspect(node.moduleReference.expression);
+        else if (ts.isCallExpression(node) && (node.expression.kind === ts.SyntaxKind.ImportKeyword || (ts.isIdentifier(node.expression) && node.expression.text === 'require'))) {
+          if (node.arguments[0]) inspect(node.arguments[0]);
+          else { gaps.push({ importer: path, specifier: '(missing argument)', kind: 'dynamic' }); unknown.add(path); }
+        }
+        ts.forEachChild(node, walk);
+      };
+      walk(source);
+    }
+    results.push({ name: group.name, roots: sorted(group.roots), reachable: sorted(reachable), gaps });
+  }
+  const uses = new Map<string, string[]>();
+  for (const group of results) for (const p of group.reachable) uses.set(p, [...(uses.get(p) ?? []), group.name]);
+  const gaps = results.flatMap(r => r.gaps);
+  const uniqueGaps = (kind: ModuleGap['kind']) => [...new Map(gaps.filter(g => g.kind === kind).map(g => [`${g.importer}\0${g.specifier}`, g])).values()]
+    .sort((a, b) => a.importer.localeCompare(b.importer) || a.specifier.localeCompare(b.specifier));
+  // The rest are *not* dead code: lazy/config/graph/plugin discovery and non-TS launchers are open-world inputs.
+  const unclassified = files.filter(p => !uses.has(p));
+  return {
+    schemaVersion: 1, trackedFiles: files.length, groups: results,
+    unionReachable: sorted(uses.keys()), unknownKeep: sorted([...unknown, ...unclassified]),
+    unresolved: uniqueGaps('unresolved'), dynamic: uniqueGaps('dynamic'),
+    unclassifiedKeep: sorted(unclassified),
+    overlaps: Object.fromEntries([...uses].filter(([, v]) => v.length > 1).sort(([a], [b]) => a.localeCompare(b))),
+    deletions: 0,
+  };
+}
+
+export function renderMarkdown(report: ReachabilityReport): string {
+  const lines = ['# Multi-entrypoint reachability inventory', '', 'This is an observation, not a safe-to-delete list. Deletions: 0.', '',
+    `Tracked source: ${report.trackedFiles}; union reachable: ${report.unionReachable.length}; unknown/keep: ${report.unknownKeep.length}; unresolved: ${report.unresolved.length}; dynamic: ${report.dynamic.length}.`, '',
+    '| Root family | roots | reachable | unknown edges |', '|---|---:|---:|---:|'];
+  for (const g of report.groups) lines.push(`| ${g.name} | ${g.roots.length} | ${g.reachable.length} | ${g.gaps.length} |`);
+  lines.push('', 'Unclassified source, dynamic imports, configuration/graph loaders and resolution gaps remain unknown/keep; no deletion candidate is asserted.', '');
+  return lines.join('\n');
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  const root = resolve(process.argv[2] ?? '.');
+  const files = trackedModules(root);
+  const report = analyzeReachability(root, files, inventoryRoots(root, files));
+  const json = JSON.stringify(report, null, 2);
+  if (process.argv.includes('--json')) process.stdout.write(json + '\n');
+  else if (process.argv.includes('--md')) process.stdout.write(renderMarkdown(report));
+  else if (process.argv.includes('--output')) {
+    const index = process.argv.indexOf('--output');
+    const target = process.argv[index + 1];
+    if (!target || target.startsWith('--')) throw new Error('--output requires a path');
+    const output = resolve(target);
+    writeFileSync(output + '.json', json + '\n');
+    writeFileSync(output + '.md', renderMarkdown(report));
+    console.log(`report: ${output}.json / ${output}.md`);
+  } else process.stdout.write(renderMarkdown(report));
+}

package/scripts/gate-0226-accepted-remaining-90.txt

@@ -0,0 +1,91 @@
+# Source: 44fe14face:docs/reports/gate-0226-failure-census.tsv (pre-change accepted census)
+apps/android/app/src/test/kotlin/com/elanvitalai/elanous/android/data/FeedbackEnvelopeVectors.test.ts > Android FeedbackEnvelope shared vectors > runs FeedbackEnvelopeVectorsTest and verifies every shared vector was accounted for
+apps/android/app/src/test/kotlin/com/elanvitalai/elanous/android/ui/chat/ChatHarnessBubble.test.ts > ChatScreen assistant bubble for harness-style turns > injects turn-end through NexusClient→ViewModel and observes the bubble badge
+apps/android/app/src/test/kotlin/com/elanvitalai/elanous/android/ui/chat/ChatLastItemScrollOffset.test.ts > chatLastItemScrollOffset aligns the list to the last item end > ChatScreenLayoutTest drives ChatScreenLayout and observes last-item end alignment
+scripts/hooks/claude-code-utterance.test.ts > UserPromptSubmit reaches the human Claude Code utterance query
+scripts/lib/nl-routing-measurement.test.ts > NL routing corpus runner safety gate > the runner entrypoint stops after final surface resolution with non-zero exit and safety guidance
+scripts/nl-routing-measurement.test.ts > NL routing corpus runner safety gate > the runner entrypoint stops after final surface resolution with non-zero exit and safety guidance
+scripts/release-loop/freeze-off-parity.test.ts > freeze switch off: gate, publish and unattended release are byte-identical to pre-freeze behavior
+scripts/test-deterministic.test.ts > terminateDirectChild > SIGKILLs the group when the direct child is already dead and a grandchild ignores SIGTERM
+scripts/test-diet/effectiveness.test.ts > TD3 effectiveness > measure --effectiveness counts unreachable imports and leaves unreadable results absent
+scripts/webclone/loop/mirror-age.test.ts > edition-check는 조용함을 재료 미러보다 앞에 두고, 미러는 기존 original-mirror 인자로 부른다
+scripts/webclone/loop/mirror-age.test.ts > mirror-age > 12시간 경계 양쪽과 여러 미러를 fetchedAt만으로 한 줄씩 판정한다
+scripts/webclone/loop/mirror-age.test.ts > mirror-age > 파일 mtime이 아니라 MIRROR.json fetchedAt으로 판정한다
+scripts/webclone/loop/ruler-version.test.ts > ruler-version rc 계약 > 12시간을 넘긴 기준선은 rc 1 이고 ***origin-drift 로 재라***를 같이 낸다
+scripts/webclone/loop/ruler-version.test.ts > ruler-version rc 계약 > 최근 기준선은 rc 0 이고 「묵었다」고 말하지 않는다
+scripts/webclone/measure-fidelity.test.ts > main RenderProbe wiring > 로컬 링크가 우세한 미러 진입 문서는 링크 수와 self-contained 상태를 보존한다
+scripts/webclone/measure-fidelity.test.ts > main RenderProbe wiring > 원격 링크가 60% 이상인 미러 진입 문서를 non-self-contained로 기록한다
+scripts/webclone/measure-fidelity.test.ts > main RenderProbe wiring > 통제한 로컬 원문과 성공 프로브가 최종 렌더 위치까지 JSON 산출로 연결된다
+scripts/webclone/measure-fidelity.test.ts > main mirror-entry locality wiring > 네트워크 지배 미러는 참조 수를 내고 픽셀 차이를 품질로 읽을 수 없다고 말한다
+scripts/webclone/measure-fidelity.test.ts > main mirror-entry locality wiring > 로컬 지배 미러는 참조 수를 내고 네트워크 지배 경고를 내지 않는다
+scripts/webclone/measure-fidelity.test.ts > main mirror-entry locality wiring > 미러 진입 문서가 없으면 참조 수와 지배 판정을 못 쟀다로 보존한다
+scripts/webclone/measure-fidelity.test.ts > main overlay observability wiring > 원본과 사본 처리 수를 더해 내고 잔여 덮개면 픽셀 차이를 미신뢰로 표시한다
+scripts/webclone/measure-fidelity.test.ts > main screenshot reliability wiring > 실제 정상·빈 PNG를 기본 통계 추출 경로로 읽어 RMSE를 보존하고 미러 공백 사유를 JSON에 낸다
+src/acp/grok-leader-manager.test.ts > GrokLeaderManager · ensureLeader idempotency contract > ensureLeader returns state object (does not throw)
+src/agent-mission/driver-workdir.test.ts > ignored files outside workdir are detected when created or modified
+src/agent-mission/driver-workdir.test.ts > workdir skips git, runs PTY in the folder by default, and accepts a new mp4
+src/autopilot/build/isolated-instance.test.ts > createIsolatedInstance — 주입 worktree > ★ defaultMergeMainIntoWorktree — fetch 실패 → error / up-to-date / merged (실 git)
+src/dashboard/first-screen-band-wiring.test.ts > showDashboard renders the startup band before and after the real first chat input
+src/directives/directive-index.test.ts > FTS5, incremental byte offsets, version search, redaction, track votes and labels; originals stay unchanged
+src/git-fs/spawn-discipline.test.ts > 실제 저장소 — 이 게이트가 지키는 것 > 실물 git 프론트도어는 --help를 git argv로 전달하고 상태 줄과 git 종료 코드를 보존한다
+src/git-fs/spawn-discipline.test.ts > 실제 저장소 — 이 게이트가 지키는 것 > 실물 진입점에서 scripts 유예와 요약을 산출한다
+src/graph-runner/graph-cli.test.ts > graph YAML triggers.schedule fires through the workflow scheduler into graph tick and persists a run
+src/graph-runner/graph-cli.test.ts > graph tick defaults to idle and --start passes JSON input, prints results, and does not restart a finished run
+src/graph-runner/graph-variant-cli.test.ts > a paused variant resumes from its saved graph after the original template changes
+src/graph-runner/graph-variant-cli.test.ts > a route plan without a budget also executes the changed route
+src/graph-runner/graph-variant-cli.test.ts > ambiguous outcome plan is rejected before ledger or node execution
+src/graph-runner/graph-variant-cli.test.ts > two plans on the same template execute distinct persisted variant graphs through fake nodes
+src/graph-runner/graph-variant-cli.test.ts > variant preserves unrelated node and edge metadata in its runnable snapshot
+src/harness/dogfood.test.ts > assertThrowawayTarget — C 안전 가드(auto-approve 우회 방지) > runHarnessDogfood 도 실경로 target 을 current CLI guidance와 함께 refuse
+src/harness/dogfood.test.ts > assertThrowawayTarget — C 안전 가드(auto-approve 우회 방지) > ★ 실경로(홈·repo·시스템) → refuse with current CLI guidance
+src/mss/logging/log-store.test.ts > LogStore writer contention > carries a failed open observation to the next writable connection
+src/plugins/adapters/claude-package.test.ts > readClaudePackageLedger > reads this machine live ledger without a pluginsRoot override
+src/self-implement/orchestrator-blocked-draft.test.ts > environment branch is committed and pushed to an existing origin without opening a PR
+src/self-implement/orchestrator-blocked-draft.test.ts > environment stop without origin commits changes on the local branch for checkout recovery
+src/self-implement/orchestrator-blocked-draft.test.ts > failed environment push is reported to the caller and never presented as preserved
+src/self-implement/orchestrator-blocked-draft.test.ts > missing worktree keeps provider attribution and reports failed preservation without a draft
+src/self-implement/orchestrator-blocked-draft.test.ts > no changes takes precedence over environment branch preservation
+src/self-implement/orchestrator-blocked-draft.test.ts > quota-exhausted blocked run preserves its branch without opening a draft; implementation deficit still opens one
+src/self-implement/orchestrator-blocked-draft.test.ts > worktree-only environment stop never pushes, even when an origin exists
+src/self-implement/run-chain-query.test.ts > queryRunChain > pages past a full matching dispatch result page to find an old matching session
+src/self-implement/seams-usage-role.test.ts > goal summary passes classify usage role alongside the unchanged resolved model
+src/session-runtime/coding-surface-shell.test.ts > coding surface — shell 실행 tool 노출 > runtime 없는 Agent 폴백은 부모 도구·dispatcher·중단 신호를 자식에 보존한다
+src/skills/tools/dev-harness.test.ts > dispatchRunDevHarness — P3 외부 repo 타깃 > target 실 git repo → repoRoot+elanousBinRoot 를 seam 으로
+src/task-agent/mission.test.ts > shadow --mission → 미션 카드 1 ⊕ 조각 카드 4 · 같은 상태 파일 · 선행 없는 조각만 launch 수 · 나머지 wait after
+src/task-orchestrator/surfaces/pod-pool-cli.test.ts > independent harness ask/say and self CLI dispatch run real kubectl apply only when lease permits
+src/video-pipeline/recipes/reframe.test.ts > reframe — Affinity 가 없어도 «끝까지» 간다 > ⛔ 러너가 «없어도» 멈추지 않는다 (앱이 없는 고객 기계의 모습)
+src/video-pipeline/recipes/vlog.test.ts > vlog 레시피 — 실제 ffmpeg > ⭐ build-layers — 덮는 층(스크림·자막)이 «투명»하다 (🩸 불투명 자막이 영상 전체를 덮었다)
+src/webclone/archive-run.test.ts > 브라우저 재현 가능한 미러 계약 > 실제 wget은 POSIX ERE를 컴파일해 www 형제 자산만 받고 외부 호스트는 받지 않는다
+test/acp-subagent-wire-meta.test.ts > AcpAgent.prompt · _meta forwarding > undefined meta → request omits _meta field
+test/ad-production.test.ts > renders planned captions after assembly while preserving the uncaptained master and named failures
+test/ad-qc-measure.test.ts > QC measurement adapter > uses distinct OCR artifacts for repeated and parallel video measurement plans
+test/dashboard-acp-boot.test.ts > bootDashboardAcpSession — boot observability > records the selected branch and every successful boot outcome
+test/dashboard-turn-typeahead-echo.test.ts > dashboard real user echo wiring > PTY screen preserves submitted Q2 → answer Q2 → submitted Q3 → answer Q3
+test/finance-tools.test.ts > finance tool surface > SQL-injection guard on attractiveness args
+test/finance-tools.test.ts > finance tool surface > finance_trend (A2.1/A4): rotation + country + guards + injection-safe
+test/harness-worktree-add.test.ts > harness worktree add > 판정 신호: goal context records a leading H1 goal title instead of structural H2 headings
+test/harness-worktree-add.test.ts > harness worktree add > 판정 신호: goal synthesis truncates generated output at 250 characters and falls back to title on empty or thrown model output
+test/intake-plane-check-repo-axis.test.ts > frequent matches do not overflow the search buffer and disclose sampling
+test/llm-openrouter-provider.test.ts > OpenRouter provider wire > ⛔ 교차 경로 — config 가 grok 이면 그 키·baseUrl 을 OpenRouter 로 «안» 보낸다
+test/nexus-api-terminals.test.ts > handleTerminalsList > merges web preview PTYs into local and federated lists with their first registration time
+test/oauth/codex-mirror-real-home-guard.test.ts > ① 가드 — 실홈이 대상이면 «던진다» (쓰기는 일어나지 않는다) > ⛔ «심볼릭 링크»로 우회해도 던진다 — 문자열 비교로는 통과했다(리뷰 must-fix)
+test/ocr-tesseract.test.ts > OcrRegistry · Tesseract picker behaviour > strengths:["context-aware"] still picks LLM Vision (Tesseract loses)
+test/persistent-grounding-runtime.test.ts > PersistentGrounding ToolRuntime > default registration alias dispatch runs the guarded search loop and records session observations
+test/persistent-grounding-runtime.test.ts > PersistentGrounding ToolRuntime > generates one session ID for ambient observations and grounding when no session ID is supplied
+test/plugin-hooks-shell.test.ts > shell-hook > array JSON → warn + {}
+test/plugin-hooks-shell.test.ts > shell-hook > env propagated to shell
+test/plugin-hooks-shell.test.ts > shell-hook > stdout JSON object → output
+test/plugin-manifest-hooks.test.ts > plugin-host hook registration > end-to-end dispatch through registered manifest hook
+test/plugin-missions-runtime.test.ts > PX-4 P3 — MissionRegistry > never policy: history grows + iteration advances each tick
+test/plugin-missions-runtime.test.ts > PX-4 P3 — MissionRegistry > score_improvement: only strictly-better score advances
+test/plugin-missions-runtime.test.ts > PX-4 P3 — runMissionEvaluator > parses JSON stdout into MissionResult
+test/preview-terminal.test.ts > PreviewTerminal > resize reaches the kernel PTY — the shell sees the new size (stty size)
+test/rules-contract.test.ts > 변경 ↔ 규칙 갱신 — sources 가 바뀌면 그 «규칙 파일»이 같은 diff 에 있다 > 이 검사가 무엇을 봤는지 «말한다»
+test/self-dev-manual-goal-evidence.test.ts > hand-authored --file goal evidence contract > passes the attached requirement to the self-implement boundary for --file input
+test/shell-audit-log.test.ts > shell-primitive audit-log: programmatic sink > run event includes truncated when output exceeds budget
+test/shell-primitive.test.ts > shell-primitive: runShell (no approval) > maxOutputChars truncates and sets truncated=true
+test/skill-tool-mermaid.test.ts > dispatchMermaidRender — happy path > renders a simple flowchart to Unicode boxes
+test/voice-tts-providers.test.ts > TTS provider availability and unpaid default > falls back to edge-tts, not openai-tts, when nobody chose and no credential resolves
+test/voice-tts-providers.test.ts > TTS provider availability and unpaid default > reports edge-tts and macos-say usable without credentials
+test/workflow-templates-packaged.test.ts > the npm package carries every workflow template the repository has
+test/plugin-missions-runtime.test.ts > [error]

package/scripts/gate-0226-failure-census.ts

@@ -5,6 +5,7 @@
  * 판정: `docs/reports/gate-0226-failure-census.tsv`가 accepted 실패 ID 96건을 중복 없이 보존하고,
  * 그중 `provider-intake` 6건(첫 감소 칸 GATE-0226-PROVIDER-INTAKE6)을 제외한 90건이 정확히 남으며,
  * `Error: no ACP` 로그 사건(34회)은 실패 ID로 더해지지 않았음. 보고서 md의 96행 색인과 선언 카운트도 실측과 일치.
+ * intake 제외 90개 ID는 변경 전 `44fe14face` TSV에서 고정한 accepted 목록과 집합 비교한다.
  *
  * 사용: bun run scripts/gate-0226-failure-census.ts [--tsv <path>] [--report <path>] [--accepted <path|none>] [--json] [--write-repair-card]
  *
@@ -17,6 +18,7 @@ import { join, resolve } from 'node:path';
 export const CENSUS_TSV = 'docs/reports/gate-0226-failure-census.tsv';
 export const CENSUS_REPORT = 'docs/reports/REPORT-gate-0226-failure-census.md';
 export const DEFAULT_ACCEPTED = 'elanous-hq/seat-state/OP/tools/accepted-0226.json';
+export const DEFAULT_REMAINING_BASELINE = 'scripts/gate-0226-accepted-remaining-90.txt';
 
 export const EXPECTED_HEADER = [
   'no',
@@ -108,6 +110,7 @@ export type CensusAudit = {
   remainingIds: string[];
   acpLogEvents: number;
   ledger: { path: string; status: 'compared' | 'skipped' | 'failed'; ids: number };
+  remainingBaseline: { path: string; status: 'compared' | 'failed'; ids: number };
 };
 
 /** RFC4180 형식의 탭 구분 표를 읽는다. 실패 ID 안의 따옴표·탭·개행을 보존한다. */
@@ -259,6 +262,9 @@ export type AuditInput = {
   reportText: string;
   /** accepted 원장 ID. null 이면 비교 불가(원장 부재)를 산출로 남긴다. */
   acceptedIds: string[] | null;
+  /** 변경 전 독립 기준으로 고정한 remaining accepted ID 집합. */
+  remainingBaselineIds: string[] | null;
+  remainingBaselinePath: string;
   ledgerPath: string;
   ledgerRequired: boolean;
 };
@@ -355,6 +361,10 @@ export function auditCensus(input: AuditInput): CensusAudit {
     problems.push(`no-test-deletion-proposed: 근거 없이 시험 삭제를 제안한 행 ${deletionProposals.length}건 (${deletionProposals.slice(0, 6).join(',')})`);
   }
 
+  if (!input.reportText.includes('## 90건 후속 조사와 남은 수리 칸')) {
+    problems.push('report-follow-up: 90건 후속 조사·상태·주인 근거 절이 없다');
+  }
+
   const index = parseReportIndex(input.reportText);
   if (index.length !== rows.length) {
     problems.push(`report-index-parity: 보고서 색인 ${index.length}행 / TSV ${rows.length}행`);
@@ -386,6 +396,27 @@ export function auditCensus(input: AuditInput): CensusAudit {
     problems.push(`report-counts: 보고서가 \`${NO_ACP_MARKER}\` ${ACP_LOG_EVENTS}회 · 겹침 0건 배제를 명시하지 않는다`);
   }
 
+  let remainingBaseline: CensusAudit['remainingBaseline'];
+  if (input.remainingBaselineIds === null) {
+    problems.push(`remaining-baseline: 고정 기준 파일이 없다 (${input.remainingBaselinePath})`);
+    remainingBaseline = { path: input.remainingBaselinePath, status: 'failed', ids: 0 };
+  } else {
+    const baselineIds = input.remainingBaselineIds;
+    const baseline = new Set(baselineIds);
+    const actual = new Set(remainingIds);
+    const missing = [...baseline].filter((id) => !actual.has(id));
+    const extra = [...actual].filter((id) => !baseline.has(id));
+    if (baseline.size !== REMAINING_IDS || baseline.size !== baselineIds.length) {
+      problems.push(`remaining-baseline: 고정 기준은 중복 없이 ${REMAINING_IDS} ID여야 한다 (행 ${baselineIds.length} / 고유 ${baseline.size})`);
+    }
+    if (missing.length > 0 || extra.length > 0 || baseline.size !== actual.size) {
+      problems.push(`remaining-baseline: 기준 ${baseline.size}건 / TSV ${actual.size}건 · 누락 ${missing.length}${missing.length ? ` (${missing.slice(0, 3).join(' | ')})` : ''} · 추가 ${extra.length}${extra.length ? ` (${extra.slice(0, 3).join(' | ')})` : ''}`);
+      remainingBaseline = { path: input.remainingBaselinePath, status: 'failed', ids: baseline.size };
+    } else {
+      remainingBaseline = { path: input.remainingBaselinePath, status: 'compared', ids: baseline.size };
+    }
+  }
+
   let ledger: CensusAudit['ledger'];
   if (input.acceptedIds === null) {
     if (input.ledgerRequired) {
@@ -414,6 +445,7 @@ export function auditCensus(input: AuditInput): CensusAudit {
     remainingIds,
     acpLogEvents: acpAttributed.length,
     ledger,
+    remainingBaseline,
   };
 }
 
@@ -425,6 +457,7 @@ export function renderText(audit: CensusAudit): string {
   lines.push(`repair-cards: ${Object.entries(audit.counts.repair).map(([key, value]) => `${key}=${value}`).join(' ')}`);
   lines.push(`no-acp: ${audit.acpLogEvents} (로그 ${ACP_LOG_EVENTS}회 사건은 실패 ID가 아니다)`);
   lines.push(`accepted-ledger: ${audit.ledger.status} ${audit.ledger.path}${audit.ledger.status === 'skipped' ? ' (원장 부재 — 원장 대조 미실시)' : ''}`);
+  lines.push(`remaining-baseline: ${audit.remainingBaseline.status} ${audit.remainingBaseline.path} (${audit.remainingBaseline.ids})`);
   for (const problem of audit.problems) lines.push(`FAIL ${problem}`);
   lines.push(audit.ok ? 'census: PASS' : `census: FAIL (${audit.problems.length})`);
   return lines.join('\n');
@@ -491,10 +524,16 @@ export function main(argv: string[] = process.argv.slice(2), cwd: string = proce
     process.stdout.write(`repair-card: ${rewritten}행 재계산 → ${options.tsv}\n`);
   }
   const acceptedIds = options.accepted ? readAcceptedIds(options.accepted) : null;
+  const remainingBaselinePath = resolve(cwd, DEFAULT_REMAINING_BASELINE);
+  const remainingBaselineIds = existsSync(remainingBaselinePath)
+    ? readFileSync(remainingBaselinePath, 'utf8').split(/\r?\n/).filter((line) => line.length > 0 && !line.startsWith('#'))
+    : null;
   const audit = auditCensus({
     tsvText: readFileSync(options.tsv, 'utf8'),
     reportText: readFileSync(options.report, 'utf8'),
     acceptedIds,
+    remainingBaselineIds,
+    remainingBaselinePath: DEFAULT_REMAINING_BASELINE,
     ledgerPath: options.accepted ?? 'none',
     ledgerRequired: options.acceptedExplicit && options.accepted !== null,
   });

package/scripts/intake-collect-telegram-saved-stage.ts

@@ -0,0 +1,48 @@
+// TG-SAVED-ZERO 무대 — save(me) 대화의 가짜 저장 메시지로 흡수 경로를 세 번 지난다.
+// ① 다른 주체가 이미 흡수한 판 · ② 사흘 0 관측 그대로(필터로 비어 커서만 전진) · ③ 판정선(저장 1건이 다음 흡수에 원장으로).
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { collectTelegramSaved, readSavedCursor, renderCollectTelegramSavedResult, savedMessageToRaws, type SavedMessage } from '../src/intake-plane/collect-telegram-saved.js';
+import { ingestIntakeItems, listIntakeItems, markIntakeItem, pickAbsorbQueue } from '../src/intake-plane/items.js';
+
+const root = mkdtempSync(join(tmpdir(), 'tg-saved-zero-'));
+const saved: SavedMessage[] = [
+  { id: 8959, date: '2026-10-22T00:05:00.000Z', text: 'https://example.com/first 메모', urls: [] },
+  { id: 8975, date: '2026-10-23T00:05:00.000Z', text: '', urls: [] },
+  { id: 9092, date: '2026-10-24T00:05:00.000Z', text: '   ', urls: [] },
+  { id: 9200, date: '2026-10-25T00:05:00.000Z', text: 'https://example.com/next 다음 것', urls: [] },
+];
+
+// 대표가 텔레그램에서 «저장한» 목록의 창 — 지금 창 안의 메시지만 fetch 가 돌려준다.
+let visibleUpTo = 8959;
+const fetchSaved = async (minId: number) => saved.filter((m) => m.id > minId && m.id <= visibleUpTo);
+const run = (max = 300) => collectTelegramSaved(root, fetchSaved, { max });
+
+// ① 다른 주체(queue)가 8959 를 먼저 가져가 흡수까지 끝낸 판 — collect 는 «이미 끝난 것» 만 본다.
+ingestIntakeItems(root, 'telegram-saved', savedMessageToRaws(saved[0]!));
+for (const item of pickAbsorbQueue(root, { max: 10, laneMax: 30 })) markIntakeItem(root, item.id, { status: 'absorbed' });
+const consumed = await run();
+console.log('=== ① 같은 항목을 다른 주체(queue)가 먼저 흡수한 판 — «원장 입력 있음 · 새 0»');
+console.log(renderCollectTelegramSavedResult(consumed));
+
+// ② 사흘 0 의 관측 그대로 — 커서는 8959→9092 로 전진했는데 원장 입력 0(빈 메시지가 필터에 걸림)
+visibleUpTo = 9092;
+const filtered = await run();
+console.log('=== ② 사흘 0 관측 그대로 — 커서만 8959 → 9092 로 전진 · 원장 입력 0');
+console.log(renderCollectTelegramSavedResult(filtered));
+console.log(`   (원장 줄 수 ${listIntakeItems(root).length} — 그대로)`);
+
+// ③ 판정 — 대표가 저장한 다음 메시지 1건(id 9200)이 다음 흡수에 원장으로 들어간다
+visibleUpTo = 9200;
+const next = await run();
+console.log('=== ③ 판정 — 대표가 저장한 메시지 1건(id 9200)이 다음 흡수에 원장으로 들어감');
+console.log(renderCollectTelegramSavedResult(next));
+
+const links = listIntakeItems(root).map((i) => i.url);
+console.log(`\n[ledger] 원장 링크 ${JSON.stringify(links)} · 커서 ${readSavedCursor(root)}`);
+const ok = filtered.raws === 0 && filtered.cursorAfter === 9092 && filtered.messages === 2
+  && (next.ingest?.added ?? 0) === 1 && links.filter((u) => u === 'https://example.com/next').length === 1
+  && consumed.ingest?.seen === 1;
+console.log(ok ? '[verdict] 판정선 통과 — 저장 메시지 1건이 다음 흡수에 원장으로 들어갔다' : '[verdict] 판정선 실패');
+process.exitCode = ok ? 0 : 1;

package/scripts/lib/morning-report-options.ts

@@ -12,10 +12,9 @@
 //     경로(model 미지정 ⇒ providerFor(cfg))를 그대로 보존한다. 값이 없거나 빈 값이면
 //     parseArgv 오류를 던져 기본 모델로 조용히 실행되지 않도록 한다.
 //
-// ⛔ 의도된 경계(비연결 선언): 이 유닛은 «정의 + 단위시험» 에서 멈춘다.
-//   scripts/morning-report.ts 탑레벨(CLI 진입) → composeMorningReport(..., { model }) 배선은
-//   의존 형제 샤드(task:d0183079b142)의 몫이다. 지금 이 유닛을 실행 경로에서 부르는 곳은
-//   scripts/lib/morning-report-options.test.ts(bun test, in-process) 다.
+// ✅ 배선 완료(SWAP-BENCH-CRON): scripts/morning-report.ts 탑레벨(CLI 진입)이 이 파서를
+//   호출해 --narrative-model 값을 composeMorningReport(..., { model }) 로 넘긴다.
+//   배선 계약 시험은 test/morning-report.test.ts(mock 무대)가 누른다.
 
 import { parseArgv, type ArgvContract } from './argv.js';