diff --git a/‎docs/dependency-graph-findings.md‎
Lines changed: 10 additions & 2 deletions b/‎docs/dependency-graph-findings.md‎
Lines changed: 10 additions & 2 deletions
diff --git a/‎scripts/layering/check.ts‎
Lines changed: 25 additions & 8 deletions b/‎scripts/layering/check.ts‎
Lines changed: 25 additions & 8 deletions
diff --git a/‎scripts/layering/model.test.ts‎
Lines changed: 4 additions & 5 deletions b/‎scripts/layering/model.test.ts‎
Lines changed: 4 additions & 5 deletions
diff --git a/‎scripts/layering/model.ts‎
Lines changed: 18 additions & 17 deletions b/‎scripts/layering/model.ts‎
Lines changed: 18 additions & 17 deletions
diff --git a/‎scripts/layering/root-module-zones.test.ts‎
Lines changed: 86 additions & 0 deletions b/‎scripts/layering/root-module-zones.test.ts‎
Lines changed: 86 additions & 0 deletions
@@ -74,8 +74,8 @@ type-only inversions, R7 pins SessionState field ownership, and the shared selec
   (`daemon/interaction/internal/interaction-common.ts`, step 3) and the recorder boundary
   (`session-action-recorder.ts`, step 4). The two-pass structure is two call sites, not a scattered
   concern.
