simfile 0.0.1

package/dist/sims/moltnetRoomClient.js

@@ -0,0 +1,41 @@
+/**
+ * Read-only Moltnet HTTP polling helpers for the composed-run driver —
+ * `/healthz`, `/v1/rooms/:id`, `/v1/agents`, `/v1/rooms/:id/messages` are
+ * Moltnet's own public wire API (documented, not a Spawnfile internal), the
+ * same endpoints `src/e2e/moltnetE2ESupport.ts`'s `createMoltnetHttpClient`
+ * speaks — reimplemented locally here (never imported from Spawnfile's
+ * `src/e2e`) so this package's charter ("Do not import Spawnfile internals")
+ * holds. Every function here is a plain GET: seeding (the one write this
+ * driver ever performs) goes through `world-participant.ts` instead.
+ */
+const DEFAULT_TIMEOUT_MS = 10_000;
+const fetchJson = async (url, options) => {
+    const timeout = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const signal = timeout > 0 ? AbortSignal.timeout(timeout) : undefined;
+    const response = await (options?.fetchFn ?? fetch)(url, { method: "GET", ...(signal ? { signal } : {}) });
+    if (!response.ok) {
+        throw new Error(`moltnet GET ${url} returned ${response.status}`);
+    }
+    return (await response.json());
+};
+/** Read-only health probe; never throws — a not-yet-ready server is a
+ * negative poll result, not an error. */
+export const moltnetHealthy = async (baseUrl, options) => {
+    try {
+        const timeout = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const signal = timeout > 0 ? AbortSignal.timeout(timeout) : undefined;
+        const response = await (options?.fetchFn ?? fetch)(`${baseUrl}/healthz`, { method: "GET", ...(signal ? { signal } : {}) });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+};
+export const getMoltnetRoom = async (baseUrl, roomId, options) => fetchJson(`${baseUrl}/v1/rooms/${encodeURIComponent(roomId)}`, options);
+export const listMoltnetAgents = async (baseUrl, options) => (await fetchJson(`${baseUrl}/v1/agents`, options)).agents ?? [];
+export const listMoltnetRoomMessages = async (baseUrl, roomId, limit, options) => (await fetchJson(`${baseUrl}/v1/rooms/${encodeURIComponent(roomId)}/messages?limit=${limit}`, options)).messages ?? [];
+/** True once every expected member both appears in room config membership
+ * AND has a live, connected bridge attachment — mirrors
+ * `moltnetE2ESupport.ts`'s `waitForAgents` gate (room membership alone can be
+ * static config, seeding before the bridge attaches is unrecoverable). */
+export const allMembersConnected = (agents, roomId, expectedMembers) => expectedMembers.every((id) => agents.some((agent) => agent.id === id && agent.rooms.includes(roomId) && agent.connected === true));

package/dist/sims/poll.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Generic bounded-retry poll helper, reused by the composed-run driver for
+ * every read-only readiness check (moltnet health, room membership, agent
+ * bridge attachment) before the ONE seed write. Ported from the shape of
+ * `src/e2e/moltnetE2ESupport.ts`'s `poll` (not imported — this package may
+ * not depend on Spawnfile internals) since the polling contract itself is
+ * generic and has nothing Spawnfile-specific about it.
+ */
+export interface PollOptions {
+    intervalMs: number;
+    sleep: (delayMs: number) => Promise<void>;
+    timeoutMs: number;
+}
+export declare const defaultSleep: (delayMs: number) => Promise<void>;
+/** Retries `attempt` until it returns a truthy value or the timeout elapses;
+ * throws a description-carrying error otherwise. Never coaxes/mutates state —
+ * every attempt is a read. */
+export declare const pollUntilReady: <T>(description: string, options: PollOptions, attempt: () => Promise<T | null>) => Promise<T>;
+//# sourceMappingURL=poll.d.ts.map

package/dist/sims/poll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poll.d.ts","sourceRoot":"","sources":["../../src/sims/poll.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,YAAY,GAAU,SAAS,MAAM,KAAG,OAAO,CAAC,IAAI,CAG7D,CAAC;AAEL;;8BAE8B;AAC9B,eAAO,MAAM,cAAc,GAAU,CAAC,EACpC,aAAa,MAAM,EACnB,SAAS,WAAW,EACpB,SAAS,MAAM,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,KAC/B,OAAO,CAAC,CAAC,CAcX,CAAC"}

