spawnfile 0.1.13 → 0.1.17

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/examples/README.md

@@ -0,0 +1,45 @@
+# Example and Test Projects
+
+Authored Spawnfile inputs live in two top-level directories:
+
+- `examples/` — showcase org projects meant to be read as reference layouts.
+- `fixtures/` — test-only org projects (and `fixtures/support/` executable
+  test-support code).
+
+They exercise portable compiler contracts and opt-in runtime integration paths;
+product code must not contain fixture-specific behavior.
+
+## Showcase Examples (`examples/`)
+
+| Project | Contract |
+|---|---|
+| `single-agent` | Full agent workspace, docs, skills, MCP, secret, and OpenClaw lowering |
+| `agent-with-subagents` | Canonical subagent graph resolution |
+| `distribution-org` | Source-free image metadata, required/optional secrets, and managed Moltnet distribution |
+| `moltnet-team-chat` | Nested-team representatives communicating through parent and child Moltnet rooms |
+| `daimon-org` | One generated Daimon app with nested agents, shared files, and persistent Mneme recall |
+| `mixed-runtime-org` | Daimon, OpenClaw, and PicoClaw sharing Moltnet and Mneme wiring |
+| `jungian-daimon-org` | Nested council topology, representative routing, and scoped memory bindings |
+
+## Test-Only Fixtures (`fixtures/`)
+
+| Project | Contract |
+|---|---|
+| `multi-runtime-team` | Hierarchical team resolution and mixed runtime capability reporting |
+| `docker-auth-agent` | Single-runtime Docker auth injection |
+| `docker-auth-team` | Mixed OpenClaw/PicoClaw Docker auth injection |
+| `operational-smoke` | Scheduled PicoClaw wake, workspace volume, Moltnet, and live status |
+| `daimon-cli-memory-org` | Codex, Claude, Grok, and Agy CLI engines receiving schedule/dream memory context |
+| `lifecycle-smoke` | Minimal single-agent scripted lifecycle (`up`/`artifacts export`/`down`) receipt smoke |
+| `moltnet-memetics` | Live two-agent Moltnet conversation over real Codex/Grok |
+| `office-sim` | Standalone scripted-engine harness proving the pi adapter's `scripted` engine kind |
+
+Executable test-support helpers (cross-process fork fixtures and the trusted
+Moltnet release stager) live under `fixtures/support/`.
+
+Simulation worlds, transcripts, clocks, and domain-specific orchestration do not
+belong in this suite. They should consume Spawnfile as an external system and
+test their own behavior in their owning project.
+
+Generated output such as `.spawn/`, runtime logs, credentials, and run
+transcripts must remain untracked.

package/examples/agent-with-subagents/AGENTS.md

@@ -0,0 +1,3 @@
+# Operating Instructions
+
+Break work into research, critique, and final editing passes when helpful.

package/examples/agent-with-subagents/Spawnfile

@@ -0,0 +1,30 @@
+spawnfile_version: "0.1"
+kind: agent
+name: editor
+
+runtime:
+  name: picoclaw
+  options:
+    restrict_to_workspace: true
+
+execution:
+  model:
+    primary:
+      provider: openai
+      name: gpt-4o-mini
+  sandbox:
+    mode: workspace
+
+workspace:
+  docs:
+    system: AGENTS.md
+
+subagents:
+  - id: researcher
+    ref: ./subagents/researcher
+  - id: critic
+    ref: ./subagents/critic
+
+policy:
+  mode: warn
+  on_degrade: warn

package/examples/agent-with-subagents/subagents/critic/AGENTS.md

@@ -0,0 +1,3 @@
+# Critic
+
+Look for weak claims, missing evidence, and avoidable ambiguity.

package/examples/agent-with-subagents/subagents/critic/Spawnfile

@@ -0,0 +1,15 @@
+spawnfile_version: "0.1"
+kind: agent
+name: critic
+
+execution:
+  model:
+    primary:
+      provider: openai
+      name: gpt-4o-mini
+  sandbox:
+    mode: sandboxed
+
+workspace:
+  docs:
+    system: AGENTS.md

