feat(supervisor): pass name, metadata, and resources in compute restore request

Restore calls now send a request body with the runner name, env override metadata,
cpu, and memory so the agent can inject them before the VM resumes. The runner
fetches these overrides from TRIGGER_METADATA_URL at restore time.

runnerId is derived per restore cycle as runner-{runIdShort}-{checkpointSuffix},
matching iceman's pattern.

Author: nicktrn

apps/supervisor/src/index.ts

@@ -225,12 +225,23 @@ class ManagedSupervisor {
 
         if (this.isComputeMode && this.computeManager) {
           try {
-            const didRestore = await this.computeManager.restore(checkpoint.location);
+            // Derive runnerId unique per restore cycle (matches iceman's pattern)
+            const runIdShort = message.run.friendlyId.replace("run_", "");
+            const checkpointSuffix = checkpoint.id.slice(-8);
+            const runnerId = `runner-${runIdShort}-${checkpointSuffix}`;
+
+            const didRestore = await this.computeManager.restore({
+              snapshotId: checkpoint.location,
+              runnerId,
+              runFriendlyId: message.run.friendlyId,
+              snapshotFriendlyId: message.snapshot.friendlyId,
+              machine: message.run.machine,
+            });
 
             if (didRestore) {
-              this.logger.log("Compute restore successful", { runId: message.run.id });
+              this.logger.log("Compute restore successful", { runId: message.run.id, runnerId });
             } else {
-              this.logger.error("Compute restore failed", { runId: message.run.id });
+              this.logger.error("Compute restore failed", { runId: message.run.id, runnerId });
             }
           } catch (error) {
             this.logger.error("Failed to restore run (compute)", { error });

apps/supervisor/src/workloadManager/compute.ts

@@ -247,34 +247,61 @@ export class ComputeWorkloadManager implements WorkloadManager {
     return true;
   }
 
-  async restore(snapshotId: string): Promise<boolean> {
-    const url = `${this.opts.gatewayUrl}/api/snapshots/${snapshotId}/restore`;
+  async restore(opts: {
+    snapshotId: string;
+    runnerId: string;
+    runFriendlyId: string;
+    snapshotFriendlyId: string;
+    machine: { cpu: number; memory: number };
+  }): Promise<boolean> {
+    const url = `${this.opts.gatewayUrl}/api/snapshots/${opts.snapshotId}/restore`;
+
+    const metadata: Record<string, string> = {
+      TRIGGER_RUNNER_ID: opts.runnerId,
+      TRIGGER_RUN_ID: opts.runFriendlyId,
+      TRIGGER_SNAPSHOT_ID: opts.snapshotFriendlyId,
+      TRIGGER_SUPERVISOR_API_PROTOCOL: this.opts.workloadApiProtocol,
+      TRIGGER_SUPERVISOR_API_PORT: String(this.opts.workloadApiPort),
+      TRIGGER_SUPERVISOR_API_DOMAIN: this.opts.workloadApiDomain ?? "",
+      TRIGGER_WORKER_INSTANCE_NAME: env.TRIGGER_WORKER_INSTANCE_NAME,
+    };
 
     const [error, response] = await tryCatch(
       fetch(url, {
         method: "POST",
         headers: this.authHeaders,
         signal: AbortSignal.timeout(this.opts.gatewayTimeoutMs),
+        body: JSON.stringify({
+          name: opts.runnerId,
+          metadata,
+          cpu: opts.machine.cpu,
+          memory_mb: opts.machine.memory * 1024,
+        }),
       })
     );
 
     if (error) {
       this.logger.error("restore request failed", {
-        snapshotId,
+        snapshotId: opts.snapshotId,
+        runnerId: opts.runnerId,
         error: error instanceof Error ? error.message : String(error),
       });
       return false;
     }
 
     if (!response.ok) {
       this.logger.error("restore request rejected", {
-        snapshotId,
+        snapshotId: opts.snapshotId,
+        runnerId: opts.runnerId,
         status: response.status,
       });
       return false;
     }
 
-    this.logger.info("restore request success", { snapshotId });
+    this.logger.info("restore request success", {
+      snapshotId: opts.snapshotId,
+      runnerId: opts.runnerId,
+    });
     return true;
   }
 }