spawnfile 0.1.14 → 0.1.17

package/dist/evidenceExportHelper/preparedBuilder.js

@@ -0,0 +1,183 @@
+import { createHash } from "node:crypto";
+import { parseDockerBaseImageReference } from "../target/dockerBaseImage.js";
+import { DockerArtifactProviderError, } from "../target/dockerArtifactsProvider.js";
+import { EVIDENCE_EXPORT_HELPER_CONTRACT_LABEL, EVIDENCE_EXPORT_HELPER_CONTRACT_VERSION, EVIDENCE_EXPORT_HELPER_ENTRYPOINT, EVIDENCE_EXPORT_HELPER_ENV, EVIDENCE_EXPORT_HELPER_USER, } from "../target/evidenceExportProvider.js";
+import { createPreparedEvidenceHelperKey, initializePreparedEvidenceHelperAuthorityStore, newPreparedEvidenceHelperCompletionRecord, newPreparedEvidenceHelperPendingRecord, } from "./preparedAuthority.js";
+import { loadLocalEvidenceHelperRecipe } from "./recipe.js";
+const ERROR = "Prepared evidence-export helper failed";
+const CONTEXT = /^[a-z][a-z0-9_-]{0,63}$/u;
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const BUILD_ID = /^(sha256:[a-f0-9]{64})(?:\r?\n)?$/u;
+const MAX_OUTPUT = 65_536;
+const BASE_FORMAT = "[{\"Architecture\":{{json .Architecture}},\"Id\":{{json .Id}},\"Os\":{{json .Os}}}]";
+const IMAGE_FORMAT = "[{\"Architecture\":{{json .Architecture}},\"Config\":{\"Cmd\":{{json (index .Config \"Cmd\")}},\"Entrypoint\":{{json (index .Config \"Entrypoint\")}},\"Env\":{{json (index .Config \"Env\")}},\"ExposedPorts\":{{json (index .Config \"ExposedPorts\")}},\"Healthcheck\":{{json (index .Config \"Healthcheck\")}},\"Labels\":{{json (index .Config \"Labels\")}},\"User\":{{json (index .Config \"User\")}},\"Volumes\":{{json (index .Config \"Volumes\")}}},\"Id\":{{json .Id}},\"Os\":{{json .Os}}}]";
+const live = new Map();
+const fail = () => { throw new Error(ERROR); };
+const hash = (domain, value) => `sha256:${createHash("sha256").update(`spawnfile.evidence-helper.${domain}.v1\0`).update(value).digest("hex")}`;
+const exact = (raw, keys) => raw !== null && typeof raw === "object" && !Array.isArray(raw)
+    && Object.getPrototypeOf(raw) === Object.prototype
+    && Object.keys(raw).sort().join("\0") === [...keys].sort().join("\0");
+const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const digest = (raw) => typeof raw === "string" && DIGEST.test(raw) ? raw : fail();
+const timeout = (raw) => raw === undefined ? 120_000
+    : typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 1 && raw <= 120_000 ? raw : fail();
+const parse = (raw) => { try {
+    return JSON.parse(raw);
+}
+catch {
+    return fail();
+} };
+const hook = async (value) => { if (value)
+    await value(); };
+const execution = (input, value) => {
+    if (!CONTEXT.test(input.context) || typeof input.executor !== "function")
+        return fail();
+    const run = async (args, stdin) => {
+        const result = await input.executor("docker", ["--context", input.context, ...args], {
+            ...(input.signal ? { signal: input.signal } : {}), timeout: value, ...(stdin ? { stdin } : {}),
+        });
+        if (!result || typeof result.stdout !== "string" || typeof result.stderr !== "string"
+            || Buffer.byteLength(result.stdout, "utf8") > MAX_OUTPUT || Buffer.byteLength(result.stderr, "utf8") > MAX_OUTPUT)
+            return fail();
+        return result.stdout;
+    };
+    return Object.freeze({ run });
+};
+const localFacts = async (run, context, baseImage) => {
+    const endpoint = parse((await run([
+        "context", "inspect", context, "--format", "{{json .Endpoints.docker.Host}}",
+    ])).trim());
+    if (typeof endpoint !== "string" || !/^(?:fd|npipe|unix):\/\/[^\s]+$/u.test(endpoint))
+        return fail();
+    const daemon = parse(await run(["info", "--format", "{\"Architecture\":{{json .Architecture}},\"DockerRootDir\":{{json .DockerRootDir}},\"OSType\":{{json .OSType}},\"ServerVersion\":{{json .ServerVersion}}}"]));
+    if (!exact(daemon, ["Architecture", "DockerRootDir", "OSType", "ServerVersion"])
+        || daemon.OSType !== "linux" || typeof daemon.DockerRootDir !== "string" || typeof daemon.ServerVersion !== "string")
+        return fail();
+    const architecture = ["amd64", "x64", "x86_64"].includes(daemon.Architecture) ? "amd64"
+        : ["arm64", "aarch64"].includes(daemon.Architecture) ? "arm64" : fail();
+    const image = parse(await run(["image", "inspect", baseImage, "--format", BASE_FORMAT]));
+    if (!Array.isArray(image) || image.length !== 1 || !exact(image[0], ["Architecture", "Id", "Os"])
+        || image[0].Os !== "linux" || image[0].Architecture !== architecture)
+        return fail();
+    return Object.freeze({ baseConfig: digest(image[0].Id), daemonDigest: hash("daemon", JSON.stringify(daemon)),
+        endpointDigest: hash("endpoint", endpoint), platform: Object.freeze({ architecture, os: "linux" }) });
+};
+const inspectHelper = async (run, reference, facts) => {
+    const image = parse(await run(["image", "inspect", reference, "--format", IMAGE_FORMAT]));
+    if (!Array.isArray(image) || image.length !== 1 || !exact(image[0], ["Architecture", "Config", "Id", "Os"])
+        || image[0].Architecture !== facts.platform.architecture || image[0].Os !== "linux"
+        || !exact(image[0].Config, ["Cmd", "Entrypoint", "Env", "ExposedPorts", "Healthcheck", "Labels", "User", "Volumes"]))
+        return fail();
+    const config = image[0].Config;
+    if (!same(config.Entrypoint, EVIDENCE_EXPORT_HELPER_ENTRYPOINT)
+        || config.Cmd !== null && !same(config.Cmd, []) || !same(config.Env, EVIDENCE_EXPORT_HELPER_ENV)
+        || config.ExposedPorts !== null
+        || config.Healthcheck !== null || config.Volumes !== null || config.User !== EVIDENCE_EXPORT_HELPER_USER
+        || !exact(config.Labels, [EVIDENCE_EXPORT_HELPER_CONTRACT_LABEL])
+        || config.Labels[EVIDENCE_EXPORT_HELPER_CONTRACT_LABEL] !== EVIDENCE_EXPORT_HELPER_CONTRACT_VERSION)
+        return fail();
+    return digest(image[0].Id);
+};
+const inspectMaybe = async (run, reference, facts) => {
+    try {
+        return await inspectHelper(run, reference, facts);
+    }
+    catch (error) {
+        if (error instanceof DockerArtifactProviderError && error.kind === "image_not_found")
+            return null;
+        throw error;
+    }
+};
+const matching = (record, baseImage, facts, recipe) => record.base_image === baseImage && record.base_config_digest === facts.baseConfig && record.daemon_digest === facts.daemonDigest
+    && record.endpoint_digest === facts.endpointDigest && same(record.platform, facts.platform)
+    && record.recipe_digest === recipe.recipeDigest;
+const build = async (input, run, facts, recipe) => {
+    await hook(input.testHooks?.beforeBuild);
+    const output = await run(["build", "--quiet", "--pull=false", "--network=none", "--platform",
+        `${facts.platform.os}/${facts.platform.architecture}`, "--build-arg", `SPAWNFILE_HELPER_BASE=${facts.baseConfig}`,
+        "-"], recipe.context);
+    const produced = BUILD_ID.exec(output)?.[1];
+    if (!produced)
+        return fail();
+    await hook(input.testHooks?.afterBuild);
+    // Docker's quiet build result is the image config ID produced by this exact
+    // invocation. Re-attest that immutable ID, never a mutable tag.
+    const inspected = await inspectHelper(run, produced, facts);
+    return inspected === produced ? inspected : fail();
+};
+const receiptOwner = async (input, baseImage, facts, recipe, key, run) => {
+    const store = await initializePreparedEvidenceHelperAuthorityStore(input.privateRoot);
+    await hook(input.testHooks?.beforeReserve);
+    const pending = await store.reserve(key, newPreparedEvidenceHelperPendingRecord({
+        base_config_digest: facts.baseConfig, base_image: baseImage, context: input.context,
+        daemon_digest: facts.daemonDigest, endpoint_digest: facts.endpointDigest, platform: facts.platform,
+        recipe_digest: recipe.recipeDigest
+    }));
+    await hook(input.testHooks?.afterReserve);
+    if (!matching(pending, baseImage, facts, recipe))
+        return fail();
+    const authority = await store.load(key);
+    if (!authority)
+        return fail();
+    if (authority.completion) {
+        let observed = await inspectMaybe(run, authority.completion.accepted_image_config_digest, facts);
+        if (observed === null)
+            observed = await build(input, run, facts, recipe);
+        if (observed !== authority.completion.accepted_image_config_digest)
+            return fail();
+        await hook(input.testHooks?.beforeReceipt);
+        return authority.completion.receipt;
+    }
+    const produced = await build(input, run, facts, recipe);
+    await hook(input.testHooks?.beforeComplete);
+    const completion = await store.complete(key, newPreparedEvidenceHelperCompletionRecord(pending, produced));
+    await hook(input.testHooks?.afterComplete);
+    if (completion.accepted_image_config_digest !== produced)
+        return fail();
+    await hook(input.testHooks?.beforeReceipt);
+    return completion.receipt;
+};
+/** Re-attests a completion-bound local config identity or rebuilds an absent exact config. */
+export const prepareEvidenceExportHelper = async (input) => {
+    const targetTimeout = timeout(input.timeoutMs);
+    const baseImage = parseDockerBaseImageReference(input.baseImage) ?? fail();
+    const run = execution(input, targetTimeout).run;
+    const recipe = await loadLocalEvidenceHelperRecipe();
+    const facts = await localFacts(run, input.context, baseImage);
+    const key = createPreparedEvidenceHelperKey({ baseConfigDigest: facts.baseConfig, context: input.context,
+        daemonDigest: facts.daemonDigest, endpointDigest: facts.endpointDigest, platform: facts.platform,
+        recipeDigest: recipe.recipeDigest });
+    const mapKey = `${input.privateRoot}\0${key}`;
+    const joined = live.get(mapKey);
+    if (joined)
+        return joined;
+    const promise = receiptOwner(input, baseImage, facts, recipe, key, run);
+    live.set(mapKey, promise);
+    try {
+        return await promise;
+    }
+    finally {
+        if (live.get(mapKey) === promise)
+            live.delete(mapKey);
+    }
+};
+/** Private target lowering resolves the config digest only after receipt-correlated reattestation. */
+export const resolvePreparedEvidenceHelperImage = async (input, receipt) => {
+    const actual = await prepareEvidenceExportHelper(input);
+    if (actual.handle !== receipt.handle || actual.digest !== receipt.digest)
+        return fail();
+    const baseImage = parseDockerBaseImageReference(input.baseImage) ?? fail();
+    const run = execution(input, timeout(input.timeoutMs)).run;
+    const facts = await localFacts(run, input.context, baseImage);
+    const recipe = await loadLocalEvidenceHelperRecipe();
+    const store = await initializePreparedEvidenceHelperAuthorityStore(input.privateRoot);
+    const key = createPreparedEvidenceHelperKey({ baseConfigDigest: facts.baseConfig, context: input.context,
+        daemonDigest: facts.daemonDigest, endpointDigest: facts.endpointDigest, platform: facts.platform,
+        recipeDigest: recipe.recipeDigest });
+    const authority = await store.load(key);
+    if (!authority?.completion || authority.completion.receipt.handle !== receipt.handle
+        || authority.completion.receipt.digest !== receipt.digest)
+        return fail();
+    return Object.freeze({ configDigest: authority.completion.accepted_image_config_digest,
+        imageReference: authority.completion.accepted_image_config_digest });
+};