package/examples/agent-with-subagents/subagents/researcher/AGENTS.md

@@ -0,0 +1,3 @@
+# Researcher
+
+Gather relevant facts quickly and return structured notes instead of full prose.

package/examples/agent-with-subagents/subagents/researcher/Spawnfile

@@ -0,0 +1,17 @@
+spawnfile_version: "0.1"
+kind: agent
+name: researcher
+
+runtime: picoclaw
+
+execution:
+  model:
+    primary:
+      provider: openai
+      name: gpt-4o-mini
+  sandbox:
+    mode: workspace
+
+workspace:
+  docs:
+    system: AGENTS.md

package/examples/daimon-org/Spawnfile

@@ -0,0 +1,68 @@
+spawnfile_version: "0.1"
+kind: team
+name: daimon-org
+description: "Legacy generated-Pi organization fixture with Moltnet and shared resources"
+
+shared:
+  workspace:
+    docs:
+      system: TEAM.md
+    skills:
+      - ref: ./shared/skills/file-note
+    resources:
+      - id: shared-lab
+        kind: volume
+        mount: ./shared-lab
+        mode: mutable
+        sharing: team
+
+members:
+  - id: mapper
+    ref: ./agents/mapper
+  - id: review
+    ref: ./teams/review
+
+memory:
+  - id: shared-recall
+    access:
+      members: [mapper]
+    store:
+      kind: json
+      path: /var/lib/spawnfile/memory/daimon-org/shared-recall.jsonl
+      persistence:
+        mode: durable
+    index:
+      lexical:
+        enabled: true
+        engine: sqlite_fts
+      vector:
+        enabled: true
+        provider: ollama
+        model: qwen3-embedding:0.6b
+        dimensions: 1024
+
+mode: hierarchical
+lead: mapper
+
+networks:
+  - id: daimon_lab
+    name: Daimon Lab
+    provider: moltnet
+    server:
+      mode: managed
+      listen:
+        bind: 0.0.0.0
+        port: 19877
+      store:
+        kind: sqlite
+        path: /var/lib/spawnfile/moltnet/networks/daimon_lab/moltnet.sqlite
+      auth:
+        mode: open
+        public_read: true
+      human_ingress: true
+      direct_messages: false
+    rooms:
+      - id: lab-floor
+        members: [mapper, review]
+        visibility: public
+        write_policy: registered_agents

package/examples/daimon-org/TEAM.md

@@ -0,0 +1,4 @@
+# Daimon Org
+
+This legacy organization verifies that Spawnfile can compile multiple generated Pi agents and
+a nested team into one generated runtime app with shared resources and memory.

package/examples/daimon-org/agents/mapper/AGENTS.md

@@ -0,0 +1,4 @@
+# Mapper
+
+You are Mapper. Keep responses short and use the shared-lab resource when a
+scheduled prompt asks for it.

package/examples/daimon-org/agents/mapper/Spawnfile

@@ -0,0 +1,37 @@
+spawnfile_version: "0.1"
+kind: agent
+name: mapper
+description: "Maps shared workspace state for the Daimon org."
+
+runtime: pi
+
+execution:
+  model:
+    primary:
+      provider: openai
+      name: gpt-5.4-mini
+      auth:
+        method: codex
+  sandbox:
+    mode: workspace
+
+schedule:
+  kind: every
+  every: 1s
+  prompt: "Create ./shared-lab/mapper-note.md with one sentence proving mapper can write to the shared resource."
+
+surfaces:
+  moltnet:
+    - network: daimon_lab
+      rooms:
+        lab-floor:
+          wake: mentions
+
+workspace:
+  docs:
+    system: AGENTS.md
+  resources:
+    - id: mapper-scratch
+      kind: volume
+      mount: ./scratch
+      mode: mutable

package/examples/daimon-org/shared/skills/file-note/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: file-note
+description: "Create short markdown notes in requested workspace paths."
+---
+
+# File Note
+
+When asked to verify filesystem access, create a short markdown note in the
+requested path and mention the exact file path in the response.