@noopolis/daimon 0.1.2 → 0.2.1

package/dist/contracts/runtimeContractManifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeContractManifest.d.ts","sourceRoot":"","sources":["../../src/contracts/runtimeContractManifest.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,iCAAiC,EAAG,8CAAuD,CAAC;AACzG,eAAO,MAAM,wCAAwC,EAAG,kDAA2D,CAAC;AACpH,eAAO,MAAM,0BAA0B;;;;;;;;CAE7B,CAAC;AACX,eAAO,MAAM,uBAAuB;;;;;;;;CAQ1B,CAAC;AACX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyIrB,CAAC;AACX,eAAO,MAAM,sBAAsB;;;;;;;CAOzB,CAAC;AASX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkC5B,CAAC"}

package/dist/contracts/runtimeContractManifest.js

@@ -0,0 +1,206 @@
+import { GROK_BROKER_TASK_CLOCK } from "./grokBrokerTaskClock.js";
+import { WAKE_MOMENTS } from "./wakeMomentContract.js";
+import { OPERATOR_DRAIN, WORK_AVAILABILITY_SCHEMA, WORK_BLOCKED_SCHEMA } from "./attentionContract.js";
+import { GROK_BROKER_MODELS, GROK_BROKER_REASONING_EFFORTS, GROK_WORKER_MAX_TURNS, GROK_WORKER_TOOL_IDS, GROK_WORKER_VISIBLE_TOOLS } from "./grokWorkerContract.js";
+import { ORGANIZATION_RUNTIME_CONFIG_SCHEMA, ORGANIZATION_RUNTIME_CONFIG_V2_SCHEMA, ORGANIZATION_RUNTIME_MAX_AGENTS, ORGANIZATION_RUNTIME_MAX_STRING_CODEPOINTS } from "./organizationRuntimeContract.js";
+export const RUNTIME_CONTRACT_MANIFEST_VERSION = "noopolis.daimon.runtime-contract-manifest.v5";
+export const ORGANIZATION_RUNTIME_ACTIVITY_V2_VERSION = "noopolis.daimon.organization-runtime-activity.v2";
+export const ENGINE_CREDENTIAL_MATERIAL = {
+    codex: { sourceSlot: "codex-auth", sourceRelativePath: ".daimon-inbound/codex-auth", destinationRelativePath: ".codex/auth.json", directoryMode: 0o700, fileMode: 0o600 }
+};
+export const GROK_SUBSCRIPTION_REALM = {
+    agentCredentialRelativePath: ".grok/auth.json",
+    bootstrapMountPath: "/var/lib/spawnfile/daimon/grok-bootstrap-auth",
+    bootstrapSourceSlot: "grok-auth",
+    directoryMode: 0o700,
+    durableMountPath: "/var/lib/spawnfile/daimon/grok-subscription-realm",
+    fileMode: 0o600,
+    maxCredentialBytes: 64 * 1024
+};
+export const GROK_ENGINE_BROKER = {
+    nativeAbiVersion: 2,
+    nativeExecutablePath: "/opt/daimon/bin/daimon-engine-broker",
+    grokExecutablePath: "/usr/local/bin/grok",
+    registrationPath: "/etc/daimon-engine-broker/registrations.bin",
+    credentialHomePath: "/var/lib/spawnfile/daimon/grok-subscription-realm",
+    turnStorePath: "/var/lib/spawnfile/daimon/grok-subscription-realm/turns",
+    controlSocketPath: "/run/daimon-engine-broker/control.sock",
+    backendSocketPath: "/run/daimon-engine-broker/backend.sock",
+    launcherSocketPath: "/run/daimon-engine-broker/launcher.sock",
+    serviceConfigPath: "/etc/daimon-engine-broker/service.json",
+    providerProxy: { host: "127.0.0.1", port: 43_123 },
+    mcpFacade: { host: "127.0.0.1", port: 43_124, path: "/mcp" },
+    identities: { organizationUid: 2_000, brokerUid: 2_100, firstWorkerUid: 2_200 },
+    grokCliVersion: "1.0.34",
+    grokCliBuild: "3736acbc8658",
+    grokCliArtifacts: {
+        arm64: { url: "https://storage.googleapis.com/grok-build-public-artifacts/cli/grok-1.0.34-linux-aarch64", sha256: "39ab87666877d64ef3a40aa60fbe0c3b6a6acd7001b78fe60e2c76bb6cfc4a94", bytes: 136_090_504 },
+        x64: { url: "https://storage.googleapis.com/grok-build-public-artifacts/cli/grok-1.0.34-linux-x86_64", sha256: "be5905e107d2b8b5f3c142d21ecfe4c8fd32a913d2fd551b788707930c4dc80d", bytes: 163_035_648 }
+    },
+    worker: {
+        modelId: "daimon-broker-grok",
+        models: GROK_BROKER_MODELS,
+        reasoningEfforts: GROK_BROKER_REASONING_EFFORTS,
+        defaultModel: "grok-4.6",
+        defaultReasoningEffort: "low",
+        toolIds: GROK_WORKER_TOOL_IDS,
+        visibleTools: GROK_WORKER_VISIBLE_TOOLS,
+        maxTurns: GROK_WORKER_MAX_TURNS,
+        systemPromptSha256: "2c31c0085a54a4efbf9c0cf0b8124c56e47f38691b7f0c7fa233a74abaa8ddf8",
+        // sha256 of `renderGrokBrokerWorkerConfig({ model, reasoningEffort })`, the unchanged production config.toml bytes.
+        configSha256: {
+            "grok-4.6": { low: "ab58499ac32678097c146479896f2b8a8e2b0e39aea22dc0a60b6227e370538e", medium: "df1a5cc84346e7f6bf6090492fbd19faaefb42953e3bb2e8c6cbc0572242403f", high: "65b0212564fb74042b1503d293fb8d3620276033264c0efade2a539ca09218e3" },
+            "grok-4.5": { low: "8247127c3625ff7c5d8d527a53596b89ec6557a821ac46cfd00bd122b90daff6", medium: "59288cee61297bb8c002097061a48f77b09d310754187a253ee089f7172a9155", high: "c63c3387ce92d94ec3f690abfe98942afcd7c9e17ff84816bbe751f340ab251f" },
+            "grok-build": { low: "fb343f2809903f26d21681470943235031f946e99085542fd89555eb7782cbb5", medium: "8a587ef75c90eab70d19b24583e60051d6fba9d90c558839fdbb15588b4cc656", high: "a23724e00d670caee185ba7690d2daa868173e53905cf446f5329666f01ab4e3" }
+        },
+        // Slot-zero template pins. Other slots replace only FAKETIME_TIMESTAMP_FILE with slotFilePattern.
+        clockedConfigSha256: {
+            "grok-4.6": {
+                "low": "751f1dcd04983e5e5883df5a8fefa04f201e187e5ef1f344d3bf83f950830432",
+                "medium": "f1406f93a8091eb0c09e07321254a9c783a89b0bbf5548d9613d53a8d087a517",
+                "high": "203744f6f0dfc0bc80cfb896880497edfd9b3de4dcf33060e8ef4d2ef5f220a7"
+            },
+            "grok-4.5": {
+                "low": "3c4f3515b21c1bffb3fb770e2ecb4b918b6c43d5e77c1fd47e1e6698d1fedee7",
+                "medium": "9117e12b2f3f6fa045799592969cbaae1c2f3b1ea79330badac8655b9b41dd7a",
+                "high": "907d8967960c342b442d6d256b2585f3c85bd846a78578f596f0b605403d6d34"
+            },
+            "grok-build": {
+                "low": "a8c63ba910623a0686930c27db0733f4a2588c7fca9dd7da25c3f18027720ab5",
+                "medium": "6afcd2b90c0d19794f8c0d22147a0f011946a92e613f89dae98b0ca729313101",
+                "high": "6efddadc82c38020d3351829e54bb09fa456cd6d76ea1247902794d82a4a3ffa"
+            }
+        },
+        taskClock: GROK_BROKER_TASK_CLOCK,
+        // Worker `GROK_HOME` layout the broker attests before every turn. The home and
+        // its `sessions/` directory are root-owned, worker-group writable and sticky so
+        // Grok can create its own state but never replace a root-owned file.
+        home: {
+            directory: { uid: 0, group: "worker", mode: 0o1771 },
+            sessionsDirectory: { relativePath: "sessions", uid: 0, group: "worker", mode: 0o1771 },
+            readOnlyFiles: { names: ["config.toml", "managed_config.toml", "requirements.toml", "sandbox.toml", "trusted_folders.toml"], uid: 0, gid: 0, mode: 0o444 },
+            sandboxEvents: { relativePath: "sessions/sandbox-events.jsonl", owner: "worker", group: "broker", mode: 0o640 },
+            // The launcher exports TMPDIR=<worker home>/tmp; Grok's strict profile grants TMPDIR read-write.
+            privateTmp: { relativeToWorkerHome: "tmp", owner: "worker", mode: 0o700 },
+            // Strict also grants shared /tmp and /var/tmp read-write and refuses to start if either is
+            // denied, so the deployment keeps them from every worker by mode: root-owned, a non-worker
+            // group (< 2200), others read-only (Grok needs to open the directory) and no search/write.
+            sharedTmp: { paths: ["/tmp", "/var/tmp"], uid: 0, maxGroupExclusive: 2_200, otherMode: 0o4, mode: 0o1774 },
+            // The organization runtime home of a brokered Grok agent: traverse-only for the
+            // worker group so the worker can reach `tool-output/` and nothing else (no group
+            // read, no group write, no world bits; `physicalReadiness.ts` refuses anything else).
+            organizationRuntimeHome: { owner: "organization", group: "worker", mode: 0o710 },
+            // Spilled tool output the worker reads with read_file: setgid directory in the worker's group,
+            // files written 0640 by the runtime, never other-readable.
+            spillDirectory: { relativeToRuntimeHome: "tool-output", owner: "organization", group: "worker", mode: 0o2750, fileMode: 0o640 }
+        }
+    },
+    bounds: { promptBytes: 65_536, capabilityBytes: 4_096, capabilityBundleBytes: 8_196, outputBytes: 262_144 },
+    // Accounting and limits (P2). The broker is the single sealed usage writer.
+    controlProtocolVersion: "noopolis.daimon.engine-broker.v4",
+    turnRecordVersions: ["noopolis.daimon.engine-broker-turn.v1", "noopolis.daimon.engine-broker-turn.v2"],
+    serviceConfigVersions: ["noopolis.daimon.engine-broker-service.v1", "noopolis.daimon.engine-broker-service.v2", "noopolis.daimon.engine-broker-service.v3"],
+    slotRouting: { key: "slot", repeatedAgentIds: true, slotEnvironment: "DAIMON_ENGINE_BROKER_SLOT", resetRequest: "reset_slot", resetResponse: "slot_reset", turnStoreDirectory: "slot-{slot}", controlCaller: "organization", workersMayControl: false },
+    runRequestBudget: { maximumField: "maxRunRequests", storeField: "runRequestStore", fileName: "run-requests.json", includesInferenceGrants: true, countsCredentialRetries: true },
+    turnLimits: {
+        keys: ["maxRequests", "maxTokens", "timeoutMs"],
+        v1Defaults: { maxRequests: 32, maxTokens: 300_000, timeoutMs: 240_000 },
+        bounds: { maxRequests: [1, GROK_WORKER_MAX_TURNS], maxTokens: [1, 10_000_000], timeoutMs: [1_000, 3_600_000] },
+        limitReasons: ["tokens", "requests", "timeout", "none"],
+        wakeMayOnlyLower: true,
+        tokenCeilingOvershoot: "at-most-one-request",
+        maxInFlightRequests: 1,
+        // A per-request usage block above this is implausible (beyond the model
+        // context window) and treated as invalid rather than added to any total.
+        requestUsageMaxTokens: 500_000,
+        // A request whose response carries no valid usage is charged this estimate.
+        missingUsageEstimate: { inputBytesPerToken: 2, outputTokens: 4_096 }
+    },
+    wakeLimitEnvironment: { timeoutMs: "DAIMON_ENGINE_WAKE_TIMEOUT_MS", maxTokens: "DAIMON_ENGINE_WAKE_TOKEN_CEILING" },
+    // Evaluator inference grants (P2c). Judges and the optimizer (organization uid
+    // only, over the control socket) borrow the broker's Grok credential through
+    // the provider proxy; they never hold it, and their spend never reaches the
+    // subject usage ledger or wake fuse.
+    inferenceGrants: {
+        requestKinds: ["request_inference_grant", "release_inference_grant"],
+        purposes: ["judge", "optimizer"],
+        tokenPrefix: "inference_",
+        ttlMs: 600_000,
+        limits: { maxRequests: 64, maxTokens: 2_000_000 },
+        maxLiveGrants: 8,
+        maxInFlightRequestsPerGrant: 1,
+        // Top-level request members Grok 1.0.34 sends for a Paideia judge/optimizer call
+        // (live stub capture); `tools` and `tool_choice` are refused outright.
+        bodyMembers: ["messages", "model", "reasoning_effort", "response_format", "stream", "stream_options"],
+        messageRoles: ["system", "user", "assistant"],
+        failureCodes: ["auth_stale", "grant_limit", "invalid_request", "unavailable"],
+        ledgerVersion: "noopolis.daimon.inference-usage.v1",
+        ledgerDedupeKey: ["grant", "request"],
+        client: {
+            modelId: "daimon-inference-grok",
+            envKey: "DAIMON_INFERENCE_GRANT",
+            // sha256 of `renderGrokInferenceClientConfig` for the production proxy base URL and this env key.
+            configSha256: {
+                "grok-4.6": { low: "79314d039f787e4ebfec7dacf57adc969086b948f564dec008f0ed6367e6062f", medium: "6f538de0547c0c4e6a3f04ae08595ceadadabb06b75f6b6ee4c428744bb95cd8", high: "5652656effa82f0c4f09cf8226b16e6140332a5a358b571194bb5563312367ac" },
+                "grok-4.5": { low: "a07f7436f1268bb399ec233c65d3b3d8fb99a11a1f175f8da1ca133c9367bc74", medium: "1f4c0d4dad1f3b09419b5739db6423a09e0049abc091594c64123a75dd53dfb9", high: "ffbc33728b821e9854fbc7c93601e599225da421ecfd6ebf10d314afcc28d6f2" },
+                "grok-build": { low: "ca15c6a562a008227d39c51d3a3a83715663089b3784e8b46debb1fb67b3c4a1", medium: "01783fb6beadcf6f8486fff0836820ad43fab5662b812a907fe9cfdb83e9804d", high: "98d16f2b7d12f4eb540d625c853e51d227933e204923e43e8b9b4176f10aca2c" }
+            }
+        }
+    },
+    projectionVersion: "noopolis.daimon.grok-broker-projection.v3",
+    slotPreflightVersion: "noopolis.daimon.grok-slot-preflight.v2",
+    artifacts: {
+        sourceSha256: "15836d7ad69f12ef581a6e5b8635c9db43b2177dac609160c0749d3d1fefbaa8",
+        x64Sha256: "95aa9c272225e74ff9f45f54dde4bc30aee324e9ba24d8a876db9151c81b454d",
+        arm64Sha256: "d0dc1c03197c3e90f09b66ad7c89b4f7b448d06dc84c03b247dce976d6018d6e"
+    }
+};
+export const AGY_SUBSCRIPTION_REALM = {
+    durableMountPath: "/var/lib/spawnfile/daimon/agy-subscription-realm",
+    unlockMountPath: "/var/lib/spawnfile/daimon/agy-unlock-secret",
+    unlockSourceSlot: "agy-unlock-secret",
+    directoryMode: 0o700,
+    fileMode: 0o600,
+    maxUnlockBytes: 4_096
+};
+const text = { type: "string", minLength: 1, maxLength: ORGANIZATION_RUNTIME_MAX_STRING_CODEPOINTS, pattern: "\\S" };
+const boundedText = { type: "string", maxLength: ORGANIZATION_RUNTIME_MAX_STRING_CODEPOINTS };
+const timestamp = { type: "string", format: "date-time", pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{3}Z$" };
+const wakeEvent = { type: "object", additionalProperties: false, required: ["version", "id", "kind", "text", "occurredAt"], properties: { version: { const: "noopolis.daimon.wake.v1" }, id: text, kind: { enum: ["manual", "message", "schedule", "external"] }, text: boundedText, occurredAt: timestamp } };
+const wakeResultBase = { version: { const: "noopolis.daimon.wake-result.v1" }, agentId: text, wakeId: text };
+const activityItem = { type: "object", additionalProperties: false, required: ["id", "agentId", "kind", "occurredAt"], properties: { id: { type: "string", format: "uuid", pattern: "^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$" }, agentId: text, wakeId: text, kind: { enum: ["wake_started", "wake_completed", "wake_rejected", "wake_aborted", "agent_stopped"] }, occurredAt: timestamp } };
+export const RUNTIME_CONTRACT_MANIFEST = {
+    version: RUNTIME_CONTRACT_MANIFEST_VERSION,
+    consumedConfigFields: ["version", "host.bindHost", "host.port", "host.controlTokenEnv", "agents[].id", "agents[].name", "agents[].instructions", "agents[].workspacePath", "agents[].runtimeHomePath", "agents[].engine.kind", "agents[].engine.model", "agents[].engine.reasoningEffort", "agents[].engine.codexSandbox", "agents[].schedule.kind", "agents[].schedule.interval_ms", "agents[].schedule.cron", "agents[].schedule.timezone", "agents[].schedule.prompt", "agents[].schedule.jitter_seconds", "agents[].mcp", "agents[].moltnet", "agents[].memory", "agents[].attention", "agents[].recording"],
+    wakeMoments: WAKE_MOMENTS,
+    organizationRuntimeConfigSchema: ORGANIZATION_RUNTIME_CONFIG_SCHEMA,
+    organizationRuntimeConfigV2Schema: ORGANIZATION_RUNTIME_CONFIG_V2_SCHEMA,
+    wakeAcceptanceTypes: ["manual", "message", "schedule", "external"],
+    deliverySemantics: {
+        activeDeliveryIdempotency: "unbounded-until-terminal",
+        terminalReceiptHorizon: 2_048,
+        recovery: "at-least-once-with-stable-wake-id",
+        concurrentSameAgentTurns: false,
+        externalEffectsExactlyOnce: false
+    },
+    attention: { enabledBy: "agents[].attention", defaultMaxBatchMessages: 8, defaultMaxBatchBytes: 12000, idleDispatch: "immediate", busyDispatch: "bounded-pending-message-batch", completion: "explicit-per-delivery", unhandled: "deferred-until-new-input", accounting: "execution-start-reservations" },
+    workAvailabilityResponseSchema: WORK_AVAILABILITY_SCHEMA,
+    workBlockedSchema: WORK_BLOCKED_SCHEMA,
+    operatorDrain: OPERATOR_DRAIN,
+    supportedEngineKinds: ["agy", "codex", "grok"],
+    engineCredentialMaterial: ENGINE_CREDENTIAL_MATERIAL,
+    grokSubscriptionRealm: GROK_SUBSCRIPTION_REALM,
+    grokEngineBroker: GROK_ENGINE_BROKER,
+    agySubscriptionRealm: AGY_SUBSCRIPTION_REALM,
+    wakeRequestSchema: { type: "object", additionalProperties: false, required: ["agentId", "event"], properties: { agentId: text, event: wakeEvent } },
+    wakeResultSchema: { oneOf: [
+            { type: "object", additionalProperties: false, required: ["version", "status", "agentId", "wakeId", "text", "durationMs"], properties: { ...wakeResultBase, status: { const: "completed" }, text: boundedText, durationMs: { type: "integer", minimum: 0 } } },
+            { type: "object", additionalProperties: false, required: ["version", "status", "agentId", "wakeId", "code"], properties: { ...wakeResultBase, status: { const: "rejected" }, code: { enum: ["unauthorized", "unknown_agent", "queue_full", "durable_inbox_required"] } } },
+            { type: "object", additionalProperties: false, required: ["version", "status", "agentId", "wakeId", "code"], properties: { version: { const: "noopolis.daimon.wake-result.v1" }, status: { const: "rejected" }, agentId: { type: "string", maxLength: ORGANIZATION_RUNTIME_MAX_STRING_CODEPOINTS }, wakeId: { type: "string", maxLength: ORGANIZATION_RUNTIME_MAX_STRING_CODEPOINTS }, code: { const: "invalid_request" } } },
+            { type: "object", additionalProperties: false, required: ["version", "status", "agentId", "wakeId", "code"], properties: { ...wakeResultBase, status: { const: "stopped" }, code: { enum: ["host_stopping", "host_stopped", "queued_wake_stopped", "active_wake_aborted"] } } },
+            { type: "object", additionalProperties: false, required: ["version", "status", "agentId", "wakeId", "code"], properties: { ...wakeResultBase, status: { const: "failed" }, code: { const: "engine_failed" } } }
+        ] },
+    healthResponseSchema: { type: "object", additionalProperties: false, required: ["version", "state", "agents"], properties: { version: { const: "noopolis.daimon.organization-runtime-health.v1" }, state: { enum: ["starting", "running", "stopping", "stopped"] }, agents: { type: "array", maxItems: ORGANIZATION_RUNTIME_MAX_AGENTS, items: { type: "object", additionalProperties: false, required: ["agentId", "state"], properties: { agentId: text, state: { enum: ["starting", "running", "stopping", "stopped", "idle", "failed"] } } } } } },
+    activityResponseSchema: { type: "object", additionalProperties: false, required: ["version", "items"], properties: { version: { const: "noopolis.daimon.organization-runtime-activity.v1" }, items: { type: "array", maxItems: 100, items: activityItem }, nextCursor: { type: "string", minLength: 1, maxLength: 16, pattern: "^(0|[1-9][0-9]{0,15})$" } } },
+    activityV2ResponseSchema: { type: "object", additionalProperties: false, required: ["version", "items"], properties: { version: { const: ORGANIZATION_RUNTIME_ACTIVITY_V2_VERSION }, state: { enum: ["running", "stopped"] }, executions: { type: "array", maxItems: ORGANIZATION_RUNTIME_MAX_AGENTS, items: { type: "object", additionalProperties: false, required: ["agent_id", "execution_id", "state", "delivery_ids"], properties: { agent_id: text, execution_id: { type: "string" }, state: { const: "running" }, delivery_ids: { type: "array", maxItems: 32, items: text } } } }, items: { type: "array", maxItems: 2_112, items: { type: "object", additionalProperties: false, required: ["version", "acceptance_id", "agent_id", "delivery_id", "request_digest", "state", "accepted_at", "updated_at", "active"], properties: { version: { const: "noopolis.daimon.wake-receipt-status.v2" }, acceptance_id: { type: "string" }, agent_id: text, delivery_id: text, request_digest: { type: "string" }, state: { enum: ["accepted", "running", "completed", "failed", "stopped"] }, accepted_at: timestamp, updated_at: timestamp, active: { type: "boolean" }, execution_id: { type: "string" }, deferred: { type: "boolean" }, text: { type: "string", maxLength: 16384 }, queue_position: { type: "integer", minimum: 1 }, code: { enum: ["engine_failed", "host_stopped", "host_stopping", "queued_wake_stopped", "active_wake_aborted", "queue_full", "unknown_agent"] } } } } } }
+};

package/dist/contracts/shellEnvironmentPolicy.d.ts

@@ -0,0 +1,3 @@
+/** Same filter order and automatic secret exclusions for direct and brokered tools. */
+export declare function shellEnvironmentPolicyEntries(env: Readonly<Record<string, string>>): readonly string[];
+//# sourceMappingURL=shellEnvironmentPolicy.d.ts.map

package/dist/contracts/shellEnvironmentPolicy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shellEnvironmentPolicy.d.ts","sourceRoot":"","sources":["../../src/contracts/shellEnvironmentPolicy.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,MAAM,EAAE,CAGtG"}

package/dist/contracts/shellEnvironmentPolicy.js

@@ -0,0 +1,5 @@
+/** Same filter order and automatic secret exclusions for direct and brokered tools. */
+export function shellEnvironmentPolicyEntries(env) {
+    const set = Object.entries(env).map(([name, value]) => `${JSON.stringify(name)}=${JSON.stringify(value)}`).join(",");
+    return ['inherit="all"', "ignore_default_excludes=false", "exclude=[]", "include_only=[]", `set={${set}}`];
+}

package/dist/contracts/wakeMomentContract.d.ts

@@ -0,0 +1,61 @@
+/** Data-only capability and on-disk bounds; presence in the manifest enables callers. */
+export declare const WAKE_MOMENTS: {
+    readonly version: "noopolis.daimon.wake-moment.v1";
+    readonly rowsFile: "wake-moments.jsonl";
+    readonly snapshotsDirectory: "snapshots";
+    readonly completionSuffix: ".complete";
+    readonly maxSnapshotRoots: 16;
+    readonly maxSnapshotEntries: 200000;
+    readonly maxRowBytes: 4194304;
+    readonly maxManifestBytes: 134217728;
+    readonly captureDeadlineMs: 60000;
+    readonly finalizationDeadlineMs: 1000;
+    readonly configField: "agents[].recording";
+};
+export type WakeMomentRecording = Readonly<{
+    directory: string;
+    keepMs: number;
+    snapshots: readonly Readonly<{
+        id: string;
+        path: string;
+    }>[];
+}>;
+export declare const WAKE_MOMENT_RECORDING_SCHEMA: {
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly required: readonly ["directory", "keepMs", "snapshots"];
+    readonly properties: {
+        readonly directory: {
+            readonly type: "string";
+            readonly pattern: "^/[^\\u0000]*$";
+            readonly maxLength: 4096;
+        };
+        readonly keepMs: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly maximum: 9007199254740991;
+        };
+        readonly snapshots: {
+            readonly type: "array";
+            readonly maxItems: 16;
+            readonly uniqueItems: true;
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: false;
+                readonly required: readonly ["id", "path"];
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                        readonly pattern: "^[A-Za-z0-9._-]{1,128}$";
+                    };
+                    readonly path: {
+                        readonly type: "string";
+                        readonly pattern: "^/[^\\u0000]*$";
+                        readonly maxLength: 4096;
+                    };
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=wakeMomentContract.d.ts.map

package/dist/contracts/wakeMomentContract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wakeMomentContract.d.ts","sourceRoot":"","sources":["../../src/contracts/wakeMomentContract.ts"],"names":[],"mappings":"AAAA,yFAAyF;AACzF,eAAO,MAAM,YAAY;;;;;;;;;;;;CAYf,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,QAAQ,CAAC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,QAAQ,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;CAC9D,CAAC,CAAC;AAGH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAW/B,CAAC"}

package/dist/contracts/wakeMomentContract.js

@@ -0,0 +1,27 @@
+/** Data-only capability and on-disk bounds; presence in the manifest enables callers. */
+export const WAKE_MOMENTS = {
+    version: "noopolis.daimon.wake-moment.v1",
+    rowsFile: "wake-moments.jsonl",
+    snapshotsDirectory: "snapshots",
+    completionSuffix: ".complete",
+    maxSnapshotRoots: 16,
+    maxSnapshotEntries: 200_000,
+    maxRowBytes: 4_194_304,
+    maxManifestBytes: 134_217_728,
+    captureDeadlineMs: 60_000,
+    finalizationDeadlineMs: 1_000,
+    configField: "agents[].recording"
+};
+const absolutePath = { type: "string", pattern: "^/[^\\u0000]*$", maxLength: 4_096 };
+export const WAKE_MOMENT_RECORDING_SCHEMA = {
+    type: "object", additionalProperties: false, required: ["directory", "keepMs", "snapshots"],
+    properties: {
+        directory: absolutePath,
+        keepMs: { type: "integer", minimum: 1, maximum: 9_007_199_254_740_991 },
+        snapshots: { type: "array", maxItems: WAKE_MOMENTS.maxSnapshotRoots, uniqueItems: true, items: {
+                type: "object", additionalProperties: false, required: ["id", "path"], properties: {
+                    id: { type: "string", pattern: "^[A-Za-z0-9._-]{1,128}$" }, path: absolutePath
+                }
+            } }
+    }
+};

package/dist/core/credentialRedaction.d.ts

@@ -0,0 +1,4 @@
+/** Redacts provider credentials before text crosses any reply or diagnostic boundary. */
+export declare function redactCredentialText(value: unknown, exactSecrets?: readonly string[], maxBytes?: number): string;
+export declare function redactCredentialError(error: unknown, exactSecrets?: readonly string[], maxBytes?: number): Error;
+//# sourceMappingURL=credentialRedaction.d.ts.map

package/dist/core/credentialRedaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentialRedaction.d.ts","sourceRoot":"","sources":["../../src/core/credentialRedaction.ts"],"names":[],"mappings":"AASA,yFAAyF;AACzF,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,YAAY,GAAE,SAAS,MAAM,EAAO,EACpC,QAAQ,GAAE,MAA0B,GACnC,MAAM,CAoBR;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,YAAY,GAAE,SAAS,MAAM,EAAO,EACpC,QAAQ,GAAE,MAA0B,GACnC,KAAK,CAEP"}

package/dist/core/credentialRedaction.js

@@ -0,0 +1,28 @@
+const DEFAULT_MAX_BYTES = 16_384;
+const truncateUtf8 = (value, maxBytes) => {
+    if (Buffer.byteLength(value, "utf8") <= maxBytes)
+        return value;
+    let result = Buffer.from(value, "utf8").subarray(0, maxBytes).toString("utf8");
+    while (result.endsWith("\uFFFD"))
+        result = result.slice(0, -1);
+    return result;
+};
+/** Redacts provider credentials before text crosses any reply or diagnostic boundary. */
+export function redactCredentialText(value, exactSecrets = [], maxBytes = DEFAULT_MAX_BYTES) {
+    let result = String(value);
+    for (const secret of [...new Set(exactSecrets.filter((entry) => entry.length > 0))]
+        .sort((left, right) => right.length - left.length)) {
+        result = result.split(secret).join("[REDACTED]");
+    }
+    result = result
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/giu, "Bearer [REDACTED]")
+        .replace(/\bmagt_v1_[A-Za-z0-9_-]{16,}\b/gu, "[REDACTED]")
+        .replace(/\b(?:sk|sk-proj|xai)-[A-Za-z0-9_-]{20,}\b/gu, "[REDACTED]")
+        .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/gu, "[REDACTED]")
+        .replace(/("(?:api[_-]?key|authorization|client[_-]?secret|credential|key|password|secret|(?:access|refresh|id)[_-]?token|token)"\s*:\s*")([^"\\]*(?:\\.[^"\\]*)*)(")/giu, "$1[REDACTED]$3")
+        .replace(/\b(api[_-]?key|authorization|client[_-]?secret|credential|password|secret|(?:access|refresh|id)[_-]?token|token)\b(\s*[:=]\s*)(["']?)[^\s"',&]{8,}\3/giu, "$1$2[REDACTED]");
+    return truncateUtf8(result, maxBytes);
+}
+export function redactCredentialError(error, exactSecrets = [], maxBytes = DEFAULT_MAX_BYTES) {
+    return new Error(redactCredentialText(error instanceof Error ? error.message : error, exactSecrets, maxBytes));
+}

package/dist/core/types.d.ts

@@ -5,6 +5,8 @@ export interface AgentStartInput {
     instructions: string;
     workspacePath: string;
     runtimeHomePath: string;
+    /** Trusted host causal identity, fixed per instance; unsupported with memory until its public API accepts context. */
+    causalRunId?: string;
     tools?: string[];
 }
 export interface HarnessModelEndpoint {

package/dist/core/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,WAAW,GAAG,QAAQ,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;KACtD,CAAC;IACF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;KAC1B,CAAC;IACF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5C,MAAM,IAAI,WAAW,CAAC;IACtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC1D"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAE7B,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,sHAAsH;IACtH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,WAAW,GAAG,QAAQ,CAAC;CACvC;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;KACtD,CAAC;IACF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,GAAG,OAAO,CAAC;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE;QACR,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;QACrB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;KAC1B,CAAC;IACF,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,OAAO,CAAC;IACZ,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5C,MAAM,IAAI,WAAW,CAAC;IACtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED,MAAM,WAAW,mBAAmB;IAClC,UAAU,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC1D"}

package/dist/examples/jungianPlayAgent.d.ts

@@ -27,6 +27,7 @@ export declare class JungianVoice {
     readonly runtimeHomePath: string;
     readonly workspacePath: string;
     private readonly memory;
+    private clockReady?;
     constructor(config: JungianVoiceConfig);
     prepare(): Promise<void>;
     stop(): Promise<void>;

package/dist/examples/jungianPlayAgent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jungianPlayAgent.d.ts","sourceRoot":"","sources":["../../src/examples/jungianPlayAgent.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAqB,KAAK,aAAa,IAAI,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEhH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,eAAe,CAAC;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,kBAAkB,CAAC;CAC3B;AAUD,qBAAa,YAAY;IAKX,QAAQ,CAAC,MAAM,EAAE,kBAAkB;IAJ/C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;gBAElB,MAAM,EAAE,kBAAkB;IAWzC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAkBxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA4DxD;AAED,eAAO,MAAM,UAAU,GAAU,CAAC,EAAE,CAAC,EACnC,QAAQ,SAAS,CAAC,EAAE,EACpB,OAAO,MAAM,EACb,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAC5B,OAAO,CAAC,CAAC,EAAE,CAYb,CAAC"}
+{"version":3,"file":"jungianPlayAgent.d.ts","sourceRoot":"","sources":["../../src/examples/jungianPlayAgent.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,iBAAiB,CAAC;AACxE,OAAO,EAAqB,KAAK,aAAa,IAAI,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEhH,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,YAAY,EAAE,eAAe,CAAC;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,kBAAkB,CAAC;CAC3B;AAUD,qBAAa,YAAY;IAMX,QAAQ,CAAC,MAAM,EAAE,kBAAkB;IAL/C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,UAAU,CAAC,CAAgB;gBAEd,MAAM,EAAE,kBAAkB;IAWzC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrB,IAAI,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,gBAAgB,CAAC;CA6DxD;AAED,eAAO,MAAM,UAAU,GAAU,CAAC,EAAE,CAAC,EACnC,QAAQ,SAAS,CAAC,EAAE,EACpB,OAAO,MAAM,EACb,KAAK,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,KAC5B,OAAO,CAAC,CAAC,EAAE,CAYb,CAAC"}

package/dist/examples/jungianPlayAgent.js

@@ -1,6 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { createMemoryRuntime } from "@noopolis/mneme";
+import { createClockedMemoryRuntime } from "../pi/memoryClock.js";
+import { verifyTaskClockProcess } from "../pi/taskClockProcess.js";
 import { runEngineDetailed } from "../pi/cliSession.js";
 const maxMemoryChars = 2200;
 const truncate = (text, maxChars) => text.length <= maxChars ? text : `${text.slice(0, maxChars).trim()}\n[truncated]`;
@@ -10,11 +11,12 @@ export class JungianVoice {
     runtimeHomePath;
     workspacePath;
     memory;
+    clockReady;
     constructor(config) {
         this.config = config;
         this.workspacePath = path.join(config.runtimeRoot, "selves", config.selfId, "voices", config.id, "workspace");
         this.runtimeHomePath = path.join(config.runtimeRoot, "selves", config.selfId, "voices", config.id, "runtime");
-        this.memory = createMemoryRuntime({
+        this.memory = createClockedMemoryRuntime({
             agentId: config.id,
             runtimeHomePath: this.runtimeHomePath,
             source: `daimon/jungian-play/${config.engine}`,
@@ -22,6 +24,7 @@ export class JungianVoice {
         });
     }
     async prepare() {
+        await (this.clockReady ??= verifyTaskClockProcess(this.runtimeHomePath));
         await mkdir(this.workspacePath, { recursive: true });
         await mkdir(this.runtimeHomePath, { recursive: true });
         await writeFile(path.join(this.workspacePath, "AGENTS.md"), [
@@ -39,6 +42,7 @@ export class JungianVoice {
         // CLI-backed voices are one-process-per-wake and have no persistent handle.
     }
     async wake(event) {
+        await (this.clockReady ??= verifyTaskClockProcess(this.runtimeHomePath));
         const startedAt = Date.now();
         const prepareStartedAt = Date.now();
         const prepared = await this.memory.prepareTurn({

package/dist/mcp/toolServer.d.ts

@@ -6,9 +6,26 @@ export declare class McpToolTurnLimitError extends Error {
 export declare class McpWakeDeadlineError extends Error {
     constructor();
 }
+/**
+ * A non-standard request AGY issues during its MCP handshake.
+ *
+ * Captured live from `agy --print … --output-format stream-json`, the client
+ * sends `initialize`, `notifications/initialized`, **`server/discover`**,
+ * `tools/list`, `tools/call`. `server/discover` is not in the MCP
+ * specification, and the throwaway probe that proved AGY's headless tool
+ * calling answered it with `{}`. Codex and Grok never send it.
+ *
+ * This server answers it the same way that working probe did, rather than the
+ * SDK default of `MethodNotFound`, because a refusal here is the one observable
+ * difference between this server and the one AGY is known to work against, and
+ * the cost of being wrong is that every AGY agent silently loses every tool.
+ * The allowance is exactly this one method: any other unknown method still gets
+ * `MethodNotFound`, so a genuine protocol mistake is never hidden.
+ */
+export declare const AGY_SERVER_DISCOVER_METHOD: "server/discover";
 export interface PiToolMcpServerOptions {
-    readonly maxToolTurns: number;
-    readonly wakeDeadline: number;
+    readonly maxToolTurns?: number;
+    readonly wakeDeadline?: number;
 }
 export declare const createPiToolMcpServer: (tools: ToolDefinition[], options: PiToolMcpServerOptions) => Server;
 //# sourceMappingURL=toolServer.d.ts.map

package/dist/mcp/toolServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toolServer.d.ts","sourceRoot":"","sources":["../../src/mcp/toolServer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAYnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE,qBAAa,qBAAsB,SAAQ,KAAK;gBAC3B,YAAY,EAAE,MAAM;CAIxC;AAED,qBAAa,oBAAqB,SAAQ,KAAK;;CAK9C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAqCD,eAAO,MAAM,qBAAqB,GAChC,OAAO,cAAc,EAAE,EACvB,SAAS,sBAAsB,KAC9B,MAmEF,CAAC"}
+{"version":3,"file":"toolServer.d.ts","sourceRoot":"","sources":["../../src/mcp/toolServer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAYnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE,qBAAa,qBAAsB,SAAQ,KAAK;gBAC3B,YAAY,EAAE,MAAM;CAIxC;AAED,qBAAa,oBAAqB,SAAQ,KAAK;;CAK9C;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,EAAG,iBAA0B,CAAC;AAErE,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAyDD,eAAO,MAAM,qBAAqB,GAChC,OAAO,cAAc,EAAE,EACvB,SAAS,sBAAsB,KAC9B,MAgEF,CAAC"}

package/dist/mcp/toolServer.js

@@ -13,6 +13,23 @@ export class McpWakeDeadlineError extends Error {
         this.name = "McpWakeDeadlineError";
     }
 }
+/**
+ * A non-standard request AGY issues during its MCP handshake.
+ *
+ * Captured live from `agy --print … --output-format stream-json`, the client
+ * sends `initialize`, `notifications/initialized`, **`server/discover`**,
+ * `tools/list`, `tools/call`. `server/discover` is not in the MCP
+ * specification, and the throwaway probe that proved AGY's headless tool
+ * calling answered it with `{}`. Codex and Grok never send it.
+ *
+ * This server answers it the same way that working probe did, rather than the
+ * SDK default of `MethodNotFound`, because a refusal here is the one observable
+ * difference between this server and the one AGY is known to work against, and
+ * the cost of being wrong is that every AGY agent silently loses every tool.
+ * The allowance is exactly this one method: any other unknown method still gets
+ * `MethodNotFound`, so a genuine protocol mistake is never hidden.
+ */
+export const AGY_SERVER_DISCOVER_METHOD = "server/discover";
 const jsonSchema = (parameters) => {
     if (parameters === null || typeof parameters !== "object" || Array.isArray(parameters)) {
         throw new TypeError("Pi tool parameters must be a JSON schema object");
@@ -25,6 +42,25 @@ const toolResult = (result) => ({
         ? { structuredContent: Object.fromEntries(Object.entries(result.details)) }
         : {})
 });
+/** Bound on the rendered Ajv violations, so a pathological schema cannot flood a turn. */
+const MAX_SCHEMA_VIOLATION_BYTES = 2_048;
+/**
+ * Why the arguments were rejected, in the schema's own words.
+ *
+ * A bare `Invalid arguments for tool X` tells an agent that its call was wrong
+ * and nothing about how, which leaves trial and error as the only way to learn
+ * a tool's argument shape. Ajv already knows which instance path failed and
+ * which keyword it failed on; saying so turns a guessing loop into one
+ * correction.
+ */
+const schemaViolations = (validator) => {
+    const rendered = (validator.errors ?? [])
+        .map((issue) => `${issue.instancePath === "" ? "(root)" : issue.instancePath} ${issue.message ?? "is invalid"}`.trim())
+        .join("; ");
+    if (rendered.length === 0)
+        return "the arguments do not match the tool's declared input schema";
+    return rendered.length > MAX_SCHEMA_VIOLATION_BYTES ? `${rendered.slice(0, MAX_SCHEMA_VIOLATION_BYTES)}…` : rendered;
+};
 const toolError = (error) => ({
     content: [{ type: "text", text: error instanceof Error ? `${error.name}: ${error.message}` : String(error) }],
     isError: true
@@ -34,16 +70,22 @@ const toolError = (error) => ({
 // The MCP mount deliberately has no Pi session context; `never` preserves typed positional checks.
 const NO_PI_EXTENSION_CONTEXT = undefined;
 const validateOptions = (options) => {
-    if (!Number.isSafeInteger(options.maxToolTurns) || options.maxToolTurns < 1) {
+    if (options.maxToolTurns !== undefined && (!Number.isSafeInteger(options.maxToolTurns) || options.maxToolTurns < 1)) {
         throw new TypeError("maxToolTurns must be a positive safe integer");
     }
-    if (!Number.isFinite(options.wakeDeadline)) {
+    if (options.wakeDeadline !== undefined && !Number.isFinite(options.wakeDeadline)) {
         throw new TypeError("wakeDeadline must be a finite epoch-millisecond deadline");
     }
 };
 export const createPiToolMcpServer = (tools, options) => {
     validateOptions(options);
     const server = new Server({ name: "daimon-pi-tools", version: "0.1.2" });
+    server.fallbackRequestHandler = async (request) => {
+        if (request.method !== AGY_SERVER_DISCOVER_METHOD) {
+            throw new McpError(ErrorCode.MethodNotFound, `Method not found: ${request.method}`);
+        }
+        return {};
+    };
     const validators = new Map(tools.map((tool) => {
         const schema = jsonSchema(tool.parameters);
         return [tool.name, new Ajv2020({ strict: false }).compile(schema)];
@@ -60,9 +102,9 @@ export const createPiToolMcpServer = (tools, options) => {
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         try {
-            if (Date.now() >= options.wakeDeadline)
+            if (options.wakeDeadline !== undefined && Date.now() >= options.wakeDeadline)
                 throw new McpWakeDeadlineError();
-            if (toolTurns >= options.maxToolTurns)
+            if (options.maxToolTurns !== undefined && toolTurns >= options.maxToolTurns)
                 throw new McpToolTurnLimitError(options.maxToolTurns);
             const tool = tools.find((candidate) => candidate.name === request.params.name);
             const validator = validators.get(request.params.name);
@@ -71,29 +113,27 @@ export const createPiToolMcpServer = (tools, options) => {
             }
             const args = request.params.arguments ?? {};
             if (!validator(args)) {
-                throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${tool.name}`);
+                throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${tool.name}: ${schemaViolations(validator)}`);
             }
             toolTurns += 1;
             // Ajv validated this value against this tool's own schema immediately above.
             const validatedArgs = args;
-            const deadlineController = new AbortController();
-            const remainingMs = Math.max(0, options.wakeDeadline - Date.now());
-            const deadlineTimer = setTimeout(() => deadlineController.abort(), remainingMs);
-            const signal = extra.signal === undefined
-                ? deadlineController.signal
-                : AbortSignal.any([extra.signal, deadlineController.signal]);
-            const deadline = new Promise((_resolve, reject) => {
+            const deadlineController = options.wakeDeadline === undefined ? undefined : new AbortController();
+            const remainingMs = options.wakeDeadline === undefined ? undefined : Math.max(0, options.wakeDeadline - Date.now());
+            const deadlineTimer = deadlineController === undefined ? undefined : setTimeout(() => deadlineController.abort(), remainingMs);
+            const signal = deadlineController === undefined ? extra.signal
+                : extra.signal === undefined ? deadlineController.signal : AbortSignal.any([extra.signal, deadlineController.signal]);
+            const deadline = deadlineController === undefined ? undefined : new Promise((_resolve, reject) => {
                 deadlineController.signal.addEventListener("abort", () => reject(new McpWakeDeadlineError()), { once: true });
             });
             let result;
             try {
-                result = await Promise.race([
-                    tool.execute(`mcp-tool-turn-${toolTurns}`, validatedArgs, signal, undefined, NO_PI_EXTENSION_CONTEXT),
-                    deadline
-                ]);
+                const execution = tool.execute(`mcp-tool-turn-${toolTurns}`, validatedArgs, signal, undefined, NO_PI_EXTENSION_CONTEXT);
+                result = deadline === undefined ? await execution : await Promise.race([execution, deadline]);
             }
             finally {
-                clearTimeout(deadlineTimer);
+                if (deadlineTimer !== undefined)
+                    clearTimeout(deadlineTimer);
             }
             return toolResult(result);
         }