spawnfile 0.1.33 → 0.1.35

package/examples/jungian-daimon-org/teams/luna/agents/shadow/Spawnfile

@@ -4,20 +4,17 @@ name: luna-shadow
 description: "Luna inner archetype (Grok CLI engine)"
 
 runtime:
-  name: pi
+  name: daimon
   options:
-    engine: grok
+    engine: codex
 
 execution:
   model:
     primary:
-      provider: local
-      name: grok-cli
+      provider: openai
+      name: gpt-5.4-mini
       auth:
-        method: none
-      endpoint:
-        compatibility: openai
-        base_url: http://127.0.0.1:11434/v1
+        method: codex
   sandbox:
     mode: workspace
 

package/examples/jungian-daimon-org/teams/selene/agents/animus/Spawnfile

@@ -4,20 +4,17 @@ name: selene-animus
 description: "Selene inner archetype (Antigravity CLI engine)"
 
 runtime:
-  name: pi
+  name: daimon
   options:
-    engine: agy
+    engine: codex
 
 execution:
   model:
     primary:
-      provider: local
-      name: agy-cli
+      provider: openai
+      name: gpt-5.4-mini
       auth:
-        method: none
-      endpoint:
-        compatibility: openai
-        base_url: http://127.0.0.1:11434/v1
+        method: codex
   sandbox:
     mode: workspace
 

package/examples/jungian-daimon-org/teams/selene/agents/representative/Spawnfile

@@ -4,20 +4,17 @@ name: selene-representative
 description: "Selene representative (Grok CLI engine)"
 
 runtime:
-  name: pi
+  name: daimon
   options:
-    engine: grok
+    engine: codex
 
 execution:
   model:
     primary:
-      provider: local
-      name: grok-dual
+      provider: openai
+      name: gpt-5.4-mini
       auth:
-        method: none
-      endpoint:
-        compatibility: openai
-        base_url: http://127.0.0.1:11434/v1
+        method: codex
   sandbox:
     mode: workspace
 

package/examples/jungian-daimon-org/teams/selene/agents/shadow/Spawnfile

@@ -4,7 +4,7 @@ name: selene-shadow
 description: "Selene inner archetype (grounding profile)"
 
 runtime:
-  name: pi
+  name: daimon
   options:
     engine: codex
 

package/examples/mixed-runtime-org/agents/localist/Spawnfile

@@ -3,18 +3,18 @@ kind: agent
 name: localist
 description: "Pi agent configured for a local OpenAI-compatible model"
 
-runtime: pi
+runtime:
+  name: daimon
+  options:
+    engine: codex
 
 execution:
   model:
     primary:
-      provider: local
-      name: llama3.2
+      provider: openai
+      name: gpt-5.4-mini
       auth:
-        method: none
-      endpoint:
-        compatibility: openai
-        base_url: http://host.docker.internal:11434/v1
+        method: codex
   sandbox:
     mode: workspace
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spawnfile",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "Canonical source compiler for autonomous agents and teams.",
   "license": "MIT",
   "type": "module",