package/dist/evidenceExportHelper/preparedBuilderTypes.d.ts

@@ -0,0 +1,19 @@
+import type { DockerArtifactExecutor } from "../target/dockerArtifactsProvider.js";
+export interface PrepareEvidenceHelperInput {
+    readonly baseImage: string;
+    readonly context: string;
+    readonly executor: DockerArtifactExecutor;
+    readonly privateRoot: string;
+    readonly signal?: AbortSignal;
+    /** Test-only fault injection at durable/mutation/receipt boundaries. */
+    readonly testHooks?: {
+        readonly afterBuild?: () => Promise<void> | void;
+        readonly afterComplete?: () => Promise<void> | void;
+        readonly afterReserve?: () => Promise<void> | void;
+        readonly beforeBuild?: () => Promise<void> | void;
+        readonly beforeComplete?: () => Promise<void> | void;
+        readonly beforeReceipt?: () => Promise<void> | void;
+        readonly beforeReserve?: () => Promise<void> | void;
+    };
+    readonly timeoutMs?: number;
+}

package/dist/evidenceExportHelper/preparedBuilderTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/evidenceExportHelper/recipe.d.ts

@@ -0,0 +1,7 @@
+export declare const LOCAL_EVIDENCE_HELPER_RECIPE_VERSION: "spawnfile.local-evidence-export-helper.recipe.v1";
+export interface LocalEvidenceHelperRecipe {
+    readonly artifactManifestDigest: `sha256:${string}`;
+    readonly context: Uint8Array;
+    readonly recipeDigest: `sha256:${string}`;
+}
+export declare const loadLocalEvidenceHelperRecipe: () => Promise<LocalEvidenceHelperRecipe>;

