@@ -20,6 +20,7 @@ function importEdge(file: string, target: string): ResolvedImportEdge {
     dynamic: false,
     typeOnly: true,
     symbols: [],
+    bindingResidue: false,
     fromZone: targetDagZone(file),
     toZone: targetDagZone(target),
   };
 
@@ -110,6 +110,39 @@ test('R74 rejects an expanded destructured dynamic import on a classified edge',
   );
 });
 
+test('R74 rejects a rest binding next to a recorded dynamic-import binding', () => {
+  const sources = {
+    'src/platform-runtime-operation-host.ts':
+      'export async function recoverLegacyAppLogMarkersAfterDaemonLock() { return {}; }\n' +
+      'export async function sweepLegacyAppLogMarkers() { return {}; }\n',
+    'src/daemon/server/daemon-runtime.ts':
+      "const { recoverLegacyAppLogMarkersAfterDaemonLock, ...operationHost } = await import('../../platform-runtime-operation-host.ts');\n" +
+      'void [recoverLegacyAppLogMarkersAfterDaemonLock, operationHost];\n',
+  };
+  const found = edgeViolations(sources, 'src/daemon/server/daemon-runtime.ts');
+  assert.equal(found.length, 1);
+  assert.equal(found[0]!.rule, DAEMON_PLATFORM_RUNTIME_RULE);
+  assert.match(found[0]!.message, /unnameable dynamic-import binding/);
+  assert.match(
+    found[0]!.message,
+    /src\/daemon\/server\/daemon-runtime\.ts -> src\/platform-runtime-operation-host\.ts/,
+  );
+});
+
+test('R74 rejects a computed destructure key on a classified dynamic import', () => {
+  const sources = {
+    'src/platform-runtime-operation-host.ts':
+      'export async function recoverLegacyAppLogMarkersAfterDaemonLock() { return {}; }\n',
+    'src/daemon/server/daemon-runtime.ts':
+      "const markerName = 'recoverLegacyAppLogMarkersAfterDaemonLock';\n" +
+      'const { [markerName]: recover } = await import("../../platform-runtime-operation-host.ts");\n' +
+      'void recover;\n',
+  };
+  const found = edgeViolations(sources, 'src/daemon/server/daemon-runtime.ts');
+  assert.equal(found.length, 1);
+  assert.match(found[0]!.message, /unnameable dynamic-import binding/);
+});
+
 test('R74 rejects a namespace-form dynamic import that hides the recorded bindings', () => {
   const sources = {
     'src/platform-runtime-operation-host.ts':
 
@@ -22,7 +22,9 @@ export type DaemonPlatformRuntimeEdge = Readonly<{
   /**
    * Exact named symbols across every edge of the pair; empty for side-effect imports and dynamic
    * imports that do not destructure named bindings (a destructured dynamic import records its
-   * bindings, so widening the destructure is a drift, not a silent expansion).
+   * bindings, so widening the destructure is a drift, not a silent expansion). A rest or computed
+   * destructure binding cannot be recorded here: it exposes exports beyond this list and R74
+   * rejects the edge.
    */
   symbols: readonly string[];
   classification: DaemonPlatformRuntimeClassification;
@@ -202,8 +204,10 @@ function sorted(symbols: readonly string[]): string[] {
 
 /**
  * Catches: unclassified daemon-to-root platform-runtime coupling regrowing — a new edge (or a
- *   new symbol on an existing edge) that the #2278 audit never classified, and the mirror
- *   failure, a classified edge that no longer exists and would silently admit its return.
+ *   new symbol on an existing edge) that the #2278 audit never classified, the mirror failure, a
+ *   classified edge that no longer exists and would silently admit its return, and a
+ *   dynamic-import destructure holding a rest or computed binding, which exposes every export
+ *   the inventory cannot name.
  * Evidence: #2278 measured 14 production edges in 9 daemon files at origin/main 6e22e266d7;
  *   this table is that measurement, classified per ADR 0022.
  * Cost: attributed to the R74 rule registration in check.ts; not a standalone CI job.
@@ -214,14 +218,19 @@ function sorted(symbols: readonly string[]): string[] {
 export function checkDaemonPlatformRuntimeInventory(
   edges: readonly ResolvedImportEdge[],
 ): LayeringViolation[] {
-  const actual = new Map<string, { line: number; symbols: Set<string> }>();
+  const actual = new Map<string, { line: number; symbols: Set<string>; residue: boolean }>();
   for (const edge of edges) {
     if (!edge.file.startsWith('src/daemon/')) continue;
     if (!isProductionSourceFile(edge.file)) continue;
     if (!isRootPlatformRuntimeTarget(edge.target)) continue;
     const key = keyOf(edge.file, edge.target);
-    const entry = actual.get(key) ?? { line: edge.line, symbols: new Set<string>() };
+    const entry = actual.get(key) ?? {
+      line: edge.line,
+      symbols: new Set<string>(),
+      residue: false,
+    };
     for (const symbol of edge.symbols) entry.symbols.add(symbol);
+    entry.residue = entry.residue || edge.bindingResidue;
     actual.set(key, entry);
   }
 
@@ -245,6 +254,18 @@ export function checkDaemonPlatformRuntimeInventory(
       continue;
     }
     seen.add(key);
+    if (entry.residue) {
+      violations.push({
+        rule: DAEMON_PLATFORM_RUNTIME_RULE,
+        file: key.split(' -> ')[0]!,
+        line: entry.line,
+        message:
+          `unnameable dynamic-import binding for ${key}: a rest or computed destructure exposes ` +
+          `bindings the inventory cannot name. Destructure every binding explicitly and record it ` +
+          `in DAEMON_PLATFORM_RUNTIME_EDGES (${DAEMON_PLATFORM_RUNTIME_RULE}), or remove the coupling.`,
+      });
+      continue;
+    }
     const expected = sorted(declaration.symbols);
     const measured = sorted([...entry.symbols]);
     if (expected.join('\u0000') !== measured.join('\u0000')) {
 
@@ -66,15 +66,24 @@ function unwrapImportInit(node: unknown): Record<string, unknown> | null {
   return null;
 }
 
+export type DestructuredDynamicImport = Readonly<{
+  /** Export names captured from static (non-computed) property keys. */
+  symbols: readonly string[];
+  /** True when the pattern also holds a rest element or a computed key: the import surface is wider than `symbols`. */
+  residue: boolean;
+}>;
+
 /**
- * Named bindings captured by destructuring a dynamic import
+ * Bindings captured by destructuring a dynamic import
  * (`const { a, b: local } = await import('...')` captures `a` and `b`), keyed by the import
- * expression's source offset. Namespace-form and bare dynamic imports capture nothing.
+ * expression's source offset. A rest element or a computed key is a binding the scanner cannot
+ * name and is reported as residue, never dropped: it exposes exports beyond `symbols`.
+ * Namespace-form and bare dynamic imports capture nothing.
  */
 export function destructuredDynamicImportBindings(
   program: unknown,
-): ReadonlyMap<number, readonly string[]> {
-  const bindings = new Map<number, readonly string[]>();
+): ReadonlyMap<number, DestructuredDynamicImport> {
+  const captures = new Map<number, DestructuredDynamicImport>();
   const visit = (node: unknown): void => {
     if (node === null || typeof node !== 'object') return;
     if (Array.isArray(node)) {
@@ -92,26 +101,32 @@ export function destructuredDynamicImportBindings(
         typeof id === 'object' &&
         (id as Record<string, unknown>).type === 'ObjectPattern'
       ) {
-        const names: string[] = [];
+        const symbols: string[] = [];
+        let residue = false;
         const properties = (id as Record<string, unknown>).properties;
-        if (Array.isArray(properties)) {
+        if (!Array.isArray(properties)) {
+          residue = true;
+        } else {
           for (const property of properties) {
             if (
-              property !== null &&
-              typeof property === 'object' &&
-              (property as Record<string, unknown>).type === 'Property' &&
-              (property as Record<string, unknown>).computed !== true
+              property === null ||
+              typeof property !== 'object' ||
+              (property as Record<string, unknown>).type !== 'Property' ||
+              (property as Record<string, unknown>).computed === true
             ) {
-              const name = propertyName((property as Record<string, unknown>).key);
-              if (name) names.push(name);
+              residue = true;
+              continue;
             }
+            const name = propertyName((property as Record<string, unknown>).key);
+            if (name) symbols.push(name);
+            else residue = true;
           }
         }
-        bindings.set(init.start, names);
+        captures.set(init.start, { symbols, residue });
       }
     }
     for (const child of Object.values(record)) visit(child);
   };
   visit(program);
-  return bindings;
+  return captures;
 }
@@ -56,15 +56,29 @@ test('parseImports detects multiline dynamic imports', () => {
   const edges = parseImports(['void import(', "  '../multiline.ts'", ');'].join('\n'));
 
   assert.deepEqual(edges, [
-    { spec: '../multiline.ts', dynamic: true, typeOnly: false, line: 1, symbols: [] },
+    {
+      spec: '../multiline.ts',
+      dynamic: true,
+      typeOnly: false,
+      line: 1,
+      symbols: [],
+      bindingResidue: false,
+    },
   ]);
 });
 
 test('parseImports resolves constant-template dynamic imports', () => {
   const edges = parseImports('void import(`../template.ts`);');
 
   assert.deepEqual(edges, [
-    { spec: '../template.ts', dynamic: true, typeOnly: false, line: 1, symbols: [] },
+    {
+      spec: '../template.ts',
+      dynamic: true,
+      typeOnly: false,
+      line: 1,
+      symbols: [],
+      bindingResidue: false,
+    },
   ]);
 });
 
@@ -74,15 +88,19 @@ test('parseImports captures destructured named bindings of dynamic imports, keye
       "const { a, 'b': c } = await import('./dyn.ts');",
       "const mod = await import('./dyn.ts');",
       "const wrapped = (await import('./dyn.ts')) as Mod;",
+      'const { a, ...rest } = await import("./dyn.ts");',
+      'const { [keyExpr]: named } = await import("./dyn.ts");',
     ].join('\n'),
   );
 
   assert.deepEqual(
-    edges.map(({ spec, symbols }) => ({ spec, symbols })),
+    edges.map(({ spec, symbols, bindingResidue }) => ({ spec, symbols, bindingResidue })),
     [
-      { spec: './dyn.ts', symbols: ['a', 'b'] },
-      { spec: './dyn.ts', symbols: [] },
-      { spec: './dyn.ts', symbols: [] },
+      { spec: './dyn.ts', symbols: ['a', 'b'], bindingResidue: false },
+      { spec: './dyn.ts', symbols: [], bindingResidue: false },
+      { spec: './dyn.ts', symbols: [], bindingResidue: false },
+      { spec: './dyn.ts', symbols: ['a'], bindingResidue: true },
+      { spec: './dyn.ts', symbols: [], bindingResidue: true },
     ],
   );
 });
 
@@ -13,6 +13,11 @@ export type ImportEdge = {
    * dynamic imports that do not destructure named bindings.
    */
   symbols: readonly string[];
+  /**
+   * True when a dynamic-import destructure holds a binding the scanner cannot name (a rest element
+   * or a computed key); `symbols` then does not enumerate the full imported surface.
+   */
+  bindingResidue: boolean;
 };
 
 export type ResolvedImportEdge = ImportEdge & {
@@ -160,12 +165,14 @@ function scanDynamicImports(source: string): ImportEdge[] {
     const spec = literalSpecifier(node.source);
     if (spec === undefined) return;
     const start = node.start as number | undefined;
+    const capture = typeof start === 'number' ? destructured.get(start) : undefined;
     edges.push({
       spec,
       dynamic: true,
       typeOnly: false,
       line: sourceLine(source, start),
-      symbols: typeof start === 'number' ? [...(destructured.get(start) ?? [])] : [],
+      symbols: capture ? [...capture.symbols] : [],
+      bindingResidue: capture?.residue ?? false,
     });
   });
   return edges;
@@ -174,7 +181,14 @@ function scanDynamicImports(source: string): ImportEdge[] {
 function scanSideEffectImport(line: string, lineNo: number): ImportEdge | null {
   const match = /^\s*import\s+['"]([^'"]+)['"]/.exec(line);
   return match
-    ? { spec: match[1]!, dynamic: false, typeOnly: false, line: lineNo, symbols: [] }
+    ? {
+        spec: match[1]!,
+        dynamic: false,
+        typeOnly: false,
+        line: lineNo,
+        symbols: [],
+        bindingResidue: false,
+      }
     : null;
 }
 
@@ -238,6 +252,7 @@ function scanFromImport(lines: string[], index: number): ImportEdge | null {
     typeOnly: statementIsTypeOnly(normalizedStatement),
     line: start + 1,
     symbols: importedSymbols(normalizedStatement),
+    bindingResidue: false,
   };
 }
 
 
@@ -19,6 +19,7 @@ function edge(file: string, fromZone: string, toZone: string, kind: Kind = {}) {
       dynamic: kind.dynamic ?? false,
       typeOnly: kind.typeOnly ?? false,
       symbols: [],
+      bindingResidue: false,
     },
   };
 }
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@ function edge(file: string, fromZone: string, toZone: string, kind: Kind = {}) {`
`19`	`19`	`dynamic: kind.dynamic ?? false,`
`20`	`20`	`typeOnly: kind.typeOnly ?? false,`
`21`	`21`	`symbols: [],`
	`22`	`+ bindingResidue: false,`
`22`	`23`	`},`
`23`	`24`	`};`
`24`	`25`	`}`