spawnfile 0.1.14 → 0.1.18

package/dist/distribution/consumeImageSupport.js

@@ -1,4 +1,6 @@
+import { readHomeDeploymentRecord, resolveDockerDeploymentTarget, verifyDockerDeploymentTarget } from "../deployment/index.js";
 import { randomBytes } from "node:crypto";
+import { createExclusiveReattachVolumeName } from "../shared/index.js";
 const GENERATED_RUNTIME_SECRET_NAMES = new Set([
     "OPENCLAW_GATEWAY_TOKEN",
     "OPENCLAW_HOOKS_TOKEN"
@@ -17,6 +19,20 @@ export const deriveVolumeName = (deploymentName, mountId) => {
     const safeMount = mountId.replace(/[^A-Za-z0-9_.-]+/g, "-");
     return `spawnfile_${deploymentName}_${safeMount}`;
 };
+/**
+ * An author-declared name wins over any derivation, in image mode exactly as
+ * in project mode. Without this, an operator who pre-created
+ * `clank-newsroom-store` and deployed the published image silently got
+ * `spawnfile-exclusive-<id>-<hash>` — a brand-new empty volume — while the
+ * spec promised the declared name verbatim.
+ *
+ * Only a DECLARED name travels in the report; an undeclared mount is still
+ * named per deployment so two deployments of one image never share state.
+ */
+export const derivePersistentMountVolumeName = (deploymentName, mount) => mount.declared_volume_name?.trim()
+    || (mount.lifecycle === "exclusive-reattach"
+        ? createExclusiveReattachVolumeName(deploymentName, mount.id)
+        : deriveVolumeName(deploymentName, mount.id));
 /**
  * Builds the container environment for a sourceless deployment: auth-profile
  * and env-file values, process-env overrides for declared secrets, and
@@ -61,3 +77,27 @@ export const renderEnvFileContent = (env) => Object.entries(env)
     .sort(([left], [right]) => left.localeCompare(right))
     .map(([name, value]) => `${name}=${value}`)
     .join("\n") + "\n";
+export const readPreviousSource = async (deploymentName) => {
+    try {
+        const existing = await readHomeDeploymentRecord(deploymentName);
+        if (existing.source.kind !== "image") {
+            return null;
+        }
+        return { digest: existing.source.digest, ref: existing.source.ref };
+    }
+    catch {
+        return null;
+    }
+};
+export const resolveExistingOrNewTarget = async (deploymentName, alreadyExists, options) => {
+    if (alreadyExists && !options.dockerContext && !options.dockerHost) {
+        const existing = await readHomeDeploymentRecord(deploymentName);
+        await verifyDockerDeploymentTarget(existing.target, { dockerCommand: options.dockerCommand });
+        return existing.target;
+    }
+    return resolveDockerDeploymentTarget({
+        context: options.dockerContext ?? null,
+        dockerCommand: options.dockerCommand,
+        dockerHost: options.dockerHost ?? null
+    });
+};

package/dist/distribution/distributionReportSchema.d.ts

@@ -27,9 +27,11 @@ export declare const distributionReportSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>;
     persistent_mounts: z.ZodArray<z.ZodObject<{
+        declared_volume_name: z.ZodOptional<z.ZodString>;
         durability: z.ZodLiteral<"persistent">;
         id: z.ZodString;
         kind: z.ZodLiteral<"volume">;
+        lifecycle: z.ZodOptional<z.ZodLiteral<"exclusive-reattach">>;
         target: z.ZodString;
     }, z.core.$strict>>;
     port_mappings: z.ZodArray<z.ZodObject<{
@@ -37,9 +39,38 @@ export declare const distributionReportSchema: z.ZodObject<{
         published_port: z.ZodNumber;
     }, z.core.$strict>>;
     ports: z.ZodArray<z.ZodNumber>;
+    recording: z.ZodOptional<z.ZodObject<{
+        keep_ms: z.ZodNumber;
+        memory_mount_ids: z.ZodArray<z.ZodString>;
+        recording_mount_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        agents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            node_id: z.ZodString;
+            slug: z.ZodString;
+            directory: z.ZodString;
+            keep_ms: z.ZodNumber;
+            networks: z.ZodArray<z.ZodString>;
+            memory: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                declared_by: z.ZodString;
+                ledger_path: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+            feeds: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                volume_name: z.ZodString;
+            }, z.core.$strict>>;
+            resources: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    git: "git";
+                    bundle: "bundle";
+                }>;
+            }, z.core.$strict>>;
+            snapshots: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
     resources: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
-        kind: z.ZodUnion<readonly [z.ZodLiteral<"git">, z.ZodLiteral<"volume">]>;
+        kind: z.ZodUnion<readonly [z.ZodLiteral<"bundle">, z.ZodLiteral<"git">, z.ZodLiteral<"volume">]>;
         link_path: z.ZodString;
         mode: z.ZodUnion<readonly [z.ZodLiteral<"mutable">, z.ZodLiteral<"readonly">]>;
         mount: z.ZodString;
@@ -47,6 +78,14 @@ export declare const distributionReportSchema: z.ZodObject<{
     }, z.core.$strict>>;
     runtime_instances: z.ZodArray<z.ZodObject<{
         config_path: z.ZodString;
+        engine_by_node_id: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            codex: "codex";
+            grok: "grok";
+            agy: "agy";
+            claude: "claude";
+            pi: "pi";
+            scripted: "scripted";
+        }>>>;
         home_path: z.ZodNullable<z.ZodString>;
         id: z.ZodString;
         internal_port: z.ZodNullable<z.ZodNumber>;
@@ -55,6 +94,7 @@ export declare const distributionReportSchema: z.ZodObject<{
         node_ids: z.ZodArray<z.ZodString>;
         published_port: z.ZodNullable<z.ZodNumber>;
         runtime: z.ZodString;
+        telemetry_mount_ids: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         workspace_path: z.ZodString;
     }, z.core.$strict>>;
     secrets: z.ZodObject<{
@@ -80,6 +120,23 @@ export declare const distributionReportSchema: z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>;
     version: z.ZodLiteral<"spawnfile.distribution-report.v1">;
+    workspace_git_resources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agent_node_ids: z.ZodArray<z.ZodString>;
+        declared_by: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        commit: z.ZodString;
+        sha256: z.ZodString;
+    }, z.core.$strict>>>;
+    workspace_bundles: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agent_node_ids: z.ZodArray<z.ZodString>;
+        declared_by: z.ZodOptional<z.ZodString>;
+        id: z.ZodString;
+        sha256: z.ZodString;
+        origin: z.ZodOptional<z.ZodEnum<{
+            built: "built";
+            prebuilt: "prebuilt";
+        }>>;
+    }, z.core.$strict>>>;
     world_bindings: z.ZodOptional<z.ZodObject<{
         artifact_path: z.ZodLiteral<"/spawnfile/world-bindings.json">;
         digest: z.ZodString;

package/dist/distribution/distributionReportSchema.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { SpawnfileError } from "../shared/index.js";
-import { DISTRIBUTION_REPORT_VERSION, WORLD_BINDINGS_IMAGE_PATH } from "./types.js";
+import { recordingReportSchema } from "../report/index.js";
+import { DISTRIBUTION_ENGINE_KINDS, DISTRIBUTION_REPORT_VERSION, WORLD_BINDINGS_IMAGE_PATH } from "./types.js";
 const secretEntrySchema = z.object({
     generated: z.boolean(),
     name: z.string().min(1),
@@ -32,6 +33,7 @@ const instanceIdSchema = z
 });
 const runtimeInstanceSchema = z.object({
     config_path: containerPathSchema,
+    engine_by_node_id: z.record(z.string().min(1), z.enum(DISTRIBUTION_ENGINE_KINDS)).optional(),
     home_path: containerPathSchema.nullable(),
     id: instanceIdSchema,
     internal_port: portSchema.nullable(),
@@ -40,6 +42,10 @@ const runtimeInstanceSchema = z.object({
     node_ids: z.array(z.string()),
     published_port: portSchema.nullable(),
     runtime: z.string().min(1),
+    // node id -> persistent mount id for per-agent telemetry; every pi/Daimon
+    // image this compiler builds carries it, so a strict schema without it
+    // refused image-mode `up` of the compiler's own output.
+    telemetry_mount_ids: z.record(z.string().min(1), instanceIdSchema).optional(),
     workspace_path: containerPathSchema
 }).strict();
 export const distributionReportSchema = z.object({
@@ -69,11 +75,23 @@ export const distributionReportSchema = z.object({
         }).strict())
     }).strict(),
     persistent_mounts: z.array(z.object({
+        // Used verbatim as a docker volume name by `consumeImage`, so it is
+        // constrained to docker's own volume-name charset here (defence in depth,
+        // exactly as `id` is).
+        declared_volume_name: z
+            .string()
+            .min(1)
+            .max(255)
+            .refine((value) => /^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(value) && !value.includes(".."), {
+            message: "must be a docker volume name (letters, digits, '_', '.', '-'; no '/', ':', whitespace, or '..')"
+        })
+            .optional(),
         durability: z.literal("persistent"),
         // Sanitized by deriveVolumeName before use, but constrained here too so the
         // schema alone keeps the volume-name source clean (defense in depth).
         id: instanceIdSchema,
         kind: z.literal("volume"),
+        lifecycle: z.literal("exclusive-reattach").optional(),
         target: containerPathSchema
     }).strict()),
     port_mappings: z.array(z.object({
@@ -81,9 +99,10 @@ export const distributionReportSchema = z.object({
         published_port: portSchema
     }).strict()),
     ports: z.array(portSchema),
+    recording: recordingReportSchema.optional(),
     resources: z.array(z.object({
         id: z.string().min(1),
-        kind: z.union([z.literal("git"), z.literal("volume")]),
+        kind: z.union([z.literal("bundle"), z.literal("git"), z.literal("volume")]),
         link_path: z.string(),
         mode: z.union([z.literal("mutable"), z.literal("readonly")]),
         mount: z.string(),
@@ -97,6 +116,20 @@ export const distributionReportSchema = z.object({
         surface: z.array(secretEntrySchema)
     }).strict(),
     version: z.literal(DISTRIBUTION_REPORT_VERSION),
+    workspace_git_resources: z.array(z.object({
+        agent_node_ids: z.array(z.string().min(1)).min(1),
+        declared_by: z.string().min(1).optional(),
+        id: z.string().min(1),
+        commit: z.string().regex(/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/u),
+        sha256: z.string().regex(/^sha256:[a-f0-9]{64}$/u)
+    }).strict()).optional(),
+    workspace_bundles: z.array(z.object({
+        agent_node_ids: z.array(z.string().min(1)).min(1),
+        declared_by: z.string().min(1).optional(),
+        id: z.string().min(1),
+        sha256: z.string().regex(/^sha256:[a-f0-9]{64}$/u),
+        origin: z.enum(["built", "prebuilt"]).optional()
+    }).strict()).optional(),
     world_bindings: z.object({
         artifact_path: z.literal(WORLD_BINDINGS_IMAGE_PATH),
         digest: z.string().regex(/^sha256:[a-f0-9]{64}$/u),

package/dist/distribution/dockerRunner.d.ts

@@ -1,5 +1,10 @@
 export interface DockerCommandRunner {
     /** Runs docker with args; resolves stdout as a Buffer. Rejects on non-zero exit. */
-    (args: string[]): Promise<Buffer>;
+    (args: string[], options?: DockerCommandOptions): Promise<Buffer>;
+}
+export interface DockerCommandOptions {
+    captureStderr?: boolean;
+    maxOutputBytes?: number;
+    timeoutMs?: number;
 }
 export declare const createConsumerDockerRunner: (dockerCommand: string, baseArgs: string[]) => DockerCommandRunner;

package/dist/distribution/dockerRunner.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { SpawnfileError } from "../shared/index.js";
-export const createConsumerDockerRunner = (dockerCommand, baseArgs) => async (args) => new Promise((resolve, reject) => {
+export const createConsumerDockerRunner = (dockerCommand, baseArgs) => async (args, options = {}) => new Promise((resolve, reject) => {
     const finalArgs = [...baseArgs, ...args];
     const child = spawn(dockerCommand, finalArgs, {
         env: { ...process.env },
@@ -8,10 +8,37 @@ export const createConsumerDockerRunner = (dockerCommand, baseArgs) => async (ar
     });
     const stdout = [];
     const stderr = [];
-    child.stdout.on("data", (chunk) => stdout.push(chunk));
-    child.stderr.on("data", (chunk) => stderr.push(String(chunk)));
-    child.on("error", reject);
+    let bytes = 0;
+    let stopped = false;
+    const stop = (reason) => {
+        stopped = true;
+        child.kill("SIGKILL");
+        reject(new SpawnfileError("runtime_error", reason));
+    };
+    const timer = options.timeoutMs === undefined ? undefined
+        : setTimeout(() => stop("Docker diagnostic command timed out"), options.timeoutMs);
+    const clearTimer = () => { if (timer)
+        clearTimeout(timer); };
+    const collect = (chunk, isStderr) => {
+        if (stopped)
+            return;
+        bytes += chunk.length;
+        if (options.maxOutputBytes !== undefined && bytes > options.maxOutputBytes) {
+            stop("Docker diagnostic output exceeded its byte limit");
+            return;
+        }
+        if (isStderr)
+            stderr.push(chunk.toString("utf8"));
+        if (!isStderr || options.captureStderr)
+            stdout.push(chunk);
+    };
+    child.stdout.on("data", (chunk) => collect(chunk, false));
+    child.stderr.on("data", (chunk) => collect(chunk, true));
+    child.on("error", (error) => { clearTimer(); reject(error); });
     child.on("close", (code) => {
+        clearTimer();
+        if (stopped)
+            return;
         if (code === 0) {
             resolve(Buffer.concat(stdout));
             return;

package/dist/distribution/imageRuntimeAuth.d.ts

@@ -1,14 +1,22 @@
 import type { ResolvedAuthProfile } from "../auth/index.js";
 import type { DistributionReport } from "./types.js";
 export interface ImageRuntimeAuthInput {
-    authProfile: ResolvedAuthProfile;
+    authProfile: ResolvedAuthProfile | null;
+    /**
+     * The uid the deployed Daimon image reads its credential leaves as. Defaults
+     * to the compiled image's organization uid; only override it against an image
+     * known to run under a different identity.
+     */
+    daimonContainerCredentialUid?: number;
     report: DistributionReport;
+    sourceEnvironment?: Record<string, string | undefined>;
     tempRoot: string;
 }
 export interface ImageRuntimeAuthResult {
     coveredModelSecrets: Set<string>;
     mountArgs: string[];
 }
+export declare const prepareDaimonImageAuthMounts: (instance: DistributionReport["runtime_instances"][number], environment: Record<string, string | undefined>, authProfile: ResolvedAuthProfile | null, containerCredentialUid?: number) => Promise<string[]>;
 /**
  * Builds the credential mounts for a sourceless image deployment that uses
  * import-based model auth. The OAuth-mode config is already baked into the

package/dist/distribution/imageRuntimeAuth.js

@@ -2,8 +2,71 @@ import path from "node:path";
 import { loadImportedClaudeCodeCredential, loadImportedCodexCredential } from "../auth/index.js";
 import { fileExists } from "../filesystem/index.js";
 import { getRuntimeAdapter } from "../runtime/index.js";
+import { DAIMON_AGY_SUBSCRIPTION_REALM, DAIMON_ENGINE_CREDENTIALS, DAIMON_GROK_SUBSCRIPTION_REALM } from "../runtime/daimon/contractManifest.js";
+import { assertDaimonCredentialContainerOwner, assertSafeDaimonSourceFile, DAIMON_AGY_UNLOCK_SOURCE_ENV, DAIMON_CREDENTIAL_CONTAINER_UID, daimonSourcePathForEngine } from "../runtime/daimon/runAuth.js";
 import { SpawnfileError } from "../shared/index.js";
 const importMountTargetName = (kind) => kind === "claude-code" ? ".claude" : ".codex";
+const daimonNodeSlug = (nodeId) => nodeId.replace(/^agent:/u, "").toLowerCase()
+    .replace(/[^a-z0-9]+/gu, "-").replace(/^-+|-+$/gu, "");
+const daimonInstanceRoot = (instance) => {
+    const root = path.posix.join("/var/lib/spawnfile/instances/daimon", instance.id);
+    if (instance.config_path !== path.posix.join(root, "daimon/daimon-organization-runtime.json")
+        || instance.workspace_path !== path.posix.join(root, "workspace")) {
+        throw new SpawnfileError("validation_error", "Daimon image runtime paths are not canonical");
+    }
+    return root;
+};
+export const prepareDaimonImageAuthMounts = async (instance, environment, authProfile, containerCredentialUid = DAIMON_CREDENTIAL_CONTAINER_UID) => {
+    const engines = Object.entries(instance.engine_by_node_id ?? {}).sort(([left], [right]) => left.localeCompare(right));
+    if (engines.length === 0) {
+        throw new SpawnfileError("validation_error", "Daimon image report is missing its engine map");
+    }
+    const engineNodeIds = engines.map(([nodeId]) => nodeId);
+    if (JSON.stringify(engineNodeIds) !== JSON.stringify([...instance.node_ids].sort())) {
+        throw new SpawnfileError("validation_error", "Daimon image engine map does not match its declared agents");
+    }
+    if (engines.some(([, engine]) => engine !== "agy" && engine !== "codex" && engine !== "grok")) {
+        throw new SpawnfileError("validation_error", "Daimon image report declares an unsupported engine");
+    }
+    const root = daimonInstanceRoot(instance);
+    const mounts = [];
+    const slugs = new Map();
+    for (const [nodeId] of engines) {
+        const slug = daimonNodeSlug(nodeId);
+        if (!slug || slugs.has(slug))
+            throw new SpawnfileError("validation_error", "Daimon image report has an unsafe agent id");
+        slugs.set(slug, nodeId);
+    }
+    const codexSource = engines.some(([, engine]) => engine === "codex")
+        ? daimonSourcePathForEngine("codex", environment, authProfile) : null;
+    if (codexSource) {
+        const ownerUid = await assertSafeDaimonSourceFile(codexSource, "codex", 64 * 1024, "codex");
+        assertDaimonCredentialContainerOwner(ownerUid, "codex", containerCredentialUid);
+    }
+    for (const [nodeId, engine] of engines) {
+        if (engine !== "codex")
+            continue;
+        const slug = daimonNodeSlug(nodeId);
+        const target = path.posix.join(root, "runtime-homes", slug, DAIMON_ENGINE_CREDENTIALS.codex.sourceRelativePath);
+        mounts.push("-v", `${codexSource}:${target}:ro`);
+    }
+    // The Grok bootstrap leaf is deliberately exempt from the container-owner
+    // assertion; see the matching note in runAuth.ts.
+    if (engines.some(([, engine]) => engine === "grok")) {
+        const source = daimonSourcePathForEngine("grok", environment);
+        await assertSafeDaimonSourceFile(source, "grok", DAIMON_GROK_SUBSCRIPTION_REALM.maxCredentialBytes, "grok");
+        mounts.push("-v", `${source}:${DAIMON_GROK_SUBSCRIPTION_REALM.bootstrapMountPath}:ro`);
+    }
+    if (engines.some(([, engine]) => engine === "agy")) {
+        const source = environment[DAIMON_AGY_UNLOCK_SOURCE_ENV]?.trim();
+        if (!source)
+            throw new SpawnfileError("validation_error", "Daimon runtime auth is missing the operator-authorized AGY realm unlock artifact");
+        const ownerUid = await assertSafeDaimonSourceFile(source, "AGY realm unlock", DAIMON_AGY_SUBSCRIPTION_REALM.maxUnlockBytes);
+        assertDaimonCredentialContainerOwner(ownerUid, "AGY realm unlock", containerCredentialUid);
+        mounts.push("-v", `${source}:${DAIMON_AGY_SUBSCRIPTION_REALM.unlockMountPath}:ro`);
+    }
+    return mounts;
+};
 /**
  * Builds the credential mounts for a sourceless image deployment that uses
  * import-based model auth. The OAuth-mode config is already baked into the
@@ -19,6 +82,12 @@ export const prepareImageRuntimeAuthMounts = async (input) => {
         if (instance.home_path) {
             runtimeHomes.add(instance.home_path);
         }
+        if (instance.runtime === "daimon") {
+            mountArgs.push(...await prepareDaimonImageAuthMounts(instance, input.sourceEnvironment ?? process.env, input.authProfile, input.daimonContainerCredentialUid ?? DAIMON_CREDENTIAL_CONTAINER_UID));
+            continue;
+        }
+        if (!input.authProfile)
+            continue;
         const adapter = getRuntimeAdapter(instance.runtime);
         if (!adapter.prepareRuntimeAuth) {
             continue;
@@ -45,7 +114,7 @@ export const prepareImageRuntimeAuthMounts = async (input) => {
     // Mount the raw credential import directories into each runtime home so the
     // runtime's OAuth client can read them (e.g. ~/.claude, ~/.codex).
     for (const kind of ["claude-code", "codex"]) {
-        const entry = input.authProfile.imports[kind];
+        const entry = input.authProfile?.imports[kind];
         if (!entry) {
             continue;
         }

package/dist/distribution/index.d.ts

@@ -6,7 +6,7 @@ export type { DockerCommandRunner, ExtractImageOptions, ImageInspection } from "
 export { parseDistributionReport } from "./distributionReportSchema.js";
 export { consumeImageUp } from "./consumeImage.js";
 export type { ConsumeImageUpOptions, ConsumeImageUpResult } from "./consumeImage.js";
-export { deriveDeploymentName, deriveVolumeName, renderEnvFileContent, resolveImageEnvironment } from "./consumeImageSupport.js";
+export { deriveDeploymentName, derivePersistentMountVolumeName, deriveVolumeName, renderEnvFileContent, resolveImageEnvironment } from "./consumeImageSupport.js";
 export { createConsumerDockerRunner } from "./dockerRunner.js";
 export { prepareImageRuntimeAuthMounts } from "./imageRuntimeAuth.js";
 export { runImagePreflight } from "./preflight.js";

package/dist/distribution/index.js

@@ -3,7 +3,7 @@ export { createDistributionFingerprint } from "./fingerprint.js";
 export { extractImageReport, resolveDockerBaseArgs } from "./extractImage.js";
 export { parseDistributionReport } from "./distributionReportSchema.js";
 export { consumeImageUp } from "./consumeImage.js";
-export { deriveDeploymentName, deriveVolumeName, renderEnvFileContent, resolveImageEnvironment } from "./consumeImageSupport.js";
+export { deriveDeploymentName, derivePersistentMountVolumeName, deriveVolumeName, renderEnvFileContent, resolveImageEnvironment } from "./consumeImageSupport.js";
 export { createConsumerDockerRunner } from "./dockerRunner.js";
 export { prepareImageRuntimeAuthMounts } from "./imageRuntimeAuth.js";
 export { runImagePreflight } from "./preflight.js";

package/dist/distribution/preflight.js

@@ -1,5 +1,9 @@
 import { SpawnfileError } from "../shared/index.js";
 const ENV_BASED_AUTH_METHODS = new Set(["api_key", "none"]);
+// Satisfied by the runtime's own credential slot (the Daimon Grok broker's
+// bootstrap realm, checked by `imageRuntimeAuth.ts`), never by an env value
+// or a host CLI import.
+const RUNTIME_OWNED_AUTH_METHODS = new Set(["grok"]);
 // Import-based auth methods are satisfiable sourceless when the consumer has the
 // matching local credential import (their logged-in Claude Code / Codex session).
 const IMPORT_AUTH_METHOD_KINDS = {
@@ -10,7 +14,7 @@ const collectUnsupportedAuth = (report, availableImports) => {
     const unsupported = [];
     for (const instance of report.runtime_instances) {
         for (const [provider, method] of Object.entries(instance.model_auth_methods)) {
-            if (ENV_BASED_AUTH_METHODS.has(method)) {
+            if (ENV_BASED_AUTH_METHODS.has(method) || RUNTIME_OWNED_AUTH_METHODS.has(method)) {
                 continue;
             }
             const importKind = IMPORT_AUTH_METHOD_KINDS[method];

package/dist/distribution/renderImageInterface.js

@@ -80,7 +80,7 @@ export const renderImageInterface = (report, options) => {
     lines.push("");
     lines.push(`next: spawnfile up ${summary.imageRef} --auth-profile <profile>`);
     if (summary.requiredSecrets.length > 0) {
-        lines.push("  supply the required secrets above via that profile or --env-file");
+        lines.push("  supply the required secrets above via that profile or --runtime-env-file");
     }
     return lines.join("\n");
 };

package/dist/distribution/types.d.ts

@@ -1,4 +1,5 @@
 import type { ModelAuthMethod } from "../shared/index.js";
+import type { RecordingReport, WorkspaceResourceOwnership } from "../report/index.js";
 export type DistributionSecretCategory = "model" | "project" | "runtime" | "surface";
 export interface DistributionSecretEntry {
     generated: boolean;
@@ -22,14 +23,24 @@ export interface DistributionOrganizationSummary {
     teams: DistributionTeamSummary[];
 }
 export interface DistributionPersistentMount {
+    /**
+     * The author's own volume name for this mount, when the manifest declared
+     * one. The report never carries a compiler-DERIVED name — that encodes the
+     * creator's plan root and deployment lineage and stays private to that host
+     * — but a declared name belongs to the published declaration and a consumer
+     * honours it verbatim, so an operator who pre-created that volume attaches
+     * it instead of silently getting an empty one.
+     */
+    declared_volume_name?: string;
     durability: "persistent";
     id: string;
     kind: "volume";
+    lifecycle?: "exclusive-reattach";
     target: string;
 }
 export interface DistributionWorkspaceResource {
     id: string;
-    kind: "git" | "volume";
+    kind: "bundle" | "git" | "volume";
     link_path: string;
     mode: "mutable" | "readonly";
     mount: string;
@@ -37,6 +48,7 @@ export interface DistributionWorkspaceResource {
 }
 export interface DistributionRuntimeInstance {
     config_path: string;
+    engine_by_node_id?: Record<string, string>;
     home_path: string | null;
     id: string;
     internal_port: number | null;
@@ -45,8 +57,11 @@ export interface DistributionRuntimeInstance {
     node_ids: string[];
     published_port: number | null;
     runtime: string;
+    telemetry_mount_ids?: Record<string, string>;
     workspace_path: string;
 }
+export declare const DISTRIBUTION_ENGINE_KINDS: readonly ["agy", "claude", "codex", "grok", "pi", "scripted"];
+export type DistributionEngineKind = typeof DISTRIBUTION_ENGINE_KINDS[number];
 export interface DistributionMoltnetNetwork {
     binding: "env";
     id: string;
@@ -73,10 +88,23 @@ export interface DistributionReport {
     persistent_mounts: DistributionPersistentMount[];
     port_mappings: DistributionPortMapping[];
     ports: number[];
+    recording?: RecordingReport;
     resources: DistributionWorkspaceResource[];
     runtime_instances: DistributionRuntimeInstance[];
     secrets: Record<DistributionSecretCategory, DistributionSecretEntry[]>;
     version: "spawnfile.distribution-report.v1";
+    /** Recording-only pins; ids are workspace resource ids, never scoped report keys. */
+    workspace_git_resources?: Array<WorkspaceResourceOwnership & {
+        id: string;
+        commit: string;
+        sha256: string;
+    }>;
+    /** Recording-only bundle identity; no creator-host paths or URLs are published. */
+    workspace_bundles?: Array<WorkspaceResourceOwnership & {
+        id: string;
+        sha256: string;
+        origin?: string;
+    }>;
     world_bindings?: DistributionWorldBindingsEvidence;
 }
 export declare const DISTRIBUTION_REPORT_VERSION = "spawnfile.distribution-report.v1";

package/dist/distribution/types.js

@@ -1,3 +1,6 @@
+export const DISTRIBUTION_ENGINE_KINDS = [
+    "agy", "claude", "codex", "grok", "pi", "scripted"
+];
 export const DISTRIBUTION_REPORT_VERSION = "spawnfile.distribution-report.v1";
 export const DISTRIBUTION_REPORT_IMAGE_PATH = "/spawnfile/spawnfile-report.json";
 export const DISTRIBUTION_REPORT_OUTPUT_FILE = "distribution-report.json";

package/dist/evidenceExportHelper/boundedExecutor.d.ts

@@ -0,0 +1,3 @@
+import { type DockerArtifactExecutor } from "../target/dockerArtifactsProvider.js";
+/** Tree-safe private Docker executor used at every local-helper boundary. */
+export declare const createPreparedEvidenceHelperExecutor: (dockerCommand: string) => DockerArtifactExecutor;

package/dist/evidenceExportHelper/boundedExecutor.js

@@ -0,0 +1,33 @@
+import { DockerArtifactProviderError, } from "../target/dockerArtifactsProvider.js";
+import { createBoundedDockerTargetExecFile, DockerTargetCommandFailure, } from "../target/dockerTargetExecFile.js";
+const missingExactImage = (args, error) => {
+    if (!(error instanceof DockerTargetCommandFailure))
+        return false;
+    const command = args[0] === "--context" ? args.slice(2) : args;
+    if (command.length !== 5 || command[0] !== "image" || command[1] !== "inspect"
+        || command[3] !== "--format")
+        return false;
+    const match = /^(?:Error response from daemon: )?No such image: ([A-Za-z0-9_.:@/-]+)$/u
+        .exec(error.stderr.trim());
+    return match?.[1] === command[2];
+};
+/** Tree-safe private Docker executor used at every local-helper boundary. */
+export const createPreparedEvidenceHelperExecutor = (dockerCommand) => {
+    const execute = createBoundedDockerTargetExecFile();
+    return async (file, args, options) => {
+        if (file !== "docker")
+            throw new Error("Prepared evidence-export helper failed");
+        try {
+            return await execute(dockerCommand, args, {
+                signal: options.signal,
+                stdin: options.stdin,
+                timeout: options.timeout,
+            });
+        }
+        catch (error) {
+            if (missingExactImage(args, error))
+                throw new DockerArtifactProviderError("image_not_found");
+            throw error;
+        }
+    };
+};