package/dist/sims/poll.js

@@ -0,0 +1,23 @@
+export const defaultSleep = async (delayMs) => new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+});
+/** Retries `attempt` until it returns a truthy value or the timeout elapses;
+ * throws a description-carrying error otherwise. Never coaxes/mutates state —
+ * every attempt is a read. */
+export const pollUntilReady = async (description, options, attempt) => {
+    const attempts = Math.max(1, Math.ceil(options.timeoutMs / options.intervalMs));
+    let lastError;
+    for (let index = 0; index <= attempts; index += 1) {
+        try {
+            const result = await attempt();
+            if (result)
+                return result;
+        }
+        catch (error) {
+            lastError = error;
+        }
+        await options.sleep(options.intervalMs);
+    }
+    const suffix = lastError instanceof Error ? `: ${lastError.message}` : "";
+    throw new Error(`${description} did not become ready${suffix}`);
+};

package/dist/sims/spawnfileCli.d.ts

@@ -0,0 +1,49 @@
+import { type SpawnfileDownReceipt, type SpawnfileExportResult, type SpawnfileUpReceipt } from "./spawnfileReceipts.js";
+/**
+ * Everything needed to shell the `spawnfile` CLI as a subprocess — the ONLY
+ * sanctioned way this package talks to Spawnfile (contracts.md's CLI rule:
+ * "simfile -> spawnfile only through documented CLI + versioned receipts").
+ * `spawnfileBin` is a path to spawnfile's built `dist/cli/index.js` (or any
+ * equivalent entrypoint script); it is always invoked as `node <spawnfileBin>
+ * <args>` rather than executed directly, so no `chmod +x`/shebang resolution
+ * is required of the caller.
+ */
+export interface SpawnfileCliContext {
+    spawnfileBin: string;
+    nodeBin?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface RunSpawnfileUpInput {
+    orgPath: string;
+    containerName: string;
+    deploymentName: string;
+    compiledOutputDirectory: string;
+}
+/** Shells `spawnfile up <org> --detach --name <container> --deployment <name>
+ * --out <compiled> --json`, detached, and parses the `spawnfile.up-receipt.v1`
+ * (run_id, moltnet base url, per-agent engine disclosure). */
+export declare const runSpawnfileUp: (context: SpawnfileCliContext, input: RunSpawnfileUpInput) => Promise<SpawnfileUpReceipt>;
+export interface RunSpawnfileArtifactsExportInput {
+    orgPath: string;
+    deploymentName: string;
+    compiledOutputDirectory: string;
+    destinationDirectory: string;
+}
+/** Shells `spawnfile artifacts export <org> --deployment <name> --compiled
+ * <compiled> --out <dest> --json`, run BEFORE `spawnfile down` (Decision 21's
+ * export-before-teardown discipline). Lands `raw/{moltnet,mneme,daimon}/...`
+ * directly under `destinationDirectory` plus `spawnfile/export-index.json`. */
+export declare const runSpawnfileArtifactsExport: (context: SpawnfileCliContext, input: RunSpawnfileArtifactsExportInput) => Promise<SpawnfileExportResult>;
+export interface RunSpawnfileDownInput {
+    orgPath: string;
+    deploymentName: string;
+    compiledOutputDirectory: string;
+    removeVolumes?: boolean;
+}
+/** Shells `spawnfile down <org> --deployment <name> --compiled <compiled>
+ * --json`, run AFTER artifacts export. Never passes `--force`: a run whose
+ * export failed should fail loudly here rather than silently discard
+ * artifacts (the export-before-teardown invariant, `src/deployment/AGENTS.md`). */
+export declare const runSpawnfileDown: (context: SpawnfileCliContext, input: RunSpawnfileDownInput) => Promise<SpawnfileDownReceipt>;
+//# sourceMappingURL=spawnfileCli.d.ts.map

package/dist/sims/spawnfileCli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnfileCli.d.ts","sourceRoot":"","sources":["../../src/sims/spawnfileCli.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACxB,MAAM,wBAAwB,CAAC;AAWhC;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAiCD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED;;8DAE8D;AAC9D,eAAO,MAAM,cAAc,GACzB,SAAS,mBAAmB,EAC5B,OAAO,mBAAmB,KACzB,OAAO,CAAC,kBAAkB,CAc5B,CAAC;AAEF,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB,EAAE,MAAM,CAAC;IAChC,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;+EAG+E;AAC/E,eAAO,MAAM,2BAA2B,GACtC,SAAS,mBAAmB,EAC5B,OAAO,gCAAgC,KACtC,OAAO,CAAC,qBAAqB,CAc/B,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB,EAAE,MAAM,CAAC;IAChC,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;mFAGmF;AACnF,eAAO,MAAM,gBAAgB,GAC3B,SAAS,mBAAmB,EAC5B,OAAO,qBAAqB,KAC3B,OAAO,CAAC,oBAAoB,CAa9B,CAAC"}

package/dist/sims/spawnfileCli.js

@@ -0,0 +1,90 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { parseSpawnfileDownReceipt, parseSpawnfileExportResult, parseSpawnfileUpReceipt } from "./spawnfileReceipts.js";
+const execFileAsync = promisify(execFile);
+/** 64MB — generous headroom for a `docker build`'s buildkit progress stream,
+ * which lands on stderr (verified: `spawnfile up --json`'s ONLY stdout write
+ * is the final receipt; docker build/run output is inherited to stderr, see
+ * `src/compiler/buildProject.ts`/`runProjectDocker.ts`). Stdout itself is
+ * always small (one JSON receipt), so this only bounds stderr capture. */
+const MAX_BUFFER_BYTES = 64 * 1024 * 1024;
+const execSpawnfile = async (context, args) => {
+    const nodeBin = context.nodeBin ?? process.execPath;
+    try {
+        return await execFileAsync(nodeBin, [context.spawnfileBin, ...args], {
+            cwd: context.cwd,
+            env: context.env ?? process.env,
+            maxBuffer: MAX_BUFFER_BYTES
+        });
+    }
+    catch (error) {
+        const stderr = error.stderr;
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`spawnfile ${args.join(" ")} failed: ${message}${stderr ? `\n\n${stderr}` : ""}`);
+    }
+};
+const parseTrailingJson = (stdout) => {
+    const trimmed = stdout.trim();
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch (error) {
+        throw new Error(`spawnfile CLI did not print valid JSON on stdout: ${error.message}\n\n${trimmed}`);
+    }
+};
+/** Shells `spawnfile up <org> --detach --name <container> --deployment <name>
+ * --out <compiled> --json`, detached, and parses the `spawnfile.up-receipt.v1`
+ * (run_id, moltnet base url, per-agent engine disclosure). */
+export const runSpawnfileUp = async (context, input) => {
+    const { stdout } = await execSpawnfile(context, [
+        "up",
+        input.orgPath,
+        "--detach",
+        "--name",
+        input.containerName,
+        "--deployment",
+        input.deploymentName,
+        "--out",
+        input.compiledOutputDirectory,
+        "--json"
+    ]);
+    return parseSpawnfileUpReceipt(parseTrailingJson(stdout));
+};
+/** Shells `spawnfile artifacts export <org> --deployment <name> --compiled
+ * <compiled> --out <dest> --json`, run BEFORE `spawnfile down` (Decision 21's
+ * export-before-teardown discipline). Lands `raw/{moltnet,mneme,daimon}/...`
+ * directly under `destinationDirectory` plus `spawnfile/export-index.json`. */
+export const runSpawnfileArtifactsExport = async (context, input) => {
+    const { stdout } = await execSpawnfile(context, [
+        "artifacts",
+        "export",
+        input.orgPath,
+        "--deployment",
+        input.deploymentName,
+        "--compiled",
+        input.compiledOutputDirectory,
+        "--out",
+        input.destinationDirectory,
+        "--json"
+    ]);
+    return parseSpawnfileExportResult(parseTrailingJson(stdout));
+};
+/** Shells `spawnfile down <org> --deployment <name> --compiled <compiled>
+ * --json`, run AFTER artifacts export. Never passes `--force`: a run whose
+ * export failed should fail loudly here rather than silently discard
+ * artifacts (the export-before-teardown invariant, `src/deployment/AGENTS.md`). */
+export const runSpawnfileDown = async (context, input) => {
+    const args = [
+        "down",
+        input.orgPath,
+        "--deployment",
+        input.deploymentName,
+        "--compiled",
+        input.compiledOutputDirectory,
+        "--json"
+    ];
+    if (input.removeVolumes)
+        args.push("--volumes");
+    const { stdout } = await execSpawnfile(context, args);
+    return parseSpawnfileDownReceipt(parseTrailingJson(stdout));
+};

