spawnfile 0.1.12 → 0.1.14

package/dist/target/worldClock.js

@@ -0,0 +1,129 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { assertOrdinaryJsonGraph, opaqueTargetHandleSchema, runIdSchema, selectedTargetSchema, } from "./contracts.js";
+export const TARGET_WORLD_CLOCK_REQUEST_VERSION = "spawnfile.target-world-clock.request.v1";
+export const TARGET_WORLD_CLOCK_RECEIPT_VERSION = "spawnfile.target-world-clock-receipt.v1";
+export const TARGET_WORLD_CLOCK_PATH = "/v1/world/clock";
+export const MAX_TARGET_WORLD_CLOCK_BYTES = 8_192;
+const digest = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const protocol = z.string().max(127).regex(/^[a-z][a-z0-9._-]*\.v[1-9][0-9]*$/u);
+const clock = z.object({
+    completed_tick: z.number().int().min(0).max(1_000_000_000),
+    next_tick: z.number().int().min(1).max(1_000_000_001),
+    state: z.literal("running"),
+}).strict().superRefine((value, context) => {
+    if (value.next_tick !== value.completed_tick + 1)
+        context.addIssue({
+            code: z.ZodIssueCode.custom, message: "world clock frontier is invalid",
+        });
+});
+const observation = z.object({
+    action_count: z.number().int().min(0).max(1_000_000_000),
+    clock,
+    run_id: runIdSchema,
+    version: protocol,
+    world_instance_id: runIdSchema,
+}).strict();
+export const targetWorldClockRequestSchema = z.object({
+    activation_digest: digest,
+    activation_receipt_digest: digest,
+    descriptor_digest: digest,
+    endpoint: z.object({
+        internal_port: z.number().int().min(1).max(65_535),
+        path: z.literal(TARGET_WORLD_CLOCK_PATH),
+    }).strict(),
+    expected: z.object({ document_version: protocol, world_instance_id: runIdSchema }).strict(),
+    run_id: runIdSchema,
+    selected_target: selectedTargetSchema,
+    topology_receipt_digest: digest,
+    topology_request_digest: digest,
+    version: z.literal(TARGET_WORLD_CLOCK_REQUEST_VERSION),
+    world_service_handle: opaqueTargetHandleSchema,
+}).strict();
+export const targetWorldClockReceiptSchema = z.object({
+    action_count: z.literal(0),
+    activation_digest: digest,
+    activation_receipt_digest: digest,
+    clock: clock.superRefine((value, context) => {
+        if (value.completed_tick < 1)
+            context.addIssue({
+                code: z.ZodIssueCode.custom, message: "world has not completed its first tick",
+            });
+    }),
+    observation_digest: digest,
+    receipt_digest: digest,
+    request_digest: digest,
+    run_id: runIdSchema,
+    topology_receipt_digest: digest,
+    topology_request_digest: digest,
+    version: z.literal(TARGET_WORLD_CLOCK_RECEIPT_VERSION),
+    world_instance_id: runIdSchema,
+    world_service_handle: opaqueTargetHandleSchema,
+}).strict();
+const canonical = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonical(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+};
+const hash = (domain, value) => `sha256:${createHash("sha256").update(`${domain}\0${canonical(value)}`, "utf8").digest("hex")}`;
+const parse = (schema, raw) => {
+    assertOrdinaryJsonGraph(raw);
+    return schema.parse(raw);
+};
+export const parseTargetWorldClockRequest = (raw) => parse(targetWorldClockRequestSchema, raw);
+export const createTargetWorldClockRequestDigest = (raw) => hash(TARGET_WORLD_CLOCK_REQUEST_VERSION, parseTargetWorldClockRequest(raw));
+const parseObservation = (raw) => parse(observation, raw);
+const bodyFor = (observed, request) => {
+    if (observed.action_count !== 0 || observed.clock.completed_tick < 1
+        || observed.run_id !== request.run_id
+        || observed.version !== request.expected.document_version
+        || observed.world_instance_id !== request.expected.world_instance_id) {
+        throw new TypeError("Target world clock observation correlation is invalid");
+    }
+    return {
+        action_count: 0,
+        activation_digest: request.activation_digest,
+        activation_receipt_digest: request.activation_receipt_digest,
+        clock: observed.clock,
+        observation_digest: hash("spawnfile.target-world-clock.observation.v1", observed),
+        request_digest: createTargetWorldClockRequestDigest(request),
+        run_id: request.run_id,
+        topology_receipt_digest: request.topology_receipt_digest,
+        topology_request_digest: request.topology_request_digest,
+        version: TARGET_WORLD_CLOCK_RECEIPT_VERSION,
+        world_instance_id: observed.world_instance_id,
+        world_service_handle: request.world_service_handle,
+    };
+};
+export const parseTargetWorldClockReceipt = (raw) => {
+    const receipt = parse(targetWorldClockReceiptSchema, raw);
+    const { receipt_digest: _digest, ...body } = receipt;
+    if (receipt.receipt_digest !== hash(TARGET_WORLD_CLOCK_RECEIPT_VERSION, body)) {
+        throw new TypeError("Target world clock receipt digest is invalid");
+    }
+    return receipt;
+};
+export const createTargetWorldClockReceipt = (input) => {
+    const body = bodyFor(parseObservation(input.observation), parseTargetWorldClockRequest(input.request));
+    return parseTargetWorldClockReceipt({
+        ...body, receipt_digest: hash(TARGET_WORLD_CLOCK_RECEIPT_VERSION, body),
+    });
+};
+export const verifyTargetWorldClockReceipt = (input) => {
+    const receipt = parseTargetWorldClockReceipt(input.receipt);
+    const request = parseTargetWorldClockRequest(input.request);
+    const expectedBody = bodyFor({
+        action_count: receipt.action_count, clock: receipt.clock, run_id: receipt.run_id,
+        version: request.expected.document_version, world_instance_id: receipt.world_instance_id,
+    }, request);
+    const { receipt_digest: _digest, ...body } = receipt;
+    if (canonical(body) !== canonical(expectedBody)) {
+        throw new TypeError("Target world clock receipt correlation is invalid");
+    }
+    return receipt;
+};
+export const createCanonicalTargetWorldClockReceiptBytes = (raw) => canonical(parseTargetWorldClockReceipt(raw));