@@ -18,7 +18,7 @@
   },
   "scripts": {
     "compile:explicit-test-mcp": "node --experimental-strip-types scripts/compile-explicit-test-mcp.ts",
-    "build": "rm -rf dist && tsc --project tsconfig.build.json && tsc --project tsconfig.training.build.json && chmod +x dist/cli/index.js && node --experimental-strip-types ./src/evidenceExportHelper/copyAssets.ts && node --experimental-strip-types ./src/runtime/copyScaffoldAssets.ts && node --experimental-strip-types ./src/deployment/native/copyArtifacts.ts && node --experimental-strip-types ./src/compiler/training/preparation/copyAssets.ts && node --experimental-strip-types ./src/training/copyAssets.ts",
+    "build": "rm -rf dist && tsc --project tsconfig.build.json && tsc --project tsconfig.training.build.json && chmod +x dist/cli/index.js && node --experimental-strip-types ./src/evidenceExportHelper/copyAssets.ts && node --experimental-strip-types ./src/runtime/copyScaffoldAssets.ts && node --experimental-strip-types ./src/deployment/native/copyArtifacts.ts && node --experimental-strip-types ./src/training/copyAssets.ts",
     "build:native": "node --experimental-strip-types ./src/deployment/native/build.ts",
     "clean": "rm -rf coverage dist",
     "coverage": "vitest run --coverage",
@@ -43,7 +43,6 @@
     "test:moltnet-source-provenance-docker": "node --experimental-strip-types --test scripts/moltnet-source-provenance.integration.test.ts",
     "verify:package-closure": "node --experimental-strip-types ./scripts/verify-package-closure.ts",
     "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",
@@ -55,19 +54,15 @@
     "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)');\"",
-    "verify:training-image-modes": "tsx scripts/verify-training-image-modes.ts",
     "test:product-state-volume": "node --experimental-strip-types scripts/product-state-volume-integration.test.ts",
     "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 && tsc --project scripts/tsconfig.json && tsc --project .github/scripts/ci/tsconfig.json && tsc --project tsconfig.training.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:daimon-org": "tsx src/e2e/cli.ts daimon-org",
     "test:live:grok-lean-worker": "node --experimental-strip-types ./scripts/grok-lean-worker-live-check.ts",
-    "test:scripts": "node --experimental-strip-types --test scripts/build-local-daimon-runtime.test.ts scripts/daimon-publish-inputs.test.ts scripts/daimon-image-contract.test.ts scripts/generate-daimon-engine-descriptors.test.ts scripts/runtime-image-workflows.test.ts scripts/grok-lean-worker-live-check.test.ts scripts/build-local-moltnet.test.ts scripts/compile-explicit-test-mcp.test.ts scripts/native-helper-workflows.test.ts scripts/typescript-policy.test.ts scripts/training-image-modes.test.ts scripts/training-public-exports.test.ts && node --import tsx --test scripts/training-native-image.test.ts",
-    "test:unit": "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:scripts": "node --experimental-strip-types --test scripts/build-local-daimon-runtime.test.ts scripts/daimon-publish-inputs.test.ts scripts/daimon-image-contract.test.ts scripts/generate-daimon-engine-descriptors.test.ts scripts/runtime-image-workflows.test.ts scripts/grok-lean-worker-live-check.test.ts scripts/build-local-moltnet.test.ts scripts/compile-explicit-test-mcp.test.ts scripts/native-helper-workflows.test.ts scripts/typescript-policy.test.ts scripts/training-public-exports.test.ts",
+    "test:unit": "npm run test:vitest; vitest_status=$?; npm run test:verdict; verdict_status=$?; npm run test:coverage-verdict; coverage_status=$?; failed_lanes=''; if [ \"$verdict_status\" -eq 2 ]; then failed_lanes='vitest test failures'; 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 [ \"$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": "npm run test:unit && npm run test:scripts",
     "test:training-python": "node --experimental-strip-types scripts/test-training-python.ts",
     "vendor:daimon-engine-descriptors": "node --experimental-strip-types ./scripts/generate-daimon-engine-descriptors.ts"
@@ -112,10 +107,6 @@
       "types": "./dist/training/public.d.ts",
       "import": "./dist/training/public.js"
     },