package/dist/sims/spawnfileReceipts.d.ts

@@ -0,0 +1,76 @@
+import { z } from "zod";
+/**
+ * Minimal local schemas for the THREE documented `spawnfile ... --json`
+ * receipts the composed-run driver shells (contracts.md's CLI rule: "simfile
+ * -> spawnfile only through documented CLI + versioned receipts"). These are
+ * deliberately NOT imported from Spawnfile's own `src/deployment/*Types.ts` —
+ * this package's charter ("Do not import Spawnfile internals. Consume
+ * explicit machine-readable artifacts.") means simfile treats each receipt as
+ * an external wire contract it parses on its own terms, the same way
+ * `observe/manifest.ts` and `observe/report.ts` own their schemas rather than
+ * importing anyone else's. Every schema below is intentionally loose
+ * (`.passthrough()`, no `.strict()`) and only asserts the fields this driver
+ * actually reads, so an additive field on the real contract never breaks
+ * parsing here.
+ */
+declare const upReceiptSchema: z.ZodObject<{
+    version: z.ZodString;
+    run_id: z.ZodNullable<z.ZodString>;
+    fingerprint: z.ZodOptional<z.ZodString>;
+    deployment: z.ZodObject<{
+        name: z.ZodNullable<z.ZodString>;
+        container_ids: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>;
+    readiness: z.ZodObject<{
+        state: z.ZodString;
+        moltnet_base_url: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>;
+    engines: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        agent: z.ZodString;
+        engine: z.ZodString;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export type SpawnfileUpReceipt = z.infer<typeof upReceiptSchema>;
+/** Parses `spawnfile up --json`'s stdout (`spawnfile.up-receipt.v1`). */
+export declare const parseSpawnfileUpReceipt: (raw: unknown) => SpawnfileUpReceipt;
+declare const exportIndexFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    sha256: z.ZodString;
+    bytes: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$loose>;
+declare const exportResultSchema: z.ZodObject<{
+    deployment: z.ZodString;
+    failed_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    missing_optional_files: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    index_path: z.ZodString;
+    index: z.ZodObject<{
+        version: z.ZodString;
+        run_id: z.ZodString;
+        deployment: z.ZodString;
+        exported_at: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            sha256: z.ZodString;
+            bytes: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodUnknown>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$loose>;
+export type SpawnfileExportResult = z.infer<typeof exportResultSchema>;
+export type SpawnfileExportIndexFile = z.infer<typeof exportIndexFileSchema>;
+/** Parses `spawnfile artifacts export --json`'s stdout (folds
+ * `spawnfile.export-index.v1` inside `index`). */
+export declare const parseSpawnfileExportResult: (raw: unknown) => SpawnfileExportResult;
+declare const downReceiptSchema: z.ZodObject<{
+    version: z.ZodString;
+    deployment: z.ZodString;
+    units_stopped: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    retained_volumes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    errors: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type SpawnfileDownReceipt = z.infer<typeof downReceiptSchema>;
+/** Parses `spawnfile down --json`'s stdout (`spawnfile.down-receipt.v1`). */
+export declare const parseSpawnfileDownReceipt: (raw: unknown) => SpawnfileDownReceipt;
+export {};
+//# sourceMappingURL=spawnfileReceipts.d.ts.map

package/dist/sims/spawnfileReceipts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawnfileReceipts.d.ts","sourceRoot":"","sources":["../../src/sims/spawnfileReceipts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;GAaG;AAEH,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;iBA4BL,CAAC;AAEjB,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEjE,yEAAyE;AACzE,eAAO,MAAM,uBAAuB,GAAI,KAAK,OAAO,KAAG,kBAUtD,CAAC;AAEF,QAAA,MAAM,qBAAqB;;;;;iBAOX,CAAC;AAEjB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;iBAgBR,CAAC;AAEjB,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACvE,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE7E;kDACkD;AAClD,eAAO,MAAM,0BAA0B,GAAI,KAAK,OAAO,KAAG,qBAUzD,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAQP,CAAC;AAEjB,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAErE,6EAA6E;AAC7E,eAAO,MAAM,yBAAyB,GAAI,KAAK,OAAO,KAAG,oBAUxD,CAAC"}

package/dist/sims/spawnfileReceipts.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+/**
+ * Minimal local schemas for the THREE documented `spawnfile ... --json`
+ * receipts the composed-run driver shells (contracts.md's CLI rule: "simfile
+ * -> spawnfile only through documented CLI + versioned receipts"). These are
+ * deliberately NOT imported from Spawnfile's own `src/deployment/*Types.ts` —
+ * this package's charter ("Do not import Spawnfile internals. Consume
+ * explicit machine-readable artifacts.") means simfile treats each receipt as
+ * an external wire contract it parses on its own terms, the same way
+ * `observe/manifest.ts` and `observe/report.ts` own their schemas rather than
+ * importing anyone else's. Every schema below is intentionally loose
+ * (`.passthrough()`, no `.strict()`) and only asserts the fields this driver
+ * actually reads, so an additive field on the real contract never breaks
+ * parsing here.
+ */
+const upReceiptSchema = z
+    .object({
+    version: z.string().min(1),
+    run_id: z.string().min(1).nullable(),
+    fingerprint: z.string().min(1).optional(),
+    deployment: z
+        .object({
+        name: z.string().min(1).nullable(),
+        container_ids: z.array(z.string())
+    })
+        .passthrough(),
+    readiness: z
+        .object({
+        state: z.string(),
+        moltnet_base_url: z.string().min(1).nullable()
+    })
+        .passthrough(),
+    engines: z
+        .array(z
+        .object({
+        agent: z.string().min(1),
+        engine: z.string().min(1)
+    })
+        .passthrough())
+        .optional()
+})
+    .passthrough();
+/** Parses `spawnfile up --json`'s stdout (`spawnfile.up-receipt.v1`). */
+export const parseSpawnfileUpReceipt = (raw) => {
+    const result = upReceiptSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`invalid spawnfile up-receipt: ${result.error.issues
+            .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+            .join("; ")}`);
+    }
+    return result.data;
+};
+const exportIndexFileSchema = z
+    .object({
+    path: z.string().min(1),
+    sha256: z.string().regex(/^[0-9a-f]{64}$/u),
+    bytes: z.number().int().nonnegative().optional(),
+    source: z.unknown().optional()
+})
+    .passthrough();
+const exportResultSchema = z
+    .object({
+    deployment: z.string().min(1),
+    failed_files: z.array(z.string()).default([]),
+    missing_optional_files: z.array(z.string()).default([]),
+    index_path: z.string().min(1),
+    index: z
+        .object({
+        version: z.string().min(1),
+        run_id: z.string().min(1),
+        deployment: z.string().min(1),
+        exported_at: z.string().min(1),
+        files: z.array(exportIndexFileSchema)
+    })
+        .passthrough()
+})
+    .passthrough();
+/** Parses `spawnfile artifacts export --json`'s stdout (folds
+ * `spawnfile.export-index.v1` inside `index`). */
+export const parseSpawnfileExportResult = (raw) => {
+    const result = exportResultSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`invalid spawnfile artifacts export result: ${result.error.issues
+            .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+            .join("; ")}`);
+    }
+    return result.data;
+};
+const downReceiptSchema = z
+    .object({
+    version: z.string().min(1),
+    deployment: z.string().min(1),
+    units_stopped: z.array(z.string()).default([]),
+    retained_volumes: z.array(z.string()).default([]),
+    errors: z.array(z.string()).default([])
+})
+    .passthrough();
+/** Parses `spawnfile down --json`'s stdout (`spawnfile.down-receipt.v1`). */
+export const parseSpawnfileDownReceipt = (raw) => {
+    const result = downReceiptSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`invalid spawnfile down-receipt: ${result.error.issues
+            .map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`)
+            .join("; ")}`);
+    }
+    return result.data;
+};

package/dist/sims/worldDrivenOfficeSimDriver.d.ts

@@ -0,0 +1,59 @@
+import { type ExchangeEndReason } from "./exchangeWait.js";
+/**
+ * Memetics increment (a)'s live world-driven variant of
+ * `composedOfficeSimDriver.ts`. That file's own charter — seed-once,
+ * poll-read-only, shell spawnfile only through its three documented `--json`
+ * subcommands, zero Docker/runtime-auth/Spawnfile-TS-imports here — still
+ * holds. What changes is the core loop: instead of one operator-authored
+ * seed message, the Simfile WORLD itself (`worldPath`) runs as a live tick
+ * loop between "org ready" and "concluded" — ingesting room messages,
+ * stepping `stepSimfileTick` once per wall-clock poll, scanning the tick's
+ * own ingested messages for marker tokens, delivering any rule-emitted
+ * `world.message`/`wake.recommended`, and appending everything to
+ * `raw/world/causal.jsonl` — so the room's opening message (the `kickoff`
+ * rule) comes from the world's own ledger, not a driver-injected string.
+ * There is deliberately no "seed message" builder in this file: "seed" is
+ * reserved for the Decision-13 doc-seeded secret (`seed_declaration`); the
+ * room's own opening line is the world's `kickoff` rule, delivered like any
+ * other rule-emitted world-effect event.
+ */
+export interface RunWorldDrivenOfficeSimOptions {
+    spawnfileBin: string;
+    /** Path to the composed org (e.g. `fixtures/sims/office-secret-v0/org`). */
+    orgPath: string;
+    /** Path to the Simfile world file driving this run. */
+    worldPath: string;
+    containerName: string;
+    deploymentName: string;
+    compiledOutputDirectory: string;
+    runsRootDirectory: string;
+    networkId?: string;
+    roomId?: string;
+    agentIds?: readonly string[];
+    /** Agent whose `workspace.docs.memory` carries the Decision-13 secret. */
+    seedAgentId?: string;
+    /** Absolute path to the seed agent's memory doc; defaults to
+     * `<orgPath>/agents/<seedAgentId>/MEMORY.md`. */
+    memoryDocPath?: string;
+    /** The memetics token set to lint the world against and declare as seeded. */
+    tokenSet?: readonly string[];
+    targetTurns?: number;
+    quietGraceMs?: number;
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    /** Safety fuse on world ticks, independent of the timeout/turn-cap stop
+     * conditions below (which are expected to fire first in any healthy run). */
+    maxTicks?: number;
+    removeVolumesOnDown?: boolean;
+    now?: () => Date;
+}
+export interface RunWorldDrivenOfficeSimResult {
+    runDir: string;
+    runId: string;
+    endedReason: ExchangeEndReason;
+    ticksRun: number;
+    markerFired: boolean;
+    agentTurnCount: number;
+}
+export declare const runWorldDrivenOfficeSim: (options: RunWorldDrivenOfficeSimOptions) => Promise<RunWorldDrivenOfficeSimResult>;
+//# sourceMappingURL=worldDrivenOfficeSimDriver.d.ts.map

package/dist/sims/worldDrivenOfficeSimDriver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldDrivenOfficeSimDriver.d.ts","sourceRoot":"","sources":["../../src/sims/worldDrivenOfficeSimDriver.ts"],"names":[],"mappings":"AAkBA,OAAO,EAA8C,KAAK,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAkBvG;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,8BAA8B;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,4EAA4E;IAC5E,OAAO,EAAE,MAAM,CAAC;IAChB,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,uBAAuB,EAAE,MAAM,CAAC;IAChC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,0EAA0E;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;qDACiD;IACjD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;iFAC6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,6BAA6B;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,iBAAiB,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB;AAoDD,eAAO,MAAM,uBAAuB,GAClC,SAAS,8BAA8B,KACtC,OAAO,CAAC,6BAA6B,CAiJvC,CAAC"}