package/dist/target/worldReadiness.d.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+export declare const TARGET_WORLD_READINESS_REQUEST_VERSION: "spawnfile.target-world-readiness.request.v1";
+export declare const TARGET_WORLD_READINESS_RECEIPT_VERSION: "spawnfile.target-world-readiness-receipt.v1";
+export declare const TARGET_WORLD_READINESS_PATH: "/v1/world/readiness";
+export declare const MAX_TARGET_WORLD_READINESS_BYTES = 32768;
+export declare const targetWorldReadinessDocumentSchema: z.ZodObject<{
+    artifact_digest: z.ZodNullable<z.ZodString>;
+    bundle_digest: z.ZodString;
+    capability_manifest_digests: z.ZodArray<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        identity: z.ZodString;
+        manifest_digest: z.ZodString;
+    }, z.core.$strict>>>;
+    clock: z.ZodObject<{
+        next_tick: z.ZodLiteral<0>;
+        state: z.ZodLiteral<"paused">;
+    }, z.core.$strict>;
+    decisions: z.ZodObject<{
+        count: z.ZodLiteral<0>;
+        phase: z.ZodLiteral<"open">;
+    }, z.core.$strict>;
+    mechanics_sha256: z.ZodString;
+    normalized_checkpoint_sha256: z.ZodString;
+    run_id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").RunId, string>>;
+    runtime_abi: z.ZodString;
+    status: z.ZodLiteral<"ready">;
+    version: z.ZodString;
+    world_instance_id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").RunId, string>>;
+}, z.core.$strict>;
+export declare const targetWorldReadinessRequestSchema: z.ZodObject<{
+    descriptor_digest: z.ZodString;
+    endpoint: z.ZodObject<{
+        internal_port: z.ZodNumber;
+        path: z.ZodLiteral<"/v1/world/readiness">;
+    }, z.core.$strict>;
+    expected: z.ZodObject<{
+        artifact_digest: z.ZodNullable<z.ZodString>;
+        bundle_digest: z.ZodString;
+        capability_manifest_digests: z.ZodArray<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            identity: z.ZodString;
+            manifest_digest: z.ZodString;
+        }, z.core.$strict>>>;
+        document_version: z.ZodString;
+        mechanics_sha256: z.ZodString;
+        normalized_checkpoint_sha256: z.ZodString;
+        runtime_abi: z.ZodString;
+        world_instance_id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").RunId, string>>;
+    }, z.core.$strict>;
+    run_id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").RunId, string>>;
+    selected_target: z.ZodObject<{
+        fingerprint: z.ZodString;
+        handle: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").OpaqueTargetHandle, string>>;
+    }, z.core.$strict>;
+    version: z.ZodLiteral<"spawnfile.target-world-readiness.request.v1">;
+    world_service_handle: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").OpaqueTargetHandle, string>>;
+}, z.core.$strict>;
+export declare const targetWorldReadinessReceiptSchema: z.ZodObject<{
+    readiness: z.ZodObject<{
+        artifact_digest: z.ZodNullable<z.ZodString>;
+        bundle_digest: z.ZodString;
+        capability_manifest_digests: z.ZodArray<z.ZodString>;
+        capabilities: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            identity: z.ZodString;
+            manifest_digest: z.ZodString;
+        }, z.core.$strict>>>;
+        clock: z.ZodObject<{
+            next_tick: z.ZodLiteral<0>;
+            state: z.ZodLiteral<"paused">;
+        }, z.core.$strict>;
+        decisions: z.ZodObject<{
+            count: z.ZodLiteral<0>;
+            phase: z.ZodLiteral<"open">;
+        }, z.core.$strict>;
+        mechanics_sha256: z.ZodString;
+        normalized_checkpoint_sha256: z.ZodString;
+        run_id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").RunId, string>>;
+        runtime_abi: z.ZodString;
+        status: z.ZodLiteral<"ready">;
+        version: z.ZodString;
+        world_instance_id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").RunId, string>>;
+    }, z.core.$strict>;
+    readiness_digest: z.ZodString;
+    request_digest: z.ZodString;
+    run_id: z.ZodPipe<z.ZodString, z.ZodTransform<import("./contracts.js").RunId, string>>;
+    version: z.ZodLiteral<"spawnfile.target-world-readiness-receipt.v1">;
+}, z.core.$strict>;
+export type TargetWorldReadinessDocument = z.infer<typeof targetWorldReadinessDocumentSchema>;
+export type TargetWorldReadinessRequest = z.infer<typeof targetWorldReadinessRequestSchema>;
+export type TargetWorldReadinessReceipt = z.infer<typeof targetWorldReadinessReceiptSchema>;
+export declare const parseTargetWorldReadinessDocument: (raw: unknown) => TargetWorldReadinessDocument;
+export declare const parseTargetWorldReadinessRequest: (raw: unknown) => TargetWorldReadinessRequest;
+export declare const parseTargetWorldReadinessReceipt: (raw: unknown) => TargetWorldReadinessReceipt;
+export declare const createTargetWorldReadinessRequestDigest: (raw: unknown) => `sha256:${string}`;
+export declare const createTargetWorldReadinessReceipt: (input: {
+    readonly document: unknown;
+    readonly request: unknown;
+}) => TargetWorldReadinessReceipt;
+export declare const verifyTargetWorldReadinessReceipt: (input: {
+    readonly receipt: unknown;
+    readonly request: unknown;
+}) => TargetWorldReadinessReceipt;
+export declare const createCanonicalTargetWorldReadinessReceiptBytes: (raw: unknown) => string;