package/dist/evidenceExportHelper/recipe.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { EVIDENCE_EXPORT_HELPER_PATH } from "../target/evidenceExportProvider.js";
+export const LOCAL_EVIDENCE_HELPER_RECIPE_VERSION = "spawnfile.local-evidence-export-helper.recipe.v1";
+const BLOCK = 512;
+const MAX_SOURCE_BYTES = 65_536;
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const fail = () => { throw new Error("Local evidence-export helper recipe failed"); };
+const octal = (value, width) => {
+    const raw = value.toString(8);
+    if (!Number.isSafeInteger(value) || value < 0 || raw.length > width - 1)
+        return fail();
+    return Buffer.from(`${raw.padStart(width - 1, "0")}\0`, "ascii");
+};
+const checksum = (header) => {
+    header.fill(0x20, 148, 156);
+    let sum = 0;
+    for (const byte of header)
+        sum += byte;
+    if (sum > 0o777777)
+        return fail();
+    header.set(Buffer.from(`${sum.toString(8).padStart(6, "0")}\0 `, "ascii"), 148);
+};
+const archive = (entries) => {
+    const output = [];
+    for (const entry of [...entries].sort((left, right) => Buffer.compare(Buffer.from(left.path), Buffer.from(right.path)))) {
+        const name = Buffer.from(entry.path, "utf8");
+        if (name.byteLength < 1 || name.byteLength > 100
+            || entry.mode !== 0o444 && entry.mode !== 0o555)
+            return fail();
+        const header = Buffer.alloc(BLOCK);
+        header.set(name, 0);
+        header.set(octal(entry.mode, 8), 100);
+        header.set(octal(0, 8), 108);
+        header.set(octal(0, 8), 116);
+        header.set(octal(entry.bytes.byteLength, 12), 124);
+        header.set(octal(0, 12), 136);
+        header[156] = 48;
+        header.set(Buffer.from("ustar\0", "ascii"), 257);
+        header.set(Buffer.from("00", "ascii"), 263);
+        header.set(octal(0, 8), 329);
+        header.set(octal(0, 8), 337);
+        checksum(header);
+        output.push(header, Buffer.from(entry.bytes));
+        const padding = (BLOCK - entry.bytes.byteLength % BLOCK) % BLOCK;
+        if (padding > 0)
+            output.push(Buffer.alloc(padding));
+    }
+    output.push(Buffer.alloc(BLOCK), Buffer.alloc(BLOCK));
+    return Buffer.concat(output);
+};
+const dockerfile = Buffer.from([
+    "ARG SPAWNFILE_HELPER_BASE",
+    "FROM ${SPAWNFILE_HELPER_BASE} AS runtime",
+    "FROM scratch",
+    "COPY --from=runtime / /",
+    "COPY helperProgram.mjs /bin/spawnfile-export-helper",
+    "LABEL spawnfile.target.evidence-export.helper-contract=\"v1\"",
+    `ENV PATH=${EVIDENCE_EXPORT_HELPER_PATH}`,
+    "USER 65534:65534",
+    "ENTRYPOINT [\"/bin/spawnfile-export-helper\"]",
+    "CMD []",
+    "",
+].join("\n"), "utf8");
+const digest = (domain, bytes) => `sha256:${createHash("sha256")
+    .update(`spawnfile.local-evidence-export-helper.${domain}.v1\0`, "utf8")
+    .update(bytes)
+    .digest("hex")}`;
+export const loadLocalEvidenceHelperRecipe = async () => {
+    const source = await readFile(new URL("./helperProgram.mjs", import.meta.url));
+    if (source.byteLength < 1 || source.byteLength > MAX_SOURCE_BYTES
+        || !source.subarray(0, 22).toString("utf8").startsWith("#!/usr/local/bin/node"))
+        return fail();
+    const context = archive([
+        { bytes: dockerfile, mode: 0o444, path: "Dockerfile" },
+        { bytes: source, mode: 0o555, path: "helperProgram.mjs" },
+    ]);
+    const recipeDigest = digest("recipe", context);
+    const artifactManifestDigest = digest("artifact-manifest", recipeDigest);
+    if (!DIGEST.test(recipeDigest) || !DIGEST.test(artifactManifestDigest))
+        return fail();
+    return Object.freeze({ artifactManifestDigest, context, recipeDigest });
+};