-    "./training/daimon": {
-      "types": "./dist/runtime/daimon/training/public.d.ts",
-      "import": "./dist/runtime/daimon/training/public.js"
-    },
     "./training/cli": {
       "types": "./dist/runtime/trainingPublic.d.ts",
       "import": "./dist/runtime/trainingPublic.js"

package/runtimes.yaml

@@ -13,16 +13,16 @@
 runtimes:
   daimon:
     remote: git@github.com:noopolis/daimon-harness.git
-    ref: d8aec28df0f0b5705db537136662642416a70d71
+    ref: c5337565df0b60151ae731b17878f784c13a9337
     default_branch: main
     install:
       kind: container_image
       image: noopolis/spawnfile-runtime-daimon
-      tag: 0.2.12-d8aec28
-      digest: sha256:40badb0eca3b332aa23ac8eef45f9f07e739dc51aed825ee4ca496542a3e0697
+      tag: 0.2.16-c533756
+      digest: sha256:cec10f3e0b0547d352de0a61d7d2345efe66f8ece6bf6fe7e5178cee1465f239
       capability_receipts:
-        amd64: sha256:6558ccd7a9d4aa0dfc49dd5bd664002c11eea4b1e9d6bbf061a6d9b74a9b123d
-        arm64: sha256:0c66a9d3e1bc65ac2b8b8fdb7e3c327ed026ac8e7b8c2365fdd7aabe2f74f727
+        amd64: sha256:effee312a6ad276d19176e11eb34eea20f3dcb823a0141117e00f81ef970a491
+        arm64: sha256:01a5c19684a2a61de82b7630cafe8085bee7164f53555e5a3680b9e11f657c6a
       contract_manifest_sha256: sha256:85de96d75cf1e02e0e88bd6e1dcce39a125c1d5b97f1eb9c01911a0d5c3316e8
     status: active
 
@@ -46,16 +46,6 @@ runtimes:
       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:
     remote: git@github.com:NousResearch/hermes-agent.git
     ref: v2026.6.5

package/dist/compiler/containerDaimonGrokTaskClock.d.ts

@@ -1,5 +0,0 @@
-import type { DaimonGrokRegistration } from "./containerDaimonGrokWorkerRender.js";
-/** Exit without closing/unlinking the listener: the next process needs a socket inode, not a live peer. */
-export declare const GROK_SOCKET_PLACEHOLDER_PROGRAM: string;
-/** Lines inside the shared root program, after its canonical-path and ownership helpers. */
-export declare const renderDaimonGrokTaskClockProvisioning: (registrations: readonly DaimonGrokRegistration[]) => string[];

package/dist/compiler/containerDaimonGrokTaskClock.js

@@ -1,29 +0,0 @@
-import { DAIMON_GROK_ENGINE_BROKER } from "../runtime/daimon/contractManifest.js";
-const broker = DAIMON_GROK_ENGINE_BROKER;
-const clock = broker.worker.taskClock;
-/** Exit without closing/unlinking the listener: the next process needs a socket inode, not a live peer. */
-export const GROK_SOCKET_PLACEHOLDER_PROGRAM = [
-    "const fs = require('node:fs'), net = require('node:net');",
-    "const [file, uid, gid] = process.argv.slice(1);",
-    "const server = net.createServer(); server.on('error', (error) => { console.error(error.message); process.exit(1); });",
-    "server.listen(file, () => { fs.chmodSync(file, 0o600); fs.chownSync(file, Number(uid), Number(gid)); process.exit(0); });"
-].join("\n");
-/** Lines inside the shared root program, after its canonical-path and ownership helpers. */
-export const renderDaimonGrokTaskClockProvisioning = (registrations) => {
-    if (!registrations.some((entry) => entry.configVariant === "clocked"))
-        return [];
-    return [
-        `const taskClock = ${JSON.stringify(clock)};`,
-        `const clocks = ${JSON.stringify(registrations.filter(entry => entry.configVariant === "clocked").map(entry => ({ directoryPath: clock.slotDirectoryPattern.replace("{slot}", String(entry.slot)), timestampFilePath: clock.slotFilePattern.replace("{slot}", String(entry.slot)) })))};`,
-        // All ancestors must stay searchable and non-writable by the worker, including the control root.
-        "for (const entry of grokWorkers) { for (let at = require('node:path').dirname(taskClock.rootDirectoryPath);; at = require('node:path').dirname(at)) { const info = assertCanonical(at, 'task clock ancestor'); const access = info.uid === entry.uid ? (info.mode >> 6) & 7 : info.gid === entry.uid ? (info.mode >> 3) & 7 : info.mode & 7; if (!info.isDirectory() || !(access & 1) || (access & 2)) throw new Error(`unsafe task clock ancestor: ${at}`); if (at === '/') break; } }",
-        "ensureDirectory(taskClock.rootDirectoryPath, 0, 0, taskClock.directoryMode); assertCanonical(taskClock.rootDirectoryPath, 'task clock root');",
-        "for (const current of clocks) { ensureDirectory(current.directoryPath, 0, 0, taskClock.directoryMode); assertCanonical(current.directoryPath, 'task clock');",
-        "ensureExactFile(current.timestampFilePath, '+0\\n', taskClock.fileMode); fs.chownSync(current.timestampFilePath, taskClock.ownerUid, taskClock.ownerUid);",
-        "withMode(current.directoryPath, taskClock.directoryMode, taskClock.ownerUid, taskClock.ownerUid); }",
-        // Startup attestation runs BEFORE the backend listens. All deny targets must already exist,
-        // and the backend only replaces a socket owned by its uid. Listeners unlink these real socket
-        // nodes in turn; readiness must prove replacement, never certify a placeholder as a listener.
-        `for (const socket of ${JSON.stringify([broker.controlSocketPath, broker.backendSocketPath, broker.launcherSocketPath])}) { require('node:child_process').execFileSync(process.execPath, ['-e', ${JSON.stringify(GROK_SOCKET_PLACEHOLDER_PROGRAM)}, socket, '${clock.ownerUid}', '${clock.ownerUid}'], { timeout: 5000, stdio: 'pipe' }); const info = fs.lstatSync(socket); if (!info.isSocket() || info.uid !== ${clock.ownerUid} || info.gid !== ${clock.ownerUid} || (info.mode & 0o7777) !== 0o600) throw new Error('unsafe broker socket placeholder'); }`
-    ];
-};

package/dist/compiler/daimonTelemetryArtifacts.d.ts

@@ -1,22 +0,0 @@
-import type { ContainerPersistentMountReport } from "../report/index.js";
-import type { CompiledNodeArtifact, RuntimeTargetPlan } from "./containerArtifactsTypes.js";
-import type { CompilePlan } from "./types.js";
-export interface DaimonTelemetryArtifactBundle {
-    /** One durable volume per legacy Pi agent, mounted onto its telemetry directory. */
-    mounts: ContainerPersistentMountReport[];
-    /** Runtime target plan id (e.g. "pi-app") -> { node id -> telemetry persistent mount id
-     * }, so `containerArtifacts.ts` can stamp `runtime_instances[].telemetry_mount_ids` and
-     * `artifactsExportPlan.ts`'s `planDaimonFiles` can resolve each agent's telemetry volume
-     * without re-deriving container paths of its own. */
-    telemetryMountIdsByInstance: Map<string, Record<string, string>>;
-}
-/**
- * Registers one run-scoped durable volume per legacy Pi agent for its daimon turn/wake
- * causal telemetry directory (`<instanceRoot>/runtime/agents/<slug>/telemetry` — the parent
- * of `causal.jsonl`, see `appCoreSource.ts`'s `runtimeHomePath`/`instanceRoot`), mirroring
- * exactly how `moltnetArtifacts.ts` mounts the Moltnet causal directory (Piece 4b,
- * Decision 21: daimon inner-truth telemetry was container-local — `docker cp` only — until
- * now). Daimon's own write path is untouched: this only makes the HOST side of that same
- * directory a named volume, so `docker rm` no longer discards it.
- */
-export declare const createDaimonTelemetryArtifacts: (plan: CompilePlan, runtimePlans: RuntimeTargetPlan[], compiledNodes: CompiledNodeArtifact[]) => DaimonTelemetryArtifactBundle;

package/dist/compiler/daimonTelemetryArtifacts.js

@@ -1,56 +0,0 @@
-import path from "node:path/posix";
-import { resolveNoopolisRunId } from "../runtime/index.js";
-import { createPersistentVolumeName } from "./moltnetArtifactPaths.js";
-/** Only the legacy generated Pi application writes this telemetry layout. */
-const PI_TELEMETRY_RUNTIME_NAMES = new Set(["pi"]);
-const createTelemetryMountId = (agentSlug) => `agent-${agentSlug}-daimon-telemetry`;
-/**
- * Registers one run-scoped durable volume per legacy Pi agent for its daimon turn/wake
- * causal telemetry directory (`<instanceRoot>/runtime/agents/<slug>/telemetry` — the parent
- * of `causal.jsonl`, see `appCoreSource.ts`'s `runtimeHomePath`/`instanceRoot`), mirroring
- * exactly how `moltnetArtifacts.ts` mounts the Moltnet causal directory (Piece 4b,
- * Decision 21: daimon inner-truth telemetry was container-local — `docker cp` only — until
- * now). Daimon's own write path is untouched: this only makes the HOST side of that same
- * directory a named volume, so `docker rm` no longer discards it.
- */
-export const createDaimonTelemetryArtifacts = (plan, runtimePlans, compiledNodes) => {
-    // Same run-scoping key as every other durable mount (see
-    // moltnetArtifactPaths.ts's createPersistentVolumeName doc comment): present for
-    // `spawnfile run`/`up` (which always call ensureNoopolisRunId() first), absent for a
-    // bare `spawnfile compile`/`build`, keeping those byte-identical to before this module
-    // existed.
-    const runId = resolveNoopolisRunId(process.env);
-    const agentSlugByNodeId = new Map(compiledNodes
-        .filter((node) => node.kind === "agent" && Boolean(node.id))
-        .map((node) => [node.id, node.slug]));
-    const mounts = [];
-    const telemetryMountIdsByInstance = new Map();
-    for (const runtimePlan of runtimePlans) {
-        if (!PI_TELEMETRY_RUNTIME_NAMES.has(runtimePlan.runtimeName) || !runtimePlan.instancePaths.homePath) {
-            continue;
-        }
-        const instanceRoot = runtimePlan.instancePaths.instanceRoot ?? path.dirname(runtimePlan.instancePaths.homePath);
-        const mountIdsByNodeId = {};
-        for (const nodeId of runtimePlan.sourceIds ?? []) {
-            const agentSlug = agentSlugByNodeId.get(nodeId);
-            if (!agentSlug) {
-                continue;
-            }
-            const mountId = createTelemetryMountId(agentSlug);
-            mounts.push({
-                id: mountId,
-                mount_path: path.join(instanceRoot, "runtime", "agents", agentSlug, "telemetry"),
-                reason: `daimon turn/wake causal telemetry for ${agentSlug}`,
-                volume_name: createPersistentVolumeName(plan.root, mountId, runId)
-            });
-            mountIdsByNodeId[nodeId] = mountId;
-        }
-        if (Object.keys(mountIdsByNodeId).length > 0) {
-            telemetryMountIdsByInstance.set(runtimePlan.id, mountIdsByNodeId);
-        }
-    }
-    return {
-        mounts: mounts.sort((left, right) => left.id.localeCompare(right.id)),
-        telemetryMountIdsByInstance
-    };
-};

package/dist/compiler/training/broker/clockProbe.d.ts

@@ -1,6 +0,0 @@
-/** Clock directories are public by contract; prove the sibling mask in the worker's mount namespace. */
-export declare const probeTrainingSiblingClock: (slot: number, target: string, execute?: (command: string, args: string[], options: {
-    timeout: number;
-}) => Promise<{
-    stdout: string;
-}>) => Promise<boolean>;

package/dist/compiler/training/broker/clockProbe.js

@@ -1,27 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { SpawnfileError } from "../../../shared/index.js";
-import { trainingSlotPaths } from "./paths.js";
-const run = promisify(execFile);
-const quote = (value) => `'${value.replace(/'/gu, `'"'"'`)}'`;
-/** Clock directories are public by contract; prove the sibling mask in the worker's mount namespace. */
-export const probeTrainingSiblingClock = async (slot, target, execute = run) => {
-    const p = trainingSlotPaths(slot);
-    const script = [
-        'set -eu',
-        `cat ${quote(p.clockFile)} >/dev/null`,
-        // Use the same mode-000 directory bind as Grok's deny mounts. Neither an unavailable
-        // namespace nor a hidden own clock is a successful denial.
-        `blocked=$(mktemp -d ${quote(`${p.privateTmp}/clock-probe.XXXXXX`)})`,
-        'trap \'chmod 700 "$blocked"; rmdir "$blocked"\' EXIT',
-        'chmod 000 "$blocked"',
-        `bwrap --die-with-parent --cap-drop ALL --ro-bind / / --dev /dev --ro-bind "$blocked" ${quote(target)} -- /bin/sh -ceu ${quote(`cat ${quote(p.clockFile)} >/dev/null; if ls -A ${quote(target)} >/dev/null 2>&1; then echo reachable; else echo denied; fi`)}`
-    ].join("\n");
-    const result = await execute("setpriv", ["--clear-groups", `--reuid=${p.workerUid}`, `--regid=${p.workerUid}`,
-        "--inh-caps=-all", "--ambient-caps=-all", "--bounding-set=-all", "--", "/bin/sh", "-ceu", script], { timeout: 10_000 });
-    if (result.stdout.trim() === "denied")
-        return true;
-    if (result.stdout.trim() === "reachable")
-        return false;
-    throw new SpawnfileError("runtime_error", "Training clock canary returned no verified verdict");
-};

package/dist/compiler/training/broker/declaration.d.ts

@@ -1,54 +0,0 @@
-import { z } from "zod";
-/**
- * `spawnfile.training-broker.v2`: the only thing the host tells the
- * broker-capable training container about its slot. It is data, never code —
- * the image's own Spawnfile distribution renders the provisioning from it with
- * the same renderers production uses, so no host-written executable is ever
- * mounted (`../container/AGENTS.md`).
- *
- * It carries no credentials: the training Grok login reaches the container only
- * as the read-only bootstrap leaf bind, and the rotating credential lives on
- * the named realm volume.
- */
-export declare const trainingBrokerDeclarationSchema: z.ZodObject<{
-    version: z.ZodLiteral<"spawnfile.training-broker.v2">;
-    maxRunRequests: z.ZodDefault<z.ZodNumber>;
-    slots: z.ZodDefault<z.ZodNumber>;
-    engine: z.ZodLiteral<"grok">;
-    agentId: z.ZodString;
-    model: z.ZodEnum<{
-        "grok-4.6": "grok-4.6";
-        "grok-4.5": "grok-4.5";
-        "grok-build": "grok-build";
-    }>;
-    reasoningEffort: z.ZodEnum<{
-        low: "low";
-        medium: "medium";
-        high: "high";
-    }>;
-    architecture: z.ZodEnum<{
-        arm64: "arm64";
-        x64: "x64";
-    }>;
-    limits: z.ZodObject<{
-        maxRequests: z.ZodNumber;
-        maxTokens: z.ZodNumber;
-        timeoutMs: z.ZodNumber;
-    }, z.core.$strict>;
-    bootstrap: z.ZodString;
-    organizationUid: z.ZodLiteral<2000>;
-    seccompProfileSha256: z.ZodString;
-    unenforcedBindPolicy: z.ZodDefault<z.ZodEnum<{
-        refuse: "refuse";
-        "profile-only": "profile-only";
-    }>>;
-    skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        files: z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            content: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export type TrainingBrokerDeclaration = z.infer<typeof trainingBrokerDeclarationSchema>;
-export declare const parseTrainingBrokerDeclaration: (value: unknown) => TrainingBrokerDeclaration;

package/dist/compiler/training/broker/declaration.js

@@ -1,70 +0,0 @@
-import { DAIMON_BROKER_ENGINE_ID } from "../../../runtime/daimon/index.js";
-import path from "node:path";
-import { z } from "zod";
-import { DAIMON_GROK_BROKER_MODELS, DAIMON_GROK_BROKER_REASONING_EFFORTS, DAIMON_GROK_ENGINE_BROKER } from "../../../runtime/daimon/contractManifest.js";
-const canonical = z.string().min(2).max(4_096).refine((value) => path.posix.isAbsolute(value) && path.posix.normalize(value) === value && !value.endsWith("/") && !value.includes("\0"), "canonical absolute path");
-/**
- * `spawnfile.training-broker.v2`: the only thing the host tells the
- * broker-capable training container about its slot. It is data, never code —
- * the image's own Spawnfile distribution renders the provisioning from it with
- * the same renderers production uses, so no host-written executable is ever
- * mounted (`../container/AGENTS.md`).
- *
- * It carries no credentials: the training Grok login reaches the container only
- * as the read-only bootstrap leaf bind, and the rotating credential lives on
- * the named realm volume.
- */
-export const trainingBrokerDeclarationSchema = z.strictObject({
-    version: z.literal("spawnfile.training-broker.v2"),
-    maxRunRequests: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).default(1000),
-    slots: z.number().int().min(1).max(8).default(4),
-    engine: z.literal(DAIMON_BROKER_ENGINE_ID),
-    agentId: z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u),
-    model: z.enum(DAIMON_GROK_BROKER_MODELS),
-    reasoningEffort: z.enum(DAIMON_GROK_BROKER_REASONING_EFFORTS),
-    architecture: z.enum(["arm64", "x64"]),
-    limits: z.strictObject({
-        maxRequests: z.number().int().min(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.maxRequests[0]).max(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.maxRequests[1]),
-        maxTokens: z.number().int().min(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.maxTokens[0]).max(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.maxTokens[1]),
-        timeoutMs: z.number().int().min(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.timeoutMs[0]).max(DAIMON_GROK_ENGINE_BROKER.turnLimits.bounds.timeoutMs[1])
-    }),
-    /** The read-only bootstrap credential leaf, already refused if it is the desktop `~/.grok/auth.json`. */
-    bootstrap: canonical,
-    /** The uid the trained evaluator (Training, DSPy, judges) runs as; the only uid the slot supervisor serves. */
-    organizationUid: z.literal(DAIMON_GROK_ENGINE_BROKER.identities.organizationUid),
-    seccompProfileSha256: z.string().regex(/^[a-f0-9]{64}$/u),
-    /**
-     * What the slot supervisor does with a deny path whose backing filesystem
-     * does not enforce unix ownership — virtiofs and grpcfuse under Docker
-     * Desktop and Colima, where `chown` is silently ignored and uid 2200 reads a
-     * root `0600` file (P0 §5). The backing filesystem decides, not the fact of
-     * being a host bind: the same bind over ext4 or overlay on a Linux daemon is
-     * probed for real, which is what makes `refuse` a default a run can meet.
-     *
-     * `refuse` (the default) fails the slot and writes no receipt: a worker-uid
-     * probe over such a path carries no information, so the supervisor will not
-     * certify it. `profile-only` is the operator's explicit acceptance that for
-     * those paths the boundary is the bubblewrap-enforced `deny` list alone —
-     * verified to block both shell `cat` and `read_file` on 1.0.34 (P0 §4), but
-     * *not* a boundary a worker-uid namespace cannot lift — and the supervisor
-     * records every path that used that weaker evidence in its log.
-     *
-     * It does not reach `TRAINING_SEALED_DENY_PATHS`. The sealed train and test
-     * datasets are held by DAC on their ancestor under both values, and a slot
-     * that cannot prove that denial is refused whatever this says.
-     */
-    unenforcedBindPolicy: z.enum(["refuse", "profile-only"]).default("refuse"),
-    /**
-     * The subject's declared skills in Daimon's engine-neutral form (the
-     * compiled `.agents/skills` tree), omitted when it declares none. Root
-     * provisioning renders them into every slot's `$GROK_HOME/skills`, and the
-     * entrypoint, supervisor and lease all resolve the projection from this one
-     * read-only input, so they bind the same `skillsSha256`. Daimon's own parser
-     * (mirrored in `runtime/daimon/grokWorkerSkills.ts`) enforces the bounds.
-     */
-    skills: z.array(z.strictObject({
-        name: z.string().min(1).max(128),
-        files: z.array(z.strictObject({ path: z.string().min(1).max(1_024), content: z.string() })).min(1).max(64)
-    })).min(1).max(64).optional()
-}).strict();
-export const parseTrainingBrokerDeclaration = (value) => trainingBrokerDeclarationSchema.parse(value);

