arkgate 2.10.0 → 2.12.0

package/CHANGELOG.md

@@ -4,6 +4,113 @@ All notable changes to ArkGate (`arkgate`; formerly `ark-runtime-kernel`) are do
 
 ## Unreleased
 
+## 2.12.0 — 2026-07-10
+
+### Fixed
+
+- **Install agent gates on temp roots:** skip rewriting the developer's real
+  `~/.codex/config.toml` when the project root is a temp/upgrade scratch and
+  `CODEX_HOME` is unset. Home MCP wire failures no longer fail an otherwise
+  successful repo gate install (sandbox/EPERM). Explicit `CODEX_HOME` and
+  `--codex-home` still wire as before.
+- **Q1 coverage floors (broad include, 80/85/95):** Vitest thresholds statements/lines **≥80%**,
+  branches/functions **≥85%** on the **full product unit surface** (`src/**` + `bin/lib/**` +
+  `bin/ark-shared.mjs`; only process-entry shells excluded — no cherry-picked enforcement-core
+  include). Per-path critical floors: write-path-detect / auto-patch / prepare-write /
+  safety-diagnostics / baseline-key / graph-cycles at **≥95%** branch. Real branch-driving tests
+  under `tests/unit/static-check/` (critical + surface/topup/seam suites). Two consecutive
+  green `npm run test:coverage` captures (stmts/lines **92.71%**, branches **85%**, functions
+  **94.76%**; critical modules all **≥95%** branch).
+- **agent-gates modularization:** thin facade (`bin/lib/agent-gates.mjs` ~100 LOC) re-exports
+  `gate-files`, `skill-install`, `ci-and-commands`, `mcp-adoption`, `install-migrate`,
+  `typescript-host`, `hook-templates`, `write-path-detect`, plus field/codex helpers.
+  `detectDeployPathQuality` extracted to `bin/lib/deploy-path.mjs` so `mcp-adoption.mjs` stays
+  under the 600 LOC module budget. Import hygiene on extract modules; `loadTypeScript` uses
+  `__arkCheckCli` for the nested arkgate TypeScript fallback.
+- **Deny→repair CI proof:** `tests/unit/static-check/writePathDetect.test.ts` drives
+  shipped `bin/ark-mcp.mjs --hook --hook-repair` and asserts `ARK_REPAIR_JSON` /
+  `ARK_AUTOPATCH_JSON` on deny (exit 2); reject-only without repair flag still supported.
+- **Dogfood write path repair:** local Claude/Grok hooks use `--hook-repair`; doctor
+  reports `writePath.mode = repair` on this tree.
+- **Self-hosted AGENTS.md:** `--install-agent-gates --force` no longer overwrites library
+  mother-repo Identity (`skipped-self-hosted`).
+- **hexagonal-order-api:** `safety.allowInMemory` for ephemeral demo kernel; prefer
+  `arkgate/runtime` imports; `npm run check` green under `--strict-config`.
+- **multi-app / monorepo rules:** deny App→Persistence, Presentation→Domain, and
+  Persistence→Presentation (parity with crud-product starter).
+- **Generated CI Node default lags local npm (again):** when a project had no
+  `.nvmrc` / `engines.node`, the Ark architecture gate workflow defaulted to
+  Node 22. Lockfiles written on Node 24/26 then failed `npm ci` with
+  "Missing: … from lock file" before `ark-check` ran — CI green, Ark red.
+  Detection order is now `.nvmrc` / `.node-version` → `engines.node` → **highest
+  `node-version` from sibling workflows** (excludes `ark-check.yml` so a stale
+  gate cannot re-pin itself) → default **24**. Refresh existing gates with
+  `ark-check --install-agent-gates --force` (or edit `node-version` in
+  `.github/workflows/ark-check.yml`).
+
+### Changed
+
+- **Hook templates extracted** to `bin/lib/hook-templates.mjs` (agent-gates seam).
+- **Write-path detect extracted** to `bin/lib/write-path-detect.mjs` (doctor W5; re-exported
+  from agent-gates).
+- **Coverage thresholds** raised to Q1 floors on the broad include set: statements/lines **≥80**,
+  branches/functions **≥85**, critical write/safety modules **≥95%** branch (see Fixed above).
+- **`/ark-explore` skill:** decision-grade recon — field path (run starters/checks),
+  installed hooks vs install templates, coupling via fan-in/exports (not LOC alone),
+  ranked “así te lo re-soluciono” rows only when residual changes action; ENFORCE /
+  empty plan treated as baseline, not the story. **v2.1:** output modes (recon vs
+  dual-plan seed, no multi-week roadmaps by default); path-correct vs design-correct
+  + semantic false-green; success signals and kill-switches on bets (anti-vanity).
+- **`/ark-autopilot` skill:** explore-first (decision-grade), **dual plan** —
+  A remediation from `--plan` + B pattern/evolution bets (never auto-apply B as
+  mechanical-safe); empty plan no longer means “healthy” without explore/B.
+- **Day-zero origin first:** `ark start` / `ark init` freeze `.ark/reports/origin.*`
+  immediately after `ark.config.json` exists and **before** agent docs, skills, and CI
+  templates. Later `--report` still shows evolution vs that snapshot.
+
+## 2.11.0 — 2026-07-10
+
+Fail-closed enforcement hardening: `--strict` now combines contract coverage, installed-gate
+checks, write-hook presence, and bypass diagnostics in one CI profile. The GitHub Action runs
+the exact checked-out revision by default, and runtime workflows cancel timed-out work
+cooperatively.
+
+### Added
+
+- **Strict CI profile:** `arkgate-check --strict` enables strict config validation, requires
+  generated gates plus a PreToolUse write hook, and fails on configured safety diagnostics.
+- **Bypass diagnostics:** new `dynamicImportAllowlist` and `safety` config fields detect
+  non-literal dynamic imports, TypeScript suppression directives, explicit `any` casts,
+  production InMemory defaults, and disabled or omitted peer isolation. `--doctor --json`
+  exposes the same evidence under `doctor.safety`.
+- **Release-quality CI:** JavaScript syntax validation, enforced coverage thresholds, and a
+  Node 18/20/22/24 compatibility matrix now run before merge.
+
+### Changed
+
+- **Pinned GitHub Action execution:** `uses: pedroknigge/arkgate@<tag-or-SHA>` now runs that
+  checked-out ArkGate source. The `version` input remains available only as an explicit exact
+  npm compatibility override.
+- **Complete MCP contract:** `ark://manifest` exposes every configured file layer separately
+  from runtime intent layers, plus reviewed dynamic-import and safety policy.
+- **Workflow cancellation contract:** workflow steps receive an `AbortSignal` as their third
+  argument. `timeoutMs` aborts that signal, clears the active step, and rejects duplicate step
+  names before execution can corrupt compensation order.
+- **Filesystem confinement:** source scans follow internal symlinks once and reject symlinks
+  that escape the project root.
+
+### Fixed
+
+- **Baseline duplicate honesty:** repeated violations now receive stable per-occurrence keys,
+  so adding a second identical violation is new debt instead of being hidden by one baseline
+  entry.
+- **Write-hook duplicate honesty:** proposed writes compare violation counts, preventing a new
+  duplicate from being mistaken for an already-existing violation.
+- **CLI argument safety:** unknown flags and missing flag values fail with usage guidance
+  instead of silently weakening enforcement or throwing an internal error.
+- **Action gate detection:** repositories using the ArkGate composite Action satisfy the CI
+  gate check without needing a separate literal `ark-check` command.
+
 ## 2.10.0 — 2026-07-10
 
 Track W — **Constrained write → verified repair**: write-boundary autoPatch, prepare_write,