package/dist/filesystem/io.d.ts

@@ -3,9 +3,11 @@ export interface CopyDirectoryOptions {
 }
 export declare const copyDirectory: (sourcePath: string, destinationPath: string, options?: CopyDirectoryOptions) => Promise<void>;
 export declare const ensureDirectory: (directoryPath: string) => Promise<void>;
+export declare const ensurePrivateDirectory: (directoryPath: string) => Promise<void>;
 export declare const fileExists: (filePath: string) => Promise<boolean>;
 export declare const isSymlink: (filePath: string) => Promise<boolean>;
 export declare const readUtf8File: (filePath: string) => Promise<string>;
 export declare const ensureGitignoreEntry: (directoryPath: string, entry: string) => Promise<boolean>;
 export declare const removeDirectory: (directoryPath: string) => Promise<void>;
 export declare const writeUtf8File: (filePath: string, content: string) => Promise<void>;
+export declare const writePrivateUtf8File: (filePath: string, content: string) => Promise<void>;

package/dist/filesystem/io.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { cp, mkdir, lstat, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { chmod, cp, mkdir, lstat, open, readFile, rm, stat, writeFile } from "node:fs/promises";
 export const copyDirectory = async (sourcePath, destinationPath, options = {}) => {
     await cp(sourcePath, destinationPath, {
         filter: options.filter,
@@ -10,6 +10,10 @@ export const copyDirectory = async (sourcePath, destinationPath, options = {}) =
 export const ensureDirectory = async (directoryPath) => {
     await mkdir(directoryPath, { recursive: true });
 };
+export const ensurePrivateDirectory = async (directoryPath) => {
+    await mkdir(directoryPath, { recursive: true, mode: 0o700 });
+    await chmod(directoryPath, 0o700);
+};
 export const fileExists = async (filePath) => {
     try {
         await stat(filePath);
@@ -55,3 +59,14 @@ export const removeDirectory = async (directoryPath) => {
 export const writeUtf8File = async (filePath, content) => {
     await writeFile(filePath, content, "utf8");
 };
+export const writePrivateUtf8File = async (filePath, content) => {
+    const handle = await open(filePath, "w", 0o600);
+    try {
+        // Creation mode does not change an existing file's permissions.
+        await handle.chmod(0o600);
+        await handle.writeFile(content, "utf8");
+    }
+    finally {
+        await handle.close();
+    }
+};

package/dist/manifest/executionSchemas.d.ts

@@ -1,10 +1,17 @@
 import { z } from "zod";
+/**
+ * The closed reasoning-effort vocabulary a brokered Daimon Grok worker accepts
+ * (`DAIMON_GROK_BROKER_REASONING_EFFORTS`). Only valid on a target that
+ * declares `auth.method: grok` itself; it is never inherited.
+ */
+export declare const MODEL_REASONING_EFFORTS: readonly ["low", "medium", "high"];
 export declare const modelEntryAuthSchema: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     method: z.ZodOptional<z.ZodEnum<{
         api_key: "api_key";
         "claude-code": "claude-code";
         codex: "codex";
+        grok: "grok";
         none: "none";
     }>>;
 }, z.core.$strict>;
@@ -22,6 +29,7 @@ export declare const modelTargetSchema: z.ZodObject<{
             api_key: "api_key";
             "claude-code": "claude-code";
             codex: "codex";
+            grok: "grok";
             none: "none";
         }>>;
     }, z.core.$strict>>;
@@ -34,6 +42,11 @@ export declare const modelTargetSchema: z.ZodObject<{
     }, z.core.$strict>>;
     name: z.ZodString;
     provider: z.ZodString;
+    reasoning_effort: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
 }, z.core.$strict>;
 export declare const executionSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodObject<{
@@ -42,12 +55,14 @@ export declare const executionSchema: z.ZodObject<{
                 api_key: "api_key";
                 "claude-code": "claude-code";
                 codex: "codex";
+                grok: "grok";
                 none: "none";
             }>>;
             methods: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
                 api_key: "api_key";
                 "claude-code": "claude-code";
                 codex: "codex";
+                grok: "grok";
                 none: "none";
             }>>>;
         }, z.core.$strict>>;
@@ -58,6 +73,7 @@ export declare const executionSchema: z.ZodObject<{
                     api_key: "api_key";
                     "claude-code": "claude-code";
                     codex: "codex";
+                    grok: "grok";
                     none: "none";
                 }>>;
             }, z.core.$strict>>;
@@ -70,6 +86,11 @@ export declare const executionSchema: z.ZodObject<{
             }, z.core.$strict>>;
             name: z.ZodString;
             provider: z.ZodString;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
         }, z.core.$strict>>>;
         primary: z.ZodObject<{
             auth: z.ZodOptional<z.ZodObject<{
@@ -78,6 +99,7 @@ export declare const executionSchema: z.ZodObject<{
                     api_key: "api_key";
                     "claude-code": "claude-code";
                     codex: "codex";
+                    grok: "grok";
                     none: "none";
                 }>>;
             }, z.core.$strict>>;
@@ -90,6 +112,11 @@ export declare const executionSchema: z.ZodObject<{
             }, z.core.$strict>>;
             name: z.ZodString;
             provider: z.ZodString;
+            reasoning_effort: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
         }, z.core.$strict>;
     }, z.core.$strict>>;
     sandbox: z.ZodOptional<z.ZodObject<{

package/dist/manifest/executionSchemas.js

@@ -1,5 +1,11 @@
 import { z } from "zod";
-const modelAuthMethodSchema = z.enum(["api_key", "claude-code", "codex", "none"]);
+const modelAuthMethodSchema = z.enum(["api_key", "claude-code", "codex", "grok", "none"]);
+/**
+ * The closed reasoning-effort vocabulary a brokered Daimon Grok worker accepts
+ * (`DAIMON_GROK_BROKER_REASONING_EFFORTS`). Only valid on a target that
+ * declares `auth.method: grok` itself; it is never inherited.
+ */
+export const MODEL_REASONING_EFFORTS = ["low", "medium", "high"];
 const modelEndpointCompatibilitySchema = z.enum(["anthropic", "openai"]);
 const modelAuthSchema = z
     .object({
@@ -58,10 +64,23 @@ export const modelTargetSchema = z
     auth: modelEntryAuthSchema.optional(),
     endpoint: modelEndpointSchema.optional(),
     name: z.string(),
-    provider: z.string()
+    provider: z.string(),
+    reasoning_effort: z.enum(MODEL_REASONING_EFFORTS).optional()
 })
     .strict()
     .superRefine((value, context) => {
+    if (value.auth?.method === "grok" && (value.provider !== "xai" || value.endpoint)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "grok auth is only valid for provider xai without an endpoint"
+        });
+    }
+    if (value.reasoning_effort !== undefined && value.auth?.method !== "grok") {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "reasoning_effort is only valid on a model that declares auth.method grok"
+        });
+    }
     const usesCustomEndpoint = value.provider === "custom" || value.provider === "local";
     if (usesCustomEndpoint && !value.endpoint) {
         context.addIssue({

package/dist/manifest/mcpSchemas.d.ts

@@ -13,5 +13,6 @@ export declare const mcpServerSchema: z.ZodObject<{
         stdio: "stdio";
         streamable_http: "streamable_http";
     }>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     url: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/dist/manifest/mcpSchemas.js

@@ -22,10 +22,13 @@ export const mcpServerSchema = z
     env: z.record(z.string(), z.string()).optional(),
     name: z.string().min(1),
     transport: z.enum(["sse", "stdio", "streamable_http"]),
+    tools: z.array(z.string().min(1)).max(32).optional(),
     url: z.string().optional()
 })
     .strict()
     .superRefine((value, context) => {
+    if (value.tools !== undefined && (value.tools.length === 0 || new Set(value.tools).size !== value.tools.length))
+        context.addIssue({ code: z.ZodIssueCode.custom, message: "MCP tools must be a nonempty unique allowlist" });
     if (value.name.startsWith("spawnfile.") || value.name.startsWith("mneme-")) {
         context.addIssue({ code: z.ZodIssueCode.custom, message: "MCP server name is reserved for compiler-owned generated services" });
     }

package/dist/manifest/renderSpawnfileNetworks.js

@@ -8,6 +8,16 @@ const orderTeamAuthToken = (token) => withDefinedEntries([
 const orderTeamAuthPairing = (pairing) => withDefinedEntries([
     ["id", pairing.id],
     ["remote_base_url", pairing.remote_base_url],
+    [
+        "relay",
+        pairing.relay
+            ? withDefinedEntries([
+                ["url", pairing.relay.url],
+                ["room", pairing.relay.room],
+                ["token_secret", pairing.relay.token_secret]
+            ])
+            : undefined
+    ],
     ["remote_network_id", pairing.remote_network_id],
     ["remote_network_name", pairing.remote_network_name],
     ["token_secret", pairing.token_secret]
@@ -87,6 +97,7 @@ export const orderTeamNetworks = (networks) => networks?.map((network) => withDe
             ["name", room.name],
             ["visibility", room.visibility],
             ["write_policy", room.write_policy],
+            ["federation", room.federation],
             ["members", room.members]
         ]))
     ]

package/dist/manifest/renderSpawnfileWorkspace.js

@@ -26,6 +26,11 @@ const orderWorkspaceResource = (resource) => {
             ["sharing", resource.sharing]
         ]);
     }
+    if (resource.kind === "bundle")
+        return withDefinedEntries([
+            ["id", resource.id], ["kind", resource.kind], ["source", resource.source],
+            ["sha256", resource.sha256], ["mount", resource.mount], ["mode", resource.mode], ["sharing", resource.sharing]
+        ]);
     return withDefinedEntries([
         ["id", resource.id],
         ["kind", resource.kind],

package/dist/manifest/scheduleSchemas.d.ts

@@ -1,11 +1,13 @@
 import { z } from "zod";
 export declare const agentScheduleSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    cron: z.ZodString;
+    cron: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+    jitter_seconds: z.ZodOptional<z.ZodNumber>;
     kind: z.ZodLiteral<"cron">;
     prompt: z.ZodOptional<z.ZodString>;
     timezone: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     every: z.ZodString;
+    jitter_seconds: z.ZodOptional<z.ZodNumber>;
     kind: z.ZodLiteral<"every">;
     prompt: z.ZodOptional<z.ZodString>;
     timezone: z.ZodOptional<z.ZodString>;