arkgate 3.7.0 → 3.8.0

package/bin/lib/architecture-scan.mjs

@@ -2,373 +2,86 @@
  * Architecture check pipeline: content scan → import graph → layer edges → cycles.
  * Extracted from ark-check entry (R3). Entry remains orchestration + presentation.
  */
-import fs from 'node:fs';
 import path from 'node:path';
-import {
-  layerForFile,
-  looksLikeIntent,
-} from '../ark-shared.mjs';
-import {
-  isArkPublishCandidate,
-  isPublishCall,
-  lineOf,
-  namedModuleBindings,
-  objectHasProperty,
-  publishHasSource,
-  publishSourceLiteral,
-  sourceFileExportsOnlyTypes,
-  sourceFileHasTopLevelSideEffects,
-  stringLiteralText,
-  typeOnlyExportNames,
-} from './ast-scan.mjs';
-import { provePortProofInject } from './port-proof.mjs';
 import { summarizeParseHealth } from './parse-health.mjs';
 import {
-  intentLayersFromManifest,
-  layerForIntent,
-  isBlocked,
-  collectConfigWarnings,
-} from './config-warnings.mjs';
-import {
-  ambientCoveredByForbiddenGlobals,
-  collectCapabilityUses,
-  collectForbiddenCapabilityUses,
-  effectiveCapabilityDeny,
-  evaluateArchitectureGraph,
-  extractSemanticDependencies,
-  forbiddenGlobalForModuleSpecifier,
+  analyzeTrustedResolvedProject,
+  loadContract,
 } from './analysis-engine.mjs';