-- Still outside every rule: **dynamic** import direction (0 inversions today, nothing watching),
-  and anything inside a zone.
+- Still outside every rule: **dynamic** import direction, out of scope by decision with the reason
+  recorded at R5 in `scripts/layering/check.ts` (#3280), and anything inside a zone.
 
 ## 0. Where the inversions ended up (and why 5 is the floor for now)
 
@@ -263,6 +263,14 @@ moving `DaemonRequest` is most of what §1's second cluster needs.
 
 ## 3. `(root)`: what is left is there for a reason
 
+> **Status after #3280:** the section below is historical. Every root module now declares its zone
+> in `scripts/layering/root-module-zones.ts`, `(root)` ranks above the spine and holds only
+> `bin.ts`, `cli.ts` and `daemon.ts`, and R80 asserts that the zone graph of static value imports is
+> acyclic. Ranking the composition roots did not weaken R2: it still rejects a direct `daemon/` ->
+> `commands/` import, and the daemon reaches the command surface through the ranked
+> `command-runtime` zone, which the zone graph now shows instead of hiding. The SDK entries rank
+> above `daemon-client`, because the typed client they publish reaches the daemon through it.
+
 13 files: 11 published `package.json` entrypoints, the three executables (`bin.ts`, `cli.ts`,
 `daemon.ts`), and the composition roots — `runtime.ts`, `agent-device-client.ts`,
 `provider-device-runtime.ts`, `command-catalog.ts`.
 
@@ -3,10 +3,12 @@
 //
 // Ranked target spine, as rank groups lowest to highest. `A ◄ B` means B may not
 // be outranked by A (the back-edge order the gate rejects), NOT that every displayed import exists:
-//   { contracts, request, selectors } ◄ core ◄ commands
-//         ◄ { client, daemon-server } ◄ daemon-client ◄ cli
-// (authoritative ranks: `TARGET_DAG_RANK` in model.ts. The former rank-0 kernel
-// zone lives in packages/kernel since #1490 W0; R11 owns its boundary.)
+//   { contracts, selectors, ... } ◄ { core, daemon-contracts } ◄ { commands, command-runtime }
+//         ◄ { client, daemon-server, platform-runtime, ... }
+//         ◄ { daemon-client, platform-runtime-host } ◄ { sdk, ai-sdk } ◄ cli ◄ (root)
+// (authoritative ranks: `TARGET_DAG_RANK` in model.ts; root modules declare their zone in
+// root-module-zones.ts. The former rank-0 kernel zone lives in packages/kernel since #1490 W0;
+// R11 owns its boundary.)
 // `commands/schema/` renders the rest of commands/'s facets and reads them; commands never
 // imports it back (#2543). It shares the commands zone (#2679 folded the standalone
 // cli-schema zone into it), so the ranked spine and the R2 zone-policy table cannot see the
@@ -22,6 +24,8 @@
 //   - Over the RANKED SPINE only: rejection of every spine back-edge (R5), i.e.
 //     an import whose source zone outranks its target zone, plus a ratchet on the
 //     same inversion measured over TYPE-ONLY edges (R6).
+//   - Over the ZONE GRAPH: static value imports between zones form no cycle (R80), which R5
+//     cannot see between two zones of the same rank.
 //   - Over the DAEMON and its capture-admission adapters: SessionState field ownership (R7), because the session
 //     record is store-owned mutable state that any daemon module can write; and the terminal
 //     concrete-platform boundary (R65), which rejects every import form into the retired
@@ -52,9 +56,9 @@
 // R6, R9, and the R10 R7 counts are ratchets with no written-down reference: each is the same
 // measurement taken over the merge-base with origin/main (`ratchet-reference.ts`), so growth
 // fails, a shrink needs no edit, and no change can bank headroom.
-// `(root)` holds entrypoints and composition roots. The retired `src/utils` zone is deliberately
-// outside the spine and is rejected separately by R14; extracted workspace package zones are
-// classified separately and held behind R11 instead of the src folder spine.
+// `(root)` holds the executables and ranks above the spine. The retired `src/utils` zone is
+// deliberately outside the spine and is rejected separately by R14; extracted workspace package
+// zones are classified separately and held behind R11 instead of the src folder spine.
 
 import { execFileSync } from 'node:child_process';
 import fs from 'node:fs';
@@ -79,6 +83,7 @@ import {
   type ResolvedImportEdge,
 } from './model.ts';
 import { checkTypeInversions } from './type-inversion-ratchet.ts';
+import { checkZoneValueDag } from './zone-value-dag.ts';
 import {
   measureRatchets,
   mergeBaseRatchets,
@@ -237,6 +242,15 @@ function checkRecordRuntimeOwnership(sources: ReadonlyMap<string, string>): Laye
  *   import direction no longer matters. Splitting zones into packages would not replace it: the
  *   A4 spike found an undeclared workspace package still resolves through root node_modules and
  *   a relative tunnel into another package's src still compiles.
+ * Scope: static value imports. Dynamic imports are out of scope for R5 and R80 by decision
+ *   (#3280). An `import()` target never joins the importer's eager closure, so a lazy edge cannot
+ *   cost what a value back-edge costs, and the code places lazy seams exactly where a module
+ *   defers one ranked above it or one that depends back on it: `cli/process-entry.ts` loads
+ *   `cli.ts`, the MCP tools load the typed client, the daemon's provider registry loads the
+ *   Limrun runtime from `src/sdk/`, and the platform runtime loads its operation host
+ *   (`loadHost`), which reads daemon session artifacts. Ranking them would reject that pattern
+ *   rather than a mistake; what a lazy edge may load is owned by R13's laziness policy and the
+ *   eager-closure budgets.
  */
 function checkBackEdges(edges: readonly ResolvedImportEdge[]): LayeringViolation[] {
   const seen = new Set<string>();
@@ -398,7 +412,8 @@ function report(
     process.stdout.write(
       `Layering guard: OK — ${files.length} source files satisfy R2 and contain no ` +
         `value-import cycles (both checked globally); the ranked target spine contains no ` +
-        `back-edges; the ranked spine's type-only inversions hold at or under the merge-base ` +
+        `back-edges and the zone graph no value-import cycle (R80); the ranked spine's ` +
+        `type-only inversions hold at or under the merge-base ` +
         `${reference.ref.slice(0, 10)} per zone pair (R6, ${inversions} remaining); ` +
         `${RETIRED_PATH_RULES.R14.rule} permits no tracked paths under retired src/utils; ` +
         `all ${sessionStateFieldCount()} SessionState fields are classified and every write is ` +
@@ -473,6 +488,7 @@ export const LAYERING_RULE_IDS = [
   'substrate-domain-shape',
   'selector-pipeline-ownership',
   'back-edges',
+  'zone-value-dag',
   'type-spine-inversions',
   'session-state-ownership',
   'daemon-modularity-ratchets',
@@ -514,6 +530,7 @@ export const LAYERING_RULES: Readonly<Record<LayeringRuleId, LayeringRule>> = {
   'selector-pipeline-ownership': (context) =>
     selectorPipelineOwnershipViolations(context.edges, workspaceSpecifierTargets(repoRoot)),
   'back-edges': (context) => checkBackEdges(context.edges),
+  'zone-value-dag': (context) => checkZoneValueDag(context.edges),
   'type-spine-inversions': (context) =>
     checkTypeInversions(context.edges, context.reference.typeInversions),
   'session-state-ownership': (context) => checkSessionStateOwnership(context.sources),
 
@@ -285,12 +285,11 @@ test('ranked and unranked zones are disjoint and both non-empty', () => {
 test('classifyZone separates the ranked spine from intentionally-unranked zones', () => {
   assert.equal(classifyZone('contracts'), 'ranked');
   assert.equal(classifyZone('daemon-server'), 'ranked');
-  assert.equal(classifyZone('(root)'), 'unranked');
-  assert.equal(classifyZone('platform-runtime'), 'unranked');
   assert.equal(classifyZone('platforms'), 'unclassified');
   assert.equal(classifyZone('utils'), 'unclassified');
-  // Every satellite zone joined the spine; only the composition root stays out, because R2
-  // forbids daemon/ from importing commands/ so the files that wire them cannot be ranked.
+  // Every src/ zone is on the spine, `(root)` and the zones root modules declare included.
+  assert.equal(classifyZone('(root)'), 'ranked');
+  assert.equal(classifyZone('platform-runtime'), 'ranked');
   assert.equal(classifyZone('mcp'), 'ranked');
   assert.equal(classifyZone('screenshot-diff'), 'ranked');
   // A zone that is neither ranked nor listed peripheral must be flagged, never
@@ -302,7 +301,7 @@ test('every production zone is deliberately classified as ranked or unranked', (
   // Drift guard: a new src/<folder>/ (or a daemon-client/server split) forces a
   // deliberate ranked-vs-peripheral decision here instead of silently escaping
   // spine back-edge detection. If this fails, add the new zone to TARGET_DAG_RANK
-  // (ranked spine) or UNRANKED_ZONES (root/peripheral) in model.ts.
+  // (ranked spine) or UNRANKED_ZONES (peripheral) in model.ts.
   const productionFiles = listSourceFiles();
   assert.deepEqual(unclassifiedZones(productionFiles), []);
 
 
@@ -2,6 +2,7 @@ import path from 'node:path';
 import { PLATFORMS } from '@agent-device/kernel/device';
 import { parseSync } from 'oxc-parser';
 import { destructuredDynamicImportBindings, visitAst } from './layering-ast.ts';
+import { declaredRootModuleZone } from './root-module-zones.ts';
 
 export type ImportEdge = {
   spec: string;
@@ -56,17 +57,23 @@ const TARGET_DAG_RANK = new Map([
   ['selectors', 1],
   ['session-journal', 1],
   ['core', 2],
+  ['daemon-contracts', 2],
+  ['command-runtime', 3],
   ['commands', 3],
   ['mcp', 3],
-  ['ai-sdk', 4],
   ['client', 4],
   ['daemon-server', 4],
   ['metro', 4],
+  ['platform-runtime', 4],
   ['remote', 4],
-  ['sdk', 4],
   ['plugins', 4],
   ['daemon-client', 5],
-  ['cli', 6],
+  ['platform-runtime-host', 5],
+  // The SDK entries publish the typed client, which reaches the daemon through daemon-client.
+  ['ai-sdk', 6],
+  ['sdk', 6],
+  ['cli', 7],
+  ['(root)', 8],
 ]);
 
 export const RANKED_ZONES: ReadonlySet<string> = new Set(TARGET_DAG_RANK.keys());
@@ -81,25 +88,19 @@ export function zoneRank(zone: string): number | null {
 }
 
 // Zones deliberately left OUT of the src folder spine. They are NOT unenforced:
-// every file remains under the global value-cycle rule (R4). `(root)` composes
-// the spine from above; extracted package zones are held by R11 package exports
-// and the no-root-back-import rule instead of their former src folder rank.
+// every file remains under the global value-cycle rule (R4) and the zone-level value DAG
+// (R80). Extracted package zones are held by R11 package exports and the no-root-back-import
+// rule instead of a src folder rank.
 //
-// The satellite zones used to be listed here too, on the grounds that ranking them would
-// invent an order the architecture had not committed to. Once `(root)` was emptied of shared
-// contracts, every one of them turned out to have a consistent rank already — so the order was
-// there, just unasserted. The former `utils` zone was retired into owning modules and packages.
-// Extracted workspace packages are not src/ zones: R11 owns their physical seams, and their zone
-// names only appear in workspace-aware graphs. The platform packages additionally carry R13's
+// Every other src/ zone is ranked, `(root)` included: root modules declare their zone in
+// `root-module-zones.ts`, and `(root)` ranks above the spine. Extracted workspace packages are
+// not src/ zones: R11 owns their physical seams, and their zone names only appear in
+// workspace-aware graphs. The platform packages additionally carry R13's
 // exact-family/composition/laziness policy.
 export const UNRANKED_ZONES: ReadonlySet<string> = new Set([
-  '(root)',
   // Stand-ins the bundler resolves in place of a dependency it deliberately omits. Nothing in
   // the production graph imports them, so ranking them would claim an edge the alias replaces.
   'vendor',
-  // Private implementation submodules of the canonical root composition. R13 owns their exact
-  // importer and concrete-platform authority; giving them a spine rank would duplicate that seam.
-  'platform-runtime',
   'kernel',
   'host-kit',
   'capture-kit',
@@ -293,7 +294,7 @@ export function targetDagZone(file: string): string {
   // #2342 relocated the daemon client to its own `src/daemon-client/` folder, so the
   // client zone now falls out of the folder itself; `src/daemon/` is server-only.
   if (file.startsWith('src/daemon/')) return 'daemon-server';
-  return topFolder(file);
+  return declaredRootModuleZone(file) ?? topFolder(file);
 }
 
 // The set of zones every production file resolves into. A zone that is neither ranked
 
@@ -0,0 +1,86 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { listSourceFiles } from './check.ts';
+import { collectBackEdges, RANKED_ZONES, resolveImportEdges, zoneRank } from './model.ts';
+import { rootModuleZoneDrift } from './root-module-zones.ts';
+
+test('every root module is declared in exactly one zone, and every declaration names a module', () => {
+  assert.deepEqual(
+    rootModuleZoneDrift(listSourceFiles()),
+    { undeclared: [], stale: [], duplicated: [] },
+    'declare each src/*.ts module in exactly one zone of ROOT_MODULE_ZONES (root-module-zones.ts)',
+  );
+});
+
+test('drift names a root module with no declared zone and a declaration with no module', () => {
+  const drift = rootModuleZoneDrift(['src/bin.ts', 'src/new-helper.ts', 'src/cli/new-helper.ts']);
+  assert.deepEqual(drift.undeclared, ['src/new-helper.ts']);
+  assert.ok(drift.stale.includes('src/daemon.ts'));
+  assert.ok(!drift.stale.includes('src/bin.ts'));
+});
+
+test('(root) ranks above every other zone', () => {
+  const root = zoneRank('(root)')!;
+  for (const zone of RANKED_ZONES) {
+    if (zone !== '(root)') assert.ok(zoneRank(zone)! < root, `${zone} must rank below (root)`);
+  }
+});
+
+test('R5 ranks a root module by its declared zone, so no lower zone reaches the daemon client through it', () => {
+  const edges = resolveImportEdges(
+    new Map([
+      ['src/sdk/index.ts', "export { createAgentDeviceClient } from '../agent-device-client.ts';"],
+      [
+        'src/ai-sdk/index.ts',
+        "import { createAgentDeviceClient } from '../agent-device-client.ts';",
+      ],
+      [
+        'src/client/lease.ts',
+        "import { createAgentDeviceClient } from '../agent-device-client.ts';",
+      ],
+      [
+        'src/agent-device-client.ts',
+        "import { createRequestGuard } from './daemon-client/daemon-client-transport.ts';",
+      ],
+      ['src/daemon-client/daemon-client-transport.ts', 'export const createRequestGuard = 1;'],
+    ]),
+  );
+
+  // The published SDK entries rank above the typed client they publish; the client zone does not.
+  assert.deepEqual(collectBackEdges(edges), {
+    'client -> daemon-client': ['src/client/lease.ts -> src/agent-device-client.ts'],
+  });
+});
+
+test('the platform runtime reaches its operation host only through import()', () => {
+  const edges = resolveImportEdges(
+    new Map([
+      ['src/platform-runtime.ts', "void import('./platform-runtime-operation-host.ts');"],
+      [
+        'src/platform-runtime-daemon-lifecycle.ts',
+        "import './platform-runtime-operation-host.ts';",
+      ],
+      ['src/platform-runtime-operation-host.ts', "import './daemon/app-log-files.ts';"],
+      ['src/daemon/app-log-files.ts', 'export const appLog = 1;'],
+    ]),
+  );
+
+  assert.deepEqual(collectBackEdges(edges), {
+    'platform-runtime -> platform-runtime-host': [
+      'src/platform-runtime-daemon-lifecycle.ts -> src/platform-runtime-operation-host.ts',
+    ],
+  });
+});
+
+test('an undeclared root module is (root), so a ranked import of it is a back-edge', () => {
+  const edges = resolveImportEdges(
+    new Map([
+      ['src/commands/surface.ts', "import { shared } from '../new-helper.ts';"],
+      ['src/new-helper.ts', 'export const shared = 1;'],
+    ]),
+  );
+
+  assert.deepEqual(collectBackEdges(edges), {
+    'commands -> (root)': ['src/commands/surface.ts -> src/new-helper.ts'],
+  });
+});