refactor(daemon): admit-before-bind as an identity-keyed admitted-plan token; retire the R32 syntax policy

admitRuntimePlan (was inspectRequiredRuntimeUse) takes the plan and, on
success, mints an AdmittedRuntimePlan: a nominal class instance with nothing
readable on it. Its payload — a frozen copy of the device the facts were read
for, and the plan — lives in a module-private WeakMap keyed by the token's
exact identity, and the only way to read it is unwrapAdmittedRuntimePlan,
which refuses anything not minted here. The snapshot owning interface
(resolveBoundSnapshotCaptureRuntime, #1847) admits through it and its private
binder takes only the token: no bare plan, no separate device, and no
look-alike — a spread lacks the #private member (not assignable), a Proxy
around a real token types as the token but is a different identity (refused
at unwrap), Object.assign/defineProperty throw on the frozen instance, and the
class value is not exported so its constructor is not nameable.

That retires scripts/layering/runtime-command-cutover-snapshot.ts — R32's
per-command AST policy (call-shape recognition of the admission and a text
sniff for a local admission) — and the source-regex test beside the descriptor
tests. The generic row keeps retirement, narrowing, and singular execution;
the manufactured-proof column now also rejects casts to AdmittedRuntimePlan.

Planted reds: token degraded to a plain public shape → 2 unused
@ts-expect-error directives; unwrap reading the token surface via getters →
the Proxy regression fails; getter-based branded literal → the runtime
retarget test fails.

Author: thymikee

scripts/layering/runtime-command-cutover-policy.test.ts

@@ -22,6 +22,7 @@ test('the parametrized gate goes red on a planted row across every generalized c
             "import { resolvePlantedBackend } from './planted-legacy.ts';",
             "requireCommandSupported('planted', device);",
             'const widened = runtime as PlantedRuntimeOperations;',
+            'const forged = { admitted: true, plan } as AdmittedRuntimePlan<PlantedPlan>;',
             "function handlePlantedCommand() { widened.operations['plantedDump']({}); }",
           ].join('\n'),
         ],
