@@ -17,13 +17,29 @@ pnpm depgraph affected packages/host-kit/src/command.ts # bounded text
 pnpm depgraph affected packages/daemon/src/core/ref-frame.ts --json --limit 25
 ```
 
-Reverse reachability over the value-edge graph, plus the three lookups that used to follow it:
+Reverse reachability over the value-edge graph, plus the lookups that used to follow it:
 the `scripts/check-affected/` gate plan for the dependent set, the public commands whose handler
 chain reaches the file (value + dynamic edges, because handlers load through `import()`) with
 their owning live iOS scenarios when that manifest is in the tree, and the ADR 0011
 guarantee-matrix cells the file implements. See docs/agents/testing.md § "Before editing a shared
 module".
 
+Two fields keep an empty or short list from reading as "nothing else is affected":
+
+- `executableDependents` is a second reverse reachability over value + dynamic edges.
+  `dependents` keeps its value-only meaning; `beyondValue` lists the files that only a dynamic
+  import connects. Type-only edges stay out of both.
+- `commandAttribution` qualifies `commands` and `liveOwners`. `static-reachability` means the
+  lists come from import edges alone. `partial` (`injected-runtime`) means the file is reachable
+  from the root platform-runtime composition family (`src/platform-runtime*.ts`, the R76
+  declaration). Daemon code cannot import that family (R65, R76) and reaches platform code through
+  the injected gateway, so no import edge records which command drives it. The lists are then a
+  lower bound.
+
+Both are reachability, not removability and not coverage. `static-reachability` is not a
+completeness claim, and `partial` does not name the missing commands. `gates` is unchanged and
+still selected from the value dependents.
+
 ## When to reach for this
 
 It pays for itself on three questions, and misleads on a fourth.
 
@@ -30,12 +30,15 @@ import { selectChecks, type CheckPlan } from '../check-affected/model.ts';
 import {
   bound,
   collectDependents,
+  collectExecutableDependents,
+  commandAttribution,
   commandsReaching,
   formatBounded,
   guaranteeRowsForFile,
   rankByFanIn,
   weakDirectDependents,
   zoneBreakdown,
+  type CommandAttribution,
   type CommandChain,
   type GuaranteeRow,
 } from './affected.ts';
@@ -75,6 +78,10 @@ export type BlastRadius = {
     /** Direct importers over the excluded edge kinds — reported, never mixed into the counts. */
     weakDirect: { type: number; dynamic: number };
   };
+  /** Reverse reachability over value + dynamic edges; `beyondValue` is the part dynamic imports add. */
+  executableDependents: { direct: string[]; transitive: string[]; beyondValue: string[] };
+  /** How far `commands` and `liveOwners` can be trusted; applies to both. */
+  commandAttribution: CommandAttribution;
   gates: { checks: string[]; failOpen: boolean };
   commands: CommandChain[];
   liveOwners: { manifest: string; present: boolean; owners: LiveOwner[] };
@@ -219,6 +226,7 @@ export async function computeBlastRadius(repoRoot: string, target: string): Prom
   }
 
   const dependents = collectDependents(target, graph.edges);
+  const executable = collectExecutableDependents(target, graph.edges);
   const plan: CheckPlan = selectChecks({ changedFiles: [target, ...dependents.all] });
   const commands = commandsReaching(target, commandChains(repoRoot), graph.edges);
   const live = await loadLiveOwners(repoRoot, commands);
@@ -235,6 +243,12 @@ export async function computeBlastRadius(repoRoot: string, target: string): Prom
       topByFanIn: rankByFanIn(dependents.all, nodes),
       weakDirect: weakDirectDependents(target, graph.edges),
     },
+    executableDependents: {
+      direct: executable.direct,
+      transitive: executable.transitiveOnly,
+      beyondValue: executable.beyondValue,
+    },
+    commandAttribution: commandAttribution(target, executable.all),
     gates: { checks: plan.checks, failOpen: plan.failOpen },
     commands,
     liveOwners: { manifest: LIVE_COVERAGE_MANIFEST, present: live.present, owners: live.owners },
@@ -244,26 +258,35 @@ export async function computeBlastRadius(repoRoot: string, target: string): Prom
 
 /** Bounded text form — the shape an agent reads before spending its context on the edit. */
 export function formatBlastRadius(radius: BlastRadius, limit: number): string {
-  const { dependents } = radius;
+  const { dependents, executableDependents, commandAttribution: attribution } = radius;
+  const partial = attribution.kind === 'partial';
   const lines = [
     `blast radius: ${radius.file}  [zone ${radius.zone}, fan-in ${radius.fanIn}, fan-out ${radius.fanOut}]`,
     `dependents: ${dependents.direct.length} direct, ${dependents.transitive.length} transitive (value edges; ` +
       `${dependents.weakDirect.type} type-only and ${dependents.weakDirect.dynamic} dynamic direct importers not counted)`,
     `  by zone: ${formatBounded(bound(dependents.byZone, limit), (entry) => `${entry.zone} ${entry.count}`)}`,
     `  direct:  ${formatBounded(bound(dependents.direct, limit), (file) => file)}`,
     `  widest:  ${formatBounded(bound(dependents.topByFanIn, limit), (entry) => `${entry.file} (fan-in ${entry.fanIn})`)}`,
+    `executable dependents (value + dynamic edges): ${executableDependents.direct.length} direct, ${executableDependents.transitive.length} transitive; ` +
+      `${executableDependents.beyondValue.length} reached only across a dynamic import: ` +
+      formatBounded(bound(executableDependents.beyondValue, limit), (file) => file),
     `gates for this set${radius.gates.failOpen ? ' (fail-open: full set)' : ''}: ${radius.gates.checks.join(', ') || '(none)'}`,
     `  run: pnpm check:affected --run`,
     `public commands whose handler chain reaches it (${radius.commands.length}): ` +
       formatBounded(bound(radius.commands, limit), (chain) => `${chain.command} (${chain.route})`),
+    attribution.kind === 'partial'
+      ? `  attribution: PARTIAL (injected runtime) — reachable from ${formatBounded(bound(attribution.compositionRoots, limit), (file) => file)}; platform code runs behind the injected gateway, which no import edge records, so the command and live-owner lists are a lower bound`
+      : '  attribution: static import reachability only — an empty list means no handler chain imports this file, not that no command work depends on it',
   ];
 
   if (!radius.liveOwners.present) {
     lines.push(
       `live scenario owners: ${radius.liveOwners.manifest} is not in this tree (lands with the iOS simulator e2e manifest) — no live claim available`,
     );
   } else {
-    lines.push(`live scenario owners (${radius.liveOwners.owners.length}):`);
+    lines.push(
+      `live scenario owners (${radius.liveOwners.owners.length}${partial ? ', lower bound' : ''}):`,
+    );
     for (const owner of bound(radius.liveOwners.owners, limit).shown) {
       lines.push(`  ${owner.command} [${owner.level}] ${owner.owner} — ${owner.assertion}`);
     }
 
@@ -8,6 +8,8 @@ import { resolveImportEdges } from '../layering/model.ts';
 import {
   bound,
   collectDependents,
+  collectExecutableDependents,
+  commandAttribution,
   commandsReaching,
   formatBounded,
   guaranteeRowsForFile,
@@ -23,6 +25,7 @@ import {
   parseRouteEntries,
 } from './affected-run.ts';
 import { collapseEdges, type GraphNode } from './model.ts';
+import type { BlastRadius } from './affected-run.ts';
 
 const repoRoot = execFileSync('git', ['rev-parse', '--show-toplevel'], {
   encoding: 'utf8',
@@ -67,6 +70,50 @@ test('collectDependents ignores type-only and dynamic dependents, which are coun
   assert.deepEqual(weakDirectDependents('src/core/target.ts', edges), { type: 1, dynamic: 1 });
 });
 
+test('collectExecutableDependents reports what a dynamic import adds beyond value dependents', () => {
+  const edges = edgesOf({
+    'src/core/target.ts': 'export const t = 1;',
+    'src/core/mid.ts': "import { t } from './target.ts';\nexport const m = t;",
+    'src/core/lazy.ts': "export const load = () => import('./mid.ts');",
+    'src/core/lazier.ts': "export const load = () => import('./lazy.ts');",
+    'src/core/typed.ts': "import type { t } from './target.ts';\nexport type U = typeof t;",
+  });
+
+  assert.deepEqual(collectDependents('src/core/target.ts', edges).all, ['src/core/mid.ts']);
+  assert.deepEqual(collectExecutableDependents('src/core/target.ts', edges), {
+    direct: ['src/core/mid.ts'],
+    all: ['src/core/lazier.ts', 'src/core/lazy.ts', 'src/core/mid.ts'],
+    transitiveOnly: ['src/core/lazier.ts', 'src/core/lazy.ts'],
+    beyondValue: ['src/core/lazier.ts', 'src/core/lazy.ts'],
+  });
+});
+
+test('commandAttribution is partial only when the file is reachable from the platform-runtime composition root', () => {
+  const edges = edgesOf({
+    'packages/platform-apple/src/leaf.ts': 'export const leaf = 1;',
+    'packages/platform-apple/src/runtime.ts':
+      "import { leaf } from './leaf.ts';\nexport const r = leaf;",
+    'src/platform-runtime-host.ts':
+      "import { r } from '../packages/platform-apple/src/runtime.ts';\nexport const h = r;",
+    'packages/daemon/src/handler.ts': 'export const handler = 1;',
+  });
+
+  const injected = collectExecutableDependents('packages/platform-apple/src/leaf.ts', edges);
+  assert.deepEqual(commandAttribution('packages/platform-apple/src/leaf.ts', injected.all), {
+    kind: 'partial',
+    reason: 'injected-runtime',
+    compositionRoots: ['src/platform-runtime-host.ts'],
+  });
+
+  const daemonOnly = collectExecutableDependents('packages/daemon/src/handler.ts', edges);
+  assert.deepEqual(commandAttribution('packages/daemon/src/handler.ts', daemonOnly.all), {
+    kind: 'static-reachability',
+  });
+
+  // The composition root itself is injected-runtime territory even with no dependents.
+  assert.equal(commandAttribution('src/platform-runtime.ts', []).kind, 'partial');
+});
+
 test('zoneBreakdown and rankByFanIn order by weight, then name', () => {
   const nodes = nodesOf({
     'packages/daemon/src/a.ts': { zone: 'daemon-server', fanIn: 3 },
@@ -197,37 +244,73 @@ test('parseInvocation rejects a missing path, a second path, and a non-positive
   assert.throws(() => parseInvocation(['a.ts', '--limit', 'lots']), /positive integer/);
 });
 
-test('text output bounds every list and says what it hid', () => {
-  // This is an arbitrary report input used to exercise formatting, not a live source path.
-  const text = formatBlastRadius(
-    {
-      file: 'src/utils/exec.ts',
-      zone: 'utils',
-      fanIn: 81,
-      fanOut: 3,
-      dependents: {
-        direct: ['src/a.ts', 'src/b.ts', 'src/c.ts'],
-        transitive: ['src/d.ts'],
-        byZone: [{ zone: 'utils', count: 4 }],
-        topByFanIn: [{ file: 'src/a.ts', fanIn: 7 }],
-        weakDirect: { type: 2, dynamic: 1 },
-      },
-      gates: { checks: ['lint', 'typecheck'], failOpen: false },
-      commands: [
-        { command: 'click', route: 'interaction', entry: 'packages/daemon/src/handlers/x.ts' },
-      ],
-      liveOwners: { manifest: 'test/…/coverage-manifest.ts', present: false, owners: [] },
-      guaranteeRows: [],
+function radiusFixture(overrides: Partial<BlastRadius> = {}): BlastRadius {
+  // An arbitrary report input used to exercise formatting, not a live source path.
+  return {
+    file: 'src/utils/exec.ts',
+    zone: 'utils',
+    fanIn: 81,
+    fanOut: 3,
+    dependents: {
+      direct: ['src/a.ts', 'src/b.ts', 'src/c.ts'],
+      transitive: ['src/d.ts'],
+      byZone: [{ zone: 'utils', count: 4 }],
+      topByFanIn: [{ file: 'src/a.ts', fanIn: 7 }],
+      weakDirect: { type: 2, dynamic: 1 },
     },
-    2,
-  );
+    executableDependents: {
+      direct: ['src/a.ts', 'src/b.ts', 'src/c.ts', 'src/lazy.ts'],
+      transitive: ['src/d.ts', 'src/lazier.ts'],
+      beyondValue: ['src/lazy.ts', 'src/lazier.ts'],
+    },
+    commandAttribution: { kind: 'static-reachability' },
+    gates: { checks: ['lint', 'typecheck'], failOpen: false },
+    commands: [
+      { command: 'click', route: 'interaction', entry: 'packages/daemon/src/handlers/x.ts' },
+    ],
+    liveOwners: { manifest: 'test/…/coverage-manifest.ts', present: false, owners: [] },
+    guaranteeRows: [],
+    ...overrides,
+  };
+}
+
+test('text output bounds every list and says what it hid', () => {
+  const text = formatBlastRadius(radiusFixture(), 2);
 
   assert.match(text, /3 direct, 1 transitive .*2 type-only and 1 dynamic/);
   assert.match(text, /direct: {2}src\/a\.ts, src\/b\.ts \(\+1 more\)/);
+  assert.match(
+    text,
+    /executable dependents .*: 4 direct, 2 transitive; 2 reached only across a dynamic import: src\/lazy\.ts, src\/lazier\.ts/,
+  );
   assert.match(text, /gates for this set: lint, typecheck/);
   assert.match(text, /is not in this tree/);
 });
 
+test('text output tells a known-empty command list from an incomplete one', () => {
+  const noCommands = { commands: [] };
+  const staticText = formatBlastRadius(radiusFixture(noCommands), 5);
+  const partialText = formatBlastRadius(
+    radiusFixture({
+      ...noCommands,
+      commandAttribution: {
+        kind: 'partial',
+        reason: 'injected-runtime',
+        compositionRoots: ['src/platform-runtime.ts', 'src/platform-runtime-host.ts', 'src/x.ts'],
+      },
+    }),
+    2,
+  );
+
+  assert.match(staticText, /\(0\): \(none\)\n {2}attribution: static import reachability only/);
+  assert.doesNotMatch(staticText, /PARTIAL/);
+  assert.match(
+    partialText,
+    /\(0\): \(none\)\n {2}attribution: PARTIAL \(injected runtime\) — reachable from src\/platform-runtime\.ts, src\/platform-runtime-host\.ts \(\+1 more\)/,
+  );
+  assert.doesNotMatch(partialText, /static import reachability only/);
+});
+
 test('blast radius over the real tree agrees with check:affected and stays under 10s', async () => {
   const file = 'packages/host-kit/src/internal/exec.ts';
   const started = Date.now();
@@ -243,3 +326,23 @@ test('blast radius over the real tree agrees with check:affected and stays under
   const single = selectChecks({ changedFiles: [file] });
   for (const check of single.checks) assert.ok(radius.gates.checks.includes(check), check);
 });
+
+test('the real platform snapshot route is flagged partial while a daemon handler is not', async () => {
+  const platform = await computeBlastRadius(
+    repoRoot,
+    'packages/platform-apple/src/snapshot-route.ts',
+  );
+  assert.deepEqual(platform.commands, []);
+  assert.equal(platform.commandAttribution.kind, 'partial');
+  assert.ok(
+    platform.executableDependents.beyondValue.length > 0,
+    'platform files are reached from the composition root only across dynamic imports',
+  );
+
+  const handler = await computeBlastRadius(
+    repoRoot,
+    'packages/daemon/src/sessions/handlers/session.ts',
+  );
+  assert.deepEqual(handler.commandAttribution, { kind: 'static-reachability' });
+  assert.ok(handler.commands.length > 0);
+});
@@ -8,6 +8,7 @@
 // gate's own model — the dependents reported here are exactly the edges CI enforces.
 
 import { genBFS, getPredecessors, type Graph, type TraversalDirection } from '@statelyai/graph';
+import { isRootPlatformRuntimeTarget } from '../layering/daemon-platform-runtime-inventory.ts';
 import { EXECUTABLE_EDGES, importGraph, VALUE_EDGES } from './import-graph.ts';
 import type { GraphEdge, GraphNode } from './model.ts';
 
@@ -48,6 +49,36 @@ export function collectDependents(file: string, edges: readonly GraphEdge[]): De
   return { direct, all, transitiveOnly: all.filter((entry) => !directSet.has(entry)) };
 }
 
+export type ExecutableDependentSet = DependentSet & {
+  /** Executable dependents that value edges alone do not reach: the path crosses a dynamic import. */
+  beyondValue: string[];
+};
+
+/**
+ * Reverse reachability over value and dynamic edges: every file whose code can run the target,
+ * including handlers a route loads through `import()`. Kept apart from `collectDependents` so the
+ * value count keeps its R4 meaning; type-only edges stay excluded because they never run.
+ * Reachability here is not a removability claim.
+ */
+export function collectExecutableDependents(
+  file: string,
+  edges: readonly GraphEdge[],
+): ExecutableDependentSet {
+  const executableGraph = importGraph(edges, EXECUTABLE_EDGES, [file]);
+  const direct = getPredecessors(executableGraph, file)
+    .map((node) => node.id)
+    .sort();
+  const all = [...reachable(executableGraph, file, 'incoming')].sort();
+  const directSet = new Set(direct);
+  const valueSet = new Set(collectDependents(file, edges).all);
+  return {
+    direct,
+    all,
+    transitiveOnly: all.filter((entry) => !directSet.has(entry)),
+    beyondValue: all.filter((entry) => !valueSet.has(entry)),
+  };
+}
+
 /**
  * Direct importers over the edge kinds `collectDependents` leaves out. A pure vocabulary module
  * has zero value dependents and dozens of type-only ones; reporting only the value count there
@@ -132,6 +163,28 @@ export function commandsReaching(
     .sort((left, right) => left.command.localeCompare(right.command));
 }
 
+/**
+ * How far the `commands` and live-owner lists can be trusted as a statement about impact.
+ * - `static-reachability`: the lists come from import edges alone; an empty list means no handler
+ *   chain imports the file, not that no command work depends on it.
+ * - `partial`: the file is reachable from the root platform-runtime composition family, which
+ *   daemon code may not import (R65, R76); platform code runs behind the injected gateway and no
+ *   import edge records which command drives it, so the lists are a lower bound.
+ */
+export type CommandAttribution =
+  | { kind: 'static-reachability' }
+  | { kind: 'partial'; reason: 'injected-runtime'; compositionRoots: string[] };
+
+export function commandAttribution(
+  file: string,
+  executableDependents: readonly string[],
+): CommandAttribution {
+  const compositionRoots = [file, ...executableDependents].filter(isRootPlatformRuntimeTarget);
+  return compositionRoots.length === 0
+    ? { kind: 'static-reachability' }
+    : { kind: 'partial', reason: 'injected-runtime', compositionRoots };
+}
+
 export type GuaranteeRow = {
   path: string;
   guarantee: string;