fix: align the input-cache digest across control plane and runner

The two ends computed the SAME contract differently — the runner joined
(storage session, id) with a literal NUL byte, the control plane with a
space — so every pushed object landed under a name no lookup could ever
produce. Both unit suites passed because each was self-consistent; the
route test and the priming test used one side only. A live execution
reported 'No such file' for files that had been delivered successfully.

Both now use an explicit \u0000 escape (no raw NUL in source, which also
made grep treat the file as binary), and both suites assert the same
golden vector so the contract cannot silently drift again.

Author: danny-avila

api/src/session-inputs.test.ts

@@ -40,7 +40,24 @@ async function makeBatch(
   return tar.stdout;
 }
 
+/**
+ * Cross-component contract. The control plane names batch members with ITS
+ * implementation of this digest and the runner looks entries up with THIS one;
+ * nothing else ties them together, so both suites assert the same vector.
+ *
+ * They silently diverged once — one side used a literal NUL separator, the
+ * other a space — and every push landed in the cache under names no lookup
+ * would ever produce. Both unit suites passed (each self-consistent) and only
+ * a live execution showed it, as "file not found" for files that had been
+ * delivered successfully.
+ */
+const GOLDEN_KEY_SID_1_FILE_1 = 'a995f1e7977466c5636419d21582e0b44420c44d2d7e2660b13aa4d4b4667d90';
+
 describe('pushed input cache', () => {
+  test('digests match the wire contract the control plane names members with', () => {
+    expect(inputCacheKey('sid-1', 'file-1')).toBe(GOLDEN_KEY_SID_1_FILE_1);
+  });
+
   test('lives outside the workspace root so the reaper cannot eat it', async () => {
     /* Regression: the cache was originally a dot-directory INSIDE
      * SANDBOX_WORKSPACE_ROOT, where the stale-workspace reaper treats every

api/src/session-inputs.ts

@@ -0,0 +1,21 @@
+import { AwsLambdaMicrovmClient } from './runtime-session/lambda-client-aws';
+import { probeInputs, pushInputs } from './runtime-session/checkpoint';
+import { buildInputBatch } from './runtime-session/files';
+import { normalizeMicrovmEndpoint } from './sandbox-backend/lambda-microvm';
+
+const [microvmId, endpoint] = process.argv.slice(2);
+const client = new AwsLambdaMicrovmClient({ region: 'us-east-1' });
+const cfg = { port: 8080, authTokenTtlSeconds: 300, maxBytes: 512 * 1024 * 1024, timeoutMs: 30_000 };
+const mintToken = () => client.createMicrovmAuthToken({ microvmId, port: 8080, ttlSeconds: 300 });
+const base = normalizeMicrovmEndpoint(endpoint);
+const refs = [{ storage_session_id: 'AP-6YQGnfCXsIbT1F00zs', id: 'V_WL-92AoQdSZWdN85fkt' }];
+
+console.log('probe #1:', JSON.stringify(await probeInputs({ mintToken, endpointBase: base }, refs, cfg)));
+const batch = await buildInputBatch(
+  [{ storage_session_id: 'AP-6YQGnfCXsIbT1F00zs', id: 'V_WL-92AoQdSZWdN85fkt', name: 'probe.csv' }],
+  { timeoutMs: 30_000, maxBytes: 1024 * 1024 },
+);
+console.log('batch bytes:', batch?.data.length);
+await pushInputs({ mintToken, endpointBase: base }, batch!.data, cfg);
+console.log('push: ok');
+console.log('probe #2:', JSON.stringify(await probeInputs({ mintToken, endpointBase: base }, refs, cfg)));

service/src/probecheck.tmp.ts

@@ -56,6 +56,21 @@ async function membersOf(data: Buffer): Promise<string[]> {
   }
 }
 
+/**
+ * Cross-component contract — see the twin assertion in the runner's
+ * session-inputs.test.ts. Members are named here and looked up there, so a
+ * silent divergence makes every delivery land under names the runner can never
+ * find. That happened (NUL vs space separator) and only live execution caught
+ * it; this vector is what makes it a test failure instead.
+ */
+const GOLDEN_KEY_SID_1_FILE_1 = 'a995f1e7977466c5636419d21582e0b44420c44d2d7e2660b13aa4d4b4667d90';
+
+describe('inputCacheKey', () => {
+  test('matches the digest the runner resolves cache entries with', () => {
+    expect(inputCacheKey('sid-1', 'file-1')).toBe(GOLDEN_KEY_SID_1_FILE_1);
+  });
+});
+
 describe('sessionFileRefs', () => {
   test('collapses the same object requested under multiple names', () => {
     /* Identity is (storage session, id): one delivery, and priming writes it

service/src/runtime-session/files.test.ts

@@ -44,7 +44,7 @@ export interface SessionFileRef {
 /** Mirrors the runner's `inputCacheKey` (api/src/session-inputs.ts): both ends
  *  ship in the same image, so the digest is a hard-coded contract. */
 export function inputCacheKey(storageSessionId: string, id: string): string {
-  return crypto.createHash('sha256').update(`${storageSessionId} ${id}`, 'utf8').digest('hex');
+  return crypto.createHash('sha256').update(`${storageSessionId}\u0000${id}`, 'utf8').digest('hex');
 }
 
 /** The by-reference subset of the payload's files (inline `content` entries

service/src/runtime-session/files.ts

@@ -638,6 +638,11 @@ export class LambdaMicrovmSandboxBackend implements SandboxBackend {
         refs.map((ref) => ({ storage_session_id: ref.storage_session_id, id: ref.id })),
         this.config.checkpoint,
       );
+      logger.info('Session input delivery', {
+        microvmId: vm.microvmId,
+        refs: refs.length,
+        missing: missing.length,
+      });
       if (missing.length === 0) return;
       const wanted = new Set(missing.map((ref) => `${ref.storage_session_id}/${ref.id}`));
       const batch = await buildInputBatch(