package/dist/compiler/training/broker/entrypoint.d.ts

@@ -1,39 +0,0 @@
-import { type DaimonProjectionModule } from "./projection.js";
-export declare const TRAINING_GROK_BROKER_CONTROL_SOCKET_ENV = "SPAWNFILE_TRAINING_GROK_BROKER_CONTROL_SOCKET";
-export declare const TRAINING_GROK_GRANT_HOME_ROOT_ENV = "SPAWNFILE_TRAINING_GROK_GRANT_HOME_ROOT";
-export declare const TRAINING_ENTRYPOINT_COMMAND = "/opt/training/bin/train";
-/**
- * The desktop Grok login, in every spelling a caller might reach it by.
- *
- * D2 is explicit: training uses one dedicated Grok login and never the
- * developer's own. An in-container refresh rotates the credential, so mounting
- * the desktop leaf would invalidate the developer's desktop session as a side
- * effect of a training run — and the refreshed token would live on tmpfs, so
- * the desktop login would be gone rather than moved.
- */
-export declare const desktopGrokAuthPaths: (home?: string) => string[];
-export declare const assertNotDesktopGrokAuth: (source: string, home?: string) => string;
-export interface TrainingEntrypointOptions {
-    argv: readonly string[];
-    declarationPath?: string;
-    loadDaimon?: () => Promise<DaimonProjectionModule>;
-    log?: (line: string) => void;
-}
-/**
- * The broker-capable training container's root entrypoint.
- *
- * Order matters and is the whole privilege model: provision as root with the
- * production capability set, start the launcher (root) and the broker and
- * relay (2100) and prove each one's post-drop identity, publish the slot
- * supervisor socket, and only then drop to uid 2000 with an empty capability
- * bounding set to run `train`. The training core, DSPy and the judges are that uid; the
- * model's own tools are the worker uid the launcher alone can reach.
- */
-export declare const runTrainingBrokerEntrypoint: (options: TrainingEntrypointOptions) => Promise<number>;
-/**
- * `train` as uid 2000 with an empty bounding set, proven inside the child
- * before it execs: `setpriv --bounding-set=-all` silently does nothing without
- * `CAP_SETPCAP`, so the guard has to read `/proc/self/status` rather than
- * trust the flag.
- */
-export declare const trainingChildArgv: (argv: readonly string[], uid?: number) => string[];