@quolu/lattice 0.1.0 → 0.12.2

package/src/cli-help.mjs

@@ -0,0 +1,163 @@
+const ROOT_HELP = `Usage: lattice <command> [options]
+
+Commands:
+  status --json                 Discover the current project and next action
+  plan <command>                Create, compile, or verify plans
+  run <command>                 Start or observe compiled runs
+  event verify                  Verify a runtime event log
+  todo <command>                Read and update the canonical TODO store
+  sensor <command>              Initialize or synchronize the bundled sensor
+  factory-diagnostics --json    Check native factory integration
+  runtime-errors <command>      Inspect the local runtime error store
+  bridge <command>              Configure the optional network bridge
+
+Options:
+  -h, --help                    Show help
+  --version                     Show the installed version
+`;
+
+const NAMESPACE_HELP = Object.freeze({
+  plan: `Usage: lattice plan <command> [options]
+
+Commands:
+  create --input <file>
+  create --schema --json
+  create --schema-version <2|3> --json
+  compile --request <request.json>
+  verify --request <request.json> --plan <plan.json>
+`,
+  run: `Usage: lattice run <command> [options]
+
+Commands:
+  start --request <request.json> --executor <adapter>
+  observe --run .lattice/runs/<id>
+  status --run .lattice/runs/<id>
+  resume --run .lattice/runs/<id>
+  close --run .lattice/runs/<id>
+  abandon --run .lattice/runs/<id> --reason <reason>
+  list --json
+`,
+  event: `Usage: lattice event verify --run .lattice/runs/<id>
+`,
+  todo: `Usage: lattice todo <command> [options]
+
+Read commands:
+  status [--json]
+  verify [--plan <key>] [--json]
+  snapshot --rebuild --plan <key>
+  gantt [--out <file>]
+  gantt status [--out <file>]
+  gantt serve --port <port>  # /projects/<project_id>/ をforeground配信
+  phase status --plan <key>
+
+Write commands:
+  start --plan <key> --task <id> [--parallel-frontier|--override-reason <text>]
+  block --plan <key> --task <id> --reason <text>
+  unblock --plan <key> --task <id>
+  done --plan <key> --task <id> --evidence <file>
+  reopen --plan <key> --task <id> --reason <text> [--override-reason <text>]
+  evidence promote --plan <key> --task <id> --evidence <file>
+  revise --plan <key> --input <file>
+  revise-phase --plan <key> --input <file>
+  revise-set --input <file>
+  phase review --plan <key> --phase <id> --reason <text>
+  phase <accept|reject> --plan <key> --phase <id> --input <file>
+  phase reopen --plan <key> --phase <id> --reason <text> [--override-reason <text>]
+
+Write commands require LATTICE_TODO_ACTOR_HOST, LATTICE_TODO_ACTOR_SESSION,
+and LATTICE_TODO_ACTOR_AGENT.
+`,
+  sensor: `Usage: lattice sensor <init|sync> [path] --json
+`,
+  'factory-diagnostics': `Usage: lattice factory-diagnostics --json
+`,
+  'runtime-errors': `Usage: lattice runtime-errors <command> --json
+
+Commands:
+  snapshot [--after-cursor <n>] [--limit <n>]
+  ack <cursor>
+  diagnostics
+  resolve <fingerprint>
+  reopen <fingerprint>
+  compact
+`,
+  bridge: `Usage: lattice bridge <command> [options] --json
+
+Commands:
+  setup --listen <IP> [--port <49152..65535|auto>] [--dashboard|--upstream <URL>] [--allow-host <host>...]
+  reconfigure [--listen <IP>] [--port <49152..65535|auto>] [--dashboard|--upstream <URL>] [--allow-host <host>...]
+  status
+  disable
+`,
+});
+
+const SUBCOMMAND_USAGE = Object.freeze({
+  'plan create': 'plan create --input <file> | --schema --json | --schema-version <2|3> --json',
+  'plan compile': 'plan compile --request <request.json>',
+  'plan verify': 'plan verify --request <request.json> --plan <plan.json>',
+  'run start': 'run start --request <request.json> --executor <adapter>',
+  'run observe': 'run observe --run .lattice/runs/<id>',
+  'run status': 'run status --run .lattice/runs/<id>',
+  'run resume': 'run resume --run .lattice/runs/<id>',
+  'run close': 'run close --run .lattice/runs/<id>',
+  'run abandon': 'run abandon --run .lattice/runs/<id> --reason <reason>',
+  'run list': 'run list --json',
+  'event verify': 'event verify --run .lattice/runs/<id>',
+  'todo status': 'todo status [--json]',
+  'todo verify': 'todo verify [--plan <key>] [--json]',
+  'todo snapshot': 'todo snapshot --rebuild --plan <key>',
+  'todo gantt': 'todo gantt [--out <file>] | status [--out <file>] | serve --port <port>',
+  'todo phase': 'todo phase <status|review|accept|reject|reopen> --plan <key> [options]',
+  'todo phase status': 'todo phase status --plan <key>',
+  'todo phase review': 'todo phase review --plan <key> --phase <id> --reason <text>',
+  'todo phase accept': 'todo phase accept --plan <key> --phase <id> --input <file>',
+  'todo phase reject': 'todo phase reject --plan <key> --phase <id> --input <file>',
+  'todo phase reopen': 'todo phase reopen --plan <key> --phase <id> --reason <text> [--override-reason <text>]',
+  'todo start': 'todo start --plan <key> --task <id> [--parallel-frontier|--override-reason <text>]',
+  'todo block': 'todo block --plan <key> --task <id> --reason <text>',
+  'todo unblock': 'todo unblock --plan <key> --task <id>',
+  'todo done': 'todo done --plan <key> --task <id> --evidence <file>',
+  'todo reopen': 'todo reopen --plan <key> --task <id> --reason <text> [--override-reason <text>]',
+  'todo evidence': 'todo evidence promote --plan <key> --task <id> --evidence <file>',
+  'todo evidence promote': 'todo evidence promote --plan <key> --task <id> --evidence <file>',
+  'todo revise': 'todo revise --plan <key> --input <file>',
+  'todo revise-phase': 'todo revise-phase --plan <key> --input <file>',
+  'todo revise-set': 'todo revise-set --input <file>',
+  'sensor init': 'sensor init [path] --json',
+  'sensor sync': 'sensor sync [path] --json',
+  'runtime-errors snapshot': 'runtime-errors snapshot [--after-cursor <n>] [--limit <n>] --json',
+  'runtime-errors ack': 'runtime-errors ack <cursor> --json',
+  'runtime-errors diagnostics': 'runtime-errors diagnostics --json',
+  'runtime-errors resolve': 'runtime-errors resolve <fingerprint> --json',
+  'runtime-errors reopen': 'runtime-errors reopen <fingerprint> --json',
+  'runtime-errors compact': 'runtime-errors compact --json',
+  'bridge setup': 'bridge setup --listen <IP> [--port <49152..65535|auto>] [--dashboard|--upstream <URL>] [--allow-host <host>...] --json',
+  'bridge reconfigure': 'bridge reconfigure [--listen <IP>] [--port <49152..65535|auto>] [--dashboard|--upstream <URL>] [--allow-host <host>...] --json',
+  'bridge status': 'bridge status --json',
+  'bridge disable': 'bridge disable --json',
+});
+
+function requestedNamespace(argv) {
+  if (argv.length === 2 && ['-h', '--help'].includes(argv[1])) return argv[0];
+  if (argv.length === 2 && argv[0] === 'help') return argv[1];
+  return null;
+}
+
+function requestedSubcommand(argv) {
+  if (argv.length >= 3 && ['-h', '--help'].includes(argv.at(-1))) {
+    return argv.slice(0, -1).join(' ');
+  }
+  if (argv.length >= 3 && argv[0] === 'help') return argv.slice(1).join(' ');
+  return null;
+}
+
+export function renderCliHelp(argv) {
+  if (argv.length === 1 && ['-h', '--help', 'help'].includes(argv[0])) return ROOT_HELP;
+  const subcommand = requestedSubcommand(argv);
+  if (subcommand !== null) {
+    const usage = SUBCOMMAND_USAGE[subcommand];
+    return usage === undefined ? null : `Usage: lattice ${usage}\n`;
+  }
+  const namespace = requestedNamespace(argv);
+  return namespace === null ? null : NAMESPACE_HELP[namespace] ?? null;
+}