-import { normalize } from './scan-files.mjs';
-import { collectSafetyDiagnostics } from './safety-diagnostics.mjs';
-import { classifyPublishFacts } from './source-policy.mjs';
-import {
-  createCompilerOptionsLookup,
-  createModuleResolutionHost,
-  loadScanCache,
-  resolveImport,
-  saveScanCache,
-  scanCacheKey,
-} from './ts-resolve.mjs';
-
-/**
- * Parse one governed source file into content violations + module edges.
- */
-export function scanSourceFile(ts, root, config, rules, manifestIntentLayers, file, sourceLayer) {
-  const source = fs.readFileSync(file, 'utf8');
-  const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
-  const violations = [];
-  const edges = [];
-
-  const layerConfig = config.layers.find((layer) => layer.name === sourceLayer);
-  const forbiddenGlobals = Array.isArray(layerConfig?.forbiddenGlobals)
-    ? layerConfig.forbiddenGlobals.filter((entry) => typeof entry === 'string')
-    : [];
-  for (const use of collectForbiddenCapabilityUses(ts, sourceFile, forbiddenGlobals)) {
-    violations.push({
-      ruleId: 'FORBIDDEN_GLOBAL',
-      file: normalize(path.relative(root, file)),
-      line: use.line,
-      fromLayer: sourceLayer,
-      target: use.name,
-      message: `${sourceLayer} must not use the ambient global "${use.name}".`,
-    });
-  }
-
-  // U04 — opted-in capability walls (ADR 0009). One violation, one voice: an
-  // ambient use already covered by this layer's forbiddenGlobals reports only
-  // FORBIDDEN_GLOBAL (D7 dedup); absence of the surface adds nothing.
-  const capabilityDeny = new Set(effectiveCapabilityDeny(layerConfig ?? {}));
-  if (capabilityDeny.size > 0) {
-    for (const use of collectCapabilityUses(ts, sourceFile)) {
-      if (!capabilityDeny.has(use.capability)) continue;
-      if (
-        (use.source === 'ambient-global' &&
-          ambientCoveredByForbiddenGlobals(use.symbol, forbiddenGlobals)) ||
-        (use.source === 'import-based' &&
-          forbiddenGlobalForModuleSpecifier(use.symbol, forbiddenGlobals))
-      ) {
-        continue;
-      }
-      violations.push({
-        ruleId: 'CAPABILITY_VIOLATION',
-        file: normalize(path.relative(root, file)),
-        line: use.line,
-        fromLayer: sourceLayer,
-        target: use.symbol,
-        capability: use.capability,
-        message:
-          use.source === 'import-based'
-            ? `${sourceLayer} denies the ${use.capability} capability; found import of "${use.symbol}".`
-            : `${sourceLayer} denies the ${use.capability} capability; found ambient "${use.symbol}".`,
-      });
-    }
-  }
-
-  const checkModuleEdge = (specifier, node, kind, typeOnly = false) => {
-    const namedBindings = namedModuleBindings(ts, node);
-    edges.push({
-      specifier,
-      line: lineOf(sourceFile, node.getStart(sourceFile)),
-      kind,
-      typeOnly,
-      ...(namedBindings ? { namedBindings } : {}),
-    });
-  };
-
-  for (const dependency of extractSemanticDependencies(ts, sourceFile)) {
-    if (!dependency.specifier) continue;
-    checkModuleEdge(
-      dependency.specifier,
-      dependency.node,
-      dependency.kind,
-      dependency.typeOnly
-    );
-  }
-
-  const needsPolicyWalk =
-    /\bpublish\s*\(|\bintent\b/.test(source) ||
-    /['"`]\s*[A-Z][A-Za-z0-9_]*\./.test(source);
-  const visit = (node) => {
-    if (ts.isCallExpression(node)) {
-      if (isPublishCall(ts, node)) {
-        const firstArg = node.arguments[0];
-        const rawIntent = stringLiteralText(ts, firstArg);
-        for (const finding of classifyPublishFacts({
-          publishCall: true,
-          rawIntentName: rawIntent,
-          objectHasIntent: objectHasProperty(ts, firstArg, 'intent'),
-          arkPublishCandidate: isArkPublishCandidate(ts, node),
-          hasSource: publishHasSource(ts, node),
-        })) {
-          violations.push({
-            ruleId: finding.ruleId,
-            file: normalize(path.relative(root, file)),
-            line: lineOf(sourceFile, node.getStart(sourceFile)),
-            ...(finding.ruleId === 'PUBLISH_MISSING_SOURCE' ? { fromLayer: sourceLayer } : {}),
-            message: finding.message,
-          });
-        }
-
-        const sourceIntent = publishSourceLiteral(ts, node);
-        if (sourceIntent && looksLikeIntent(sourceIntent)) {
-          const sourceIntentLayer = layerForIntent(
-            sourceIntent,
-            config.layers,
-            manifestIntentLayers
-          );
-          if (sourceIntentLayer && sourceIntentLayer !== sourceLayer) {
-            violations.push({
-              ruleId: 'PUBLISH_SOURCE_LAYER_MISMATCH',
-              file: normalize(path.relative(root, file)),
-              line: lineOf(sourceFile, node.getStart(sourceFile)),
-              fromLayer: sourceLayer,
-              toLayer: sourceIntentLayer,
-              target: sourceIntent,
-              message:
-                `Publish source "${sourceIntent}" resolves to ${sourceIntentLayer}, but the publishing file is classified as ${sourceLayer}.`,
-            });
-          }
-        }
-      }
-    }
-
-    if (ts.isStringLiteralLike(node) && looksLikeIntent(node.text)) {
-      const targetLayer = layerForIntent(node.text, config.layers, manifestIntentLayers);
-      const rule = targetLayer ? isBlocked(rules, sourceLayer, targetLayer) : undefined;
-      if (rule) {
-        violations.push({
-          ruleId: 'LAYER_INTENT_REFERENCE_VIOLATION',
-          file: normalize(path.relative(root, file)),
-          line: lineOf(sourceFile, node.getStart(sourceFile)),
-          fromLayer: sourceLayer,
-          toLayer: targetLayer,
-          target: node.text,
-          message:
-            rule.message ??
-            `${sourceLayer} must not reference ${targetLayer} intent ${node.text}.`,
-        });
+import { effectiveAnalysisConfig } from './analysis-policy.mjs';
+import { resolveCandidateFacts } from './resolved-candidate-facts.mjs';
+
+/** Resolve canonical facts and optionally retain filesystem probes for resident invalidation. */
+export function resolveArchitectureSnapshot({
+  root,
+  config,
+  manifest,
+  rules,
+  files,
+  ts,
+  args,
+  captureInputs = true,
+}) {
+  const observedInputs = captureInputs ? new Map() : undefined;
+  const observeInput = observedInputs
+    ? (inputPath, kind) => {
+        const absolute = path.resolve(inputPath);
+        const kinds = observedInputs.get(absolute) ?? new Set();
+        kinds.add(kind);
+        observedInputs.set(absolute, kinds);
       }
-    }
-
-    ts.forEachChild(node, visit);
-  };
-  if (needsPolicyWalk) visit(sourceFile);
-  return {
-    contentViolations: violations,
-    edges,
-    parseDiagnosticCount: sourceFile.parseDiagnostics?.length ?? 0,
-    exportsOnlyTypes: sourceFileExportsOnlyTypes(ts, sourceFile),
-    typeOnlyExportNames: typeOnlyExportNames(ts, sourceFile),
-    hasTopLevelSideEffects: sourceFileHasTopLevelSideEffects(ts, sourceFile),
+    : undefined;
+  const configPath = args?.config
+    ? path.resolve(root, args.config)
+    : path.join(root, 'ark.config.json');
+  observeInput?.(configPath, 'ark-config');
+  if (args?.manifest) observeInput?.(path.resolve(root, args.manifest), 'manifest');
+  const effectiveConfig = effectiveAnalysisConfig(
+    { ...config, rules: rules ?? config.rules },
+    manifest
+  );
+  const facts = resolveCandidateFacts({
+    root,
+    config: effectiveConfig,
+    ts,
+    ...(args?.tsconfig ? { tsconfig: args.tsconfig } : {}),
+    observeInput,
+  });
+  const loadedContract = loadContract(effectiveConfig, configPath);
+  const analyzed = analyzeTrustedResolvedProject({ contract: loadedContract, facts });
+  const parseHealth = summarizeParseHealth(
+    facts.files.map((file) => ({
+      relFile: file.path,
+      entry: { parseDiagnosticCount: file.parseDiagnosticCount },
+    }))
+  );
+  const result = {
+    violations: analyzed.ir.violations,
+    warnings: analyzed.ir.warnings,
+    safety: analyzed.safety,
+    parseHealth,
+    completeness: analyzed.completeness,
+    completenessReasons: analyzed.completenessReasons,
+    valid: analyzed.valid,
+    strictValid: analyzed.strictValid,
+    mode: analyzed.mode,
+    policyHash: analyzed.policyHash,
+    resolverIdentity: analyzed.resolverIdentity,
+    factsHash: analyzed.factsHash,
+    candidateTreeHash: analyzed.candidateTreeHash,
   };
+  const inputs = observedInputs
+    ? [...observedInputs]
+        .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+        .map(([inputPath, kinds]) => ({ path: inputPath, kinds: [...kinds].sort() }))
+    : [];
+  return { facts, result, inputs };
 }
 
 /**
  * Full architecture scan for governed files.
  * @returns {{ violations: object[], warnings: object[] }}
  */
-export function runArchitectureScan({ root, config, manifest, rules, files, ts, args }) {
-  const manifestIntentLayers = intentLayersFromManifest(manifest);
-  const compilerOptionsFor = createCompilerOptionsLookup(ts, root, args.tsconfig);
-  const moduleHost = createModuleResolutionHost(ts);
-
-  const warnings = collectConfigWarnings(root, config, files, rules, manifest);
-  const safety = collectSafetyDiagnostics(ts, root, config, files);
-  warnings.push(...safety.warnings);
-  const cacheKey = args.noCache ? undefined : scanCacheKey(root, args, ts.version);
-  const cachedFiles = cacheKey ? loadScanCache(root, cacheKey) : undefined;
-  const nextCacheFiles = {};
-
-  const scanned = [];
-  for (const file of files) {
-    const sourceLayer = layerForFile(root, file, config.layers);
-    if (!sourceLayer) continue;
-    const relFile = normalize(path.relative(root, file));
-    const stat = fs.statSync(file);
-    const fileKey = `${stat.mtimeMs}:${stat.size}`;
-    const cached = cachedFiles?.[relFile];
-    const entry =
-      cached &&
-      cached.fileKey === fileKey &&
-      Number.isSafeInteger(cached.parseDiagnosticCount) &&
-      cached.parseDiagnosticCount >= 0
-        ? cached
-        : {
-            fileKey,
-            ...scanSourceFile(
-              ts,
-              root,
-              config,
-              rules,
-              manifestIntentLayers,
-              file,
-              sourceLayer
-            ),
-          };
-    nextCacheFiles[relFile] = entry;
-    scanned.push({ file, sourceLayer, relFile, entry });
-  }
-
-  const engineEdges = [];
-  // Y08 derives exact forbidden-global module duals from dependency facts
-  // already stored in every current cache entry. This stays downstream of the
-  // cache: no second AST scan, no cache-shape/version bump, and warm pre-Y08
-  // entries gain the verdict immediately.
-  const forbiddenModuleDualViolations = [];
-  const forbiddenModuleDualKeys = new Set();
-  for (const { file, sourceLayer, relFile, entry } of scanned) {
-    const layerConfig = config.layers.find((layer) => layer.name === sourceLayer);
-    const forbiddenGlobals = Array.isArray(layerConfig?.forbiddenGlobals)
-      ? layerConfig.forbiddenGlobals.filter((item) => typeof item === 'string')
-      : [];
-    for (const edge of entry.edges) {
-      if (!edge.typeOnly) {
-        const forbiddenGlobal = forbiddenGlobalForModuleSpecifier(
-          edge.specifier,
-          forbiddenGlobals
-        );
-        if (forbiddenGlobal) {
-          forbiddenModuleDualKeys.add(`${relFile}\0${edge.specifier}`);
-          forbiddenModuleDualViolations.push({
-            ruleId: 'FORBIDDEN_GLOBAL',
-            file: relFile,
-            line: edge.line,
-            fromLayer: sourceLayer,
-            target: edge.specifier,
-            edgeKind: edge.kind,
-            message: `${sourceLayer} must not use module "${edge.specifier}" because it is the import form of forbidden global "${forbiddenGlobal}".`,
-          });
-        }
-      }
-      const target = resolveImport(
-        ts,
-        edge.specifier,
-        file,
-        compilerOptionsFor(file),
-        moduleHost,
-        root
-      );
-      const targetLayer = target ? layerForFile(root, target, config.layers) : undefined;
-      const relTarget = target ? normalize(path.relative(root, target)) : undefined;
-      const targetCached = relTarget ? nextCacheFiles[relTarget] : undefined;
-      const staticEdge = edge.kind === 'import' || edge.kind === 'export';
-      const targetTypeOnlyExports =
-        staticEdge && Boolean(targetCached?.exportsOnlyTypes) && !edge.typeOnly;
-      const sourcePureTypeModule = Boolean(entry.exportsOnlyTypes);
-      const targetTypeNames = new Set(targetCached?.typeOnlyExportNames || []);
-      const named = edge.namedBindings;
-      const namedBindingsTypeOnly =
-        staticEdge &&
-        Array.isArray(named) &&
-        named.length > 0 &&
-        targetTypeNames.size > 0 &&
-        !targetCached?.hasTopLevelSideEffects &&
-        named.every((name) => targetTypeNames.has(name));
-      const deniedRule = targetLayer
-        ? isBlocked(rules, sourceLayer, targetLayer, {
-            fromPath: relFile,
-            toPath: relTarget,
-            layers: config.layers,
-          })
-        : undefined;
-      let portProofEligible = false;
-      if (
-        deniedRule &&
-        !deniedRule.peerIsolation &&
-        !edge.typeOnly &&
-        edge.kind === 'import' &&
-        !targetTypeOnlyExports &&
-        !namedBindingsTypeOnly
-      ) {
-        try {
-          const source = fs.readFileSync(file, 'utf8');
-          portProofEligible = Boolean(provePortProofInject(ts, source, { filePath: file }).eligible);
-        } catch {
-          portProofEligible = false;
-        }
-      }
-      engineEdges.push({
-        from: relFile,
-        fromLayer: sourceLayer,
-        to: relTarget,
-        toLayer: targetLayer,
-        line: edge.line,
-        kind: edge.kind,
-        typeOnly: edge.typeOnly,
-        targetTypeOnlyExports,
-        sourcePureTypeModule,
-        namedBindingsTypeOnly,
-        portProofEligible,
-      });
-    }
-  }
-
-  if (cacheKey) saveScanCache(root, cacheKey, nextCacheFiles);
-
-  // A cache written before Y08 can retain the overlapping capability-wall
-  // finding for this import. Filter by file+specifier (not line: D7 explicitly
-  // does not depend on cross-engine line anchors), then let FORBIDDEN_GLOBAL be
-  // the one declared-policy voice.
-  const contentViolations = scanned
-    .flatMap(({ entry }) => entry.contentViolations)
-    .filter(
-      (violation) =>
-        !(
-          violation.ruleId === 'CAPABILITY_VIOLATION' &&
-          forbiddenModuleDualKeys.has(`${violation.file}\0${violation.target}`)
-        )
-    );
-
-  return {
-    ...evaluateArchitectureGraph({
-      config,
-      rules,
-      files: scanned.map(({ relFile }) => relFile),
-      contentViolations: [...contentViolations, ...forbiddenModuleDualViolations],
-      edges: engineEdges,
-      warnings,
-      safety: safety.report,
-    }),
-    parseHealth: summarizeParseHealth(scanned),
-  };
+export function runArchitectureScan(options) {
+  return resolveArchitectureSnapshot({ ...options, captureInputs: false }).result;
 }

package/bin/lib/auto-patch.mjs

@@ -194,15 +194,35 @@ export function applyImportTypeAutoPatch(ts, source, opts = {}) {
  *   filePath?: string,
  *   root: string,
  *   ts: object,
- *   validate: (source: string) => { valid: boolean, violations?: any[] },
+ *   validate: (source: string) => { valid: boolean, completeness?: string, violations?: any[] },
  *   resolveTargetAbs?: Function,
  * }} opts
  */
 export function validateWithAutoPatch(opts) {
   const { source, filePath, root, ts, validate, resolveTargetAbs } = opts;
   const result = validate(source);
+  const completeness = result.completeness === 'unavailable' ? 'unavailable' : 'partial';
+  const completenessReasons =
+    Array.isArray(result.completenessReasons) && result.completenessReasons.length > 0
+      ? result.completenessReasons
+      : [
+          {
+            code:
+              completeness === 'unavailable'
+                ? 'ANALYSIS_UNAVAILABLE'
+                : 'LEXICAL_EVIDENCE_INCOMPLETE',
+            message:
+              completeness === 'unavailable'
+                ? 'Single-file analysis is unavailable.'
+                : 'Single-file validation cannot prove complete candidate resolver evidence.',
+          },
+        ];
   const base = {
-    valid: Boolean(result.valid),
+    mode: 'lexical-compatibility',
+    valid: false,
+    lexicalValid: Boolean(result.lexicalValid ?? result.valid),
+    completeness,
+    completenessReasons,
     violations: Array.isArray(result.violations) ? result.violations : [],
   };
 
@@ -229,8 +249,16 @@ export function validateWithAutoPatch(opts) {
     };
   });
 
-  if (base.valid) {
-    return { valid: true, violations: [], autoPatch: null };
+  if (base.lexicalValid) {
+    return {
+      mode: base.mode,
+      valid: false,
+      lexicalValid: true,
+      completeness: base.completeness,
+      completenessReasons: base.completenessReasons,
+      violations: [],
+      autoPatch: null,
+    };
   }
 
   // Write-path autoPatch: import-type mechanical-safe only (W1).
@@ -242,23 +270,63 @@ export function validateWithAutoPatch(opts) {
   });
 
   if (!attempt) {
-    return { valid: false, violations, autoPatch: null };
+    return {
+      mode: base.mode,
+      valid: false,
+      lexicalValid: false,
+      completeness: base.completeness,
+      completenessReasons: base.completenessReasons,
+      violations,
+      autoPatch: null,
+    };
   }
 
   const after = validate(attempt.source);
-  if (!after.valid) {
+  if (!(after.lexicalValid ?? after.valid)) {
     // Discard — never return an unvalidated patch
-    return { valid: false, violations, autoPatch: null };
+    return {
+      mode: base.mode,
+      valid: false,
+      lexicalValid: false,
+      completeness: base.completeness,
+      completenessReasons: base.completenessReasons,
+      violations,
+      autoPatch: null,
+    };
   }
 
+  const afterCompleteness = after.completeness === 'unavailable' ? 'unavailable' : 'partial';
+  const afterCompletenessReasons =
+    Array.isArray(after.completenessReasons) && after.completenessReasons.length > 0
+      ? after.completenessReasons
+      : [
+          {
+            code:
+              afterCompleteness === 'unavailable'
+                ? 'ANALYSIS_UNAVAILABLE'
+                : 'LEXICAL_EVIDENCE_INCOMPLETE',
+            message:
+              afterCompleteness === 'unavailable'
+                ? 'Single-file analysis is unavailable.'
+                : 'Single-file validation cannot prove complete candidate resolver evidence.',
+          },
+        ];
   return {
+    mode: base.mode,
     valid: false,
+    lexicalValid: false,
+    completeness: base.completeness,
+    completenessReasons: base.completenessReasons,
     violations,
     autoPatch: {
+      mode: 'lexical-compatibility',
       source: attempt.source,
       remediationKind: attempt.remediationKind,
       confidence: attempt.confidence,
-      valid: true,
+      valid: false,
+      lexicalValid: true,
+      completeness: afterCompleteness,
+      completenessReasons: afterCompletenessReasons,
     },
   };
 }

package/bin/lib/ci-and-commands.mjs

@@ -426,6 +426,6 @@ ${nodeSetup}
 ${qualityBlock ? `${qualityBlock}\n` : ''}      - name: Ark architecture check
         env:
           ARK_POLICY_BASE_REF: \${{ github.event.pull_request.base.sha || github.event.before }}
-        run: ${pm.run}
+        run: ${pm.run} --fail-on-new-smells --base-ref "\${{ github.event.pull_request.base.sha || github.event.before }}"
 `;
 }

package/bin/lib/codex-home.mjs

@@ -68,11 +68,32 @@ export function codexProjectSlug(absRoot) {
   return `${base}_${hash}`;
 }
 
+/** Parse the one generated-style TOML args array from an MCP table body. */
+export function extractCodexArgsFromBlock(block) {
+  if (!block || typeof block !== 'string') return null;
+  const matches = [
+    ...block.matchAll(/^[ \t]*args[ \t]*=[ \t]*\[([^\]\r\n]*)\][ \t]*(?:#.*)?$/gm),
+  ];
+  if (matches.length !== 1) return null;
+  const tokens = [...matches[0][1].matchAll(/"(?:\\.|[^"\\])*"|'[^']*'/g)];
+  const shape = matches[0][1].replace(/"(?:\\.|[^"\\])*"|'[^']*'/g, '__ARK_STRING__');
+  if (!/^[ \t]*(?:__ARK_STRING__(?:[ \t]*,[ \t]*__ARK_STRING__)*[ \t]*,?)?[ \t]*$/.test(shape)) {
+    return null;
+  }
+  try {
+    return tokens.map((match) =>
+      match[0].startsWith('"') ? JSON.parse(match[0]) : match[0].slice(1, -1)
+    );
+  } catch {
+    return null;
+  }
+}
+
 /** Extract `--root` from one TOML mcp_servers table body. */
 export function extractCodexRootFromBlock(block) {
-  if (!block || typeof block !== 'string') return null;
-  const m = block.match(/"--root"\s*,\s*"([^"]+)"/);
-  return m ? m[1] : null;
+  const args = extractCodexArgsFromBlock(block);
+  const index = args?.indexOf('--root') ?? -1;
+  return index >= 0 && typeof args[index + 1] === 'string' ? args[index + 1] : null;
 }
 
 /**
@@ -82,20 +103,19 @@ export function extractCodexRootFromBlock(block) {
 export function listCodexArkServerTables(tomlText) {
   if (!tomlText || typeof tomlText !== 'string') return [];
   const out = [];
-  const headerRe = /\[mcp_servers\.(ark(?:_[a-zA-Z0-9_-]*)?)\]/g;
+  const headerRe =
+    /^[ \t]*\[[ \t]*(?:"mcp_servers"|'mcp_servers'|mcp_servers)[ \t]*\.[ \t]*(?:"(ark(?:_[a-zA-Z0-9_-]*)?)"|'(ark(?:_[a-zA-Z0-9_-]*)?)'|(ark(?:_[a-zA-Z0-9_-]*)?))[ \t]*\][ \t]*(?:#.*)?$/gm;
   const headers = [];
   let hm;
   while ((hm = headerRe.exec(tomlText)) !== null) {
-    headers.push({ table: hm[1], index: hm.index });
+    headers.push({ table: hm[1] ?? hm[2] ?? hm[3], index: hm.index });
   }
   for (let i = 0; i < headers.length; i++) {
     const start = headers[i].index;
-    let end = i + 1 < headers.length ? headers[i + 1].index : tomlText.length;
-    if (i + 1 >= headers.length) {
-      const rest = tomlText.slice(start + 1);
-      const other = rest.search(/\n\[/);
-      if (other >= 0) end = start + 1 + other;
-    }
+    let end = tomlText.length;
+    const rest = tomlText.slice(start + 1);
+    const other = rest.search(/\n(?=[ \t]*\[)/);
+    if (other >= 0) end = start + 1 + other;
     const block = tomlText.slice(start, end).replace(/\s+$/, '\n');
     out.push({
       table: headers[i].table,
@@ -148,9 +168,14 @@ export function codexScopedTableForRoot(tomlText, absRoot) {
 /** True when project TOML owns the primary Ark MCP binding for that project. */
 export function codexProjectMcpIsValid(tomlText, projectRoot) {
   const resolvedRoot = path.resolve(projectRoot);
+  if (listCodexArkServerTables(tomlText).filter((entry) => entry.table === 'ark').length !== 1) {
+    return false;
+  }
   const primary = codexPrimaryTable(tomlText);
-  if (!primary?.root || !/\b(ark|arkgate)-mcp\b/.test(primary.block)) return false;
-  const config = primary.block.match(/"--config"\s*,\s*"([^"]+)"/)?.[1];
+  const args = extractCodexArgsFromBlock(primary?.block);
+  if (!primary?.root || !args?.some((value) => /^(ark|arkgate)-mcp$/.test(value))) return false;
+  const configIndex = args.indexOf('--config');
+  const config = configIndex >= 0 ? args[configIndex + 1] : null;
   if (!config) return false;
   try {
     return (
@@ -170,7 +195,9 @@ export function extractCodexArkRootFromToml(tomlText) {
 export function codexArkBlockHasPreferredBin(tomlText) {
   const primary = codexPrimaryTable(tomlText);
   if (!primary) return false;
-  const bins = [...primary.block.matchAll(/"(arkgate-mcp|ark-mcp)"/g)].map((m) => m[1]);
+  const bins = (extractCodexArgsFromBlock(primary.block) ?? []).filter((value) =>
+    /^(arkgate-mcp|ark-mcp)$/.test(value)
+  );
   if (bins.length > 1) return false;
   return bins.length === 1 && bins[0] === PREFERRED_CODEX_MCP_BIN;
 }
@@ -180,7 +207,7 @@ export function codexArkBlockHasPreferredBin(tomlText) {
  * Permanent different project roots are NOT broken — multi-project uses a secondary table.
  */
 export function codexArkBlockNeedsRewrite(tomlText, absRoot) {
-  if (!tomlText || !tomlText.includes('[mcp_servers.ark]')) return true;
+  if (!codexPrimaryTable(tomlText)) return true;
   const rootArg = extractCodexArkRootFromToml(tomlText);
   if (!rootArg || isTempOrUpgradeRoot(rootArg)) return true;
   try {
@@ -210,7 +237,7 @@ export function codexArkBlockNeedsRewrite(tomlText, absRoot) {
  */
 export function assessCodexHomeMcp(tomlText, absRoot) {
   const resolvedRoot = path.resolve(absRoot);
-  if (!tomlText || !tomlText.includes('[mcp_servers.ark]')) {
+  if (!codexPrimaryTable(tomlText)) {
     return {
       root: null,
       tempPath: false,