package/dist/target/worldReadiness.js

@@ -0,0 +1,153 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { assertOrdinaryJsonGraph, opaqueTargetHandleSchema, runIdSchema, selectedTargetSchema } from "./contracts.js";
+export const TARGET_WORLD_READINESS_REQUEST_VERSION = "spawnfile.target-world-readiness.request.v1";
+export const TARGET_WORLD_READINESS_RECEIPT_VERSION = "spawnfile.target-world-readiness-receipt.v1";
+export const TARGET_WORLD_READINESS_PATH = "/v1/world/readiness";
+export const MAX_TARGET_WORLD_READINESS_BYTES = 32_768;
+const digestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/u);
+const protocolSchema = z.string().max(127)
+    .regex(/^[a-z][a-z0-9._-]*\.v[1-9][0-9]*$/u);
+const capabilityDigestsSchema = z.array(digestSchema).min(1).max(4_096)
+    .superRefine((value, context) => {
+    const sorted = [...new Set(value)].sort();
+    if (sorted.length !== value.length
+        || value.some((item, index) => item !== sorted[index])) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "capability manifest digests must be sorted and unique"
+        });
+    }
+});
+const capabilityIdentitiesSchema = z.array(z.object({
+    identity: protocolSchema,
+    manifest_digest: digestSchema
+}).strict()).max(32).superRefine((value, context) => {
+    const identities = value.map((entry) => entry.identity);
+    if (new Set(identities).size !== identities.length
+        || identities.some((item, index) => index > 0 && identities[index - 1] >= item)) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "capability identities must be sorted and unique"
+        });
+    }
+});
+export const targetWorldReadinessDocumentSchema = z.object({
+    artifact_digest: digestSchema.nullable(),
+    bundle_digest: digestSchema,
+    capability_manifest_digests: capabilityDigestsSchema,
+    capabilities: capabilityIdentitiesSchema.optional(),
+    clock: z.object({ next_tick: z.literal(0), state: z.literal("paused") }).strict(),
+    decisions: z.object({ count: z.literal(0), phase: z.literal("open") }).strict(),
+    mechanics_sha256: digestSchema,
+    normalized_checkpoint_sha256: digestSchema,
+    run_id: runIdSchema,
+    runtime_abi: protocolSchema,
+    status: z.literal("ready"),
+    version: protocolSchema,
+    world_instance_id: runIdSchema
+}).strict().superRefine((value, context) => {
+    if (value.capabilities?.some((entry) => !value.capability_manifest_digests.includes(entry.manifest_digest))) {
+        context.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "capability identity manifest is not advertised"
+        });
+    }
+});
+const expectationSchema = z.object({
+    artifact_digest: digestSchema.nullable(),
+    bundle_digest: digestSchema,
+    capability_manifest_digests: capabilityDigestsSchema,
+    capabilities: capabilityIdentitiesSchema.optional(),
+    document_version: protocolSchema,
+    mechanics_sha256: digestSchema,
+    normalized_checkpoint_sha256: digestSchema,
+    runtime_abi: protocolSchema,
+    world_instance_id: runIdSchema
+}).strict();
+export const targetWorldReadinessRequestSchema = z.object({
+    descriptor_digest: digestSchema,
+    endpoint: z.object({
+        internal_port: z.number().int().min(1).max(65_535),
+        path: z.literal(TARGET_WORLD_READINESS_PATH)
+    }).strict(),
+    expected: expectationSchema,
+    run_id: runIdSchema,
+    selected_target: selectedTargetSchema,
+    version: z.literal(TARGET_WORLD_READINESS_REQUEST_VERSION),
+    world_service_handle: opaqueTargetHandleSchema
+}).strict();
+export const targetWorldReadinessReceiptSchema = z.object({
+    readiness: targetWorldReadinessDocumentSchema,
+    readiness_digest: digestSchema,
+    request_digest: digestSchema,
+    run_id: runIdSchema,
+    version: z.literal(TARGET_WORLD_READINESS_RECEIPT_VERSION)
+}).strict();
+const canonicalValue = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalValue).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalValue(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+};
+const parse = (schema, raw) => {
+    assertOrdinaryJsonGraph(raw);
+    return schema.parse(raw);
+};
+const hash = (domain, raw) => `sha256:${createHash("sha256")
+    .update(`${domain}\0${canonicalValue(raw)}`, "utf8")
+    .digest("hex")}`;
+export const parseTargetWorldReadinessDocument = (raw) => parse(targetWorldReadinessDocumentSchema, raw);
+export const parseTargetWorldReadinessRequest = (raw) => parse(targetWorldReadinessRequestSchema, raw);
+export const parseTargetWorldReadinessReceipt = (raw) => {
+    const receipt = parse(targetWorldReadinessReceiptSchema, raw);
+    if (receipt.readiness_digest !== hash("spawnfile.target-world-readiness.document.v1", receipt.readiness))
+        throw new TypeError("Target world readiness receipt digest is invalid");
+    return receipt;
+};
+export const createTargetWorldReadinessRequestDigest = (raw) => hash(TARGET_WORLD_READINESS_REQUEST_VERSION, parseTargetWorldReadinessRequest(raw));
+const verifyDocument = (document, request) => {
+    const expected = request.expected;
+    if (document.version !== expected.document_version
+        || document.runtime_abi !== expected.runtime_abi
+        || document.run_id !== request.run_id
+        || document.world_instance_id !== expected.world_instance_id
+        || document.artifact_digest !== expected.artifact_digest
+        || document.bundle_digest !== expected.bundle_digest
+        || document.mechanics_sha256 !== expected.mechanics_sha256
+        || document.normalized_checkpoint_sha256
+            !== expected.normalized_checkpoint_sha256
+        || canonicalValue(document.capability_manifest_digests)
+            !== canonicalValue(expected.capability_manifest_digests)
+        || canonicalValue(document.capabilities ?? [])
+            !== canonicalValue(expected.capabilities ?? [])) {
+        throw new TypeError("Target world readiness document correlation is invalid");
+    }
+};
+export const createTargetWorldReadinessReceipt = (input) => {
+    const request = parseTargetWorldReadinessRequest(input.request);
+    const readiness = parseTargetWorldReadinessDocument(input.document);
+    verifyDocument(readiness, request);
+    return parseTargetWorldReadinessReceipt({
+        readiness,
+        readiness_digest: hash("spawnfile.target-world-readiness.document.v1", readiness),
+        request_digest: createTargetWorldReadinessRequestDigest(request),
+        run_id: request.run_id,
+        version: TARGET_WORLD_READINESS_RECEIPT_VERSION
+    });
+};
+export const verifyTargetWorldReadinessReceipt = (input) => {
+    const receipt = parseTargetWorldReadinessReceipt(input.receipt);
+    const expected = createTargetWorldReadinessReceipt({
+        document: receipt.readiness,
+        request: input.request
+    });
+    if (canonicalValue(receipt) !== canonicalValue(expected)) {
+        throw new TypeError("Target world readiness receipt correlation is invalid");
+    }
+    return receipt;
+};
+export const createCanonicalTargetWorldReadinessReceiptBytes = (raw) => canonicalValue(parseTargetWorldReadinessReceipt(raw));

