spawnfile 0.1.17 → 0.1.18

package/dist/filesystem/durableWrite.d.ts

@@ -0,0 +1,10 @@
+export declare const syncDirectorySync: (directory: string) => void;
+export declare const syncDirectory: (directory: string) => Promise<void>;
+export declare const syncFileSync: (file: string) => void;
+export declare const syncFile: (file: string) => Promise<void>;
+/** The rename is visible, but directory durability could not be confirmed. */
+export declare class PublishedFileSyncError extends Error {
+}
+/** The caller creates the parent directory and holds its domain writer lock. */
+export declare const writeDurableFileSync: (file: string, bytes: string) => void;
+export declare const writeDurableFile: (file: string, bytes: string) => Promise<void>;

package/dist/filesystem/durableWrite.js

@@ -0,0 +1,87 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, fsyncSync, openSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { open, rename, rm } from "node:fs/promises";
+import path from "node:path";
+export const syncDirectorySync = (directory) => {
+    const fd = openSync(directory, "r");
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+};
+export const syncDirectory = async (directory) => {
+    const handle = await open(directory, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};
+export const syncFileSync = (file) => {
+    const fd = openSync(file, "r");
+    try {
+        fsyncSync(fd);
+    }
+    finally {
+        closeSync(fd);
+    }
+    syncDirectorySync(path.dirname(file));
+};
+export const syncFile = async (file) => {
+    const handle = await open(file, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await syncDirectory(path.dirname(file));
+};
+/** The rename is visible, but directory durability could not be confirmed. */
+export class PublishedFileSyncError extends Error {
+}
+/** The caller creates the parent directory and holds its domain writer lock. */
+export const writeDurableFileSync = (file, bytes) => {
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        const fd = openSync(temporary, "wx", 0o600);
+        try {
+            writeFileSync(fd, bytes, "utf8");
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(temporary, file);
+        syncDirectorySync(path.dirname(file));
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+};
+export const writeDurableFile = async (file, bytes) => {
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        const handle = await open(temporary, "wx", 0o600);
+        try {
+            await handle.writeFile(bytes, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await rename(temporary, file);
+        try {
+            await syncDirectory(path.dirname(file));
+        }
+        catch (cause) {
+            throw new PublishedFileSyncError(`Published ${file}, but directory fsync failed`, { cause });
+        }
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+};

package/dist/filesystem/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./io.js";
 export * from "./paths.js";
+export * from "./retainedJsonl.js";
+export * from "./durableWrite.js";

package/dist/filesystem/index.js

@@ -1,2 +1,4 @@
 export * from "./io.js";
 export * from "./paths.js";
+export * from "./retainedJsonl.js";
+export * from "./durableWrite.js";

package/dist/filesystem/retainedJsonl.d.ts

@@ -0,0 +1,23 @@
+export interface JsonlReadResult<T> {
+    entries: T[];
+    errors: string[];
+}
+/** Missing history is empty; unreadable or corrupt history is reported, never hidden. */
+export declare const readRetainedJsonl: <T>(file: string, isEntry: (value: unknown) => value is T) => JsonlReadResult<T>;
+/** Ties use the last appended entry. No chronological ordering of the input is assumed. */
+export declare const entryAt: <T>(entries: readonly T[], instant: string | Date, timeOf: (entry: T) => string) => T | null;
+/** The last state at the cutoff is needed even if it is arbitrarily old. */
+export declare const retainEntries: <T>(entries: readonly T[], cutoff: number, timeOf: (entry: T) => string) => T[];
+/**
+ * Caller MUST hold its domain's writer lock across append + prune. One append write,
+ * then fsync; retention uses an exclusive 0600 temporary file and atomic rename.
+ * Invalid complete lines survive pruning so readers can continue reporting them.
+ * A torn tail refuses append: never join a new entry onto a partial JSON record.
+ */
+export declare const appendRetainedJsonl: <T>(file: string, entry: T, options: {
+    keepMs: number;
+    now: Date;
+    timeOf: (entry: T) => string;
+    isEntry: (value: unknown) => value is T;
+    retain?: (entries: readonly T[], cutoff: number) => T[];
+}) => void;

package/dist/filesystem/retainedJsonl.js

@@ -0,0 +1,123 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, fchmodSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from "node:fs";
+import path from "node:path";
+import { syncDirectorySync } from "./durableWrite.js";
+const parseLines = (text, isEntry) => {
+    const raw = text.split("\n"), errors = [];
+    if (raw.at(-1) === "")
+        raw.pop();
+    const lines = raw.map((line, index) => {
+        try {
+            const value = JSON.parse(line);
+            if (!isEntry(value))
+                throw new Error("invalid entry");
+            return { line, entry: value };
+        }
+        catch {
+            errors.push(`line ${index + 1}: invalid JSON or entry`);
+            return { line };
+        }
+    });
+    return { lines, errors };
+};
+/** Missing history is empty; unreadable or corrupt history is reported, never hidden. */
+export const readRetainedJsonl = (file, isEntry) => {
+    let text;
+    try {
+        text = readFileSync(file, "utf8");
+    }
+    catch (error) {
+        return { entries: [], errors: error.code === "ENOENT" ? [] : [`${file}: ${String(error)}`] };
+    }
+    const parsed = parseLines(text, isEntry);
+    return { entries: parsed.lines.flatMap(({ entry }) => entry === undefined ? [] : [entry]), errors: parsed.errors };
+};
+/** Ties use the last appended entry. No chronological ordering of the input is assumed. */
+export const entryAt = (entries, instant, timeOf) => {
+    const at = instant instanceof Date ? instant.getTime() : Date.parse(instant);
+    if (!Number.isFinite(at))
+        throw new Error("History lookup requires a valid instant");
+    let found = null, latest = -Infinity;
+    for (const entry of entries) {
+        const time = Date.parse(timeOf(entry));
+        if (time <= at && time >= latest) {
+            latest = time;
+            found = entry;
+        }
+    }
+    return found;
+};
+/** The last state at the cutoff is needed even if it is arbitrarily old. */
+export const retainEntries = (entries, cutoff, timeOf) => {
+    let boundary = -1, latest = -Infinity;
+    entries.forEach((entry, index) => {
+        const time = Date.parse(timeOf(entry));
+        if (time <= cutoff && time >= latest) {
+            latest = time;
+            boundary = index;
+        }
+    });
+    return entries.filter((entry, index) => index === boundary || Date.parse(timeOf(entry)) > cutoff);
+};
+const writeAndSync = (fd, text) => {
+    const bytes = Buffer.from(text, "utf8");
+    if (writeSync(fd, bytes) !== bytes.length)
+        throw new Error("Short recording log write");
+    fsyncSync(fd);
+};
+/**
+ * Caller MUST hold its domain's writer lock across append + prune. One append write,
+ * then fsync; retention uses an exclusive 0600 temporary file and atomic rename.
+ * Invalid complete lines survive pruning so readers can continue reporting them.
+ * A torn tail refuses append: never join a new entry onto a partial JSON record.
+ */
+export const appendRetainedJsonl = (file, entry, options) => {
+    if (!Number.isSafeInteger(options.keepMs) || options.keepMs <= 0 || !Number.isFinite(options.now.getTime())) {
+        throw new Error("Recording retention requires a positive safe duration and valid clock");
+    }
+    if (!options.isEntry(entry))
+        throw new Error("Refusing to append an invalid recording entry");
+    let previous = "";
+    try {
+        previous = readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    if (previous && !previous.endsWith("\n"))
+        throw new Error(`Recording log ${file} has an incomplete final line`);
+    const line = `${JSON.stringify(entry)}\n`;
+    mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    const fd = openSync(file, constants.O_WRONLY | constants.O_APPEND | constants.O_CREAT | constants.O_NOFOLLOW, 0o600);
+    try {
+        fchmodSync(fd, 0o600);
+        writeAndSync(fd, line);
+    }
+    finally {
+        closeSync(fd);
+    }
+    syncDirectorySync(path.dirname(file));
+    const parsed = parseLines(previous + line, options.isEntry);
+    const entries = parsed.lines.flatMap(({ entry: value }) => value === undefined ? [] : [value]);
+    const cutoff = options.now.getTime() - options.keepMs;
+    const retained = new Set(options.retain ? options.retain(entries, cutoff) : retainEntries(entries, cutoff, options.timeOf));
+    const kept = parsed.lines.filter(({ entry: value }) => value === undefined || retained.has(value));
+    if (kept.length === parsed.lines.length)
+        return;
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+        const scratch = openSync(temporary, "wx", 0o600);
+        try {
+            writeAndSync(scratch, `${kept.map(({ line: raw }) => raw).join("\n")}\n`);
+        }
+        finally {
+            closeSync(scratch);
+        }
+        renameSync(temporary, file);
+        syncDirectorySync(path.dirname(file));
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+};

package/dist/manifest/commandSchemas.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+/** A plain image reference (registry/repo[:tag]) pinned by digest; never anything Docker could read as an option. */
+export declare const pinnedImageSchema: z.ZodString;
+/** An argv: run directly, never through a shell. */
+export declare const argvSchema: z.ZodArray<z.ZodString>;

package/dist/manifest/commandSchemas.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+/** A plain image reference (registry/repo[:tag]) pinned by digest; never anything Docker could read as an option. */
+export const pinnedImageSchema = z.string().trim().regex(/^[a-zA-Z0-9][a-zA-Z0-9._/:-]*@sha256:[a-f0-9]{64}$/u, "image must be a reference pinned by @sha256 digest");
+/** An argv: run directly, never through a shell. */
+export const argvSchema = z.array(z.string().min(1)).min(1);

package/dist/manifest/executionSchemas.d.ts

@@ -5,6 +5,8 @@ import { z } from "zod";
  * declares `auth.method: grok` itself; it is never inherited.
  */
 export declare const MODEL_REASONING_EFFORTS: readonly ["low", "medium", "high"];
+/** Mirrors Daimon's ORGANIZATION_RUNTIME_CODEX_REASONING_EFFORTS contract. */
+export declare const CODEX_MODEL_REASONING_EFFORTS: readonly ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra", "persistent"];
 export declare const modelEntryAuthSchema: z.ZodObject<{
     key: z.ZodOptional<z.ZodString>;
     method: z.ZodOptional<z.ZodEnum<{
@@ -43,9 +45,15 @@ export declare const modelTargetSchema: z.ZodObject<{
     name: z.ZodString;
     provider: z.ZodString;
     reasoning_effort: z.ZodOptional<z.ZodEnum<{
+        none: "none";
         high: "high";
         medium: "medium";
         low: "low";
+        minimal: "minimal";
+        xhigh: "xhigh";
+        max: "max";
+        ultra: "ultra";
+        persistent: "persistent";
     }>>;
 }, z.core.$strict>;
 export declare const executionSchema: z.ZodObject<{
@@ -87,9 +95,15 @@ export declare const executionSchema: z.ZodObject<{
             name: z.ZodString;
             provider: z.ZodString;
             reasoning_effort: z.ZodOptional<z.ZodEnum<{
+                none: "none";
                 high: "high";
                 medium: "medium";
                 low: "low";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+                ultra: "ultra";
+                persistent: "persistent";
             }>>;
         }, z.core.$strict>>>;
         primary: z.ZodObject<{
@@ -113,9 +127,15 @@ export declare const executionSchema: z.ZodObject<{
             name: z.ZodString;
             provider: z.ZodString;
             reasoning_effort: z.ZodOptional<z.ZodEnum<{
+                none: "none";
                 high: "high";
                 medium: "medium";
                 low: "low";
+                minimal: "minimal";
+                xhigh: "xhigh";
+                max: "max";
+                ultra: "ultra";
+                persistent: "persistent";
             }>>;
         }, z.core.$strict>;
     }, z.core.$strict>>;

package/dist/manifest/executionSchemas.js

@@ -6,6 +6,8 @@ const modelAuthMethodSchema = z.enum(["api_key", "claude-code", "codex", "grok",
  * declares `auth.method: grok` itself; it is never inherited.
  */
 export const MODEL_REASONING_EFFORTS = ["low", "medium", "high"];
+/** Mirrors Daimon's ORGANIZATION_RUNTIME_CODEX_REASONING_EFFORTS contract. */
+export const CODEX_MODEL_REASONING_EFFORTS = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra", "persistent"];
 const modelEndpointCompatibilitySchema = z.enum(["anthropic", "openai"]);
 const modelAuthSchema = z
     .object({
@@ -65,7 +67,7 @@ export const modelTargetSchema = z
     endpoint: modelEndpointSchema.optional(),
     name: z.string(),
     provider: z.string(),
-    reasoning_effort: z.enum(MODEL_REASONING_EFFORTS).optional()
+    reasoning_effort: z.enum(CODEX_MODEL_REASONING_EFFORTS).optional()
 })
     .strict()
     .superRefine((value, context) => {
@@ -75,10 +77,18 @@ export const modelTargetSchema = z
             message: "grok auth is only valid for provider xai without an endpoint"
         });
     }
-    if (value.reasoning_effort !== undefined && value.auth?.method !== "grok") {
+    if (value.reasoning_effort !== undefined && value.auth?.method === "grok") {
+        const effort = z.enum(MODEL_REASONING_EFFORTS).safeParse(value.reasoning_effort);
+        if (!effort.success) {
+            for (const issue of effort.error.issues) {
+                context.addIssue({ ...issue, path: ["reasoning_effort"] });
+            }
+        }
+    }
+    if (value.reasoning_effort !== undefined && value.auth?.method !== "grok" && value.auth?.method !== "codex") {
         context.addIssue({
             code: z.ZodIssueCode.custom,
-            message: "reasoning_effort is only valid on a model that declares auth.method grok"
+            message: "reasoning_effort is only valid on a model that declares auth.method grok or codex"
         });
     }
     const usesCustomEndpoint = value.provider === "custom" || value.provider === "local";

package/dist/manifest/index.d.ts

@@ -4,3 +4,5 @@ export * from "./renderSpawnfile.js";
 export * from "./scaffold.js";
 export * from "./schemas.js";
 export * from "./skillFrontmatter.js";
+export * from "./trainingSchemas.js";
+export * from "./trainingDataSchemas.js";

package/dist/manifest/index.js

@@ -4,3 +4,5 @@ export * from "./renderSpawnfile.js";
 export * from "./scaffold.js";
 export * from "./schemas.js";
 export * from "./skillFrontmatter.js";
+export * from "./trainingSchemas.js";
+export * from "./trainingDataSchemas.js";

package/dist/manifest/loadManifest.js

@@ -1,9 +1,8 @@
 import path from "node:path";
-import { parse as parseYaml } from "yaml";
-import { z } from "zod";
 import { fileExists, isSymlink, readUtf8File, resolveProjectPath } from "../filesystem/index.js";
 import { SpawnfileError } from "../shared/index.js";
-import { isAgentManifest, isInlineAgentMember, isReferencedMember, isTeamManifest, manifestSchema } from "./schemas.js";
+import { isAgentManifest, isInlineAgentMember, isReferencedMember, isTeamManifest } from "./schemas.js";
+import { parseManifest } from "./parseManifest.js";
 import { parseSkillFrontmatter } from "./skillFrontmatter.js";
 const ensureUniqueNames = (names, label) => {
     const seen = new Set();
@@ -120,28 +119,6 @@ const validateLocalTeamManifest = async (manifestPath, manifest) => {
         }
     }
 };
-const parseManifest = (source) => {
-    let parsed;
-    try {
-        parsed = parseYaml(source);
-    }
-    catch (error) {
-        // A YAML syntax error is a malformed manifest, not a runtime failure — wrap
-        // it so it exits as a usage error instead of leaking the parser's wording.
-        const reason = error instanceof Error ? error.message : String(error);
-        throw new SpawnfileError("invalid_manifest", `Invalid Spawnfile manifest: ${reason}`);
-    }
-    try {
-        return manifestSchema.parse(parsed);
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            const issue = error.issues[0];
-            throw new SpawnfileError("invalid_manifest", `Invalid Spawnfile manifest: ${issue.message}`);
-        }
-        throw error;
-    }
-};
 export const loadManifest = async (manifestPath) => {
     let source;
     try {
@@ -154,7 +131,7 @@ export const loadManifest = async (manifestPath) => {
         }
         throw error;
     }
-    const manifest = parseManifest(source);
+    const manifest = parseManifest(source, manifestPath);
     if (isAgentManifest(manifest)) {
         await validateLocalAgentManifest(manifestPath, manifest);
     }

package/dist/manifest/mcpSchemas.d.ts

@@ -16,3 +16,64 @@ export declare const mcpServerSchema: z.ZodObject<{
     tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     url: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
+/**
+ * A team `shared.environment.mcp_servers` entry. `opt_in: true` means members
+ * do not inherit it unless they list its name in their own `mcp_servers`
+ * (a bare `{ name }` or a narrowing override). Absent or false keeps today's
+ * behaviour: every direct member inherits it.
+ */
+export declare const sharedMcpServerSchema: z.ZodObject<{
+    opt_in: z.ZodOptional<z.ZodBoolean>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    auth: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodLiteral<"bearer">>;
+        secret: z.ZodString;
+    }, z.core.$strict>>;
+    command: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    name: z.ZodString;
+    transport: z.ZodEnum<{
+        sse: "sse";
+        stdio: "stdio";
+        streamable_http: "streamable_http";
+    }>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SharedMcpServer = z.infer<typeof sharedMcpServerSchema>;
+/**
+ * An agent-level entry without `transport` narrows the inherited
+ * `shared.environment.mcp_servers` entry of the same name instead of replacing
+ * it: `tools` replaces the inherited allowlist and `env` is merged key by key.
+ * A bare `{ name }` takes the inherited server unchanged, which is how a
+ * member opts in to an `opt_in` shared server.
+ * Whether a server of that name is inherited is only known during graph
+ * resolution, so the compiler (not this schema) rejects an orphan override.
+ */
+export declare const mcpServerOverrideSchema: z.ZodObject<{
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    name: z.ZodString;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type McpServerDeclaration = z.infer<typeof mcpServerSchema>;
+export type McpServerOverride = z.infer<typeof mcpServerOverrideSchema>;
+export type McpServerEntry = McpServerDeclaration | McpServerOverride;
+/** Agent-scope MCP entry: a complete server (has `transport`) or an override of an inherited one. */
+export declare const mcpServerEntrySchema: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
+    name: string;
+    transport: "sse" | "stdio" | "streamable_http";
+    args?: string[] | undefined;
+    auth?: {
+        secret: string;
+        mode?: "bearer" | undefined;
+    } | undefined;
+    command?: string | undefined;
+    env?: Record<string, string> | undefined;
+    tools?: string[] | undefined;
+    url?: string | undefined;
+} | {
+    name: string;
+    env?: Record<string, string> | undefined;
+    tools?: string[] | undefined;
+}, unknown>>;
+export declare const isMcpServerDeclaration: (entry: McpServerEntry) => entry is McpServerDeclaration;

package/dist/manifest/mcpSchemas.js

@@ -14,24 +14,26 @@ const mcpAuthSchema = z
         });
     }
 });
-export const mcpServerSchema = z
-    .object({
+const mcpToolsSchema = z.array(z.string().min(1)).max(32);
+const refineToolsAndName = (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" });
+    }
+};
+const mcpServerFields = {
     args: z.array(z.string()).optional(),
     auth: mcpAuthSchema.optional(),
     command: z.string().optional(),
     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(),
+    tools: mcpToolsSchema.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" });
-    }
+};
+const refineServer = (value, context) => {
+    refineToolsAndName(value, context);
     if (value.transport === "stdio" && !value.command) {
         context.addIssue({ code: z.ZodIssueCode.custom, message: "stdio MCP servers must declare command" });
     }
@@ -41,4 +43,48 @@ export const mcpServerSchema = z
     if (value.transport !== "stdio" && !value.url) {
         context.addIssue({ code: z.ZodIssueCode.custom, message: `${value.transport} MCP servers must declare url` });
     }
+};
+export const mcpServerSchema = z.object(mcpServerFields).strict().superRefine(refineServer);
+/**
+ * A team `shared.environment.mcp_servers` entry. `opt_in: true` means members
+ * do not inherit it unless they list its name in their own `mcp_servers`
+ * (a bare `{ name }` or a narrowing override). Absent or false keeps today's
+ * behaviour: every direct member inherits it.
+ */
+export const sharedMcpServerSchema = z
+    .object({ ...mcpServerFields, opt_in: z.boolean().optional() })
+    .strict()
+    .superRefine(refineServer);
+/**
+ * An agent-level entry without `transport` narrows the inherited
+ * `shared.environment.mcp_servers` entry of the same name instead of replacing
+ * it: `tools` replaces the inherited allowlist and `env` is merged key by key.
+ * A bare `{ name }` takes the inherited server unchanged, which is how a
+ * member opts in to an `opt_in` shared server.
+ * Whether a server of that name is inherited is only known during graph
+ * resolution, so the compiler (not this schema) rejects an orphan override.
+ */
+export const mcpServerOverrideSchema = z
+    .object({
+    env: z.record(z.string(), z.string()).optional(),
+    name: z.string().min(1),
+    tools: mcpToolsSchema.optional()
+})
+    .strict()
+    .superRefine((value, context) => {
+    refineToolsAndName(value, context);
+});
+const hasTransportKey = (value) => typeof value === "object" && value !== null && Object.hasOwn(value, "transport");
+/** Agent-scope MCP entry: a complete server (has `transport`) or an override of an inherited one. */
+export const mcpServerEntrySchema = z.unknown().transform((value, context) => {
+    const result = hasTransportKey(value)
+        ? mcpServerSchema.safeParse(value)
+        : mcpServerOverrideSchema.safeParse(value);
+    if (result.success)
+        return result.data;
+    for (const issue of result.error.issues) {
+        context.addIssue({ code: "custom", message: issue.message, path: issue.path });
+    }
+    return z.NEVER;
 });
+export const isMcpServerDeclaration = (entry) => "transport" in entry;

package/dist/manifest/memorySchemas.d.ts

@@ -76,7 +76,7 @@ declare const memoryRetentionSchema: z.ZodObject<{
 declare const memoryAccessSchema: z.ZodObject<{
     members: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-declare const memoryBankSchema: z.ZodObject<{
+export declare const memoryBankSchema: z.ZodObject<{
     access: z.ZodOptional<z.ZodObject<{
         members: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;

package/dist/manifest/memorySchemas.js

@@ -127,7 +127,7 @@ const memoryAccessSchema = z
     members: z.array(z.string().trim().min(1)).optional()
 })
     .strict();
-const memoryBankSchema = z
+export const memoryBankSchema = z
     .object({
     access: memoryAccessSchema.optional(),
     consolidation: memoryConsolidationSchema.optional(),

package/dist/manifest/parseManifest.d.ts

@@ -0,0 +1,7 @@
+import { type Manifest } from "./schemas.js";
+/**
+ * Parses one Spawnfile. Errors name the file, and the declared kind and name
+ * when the YAML got far enough to have them, so a member's malformed manifest
+ * is attributable from `spawnfile validate` on the organization root.
+ */
+export declare const parseManifest: (source: string, manifestPath: string) => Manifest;