@@ -44,6 +45,9 @@ test('the parametrized gate goes red on a planted row across every generalized c
       'src/daemon/planted-handler.ts: legacy planted route resolvePlantedBackend',
       'src/daemon/planted-handler.ts: legacy planted capability admission requireCommandSupported',
       'src/daemon/planted-handler.ts: widened planted runtime type assertion',
+      // The admission proof is shared across rows: a route that casts its way to an
+      // AdmittedRuntimePlan has manufactured the facts-first admission the binder requires.
+      'src/daemon/planted-handler.ts: widened planted runtime type assertion',
       'src/daemon/planted-handler.ts: bracketed planted operation access',
       'src/core/command-descriptor/registry.ts: planted descriptor retains legacy capability admission',
       'src/core/capabilities.ts: static platform command set retains planted admission',

scripts/layering/runtime-command-cutover-policy.ts

@@ -13,7 +13,11 @@ import { memberName, propertyName, visitAst, type ProductionSource } from './cut
 
 type AstNode = Record<string, unknown>;
 
-const SHARED_RUNTIME_TYPE_NAME = 'BoundDeviceRuntime';
+// Types no daemon route may manufacture with an assertion: the bound runtime itself, and the
+// admission proof a facts-first binder requires (`AdmittedRuntimePlan`, minted only by
+// `admitRuntimePlan`). Together with the row's own runtime type names they are the
+// manufactured-proof column — a cast to any of them is a route repairing missing proof.
+const SHARED_RUNTIME_TYPE_NAMES = ['BoundDeviceRuntime', 'AdmittedRuntimePlan'] as const;
 
 /**
  * The one parametrized runtime-command-cutover gate (ADR 0019 §8). Every migrated
@@ -372,7 +376,7 @@ function narrowingViolations(
   // An inventory row binds no device runtime, so it has nothing to re-widen.
   if (!file.path.startsWith('src/daemon/') || row.execution !== 'device-runtime') return [];
   const violations: UnruledViolation[] = [];
-  const runtimeTypes = new Set([SHARED_RUNTIME_TYPE_NAME, ...row.runtimeTypeNames]);
+  const runtimeTypes = new Set([...SHARED_RUNTIME_TYPE_NAMES, ...row.runtimeTypeNames]);
   visitAst(program, (node) => {
     if (
       (node['type'] === 'TSAsExpression' || node['type'] === 'TSTypeAssertion') &&

scripts/layering/runtime-command-cutover-snapshot.test.ts

@@ -91,11 +91,7 @@ test('R32 snapshot rejects legacy admission and dispatcher projection', () => {
           }
           function resolveBoundSnapshotCaptureRuntime(params) {
             const plan = resolveSnapshotRuntimePlan(normalizedIntent);
-            inspectRequiredRuntimeUse({
-              device,
-              use: plan.use,
-              inspectFacts: params.inspectFacts,
-            });
+            admitRuntimePlan({ device, plan, inspectFacts: params.inspectFacts });
             return bindSnapshotCaptureRuntime(params.bindDevice, device, plan);
           }
         `,

scripts/layering/runtime-command-cutover-snapshot.ts

@@ -10,7 +10,6 @@ import {
   runtimeLifecycleRouteBindingViolations,
   sourceExecutedUsingDeclarationViolations,
 } from './runtime-command-cutover-extensions.ts';
-import { snapshotPlatformPolicyBranchViolations } from './runtime-command-cutover-snapshot.ts';
 import { recordRuntimeDaemonMechanicsViolations } from './record-runtime-mechanics-policy.ts';
 import { retiredDispatchProjectionViolations } from './runtime-command-cutover-descriptor.ts';
 
@@ -471,7 +470,7 @@ export const MIGRATED_COMMAND_CUTOVERS: readonly MigratedCommandCutover[] = [
         captureSnapshotWithoutActiveApp: ['selectSnapshotWithoutActiveApp'],
       },
     },
-    extensions: [snapshotRetiredDispatchProjectionProof, snapshotPlatformPolicyBranchViolations],
+    extensions: [snapshotRetiredDispatchProjectionProof],
   },
   {
     rule: 'R33 diff-runtime-cutover',

scripts/layering/runtime-command-cutover-table.test.ts

@@ -1,21 +1,7 @@
-import { readFileSync } from 'node:fs';
 import { snapshotRuntimePlanUses } from '@agent-device/contracts/platform';
 import { expect, test } from 'vitest';
 import { commandDescriptors } from '../registry.ts';
 
-const snapshotRuntimeSource = readFileSync(
-  new URL('../../../daemon/snapshot-runtime.ts', import.meta.url),
-  'utf8',
-);
-const snapshotRuntimeBindingSource = readFileSync(
-  new URL('../../../daemon/snapshot-runtime-binding.ts', import.meta.url),
-  'utf8',
-);
-const snapshotRuntimeCommandSource = readFileSync(
-  new URL('../../../daemon/snapshot-command-runtime.ts', import.meta.url),
-  'utf8',
-);
-
 test('snapshot descriptor declares its complete planned capture uses with no legacy projection', () => {
   const snapshot = commandDescriptors.find(({ name }) => name === 'snapshot');
 
@@ -43,39 +29,3 @@ test('diff descriptor reuses the complete snapshot plan uses with no legacy proj
     uses: snapshotRuntimePlanUses,
   });
 });
-
-test('shared snapshot owning interface inspects facts and binds the declared use exactly once', () => {
-  const publicRoute = snapshotRuntimeSource.slice(
-    snapshotRuntimeSource.indexOf('export async function dispatchSnapshotViaRuntime'),
-    snapshotRuntimeSource.indexOf('function publishedSnapshotGeneration'),
-  );
-  const owningInterface = snapshotRuntimeBindingSource.slice(
-    snapshotRuntimeBindingSource.indexOf(
-      'export async function resolveBoundSnapshotCaptureRuntime',
-    ),
-    snapshotRuntimeBindingSource.indexOf('async function bindSnapshotCaptureRuntime'),
-  );
-
-  expect(publicRoute).toContain('dispatchSnapshotRuntimeCommand({');
-  expect(
-    snapshotRuntimeCommandSource.match(
-      /resolveBoundSnapshotCaptureRuntime\(params, params\.command\)/g,
-    ),
-  ).toHaveLength(1);
-  expect(owningInterface.match(/resolveSnapshotRuntimePlan\(\{/g)).toHaveLength(1);
-  expect(owningInterface.match(/inspectRequiredRuntimeUse\(\{/g)).toHaveLength(1);
-  expect(
-    owningInterface.match(/bindSnapshotCaptureRuntime\(params\.bindDevice, device, plan\)/g),
-  ).toHaveLength(1);
-  expect(
-    owningInterface.match(/use: plan\.use,[\s\S]*inspectFacts: params\.inspectFacts/g),
-  ).toHaveLength(1);
-  expect(
-    snapshotRuntimeBindingSource.match(/const bind = requireRuntimeBinding\(bindDevice\)/g),
-  ).toHaveLength(1);
-  expect(owningInterface.match(/runtime\.captureSnapshot\(/g)).toHaveLength(1);
-  expect(publicRoute).not.toContain("requireCommandSupported('snapshot'");
-  for (const policyName of ['isIosFamily', 'isIosSimulator', 'providerOwned']) {
-    expect(snapshotRuntimeBindingSource).not.toContain(policyName);
-  }
-});

scripts/layering/runtime-command-cutover-table.ts

@@ -0,0 +1,50 @@
+import type { DeviceInfo } from '@agent-device/kernel/device';
+import { expect, test } from 'vitest';
+import {
+  IOS_SIMULATOR,
+  makeIosSession,
+  makeSessionStore,
+} from '../../__tests__/test-utils/index.ts';
+import type { BindDeviceRuntime } from '../request-runtime-binding.ts';
+import { resolveBoundSnapshotCaptureRuntime } from '../snapshot-runtime-binding.ts';
+import type { DaemonRequest } from '../types.ts';
+import { snapshotRuntimeFixture } from './snapshot-runtime-fixture.ts';
+
+// The owning interface (ADR 0019 §9): one plan, one facts-first admission, one bind — and the
+// bind target is whatever the admission was minted for, read back by token identity. The binder
+// itself is module-private; this is its only entry.
+test('the owning interface binds exactly the session device the facts were admitted for', async () => {
+  const { inspectFacts, bindDevice } = snapshotRuntimeFixture();
+  const boundDevices: DeviceInfo[] = [];
+  const recordingBind: BindDeviceRuntime = async (device, use) => {
+    boundDevices.push(device);
+    return await bindDevice(device, use);
+  };
+  const sessionStore = makeSessionStore();
+  // An active app: the fixture admits captureSnapshot for a local iOS simulator only with one.
+  sessionStore.set(
+    'bind-test',
+    makeIosSession('bind-test', { device: IOS_SIMULATOR, appBundleId: 'com.example.app' }),
+  );
+  const req: DaemonRequest = {
+    command: 'snapshot',
+    positionals: [],
+    session: 'bind-test',
+    token: 'test-token',
+  };
+
+  const resolved = await resolveBoundSnapshotCaptureRuntime(
+    {
+      req,
+      sessionName: 'bind-test',
+      logPath: '/tmp/bind-test.log',
+      sessionStore,
+      inspectFacts,
+      bindDevice: recordingBind,
+    },
+    'snapshot',
+  );
+
+  expect(resolved.ok).toBe(true);
+  expect(boundDevices).toEqual([IOS_SIMULATOR]);
+});