package/moltnet-releases.json

@@ -0,0 +1,20 @@
+{
+  "version": "spawnfile.moltnet-release-authority.v1",
+  "release_version": "v0.1.14",
+  "source_revision": "7baeb284ba0b1b5e454476141a557d68b5a4af0d",
+  "capabilities": [
+    "pi-bridge"
+  ],
+  "assets": [
+    {
+      "architecture": "amd64",
+      "asset": "moltnet_linux_amd64.tar.gz",
+      "asset_sha256": "sha256:a2e7a0acd44ab548a81d99e51401ebdee9f50a539b24c9450fc12d8e9218e5f6"
+    },
+    {
+      "architecture": "arm64",
+      "asset": "moltnet_linux_arm64.tar.gz",
+      "asset_sha256": "sha256:3d46ad047496dd32a9ad41901e7ae1f10a25e9a21f3b29d3b6ccd2cff62fa58f"
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spawnfile",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Canonical source compiler for autonomous agents and teams.",
   "license": "MIT",
   "type": "module",
@@ -9,14 +9,14 @@
   },
   "files": [
     "dist",
+    "moltnet-releases.json",
     "runtimes.yaml"
   ],
   "engines": {
-    "node": ">=22.0.0"
+    "node": ">=22.19.0"
   },
   "scripts": {
-    "blueprints": "./scripts/blueprints.sh",
-    "build": "rm -rf dist && tsc --project tsconfig.build.json && chmod +x dist/cli/index.js && node ./scripts/copy-runtime-scaffold-assets.mjs",
+    "build": "rm -rf dist && tsc --project tsconfig.build.json && chmod +x dist/cli/index.js && node ./src/runtime/copyScaffoldAssets.mjs",
     "clean": "rm -rf coverage dist",
     "coverage": "vitest run --coverage",
     "dev": "tsx src/cli/index.ts",
@@ -25,22 +25,43 @@
     "release:patch": "npm version patch && npm publish",
     "release:minor": "npm version minor && npm publish",
     "release:major": "npm version major && npm publish",
-    "runtimes": "./scripts/runtimes.sh",
-    "runtimes:sync": "./scripts/runtimes.sh && ./scripts/blueprints.sh",
+    "runtime:images": "npm run runtime:openclaw-image && npm run runtime:picoclaw-image",
+    "runtime:openclaw-image": "docker build -f runtime-images/openclaw/Dockerfile -t noopolis/spawnfile-runtime-openclaw:2026.6.11-local runtime-images/openclaw",
+    "runtime:picoclaw-image": "docker build -f runtime-images/picoclaw/Dockerfile -t noopolis/spawnfile-runtime-picoclaw:0.3.1-local runtime-images/picoclaw",
+    "audit:generate": "tsx src/audit/auditCli.ts",
+    "build:local-moltnet": "node ./scripts/build-local-moltnet.mjs",
+    "verify:package-closure": "node ./scripts/verify-package-closure.mjs",
     "test:e2e:docker-auth": "tsx src/e2e/cli.ts",
+    "test:e2e:daimon-memory-recall": "tsx src/e2e/cli.ts daimon-memory-recall",
+    "test:e2e:jungian-self-org": "tsx src/e2e/cli.ts jungian-self-org",
     "test:e2e:moltnet-team-chat": "tsx src/e2e/cli.ts moltnet-team-chat",
+    "test:e2e:moltnet-memetics": "tsx src/e2e/cli.ts moltnet-memetics",
+    "test:e2e:mixed-runtime-memory": "tsx src/e2e/cli.ts mixed-runtime-memory",
+    "test:e2e:preflight": "tsx src/e2e/cli.ts preflight",
+    "test:e2e:ollama-embeddings-probe": "tsx src/e2e/cli.ts ollama-embeddings-probe",
     "test:e2e:operational-smoke": "tsx src/e2e/cli.ts operational-smoke",
-    "test": "vitest run",
+    "test:e2e:lifecycle-smoke": "tsx src/e2e/cli.ts lifecycle-smoke",
+    "test": "npm run test:vitest; vitest_status=$?; npm run test:verdict; verdict_status=$?; npm run test:coverage-verdict; coverage_status=$?; npm run test:node; node_status=$?; failed_lanes=''; if [ \"$verdict_status\" -eq 2 ]; then failed_lanes='vitest test failures'; fi; if [ \"$node_status\" -eq 2 ]; then if [ -n \"$failed_lanes\" ]; then failed_lanes=\"$failed_lanes; node:test suite\"; else failed_lanes='node:test suite'; fi; fi; result_status=0; if [ -n \"$failed_lanes\" ]; then echo \"FAIL(tests): $failed_lanes\"; result_status=1; fi; if [ \"$verdict_status\" -ne 0 ] && [ \"$verdict_status\" -ne 2 ]; then echo 'FAIL(vitest-verdict): could not determine the vitest result'; result_status=1; fi; if [ \"$node_status\" -ne 0 ] && [ \"$node_status\" -ne 2 ]; then echo 'FAIL(node-lane): could not determine the node:test result'; result_status=1; fi; if [ \"$result_status\" -ne 0 ]; then exit 1; elif [ \"$vitest_status\" -ne 0 ]; then echo \"FAIL(vitest): exited $vitest_status with no test failure\"; exit 1; elif [ \"$coverage_status\" -eq 2 ]; then echo 'FAIL(coverage): thresholds not met (tests all passed)'; exit 2; elif [ \"$coverage_status\" -ne 0 ]; then echo 'FAIL(coverage-verdict): could not evaluate coverage (tests all passed)'; exit 1; else echo 'PASS'; fi",
+    "test:vitest": "rm -f coverage/vitest-results.json coverage/coverage-summary.json && vitest run --coverage.thresholds.branches=0 --coverage.thresholds.functions=0 --coverage.thresholds.lines=0 --coverage.thresholds.statements=0",
+    "test:verdict": "node -e \"const fs=require('fs'); const file='coverage/vitest-results.json'; if (!fs.existsSync(file)) { console.error('VERDICT: results file missing'); process.exit(1); } let result; try { result=JSON.parse(fs.readFileSync(file, 'utf8')); } catch { console.error('VERDICT: results file unparseable'); process.exit(1); } const total=result.numTotalTests; const totalSuites=result.numTotalTestSuites; const passedTests=result.numPassedTests; const failedTests=result.numFailedTests; const pendingTests=result.numPendingTests; const todoTests=result.numTodoTests; const failedSuites=result.numFailedTestSuites; if (typeof result.success !== 'boolean' || !Number.isInteger(passedTests) || passedTests < 0 || !Number.isInteger(failedTests) || failedTests < 0 || !Number.isInteger(pendingTests) || pendingTests < 0 || !Number.isInteger(todoTests) || todoTests < 0 || !Number.isInteger(failedSuites) || failedSuites < 0 || !Number.isInteger(totalSuites) || totalSuites < 0) { console.error('VERDICT: results schema unrecognised'); process.exit(1); } if (!Number.isInteger(total) || total <= 0) { console.error('VERDICT: no tests found'); process.exit(1); } if (passedTests + failedTests + pendingTests + todoTests !== total) { console.error('VERDICT: results counters do not reconcile (tests='+total+', passed='+passedTests+', failed='+failedTests+', skipped='+pendingTests+', todo='+todoTests+')'); process.exit(1); } const failed=result.success === false || failedTests > 0 || failedSuites > 0; if (failed) { console.error('VERDICT: test failures found (tests='+failedTests+', suites='+failedSuites+', success='+result.success+')'); process.exit(2); } if (passedTests === 0) { console.error('VERDICT: no tests actually ran (skipped='+pendingTests+', todo='+todoTests+')'); process.exit(1); } console.log('VERDICT: tests passed (tests='+total+', suites='+totalSuites+', passed='+passedTests+', skipped='+pendingTests+', todo='+todoTests+')');\"",
+    "test:coverage-verdict": "node --import tsx -e \"import fs from 'node:fs'; const file='coverage/coverage-summary.json'; const fail=(message)=>{ console.error('COVERAGE VERDICT: '+message); process.exit(1); }; let summary; try { summary=JSON.parse(fs.readFileSync(file, 'utf8')); } catch (error) { fail(error && error.code === 'ENOENT' ? 'summary file missing' : 'summary file unparseable'); } import('./vitest.config.ts').then(({default:config})=>{ const thresholds=config.test && config.test.coverage && config.test.coverage.thresholds; if (!thresholds || typeof thresholds !== 'object' || !summary || typeof summary !== 'object' || !summary.total || typeof summary.total !== 'object') fail('summary or threshold schema unrecognised'); const metricNames=['branches','functions','lines','statements']; const metrics=metricNames.filter((metric)=>Object.prototype.hasOwnProperty.call(thresholds, metric)); if (metrics.length === 0) fail('no threshold metrics configured'); let shortfall=false; for (const metric of metrics) { const threshold=thresholds[metric]; const pct=summary.total[metric] && summary.total[metric].pct; if (typeof threshold !== 'number' || !Number.isFinite(threshold) || typeof pct !== 'number' || !Number.isFinite(pct)) fail('missing or non-numeric value for '+metric); console.log('COVERAGE: '+metric+' '+pct+'% (threshold '+threshold+'%)'); if (pct < threshold) shortfall=true; } if (shortfall) { console.error('COVERAGE VERDICT: thresholds not met'); process.exit(2); } console.log('COVERAGE VERDICT: thresholds met'); }).catch((error)=>fail('could not load vitest config: '+error.message));\"",
+    "test:node": "mkdir -p coverage || exit 1; rm -f coverage/node-test.tap || exit 1; node --import tsx --test --test-reporter=tap src/runtime/pi/appControlDeliveryMetadata.test.ts > coverage/node-test.tap 2>&1; node_status=$?; cat coverage/node-test.tap; cat_status=$?; npm run test:node-verdict; verdict_status=$?; if [ \"$verdict_status\" -eq 2 ]; then exit 2; fi; if [ \"$verdict_status\" -ne 0 ]; then exit 1; fi; if [ \"$cat_status\" -ne 0 ]; then echo 'NODE VERDICT: could not read TAP output' >&2; exit 1; fi; if [ \"$node_status\" -ne 0 ]; then echo \"NODE VERDICT: node:test runner exited $node_status despite a passing TAP summary\" >&2; exit 1; fi; exit 0",
+    "test:node-verdict": "node -e \"const fs=require('fs'); const text=fs.readFileSync('coverage/node-test.tap', 'utf8'); const tests=text.match(/^# tests ([0-9]+)\\r?$/m); const suites=text.match(/^# suites ([0-9]+)\\r?$/m); const passed=text.match(/^# pass ([0-9]+)\\r?$/m); const failed=text.match(/^# fail ([0-9]+)\\r?$/m); const skipped=text.match(/^# skipped ([0-9]+)\\r?$/m); const todo=text.match(/^# todo ([0-9]+)\\r?$/m); const cancelled=text.match(/^# cancelled ([0-9]+)\\r?$/m); if (!tests || !suites || !passed || !failed || !skipped || !todo || !cancelled) { console.error('NODE VERDICT: TAP summary unrecognised'); process.exit(1); } const testCount=Number(tests[1]); const suiteCount=Number(suites[1]); const passCount=Number(passed[1]); const failCount=Number(failed[1]); const skippedCount=Number(skipped[1]); const todoCount=Number(todo[1]); const cancelledCount=Number(cancelled[1]); if (failCount > 0) { console.error('NODE VERDICT: test failures found (tests='+testCount+', failed='+failCount+')'); process.exit(2); } if (cancelledCount > 0) { console.error('NODE VERDICT: incomplete run (cancelled='+cancelledCount+')'); process.exit(1); } if (passCount + skippedCount + todoCount + cancelledCount !== testCount) { console.error('NODE VERDICT: TAP counts do not reconcile (tests='+testCount+', passed='+passCount+', skipped='+skippedCount+', todo='+todoCount+', cancelled='+cancelledCount+')'); process.exit(1); } if (testCount < 10) { console.error('NODE VERDICT: expected at least 10 node:test cases, found '+testCount+' — cases were removed or the file was gutted'); process.exit(1); } if (passCount < 10) { console.error('NODE VERDICT: expected at least 10 passing node:test cases, found '+passCount+' (skipped='+skippedCount+', todo='+todoCount+')'); process.exit(1); } if (suiteCount < 1) { console.error('NODE VERDICT: expected at least 1 node:test suite, found '+suiteCount); process.exit(1); } console.log('NODE VERDICT: tests passed (tests='+testCount+', suites='+suiteCount+', passed='+passCount+', skipped='+skippedCount+', todo='+todoCount+', failed=0)');\"",
+    "test:boundaries": "vitest run --coverage.enabled=false src/ownership/rootOwnershipBoundary.test.ts src/deployment/providerRuntimeBoundary.test.ts src/ownership/mnemePublicImportBoundary.test.ts src/target/containerBundleArchive.test.ts",
+    "test:causal-conformance": "tsx src/ledger/causalConformanceCli.ts",
     "typecheck": "tsc --project tsconfig.json --noEmit",
     "test:e2e:distribution-image": "tsx src/e2e/cli.ts distribution-image",
-    "test:e2e:distribution-roundtrip": "tsx src/e2e/cli.ts distribution-roundtrip"
+    "test:e2e:distribution-roundtrip": "tsx src/e2e/cli.ts distribution-roundtrip",
+    "test:e2e:daimon-org": "tsx src/e2e/cli.ts daimon-org"
   },
   "dependencies": {
+    "@noopolis/stele": "0.0.2",
     "commander": "^14.0.1",
     "yaml": "^2.8.1",
     "zod": "^4.1.12"
   },
   "devDependencies": {
+    "@noopolis/mneme": "^0.1.1",
     "@types/node": "^24.6.0",
     "@vitest/coverage-v8": "^3.2.4",
     "tsx": "^4.20.6",

package/runtimes.yaml

@@ -10,32 +10,45 @@
 #   install         Pinned install strategy for the verified runtime version
 #   status          active (has adapter) | exploratory (research only)
 #
-# Run ./scripts/runtimes.sh to clone or update all entries to their
-# pinned refs.
-
 runtimes:
+  daimon:
+    remote: git@github.com:noopolis/daimon.git
+    ref: v0.1.2
+    default_branch: main
+    install:
+      kind: container_image
+      image: noopolis/spawnfile-runtime-daimon
+      tag: 0.1.2
+    status: active
+
   openclaw:
     remote: git@github.com:openclaw/openclaw.git
-    ref: v2026.6.5
+    ref: v2026.6.11
     default_branch: main
     install:
-      kind: npm
-      package: openclaw
-      version: 2026.6.5
+      kind: container_image
+      image: noopolis/spawnfile-runtime-openclaw
+      tag: 2026.6.11
     status: active
 
   picoclaw:
     remote: git@github.com:sipeed/picoclaw.git
-    ref: v0.2.9
+    ref: v0.3.1
     default_branch: main
     install:
-      kind: github_release_archive
-      repository: sipeed/picoclaw
-      tag: v0.2.9
-      binary: picoclaw
-      assets:
-        linux_amd64: picoclaw_Linux_x86_64.tar.gz
-        linux_arm64: picoclaw_Linux_arm64.tar.gz
+      kind: container_image
+      image: noopolis/spawnfile-runtime-picoclaw
+      tag: 0.3.1
+    status: active
+
+  pi:
+    remote: git@github.com:earendil-works/pi.git
+    ref: v0.79.10
+    default_branch: main
+    install:
+      kind: npm
+      package: "@earendil-works/pi-coding-agent"
+      version: 0.79.10
     status: active
 
   hermes-agent:
@@ -44,12 +57,6 @@ runtimes:
     default_branch: main
     status: exploratory
 
-  nullclaw:
-    remote: git@github.com:nullclaw/nullclaw.git
-    ref: v2026.5.29
-    default_branch: main
-    status: exploratory
-
   opencode:
     remote: git@github.com:anomalyco/opencode.git
     ref: v1.16.2
@@ -61,9 +68,3 @@ runtimes:
     ref: v0.6.9
     default_branch: main
     status: exploratory
-
-  zeroclaw:
-    remote: git@github.com:zeroclaw-labs/zeroclaw.git
-    ref: v0.7.5
-    default_branch: master
-    status: exploratory

package/dist/runtime/openclaw/scaffold-assets/CLAUDE.md

@@ -1,5 +0,0 @@
-# OpenClaw Scaffold Assets
-
-This folder contains the bundled markdown starter files used by `spawnfile init --runtime openclaw`.
-
-These files are copied into `dist/runtime/openclaw/scaffold-assets/` during `npm run build` so the installed CLI can scaffold projects without depending on `blueprints/` or `runtimes/`.

package/dist/runtime/picoclaw/scaffold-assets/CLAUDE.md

@@ -1,5 +0,0 @@
-# PicoClaw Scaffold Assets
-
-This folder contains the bundled markdown starter files used by `spawnfile init --runtime picoclaw`.
-
-These files are copied into `dist/runtime/picoclaw/scaffold-assets/` during `npm run build` so the installed CLI can scaffold projects without depending on `blueprints/` or `runtimes/`.