package/src/control-compiler.mjs

@@ -6,7 +6,7 @@ import {
   validatePlanGraph,
   validatePlanInput,
 } from './artifact-contracts.mjs';
-import { portableCodegraphOutcome } from './codegraph-adapter.mjs';
+import { portableSensorOutcome } from './sensor-adapter.mjs';
 
 const SHA256 = /^[0-9a-f]{64}$/;
 const IDENTIFIER = /^[0-9A-Za-z](?:[0-9A-Za-z._-]{0,127})$/;
@@ -98,7 +98,7 @@ function assertManualEvidence(planInput, manualEvidence) {
 
 function assertQuerySet(querySet) {
   if (!exactRecord(querySet, ['schema', 'queries'])
-    || querySet.schema !== 'lattice.codegraph_query_set.v1'
+    || querySet.schema !== 'lattice.sensor_query_set.v1'
     || !Array.isArray(querySet.queries)
     || querySet.queries.length === 0
     || querySet.queries.length > 256) {
@@ -128,21 +128,21 @@ function assertQuerySet(querySet) {
   }
 }
 
-function assertCodegraphEvidence(querySet, codegraphEvidence) {
-  if (!exactRecord(codegraphEvidence, ['cwd', 'outcomes'])
-    || !nonEmptyText(codegraphEvidence.cwd)
-    || !Array.isArray(codegraphEvidence.outcomes)
-    || codegraphEvidence.outcomes.length !== querySet.queries.length) {
-    fail('Codegraph evidence rootがquery setと一致しない');
+function assertLatticeSensorEvidence(querySet, sensorEvidence) {
+  if (!exactRecord(sensorEvidence, ['cwd', 'outcomes'])
+    || !nonEmptyText(sensorEvidence.cwd)
+    || !Array.isArray(sensorEvidence.outcomes)
+    || sensorEvidence.outcomes.length !== querySet.queries.length) {
+    fail('LatticeSensor evidence rootがquery setと一致しない');
   }
   for (let index = 0; index < querySet.queries.length; index += 1) {
     const query = querySet.queries[index];
-    const outcome = codegraphEvidence.outcomes[index];
+    const outcome = sensorEvidence.outcomes[index];
     if (!outcome || typeof outcome !== 'object' || Array.isArray(outcome)
       || outcome.id !== query.id
       || outcome.operation !== query.operation
       || !nonEmptyText(outcome.outcome)) {
-      fail(`Codegraph evidence ${query.id}がID／operation／順序と一致しない`);
+      fail(`LatticeSensor evidence ${query.id}がID／operation／順序と一致しない`);
     }
   }
 }
@@ -190,27 +190,27 @@ function assertRc1QueryCoverage(planInput, querySet, seams) {
   }
 }
 
-function outcomeById(querySet, codegraphEvidence) {
+function outcomeById(querySet, sensorEvidence) {
   return new Map(querySet.queries.map((query, index) => [
     query.id,
-    codegraphEvidence.outcomes[index],
+    sensorEvidence.outcomes[index],
   ]));
 }
 
 function assertOutcome(outcomes, query, expected) {
   const outcome = outcomes.get(query.id);
   if (outcome.outcome !== expected) {
-    fail(`Codegraph evidence ${query.id}は${expected}でなく${outcome.outcome}`);
+    fail(`LatticeSensor evidence ${query.id}は${expected}でなく${outcome.outcome}`);
   }
   return outcome;
 }
 
-function controlGraphFacts(planInput, querySet, codegraphEvidence, seams) {
-  const outcomes = outcomeById(querySet, codegraphEvidence);
+function controlGraphFacts(planInput, querySet, sensorEvidence, seams) {
+  const outcomes = outcomeById(querySet, sensorEvidence);
   const statusQuery = findSingleQuery(querySet, 'status');
   const status = assertOutcome(outcomes, statusQuery, 'ready');
   if (!status.data || !nonEmptyText(status.data.version)) {
-    fail('Codegraph statusにversionがない');
+    fail('LatticeSensor statusにversionがない');
   }
 
   const anchorSymbol = planInput.todos[0].anchor.symbol;
@@ -227,7 +227,7 @@ function controlGraphFacts(planInput, querySet, codegraphEvidence, seams) {
   if (!Array.isArray(affected.targets)
     || affected.targets.length !== affectedQuery.targets.length
     || affected.targets.some((entry, index) => entry.target !== affectedQuery.targets[index])) {
-    fail('affected Codegraph evidenceがquery targetsと一致しない');
+    fail('affected LatticeSensor evidenceがquery targetsと一致しない');
   }
   const anchorEvidence = affected.targets[0];
   if (anchorEvidence.outcome !== 'ready'
@@ -246,7 +246,7 @@ function controlGraphFacts(planInput, querySet, codegraphEvidence, seams) {
     }
   }
   return {
-    codegraphVersion: status.data.version,
+    sensorVersion: status.data.version,
     affectedTests: [...new Set(anchorEvidence.data.affectedTests)].sort(),
     outcomes,
   };
@@ -311,12 +311,12 @@ function sharedManualConflicts(planInput, manualRecords) {
   return conflicts;
 }
 
-function graphRecords(querySet, codegraphEvidence) {
+function graphRecords(querySet, sensorEvidence) {
   return querySet.queries.map((query, index) => ({
     id: query.id,
     operation: query.operation,
-    status: codegraphEvidence.outcomes[index].outcome,
-    result_digest: digestArtifact(portableCodegraphOutcome(codegraphEvidence.outcomes[index])),
+    status: sensorEvidence.outcomes[index].outcome,
+    result_digest: digestArtifact(portableSensorOutcome(sensorEvidence.outcomes[index])),
   }));
 }
 
@@ -324,7 +324,7 @@ function compileManifest({
   planInput,
   manualEvidence,
   querySet,
-  codegraphEvidence,
+  sensorEvidence,
   codeSnapshotDigest,
   seams,
   facts,
@@ -382,9 +382,9 @@ function compileManifest({
       code_snapshot_digest: codeSnapshotDigest,
       query_set_digest: digestArtifact(querySet),
       manual_evidence_digest: digestArtifact(manualEvidence),
-      codegraph_version: facts.codegraphVersion,
+      sensor_version: facts.sensorVersion,
     },
-    graph_evidence: graphRecords(querySet, codegraphEvidence),
+    graph_evidence: graphRecords(querySet, sensorEvidence),
     manual_evidence: manualEvidenceRecords,
     todos,
     conflicts,
@@ -422,7 +422,7 @@ function compileVerdict(manifest, seams, manualEvidence) {
       })),
       preconditions: [
         'characterization verifier is green',
-        'post-transform Codegraph query set resolves proposed surfaces',
+        'post-transform LatticeSensor query set resolves proposed surfaces',
       ],
     };
   }
@@ -494,10 +494,10 @@ export function compileControlArtifacts({
   planInput,
   manualEvidence,
   querySet,
-  codegraphEvidence,
+  sensorEvidence,
   codeSnapshotDigest,
 } = {}) {
-  for (const value of [planInput, manualEvidence, querySet, codegraphEvidence]) {
+  for (const value of [planInput, manualEvidence, querySet, sensorEvidence]) {
     canonicalizeArtifact(value);
   }
   if (!validatePlanInput(planInput)) fail('plan inputがpublic contractを満たさない');
@@ -506,15 +506,15 @@ export function compileControlArtifacts({
   }
   assertManualEvidence(planInput, manualEvidence);
   assertQuerySet(querySet);
-  assertCodegraphEvidence(querySet, codegraphEvidence);
+  assertLatticeSensorEvidence(querySet, sensorEvidence);
   const seams = rc1Seams(planInput);
   assertRc1QueryCoverage(planInput, querySet, seams);
-  const facts = controlGraphFacts(planInput, querySet, codegraphEvidence, seams);
+  const facts = controlGraphFacts(planInput, querySet, sensorEvidence, seams);
   const boundaryManifest = compileManifest({
     planInput,
     manualEvidence,
     querySet,
-    codegraphEvidence,
+    sensorEvidence,
     codeSnapshotDigest,
     seams,
     facts,

package/src/dag-chain.mjs

@@ -0,0 +1,261 @@
+export class DagChainError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'DagChainError';
+    this.code = code;
+  }
+}
+
+export class DagCycleError extends DagChainError {
+  constructor(message = 'directed graph contains a cycle') {
+    super('DAG_CYCLE', message);
+    this.name = 'DagCycleError';
+  }
+}
+
+function defaultCompare(left, right) {
+  const leftText = String(left);
+  const rightText = String(right);
+  if (leftText < rightText) return -1;
+  if (leftText > rightText) return 1;
+  return 0;
+}
+
+function assertOptions(countCap, representativeLimit) {
+  if (!Number.isSafeInteger(countCap) || countCap < 1 || countCap >= Number.MAX_SAFE_INTEGER) {
+    throw new DagChainError(
+      'DAG_INVALID_COUNT_CAP',
+      'countCap must be a positive safe integer below Number.MAX_SAFE_INTEGER',
+    );
+  }
+  if (
+    !Number.isSafeInteger(representativeLimit)
+    || representativeLimit < 0
+    || representativeLimit > 8
+  ) {
+    throw new DagChainError(
+      'DAG_INVALID_REPRESENTATIVE_LIMIT',
+      'representativeLimit must be a safe integer from 0 through 8',
+    );
+  }
+}
+
+function normalizeGraph(nodes, edges) {
+  if (!Array.isArray(nodes) || !Array.isArray(edges)) {
+    throw new DagChainError('DAG_INVALID_GRAPH', 'nodes and edges must be arrays');
+  }
+
+  const nodeSet = new Set();
+  for (const node of nodes) {
+    if (nodeSet.has(node)) {
+      throw new DagChainError('DAG_DUPLICATE_NODE', 'nodes must be unique');
+    }
+    nodeSet.add(node);
+  }
+
+  const successors = new Map(nodes.map((node) => [node, []]));
+  const predecessors = new Map(nodes.map((node) => [node, []]));
+  const normalizedEdges = [];
+  const seenBySource = new Map();
+
+  for (const edge of edges) {
+    if (!Array.isArray(edge) || edge.length !== 2) {
+      throw new DagChainError('DAG_INVALID_EDGE', 'each edge must be a [from, to] pair');
+    }
+    const [from, to] = edge;
+    if (!nodeSet.has(from) || !nodeSet.has(to)) {
+      throw new DagChainError('DAG_DANGLING_EDGE', 'edge endpoint is absent from nodes');
+    }
+    let targets = seenBySource.get(from);
+    if (targets === undefined) {
+      targets = new Set();
+      seenBySource.set(from, targets);
+    }
+    if (targets.has(to)) continue;
+    targets.add(to);
+    successors.get(from).push(to);
+    predecessors.get(to).push(from);
+    normalizedEdges.push([from, to]);
+  }
+
+  return { successors, predecessors, edges: normalizedEdges };
+}
+
+function topologicalOrder(nodes, successors, predecessors) {
+  const indegree = new Map(nodes.map((node) => [node, predecessors.get(node).length]));
+  const ready = [];
+  for (const node of nodes) {
+    if (indegree.get(node) === 0) ready.push(node);
+  }
+
+  const order = [];
+  let cursor = 0;
+  while (cursor < ready.length) {
+    const node = ready[cursor];
+    cursor += 1;
+    order.push(node);
+    for (const successor of successors.get(node)) {
+      const remaining = indegree.get(successor) - 1;
+      indegree.set(successor, remaining);
+      if (remaining === 0) ready.push(successor);
+    }
+  }
+
+  if (order.length !== nodes.length) throw new DagCycleError();
+  return order;
+}
+
+function saturatedAdd(left, right, saturationPoint) {
+  if (left >= saturationPoint || right >= saturationPoint) return saturationPoint;
+  if (left > saturationPoint - right) return saturationPoint;
+  return left + right;
+}
+
+function enumerateRepresentatives({
+  orderedNodes,
+  successors,
+  down,
+  up,
+  maximumDepth,
+  representativeLimit,
+}) {
+  if (maximumDepth === 0 || representativeLimit === 0) return [];
+
+  const eligibleSuccessors = new Map();
+  for (const node of orderedNodes) {
+    eligibleSuccessors.set(
+      node,
+      successors.get(node).filter((successor) => (
+        up.get(successor) + 1 === up.get(node)
+      )),
+    );
+  }
+
+  const starts = orderedNodes.filter((node) => down.get(node) === 1 && up.get(node) === maximumDepth);
+  const representatives = [];
+
+  for (const start of starts) {
+    const path = [start];
+    const frames = [{ node: start, successorIndex: 0 }];
+
+    while (frames.length > 0 && representatives.length < representativeLimit) {
+      const frame = frames[frames.length - 1];
+      if (up.get(frame.node) === 1) {
+        representatives.push([...path]);
+        frames.pop();
+        path.pop();
+        continue;
+      }
+
+      const choices = eligibleSuccessors.get(frame.node);
+      if (frame.successorIndex >= choices.length) {
+        frames.pop();
+        path.pop();
+        continue;
+      }
+
+      const successor = choices[frame.successorIndex];
+      frame.successorIndex += 1;
+      path.push(successor);
+      frames.push({ node: successor, successorIndex: 0 });
+    }
+
+    if (representatives.length >= representativeLimit) break;
+  }
+
+  return representatives;
+}
+
+export function analyzeDagChains(
+  nodes,
+  edges,
+  {
+    countCap = 1_000_000,
+    representativeLimit = 8,
+    compare = defaultCompare,
+  } = {},
+) {
+  assertOptions(countCap, representativeLimit);
+  if (typeof compare !== 'function') {
+    throw new DagChainError('DAG_INVALID_COMPARATOR', 'compare must be a function');
+  }
+
+  const graph = normalizeGraph(nodes, edges);
+  const order = topologicalOrder(nodes, graph.successors, graph.predecessors);
+  const saturationPoint = countCap + 1;
+  const down = new Map();
+  const waysDown = new Map();
+
+  for (const node of order) {
+    let depth = 1;
+    let ways = 1;
+    for (const predecessor of graph.predecessors.get(node)) {
+      const candidateDepth = down.get(predecessor) + 1;
+      if (candidateDepth > depth) {
+        depth = candidateDepth;
+        ways = waysDown.get(predecessor);
+      } else if (candidateDepth === depth) {
+        ways = saturatedAdd(ways, waysDown.get(predecessor), saturationPoint);
+      }
+    }
+    down.set(node, depth);
+    waysDown.set(node, ways);
+  }
+
+  const up = new Map();
+  const waysUp = new Map();
+  for (let index = order.length - 1; index >= 0; index -= 1) {
+    const node = order[index];
+    let depth = 1;
+    let ways = 1;
+    for (const successor of graph.successors.get(node)) {
+      const candidateDepth = up.get(successor) + 1;
+      if (candidateDepth > depth) {
+        depth = candidateDepth;
+        ways = waysUp.get(successor);
+      } else if (candidateDepth === depth) {
+        ways = saturatedAdd(ways, waysUp.get(successor), saturationPoint);
+      }
+    }
+    up.set(node, depth);
+    waysUp.set(node, ways);
+  }
+
+  let maximumDepth = 0;
+  for (const node of nodes) maximumDepth = Math.max(maximumDepth, down.get(node) ?? 0);
+
+  let saturatedCount = 0;
+  for (const node of nodes) {
+    if (down.get(node) === maximumDepth) {
+      saturatedCount = saturatedAdd(saturatedCount, waysDown.get(node), saturationPoint);
+    }
+  }
+
+  const orderedNodes = [...nodes].sort(compare);
+  for (const values of graph.successors.values()) values.sort(compare);
+  const longestChainNodes = orderedNodes.filter((node) => (
+    down.get(node) + up.get(node) - 1 === maximumDepth
+  ));
+  const longestChainEdges = graph.edges
+    .filter(([from, to]) => down.get(from) + up.get(to) === maximumDepth)
+    .sort((left, right) => compare(left[0], right[0]) || compare(left[1], right[1]));
+
+  return {
+    maximumDepth,
+    longestChainNodes,
+    longestChainEdges,
+    longestChainCount: {
+      count: Math.min(saturatedCount, countCap),
+      overflow: saturatedCount === saturationPoint,
+    },
+    representativeChains: enumerateRepresentatives({
+      orderedNodes,
+      successors: graph.successors,
+      down,
+      up,
+      maximumDepth,
+      representativeLimit,
+    }),
+    topologicalOrder: order,
+  };
+}

package/src/factory-diagnostics.mjs

@@ -1,6 +1,6 @@
 import { readFile, lstat } from 'node:fs/promises';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 
 /**
  * dotagents工場の native factory diagnostics 面（親plan L6要件）。
@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
  * - schema `lattice.native_factory_diagnostics.v1`: exact key・bounded・秘密なしJSON。
  * - read-only: provider・network・run store書込・index生成を一切行わない。
  * - 非0意味論: overall `failed` → exit 1。CLI usage違反は既存contractどおり exit 2。
- * - 既存 `doctor --json`（bootstrap diagnostics・RC3特性化で凍結）は変更しない加算面。
+ * - 本面が健全性の唯一の診断正本（旧`doctor --json`はADR 0052で退役済み）。
  */
 
 const SCHEMA = 'lattice.native_factory_diagnostics.v1';
@@ -17,7 +17,7 @@ const MAX_DETAIL_LENGTH = 256;
 const SEMVER_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
 const UNKNOWN_VERSION_SENTINEL = '0.0.0-unknown';
 const NODE_VERSION_PATTERN = /^v(\d+)\.(\d+)\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
-const ENGINES_FLOOR_PATTERN = /^>=(\d+)(?:\.(\d+))?(?:\.\d+)?$/;
+const ENGINES_FLOOR_RANGE_PATTERN = /^(>=(\d+)(?:\.(\d+))?(?:\.\d+)?)(?: +<25(?:\.0\.0)? +\|\| +>=26(?:\.0\.0)?)$/;
 const CHECK_IDS = Object.freeze([
   'package_version',
   'node_runtime',
@@ -70,23 +70,24 @@ function checkNodeRuntime(nodeVersion, enginesNode) {
   if (!runtime) {
     return check('node_runtime', false, 'node version is unreadable');
   }
-  const floor = ENGINES_FLOOR_PATTERN.exec(enginesNode ?? '');
+  const floor = ENGINES_FLOOR_RANGE_PATTERN.exec(enginesNode ?? '');
   if (!floor) {
     return check('node_runtime', false, 'package.json engines.node floor is unreadable');
   }
   const [major, minor] = [Number(runtime[1]), Number(runtime[2])];
-  const [floorMajor, floorMinor] = [Number(floor[1]), Number(floor[2] ?? '0')];
+  const [floorMajor, floorMinor] = [Number(floor[2]), Number(floor[3] ?? '0')];
   const satisfied = major > floorMajor || (major === floorMajor && minor >= floorMinor);
   return check(
     'node_runtime',
     satisfied,
-    satisfied ? `${nodeVersion} satisfies engines.node ${enginesNode}` : `${nodeVersion} is below engines.node ${enginesNode}`,
+    satisfied ? `${nodeVersion} satisfies engines.node floor ${floor[1]}`
+      : `${nodeVersion} is below engines.node floor ${floor[1]}`,
   );
 }
 
 async function checkCliSurface(rootDir) {
   try {
-    const runtimeCli = await import(path.join(rootDir, 'src', 'runtime-cli.mjs'));
+    const runtimeCli = await import(pathToFileURL(path.join(rootDir, 'src', 'runtime-cli.mjs')).href);
     if (typeof runtimeCli.runRuntimeCli !== 'function') {
       return check('cli_surface', false, 'src/runtime-cli.mjs does not export runRuntimeCli');
     }