package/README.md

@@ -23,8 +23,8 @@ and makes sure a “green” check means something real.
 If you remember nothing else:
 
 ```text
-1.  npx arkgate start          ← install shape + gates + origin report
-2.  /ark-autopilot             ← in your agent: adopt, fix, leave gates on
+1.  npx arkgate start          ← walk tree → contract → **day-zero origin** → gates
+2.  /ark-autopilot             ← explore first, dual plan, safe fixes, leave gates on
 3.  npx arkgate-check --doctor ← “where am I?” anytime (one status screen)
 ```
 
@@ -106,7 +106,7 @@ Full checklist (CI, MCP, Codex, imports): **[docs/migrate-from-ark-runtime-kerne
 
 ```bash
 npm install -D arkgate typescript
-npx arkgate start                 # setup + origin report
+npx arkgate start                 # contract → day-zero origin → gates + plan
 # in agent:
 #   /ark-autopilot
 npx arkgate-check --doctor        # status light + next action
@@ -117,11 +117,13 @@ Aliases `ark` / `ark-check` / `ark-mcp` still work. **npm / pnpm / yarn**. No in
 <details>
 <summary>What <code>/ark-autopilot</code> does under the hood (optional detail)</summary>
 
-1. Setup if needed (`ark start`).
-2. Origin architecture report (before picture in `.ark/reports/`).
-3. Adoption: match contract to real folders, raise governed %.
-4. Plan + safe auto-fixes; judgment when you ask for full apply.
-5. Gates on + after report (evolution vs origin).
+1. Setup if needed (`ark start` — contract, then **day-zero origin**, then gates).
+2. **Explore pass** (decision-grade map of *this* product; field path when demos exist).
+3. **Dual plan:** **A** remediation from `--plan` (mechanical-safe only by default); **B** pattern/evolution bets (never auto-applied as mechanical-safe). Empty plan ≠ “healthy” without explore/B.
+4. Apply A → re-check; judgment only when you ask for full apply.
+5. Gates on + latest report (evolution vs frozen origin).
+
+Standalone recon without applying: `/ark-explore`.
 
 </details>
 
@@ -188,8 +190,14 @@ ark.config.json
 - **Presets:** hexagonal, layered, feature-sliced, monorepo, ui-surface, vertical-slice, ddd-bounded-contexts (+ aliases clean-architecture / onion-architecture). Layers start optional; doctor suggests tightening populated cores. Cross-slice / cross-context bans use optional `peerIsolation` rules.
 - **Frameworks:** Nest / Next / express / library layouts get sensible globs on init so day-one coverage is real.
 - **Brownfield:** baseline ratchet, refuse to freeze a wrong contract, `/ark-adopt` for mature trees.
-- **Agents:** skills install into Claude / Cursor / Codex / Grok; `ark start` freezes an origin report under `.ark/reports/`.
+- **Agents:** skills install into Claude / Cursor / Codex / Grok; `ark start` freezes **day-zero origin** under `.ark/reports/` **before** agent docs/CI templates.
 - **Write protocol (2.10 / Track W):** mechanical-safe **autoPatch** on the write gate (`import type`); MCP **`ark_prepare_write`** (place + validate + patch + judgmentBrief); opt-in hook **`--hook-repair`** (`ARK_REPAIR_JSON`); doctor **`writePath`** (repair vs reject-only); loop-cost eval (`npm run eval:loop-cost`). Port-proof inject is **judgment** (arity change), not silent auto-apply.
+- **Fail-closed CI (2.11):** `--strict` combines config coverage, required CI/MCP/write gates,
+  PreToolUse hook presence, and bypass diagnostics for dynamic imports, TypeScript suppressions,
+  explicit `any` casts, InMemory runtime defaults, and disabled peer isolation.
+- **Trust / coverage (2.12):** package unit-test floors on the broad product surface
+  (statements/lines **≥80%**, branches/functions **≥85%**; enforcement-critical modules **≥95%**
+  branch). Explore dual-plan + day-zero origin first (see above). Roadmap next: Q2 repair dogfood matrix.
 - **TypeScript:** project compilers 5.x / 6.x / 7.x — gate falls back to a nested JS-API TypeScript when TS 7’s main export is version-only ([docs/typescript-support.md](docs/typescript-support.md)).
 
 ### Why not only ESLint / dependency-cruiser / Nx?
@@ -211,9 +219,10 @@ ark.config.json
 ## Common commands
 
 ```bash
-npx arkgate start                         # guided setup + plan + origin report
+npx arkgate start                         # guided setup: contract → origin → gates → plan
 npx arkgate-check --doctor                # health + Adoption gaps (not just fitness)
 npx arkgate-check --doctor --json         # machine-readable doctor.adoption
+npx arkgate-check --strict                # fail-closed CI + installed-gate/safety checks
 npx arkgate-check --plan                  # safe-to-auto-fix vs your call
 npx arkgate-check --coverage              # Governed: N%
 npx arkgate-check --report ark-report.html  # showcase HTML + Adoption card + origin/latest
@@ -224,8 +233,8 @@ npx arkgate upgrade                       # package + gates/skills + MCP/Codex n
 CI (example):
 
 ```yaml
-- run: npx arkgate-check --root . --config ark.config.json --strict-config
-# or: uses: pedroknigge/arkgate@main
+- run: npx arkgate-check --root . --config ark.config.json --strict
+# or: uses: pedroknigge/arkgate@<tag-or-SHA>  # runs that checked-out revision
 ```
 
 ---

package/SECURITY.md

@@ -28,10 +28,9 @@ a private security contact without including exploit details.
 ArkGate releases are GitHub-first:
 
 1. Changes land on GitHub and must pass CI plus the dedicated security workflow.
-2. A GitHub Release is created from an annotated `vX.Y.Z` tag. Tag verification is
-   **fail-closed** by default for unsigned tags unless
-   `ARK_ALLOW_UNSIGNED_RELEASE_TAG=true` is set (CI publish sets this until GPG signing is
-   wired). Signed tags can later require `ARK_REQUIRE_SIGNED_RELEASE_TAG=true`.
+2. A GitHub Release is created from a signed `vX.Y.Z` tag (`git tag -s`). The publish
+   workflow verifies the signature and fails closed for unsigned tags. The local override
+   exists only for explicit emergency use and is not enabled in CI.
 3. The manual `Publish npm` workflow verifies the tag, requires the GitHub Release to
    exist, reruns release checks, publishes npm with provenance, and uploads a SHA-256
    checksum for the npm tarball to the GitHub Release.

package/bin/ark-check.mjs

@@ -43,6 +43,7 @@ import {
   arkPackageVersion,
   REQUIRED_GATE_FILES,
   codexPromptsDir,
+  detectWritePathCapabilities,
 } from './lib/agent-gates.mjs';
 import { syncBaselineIntoCheckSurfaces } from './lib/field-install.mjs';
 import {
@@ -64,6 +65,7 @@ import {
 import { runRatchetCores } from './lib/core-ratchet.mjs';
 import {
   baselineKey,
+  baselineOccurrenceKeys,
   readBaseline,
   summarizeViolations,
   writeBaseline,
@@ -99,6 +101,7 @@ function parseArgs(argv) {
     printConfig: undefined,
     tsconfig: undefined,
     json: false,
+    strict: false,
     strictConfig: false,
     requireGates: false,
     init: false,
@@ -122,13 +125,25 @@ function parseArgs(argv) {
     version: false,
     help: false,
   };
+  const requireValue = (flag, index) => {
+    const value = argv[index + 1];
+    if (value === undefined || value.startsWith('-')) {
+      throw new Error(`Missing value for ${flag}. Run ark-check --help for usage.`);
+    }
+    return value;
+  };
   for (let i = 2; i < argv.length; i += 1) {
     const arg = argv[i];
     if (arg === '--json') args.json = true;
+    else if (arg === '--strict') {
+      args.strict = true;
+      args.strictConfig = true;
+      args.requireGates = true;
+    }
     else if (arg === '--strict-config') args.strictConfig = true;
     else if (arg === '--require-gates') args.requireGates = true;
     else if (arg === '--init') args.init = true;
-    else if (arg === '--preset') args.preset = argv[++i];
+    else if (arg === '--preset') args.preset = requireValue(arg, i++);
     else if (arg === '--install-agent-gates') args.installAgentGates = true;
     else if (arg === '--tools') {
       // Consume the next arg only when it isn't another flag (same rule as --baseline),
@@ -152,7 +167,7 @@ function parseArgs(argv) {
     else if (arg === '--recommend') args.recommend = true;
     else if (arg === '--write-plan') args.writePlan = true;
     else if (arg === '--list-policy-packs') args.listPolicyPacks = true;
-    else if (arg === '--apply-policy-pack') args.applyPolicyPack = argv[++i];
+    else if (arg === '--apply-policy-pack') args.applyPolicyPack = requireValue(arg, i++);
     else if (arg === '--suggest-include') args.suggestInclude = true;
     else if (arg === '--adopt-contract') args.adoptContract = true;
     else if (arg === '--ratchet-cores') args.ratchetCores = true;
@@ -174,13 +189,14 @@ function parseArgs(argv) {
       const next = argv[i + 1];
       args.baseline = next && !next.startsWith('-') ? argv[++i] : '.ark-baseline.json';
     }
-    else if (arg === '--root') args.root = path.resolve(argv[++i]);
-    else if (arg === '--config') args.config = argv[++i];
-    else if (arg === '--manifest') args.manifest = argv[++i];
-    else if (arg === '--print-config') args.printConfig = argv[++i];
-    else if (arg === '--tsconfig') args.tsconfig = argv[++i];
+    else if (arg === '--root') args.root = path.resolve(requireValue(arg, i++));
+    else if (arg === '--config') args.config = requireValue(arg, i++);
+    else if (arg === '--manifest') args.manifest = requireValue(arg, i++);
+    else if (arg === '--print-config') args.printConfig = requireValue(arg, i++);
+    else if (arg === '--tsconfig') args.tsconfig = requireValue(arg, i++);
     else if (arg === '--help' || arg === '-h') args.help = true;
     else if (arg === '--version' || arg === '-V') args.version = true;
+    else throw new Error(`Unknown argument: ${arg}. Run ark-check --help for usage.`);
   }
   return args;
 }
@@ -198,7 +214,7 @@ function usage() {
   return [
     'Usage: arkgate-check | ark-check  (identical bins; product name ArkGate)',
     '       ark-check --version',
-    '       ark-check --root <project> --config <ark.config.json> [--manifest <ark.manifest.json>] [--tsconfig <tsconfig.json>] [--strict-config] [--require-gates] [--json] [--baseline [file]] [--report [file.html]] [--no-cache]',
+    '       ark-check --root <project> --config <ark.config.json> [--manifest <ark.manifest.json>] [--tsconfig <tsconfig.json>] [--strict | --strict-config] [--require-gates] [--json] [--baseline [file]] [--report [file.html]] [--no-cache]',
     '       ark-check --coverage [--json]          per-layer file counts + full unclassified list (report only, exit 0)',
     '       ark-check --plan [--json]              classified remediation plan (mechanical-safe / judgment / deferred) + goal; report only',
     '       ark-check --recommend [--json] [--write-plan]  application-shape plan; --write-plan emits ark-adoption-plan.json',
@@ -251,6 +267,8 @@ function usage() {
     '',
     'Config warnings are advisory by default and are included in JSON output.',
     'Use --strict-config to make config warnings fail the check.',
+    'Use --strict for the fail-closed CI profile: --strict-config + --require-gates',
+    'plus the security diagnostics surfaced by doctor.',
     '',
     '--require-gates fails the check when AGENTS.md, .mcp.json, or the generated CI',
     'workflow is missing, so "installed but never configured" is a red CI. Combine it',
@@ -301,6 +319,10 @@ function readConfig(root, configPath) {
     ...(raw.exclude ? { exclude: raw.exclude } : {}),
     ...(raw.excludeGenerated !== undefined ? { excludeGenerated: raw.excludeGenerated } : {}),
     ...(raw.cyclePolicy ? { cyclePolicy: raw.cyclePolicy } : {}),
+    ...(raw.dynamicImportAllowlist
+      ? { dynamicImportAllowlist: raw.dynamicImportAllowlist }
+      : {}),
+    ...(raw.safety ? { safety: raw.safety } : {}),
   };
 }
 
@@ -316,7 +338,7 @@ function detectConfig(root) {
 
   for (const entry of DEFAULT_INTENT_PREFIXES) {
     const directories = (DEFAULT_LAYER_DIRECTORIES[entry.layer] ?? []).filter(
-      (directory) => walk(path.join(root, srcDir, directory)).length > 0
+      (directory) => walk(path.join(root, srcDir, directory), [], { root }).length > 0
     );
     if (directories.length === 0) continue;
     layers.push({
@@ -784,7 +806,7 @@ function runInit(args) {
     }
     // The starter profile only governs src/. Existing source elsewhere would make the
     // gate silently green, so surface it instead of pretending the project is covered.
-    const outside = walk(args.root)
+    const outside = walk(args.root, [], { root: args.root })
       .map((file) => normalize(path.relative(args.root, file)))
       .filter((rel) => !rel.startsWith('src/') && !rel.split('/').some((s) => s.startsWith('.')));
     if (outside.length > 0) {
@@ -956,6 +978,9 @@ async function main() {
 
   if (args.requireGates) {
     const missing = missingGates(args.root);
+    if (args.strict && !detectWritePathCapabilities(args.root).hookPresent) {
+      missing.push('PreToolUse write hook');
+    }
     if (missing.length > 0) {
       const payload = {
         ok: false,
@@ -1032,7 +1057,7 @@ async function main() {
     );
   }
 
-  const { violations, warnings } = runArchitectureScan({
+  const { violations, warnings, safety } = runArchitectureScan({
     root,
     config,
     manifest,
@@ -1046,6 +1071,7 @@ async function main() {
     runDoctor(root, config, files, rules, violations, args.json, {
       configPath: path.isAbsolute(args.config) ? args.config : path.join(root, args.config),
       configMissing: !fs.existsSync(path.isAbsolute(args.config) ? args.config : path.join(root, args.config)),
+      safety,
     });
     return;
   }
@@ -1118,11 +1144,10 @@ async function main() {
   if (args.baseline) {
     const baseline = readBaseline(root, args.baseline);
     if (baseline.exists) {
-      suppressed = violations.filter((violation) => baseline.keys.has(baselineKey(violation)));
-      activeViolations = violations.filter(
-        (violation) => !baseline.keys.has(baselineKey(violation))
-      );
-      const currentKeys = new Set(violations.map(baselineKey));
+      const occurrenceKeys = baselineOccurrenceKeys(violations);
+      suppressed = violations.filter((_, index) => baseline.keys.has(occurrenceKeys[index]));
+      activeViolations = violations.filter((_, index) => !baseline.keys.has(occurrenceKeys[index]));
+      const currentKeys = new Set(occurrenceKeys);
       staleBaselineKeys = [...baseline.keys].filter((key) => !currentKeys.has(key)).length;
     } else {
       warnings.push(

package/bin/ark-mcp.mjs

@@ -48,6 +48,7 @@ import {
   DEFAULT_LAYER_DIRECTORIES,
   DEFAULT_RULES,
   arkCommand,
+  globToRegExp,
   layerForFile,
   shouldShowNewHereNudge,
   detectWorkspaces,
@@ -273,18 +274,23 @@ function runHook(gate, config, args, ts) {
   // line numbers (edits shift them); simpler than full baselineKey (no file/layer fields
   // needed — this file is fixed).
   const violationKey = (violation) => `${violation.ruleId}|${violation.target ?? violation.message}`;
-  let existingKeys = new Set();
+  let existingCounts = new Map();
   try {
     const current = fs.readFileSync(filePath, 'utf8');
-    existingKeys = new Set(
-      gate.validate(current, { layer, filePath }).violations.map(violationKey)
-    );
+    for (const violation of gate.validate(current, { layer, filePath }).violations) {
+      const key = violationKey(violation);
+      existingCounts.set(key, (existingCounts.get(key) ?? 0) + 1);
+    }
   } catch {
     // New file: nothing pre-exists, every violation is new.
   }
-  const newViolations = (result.violations ?? []).filter(
-    (violation) => !existingKeys.has(violationKey(violation))
-  );
+  const newViolations = (result.violations ?? []).filter((violation) => {
+    const key = violationKey(violation);
+    const remaining = existingCounts.get(key) ?? 0;
+    if (remaining === 0) return true;
+    existingCounts.set(key, remaining - 1);
+    return false;
+  });
   if (newViolations.length === 0) return;
 
   const lines = newViolations.map(
@@ -368,8 +374,14 @@ function runArkCheckJsonFromRoot(root, config, extraArgs, manifest) {
   const result = spawnSync(
     process.execPath,
     [arkCheckBin, '--root', root, '--config', config, ...manifestArgs, '--json', ...extraArgs],
-    { encoding: 'utf8' }
+    { encoding: 'utf8', timeout: 120_000, maxBuffer: 20 * 1024 * 1024 }
   );
+  if (result.error) {
+    return {
+      data: null,
+      raw: `ark-check failed to execute: ${result.error.message}`,
+    };
+  }
   const stdout = result.stdout ?? '';
   try {
     return { data: JSON.parse(stdout), raw: stdout };
@@ -544,6 +556,18 @@ async function main() {
       name: layer.name,
       patterns: layer.patterns,
     })),
+    allowNonLiteralDynamicImport: (filePath) => {
+      if (!filePath || !Array.isArray(config.dynamicImportAllowlist)) return false;
+      const rel = path.relative(args.root, path.resolve(args.root, filePath)).split(path.sep).join('/');
+      return config.dynamicImportAllowlist.some((pattern) => {
+        if (typeof pattern !== 'string') return false;
+        try {
+          return globToRegExp(pattern).test(rel);
+        } catch {
+          return false;
+        }
+      });
+    },
   });
 
   if (args.hook) {
@@ -706,7 +730,10 @@ async function main() {
   // DomainModel there would tell the agent to create a second layer for the same
   // prefix, making longest-prefix resolution ambiguous.
   function suggestedLayers() {
-    const activeNames = new Set(profile.layers.map((layer) => layer.name));
+    const activeNames = new Set([
+      ...configLayers.map((layer) => layer.name),
+      ...profile.layers.map((layer) => layer.name),
+    ]);
     const claimedPrefixes = new Set(
       profile.layers.flatMap((layer) =>
         (layer.prefixes ?? []).map((p) => (p.endsWith('.') ? p : `${p}.`))
@@ -732,13 +759,30 @@ async function main() {
       );
     }
     const suggestions = suggestedLayers();
+    const contractLayers = usedProjectConfig
+      ? configLayers.map((layer) => ({
+          ...layer,
+          prefixes: Array.isArray(layer.intentPrefixes) ? layer.intentPrefixes : [],
+        }))
+      : profile.layers;
     return JSON.stringify(
       {
         source: profile === ark.elevenLayerProfile ? 'strictDefaultElevenLayerProfile' : 'project',
         name: profile.name,
-        layers: profile.layers,
+        // File placement contract: every configured layer, including layers that do not
+        // own intent prefixes (e.g. Tooling / FrameworkAdapters).
+        layers: contractLayers,
+        // Runtime/intent resolution profile kept explicit so consumers never have to infer
+        // why a prefix-less file layer is absent from intent resolution.
+        intentLayers: profile.layers,
         rules: profile.rules,
         ...(Object.keys(forbiddenGlobals).length > 0 ? { forbiddenGlobals } : {}),
+        ...(Array.isArray(config.dynamicImportAllowlist)
+          ? { dynamicImportAllowlist: config.dynamicImportAllowlist }
+          : {}),
+        ...(config.safety && typeof config.safety === 'object'
+          ? { safety: config.safety }
+          : {}),
         ...(suggestions.length > 0
           ? {
               suggestedLayers: suggestions,