@noopolis/daimon 0.1.1 → 0.2.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeContractManifest.d.ts","sourceRoot":"","sources":["../../src/contracts/runtimeContractManifest.ts"],"names":[],"mappings":"AASA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoHrB,CAAC;AACX,eAAO,MAAM,sBAAsB;;;;;;;CAOzB,CAAC;AASX,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgC5B,CAAC"}

package/dist/contracts/runtimeContractManifest.js

@@ -0,0 +1,181 @@
+import { 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.v3";
+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 only accepted 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" }
+        },
+        // 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.v2",
+    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"],
+    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.v1",
+    slotPreflightVersion: "noopolis.daimon.grok-slot-preflight.v2",
+    artifacts: {
+        sourceSha256: "dd39aacfece496cc6528f6acdb4f1066a848a0fb5b0961f5c70b0ba00440dc24",
+        x64Sha256: "67e3624d3198e9c59e1ffafa4eca7c895dfe265d5b8bb0614cb547b68b8b93a7",
+        arm64Sha256: "c07d22225ff968bc289e5ddf0981cdd5d64040eee6e3ea45da7d03e1439dea98"
+    }
+};
+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"],
+    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,
+    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/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/siblingBuildFreshness.d.ts

@@ -0,0 +1,21 @@
+export type SiblingFileFact = {
+    path: string;
+    mtimeMs: number;
+};
+export type SiblingBuildFacts = {
+    packageName: string;
+    packageDirectory: string;
+    hasSourceDirectory: boolean;
+    sourceFiles: SiblingFileFact[];
+    outputFiles: SiblingFileFact[];
+};
+export type SiblingBuildFreshness = {
+    packageName: string;
+    linked: boolean;
+    sourcesScanned: number;
+    outputsScanned: number;
+    ok: boolean;
+    message?: string;
+};
+export declare function checkSiblingBuildFreshness(facts: SiblingBuildFacts): SiblingBuildFreshness;
+//# sourceMappingURL=siblingBuildFreshness.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"siblingBuildFreshness.d.ts","sourceRoot":"","sources":["../../src/core/siblingBuildFreshness.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,WAAW,EAAE,eAAe,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAIF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,iBAAiB,GAAG,qBAAqB,CA2B1F"}

package/dist/core/siblingBuildFreshness.js

@@ -0,0 +1,25 @@
+const excludedSource = /(?:\.test\.ts|\.test-helper\.ts|\.d\.ts)$/u;
+export function checkSiblingBuildFreshness(facts) {
+    if (!facts.hasSourceDirectory) {
+        return { packageName: facts.packageName, linked: false, sourcesScanned: 0, outputsScanned: 0, ok: true };
+    }
+    const sourceFiles = facts.sourceFiles.filter(({ path }) => !excludedSource.test(path));
+    const outputFiles = facts.outputFiles.filter(({ path }) => path.endsWith(".js"));
+    const command = `run "npm run build" in ${facts.packageDirectory}`;
+    if (sourceFiles.length === 0) {
+        return failure(facts.packageName, sourceFiles.length, outputFiles.length, `linked package ${facts.packageName} scanned zero source files; ${command}`);
+    }
+    if (outputFiles.length === 0) {
+        return failure(facts.packageName, sourceFiles.length, outputFiles.length, `linked package ${facts.packageName} has no emitted JavaScript; ${command}`);
+    }
+    const newestSource = sourceFiles.reduce((newest, file) => file.mtimeMs > newest.mtimeMs ? file : newest);
+    const oldestOutput = outputFiles.reduce((oldest, file) => file.mtimeMs < oldest.mtimeMs ? file : oldest);
+    if (newestSource.mtimeMs > oldestOutput.mtimeMs) {
+        return failure(facts.packageName, sourceFiles.length, outputFiles.length, `linked package ${facts.packageName} is stale: newest source ${newestSource.path} (${newestSource.mtimeMs}) `
+            + `is newer than oldest output ${oldestOutput.path} (${oldestOutput.mtimeMs}); ${command}`);
+    }
+    return { packageName: facts.packageName, linked: true, sourcesScanned: sourceFiles.length, outputsScanned: outputFiles.length, ok: true };
+}
+function failure(packageName, sourcesScanned, outputsScanned, message) {
+    return { packageName, linked: true, sourcesScanned, outputsScanned, ok: false, message };
+}

package/dist/core/types.d.ts

@@ -20,9 +20,15 @@ export interface HarnessModelSpec {
     name: string;
     provider: string;
 }
+export interface WakeDeliveryMetadata {
+    eventId: string;
+    sender: string;
+    target: string;
+    contextId: string;
+}
 export interface WakeEvent {
     id: string;
-    kind: "manual" | "message" | "schedule";
+    kind: "manual" | "message" | "schedule" | "dream";
     from?: string;
     text: string;
     context?: {
@@ -35,6 +41,9 @@ export interface WakeEvent {
         pairPeers?: string[];
         artifactPaths?: string[];
     };
+    delivery?: WakeDeliveryMetadata;
+    /** Exact transport body retained outside the runtime-enriched model prompt. */
+    transportText?: string;
 }
 export interface WakeResult {
     agentId: AgentId;

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,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;IACxC,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;CACH;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,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/exampleCausalId.d.ts

@@ -0,0 +1,3 @@
+/** Namespaces caller-authored example wakes for the shared causal contract. */
+export declare const exampleCausalId: (localId: string) => string;
+//# sourceMappingURL=exampleCausalId.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exampleCausalId.d.ts","sourceRoot":"","sources":["../../src/examples/exampleCausalId.ts"],"names":[],"mappings":"AAEA,+EAA+E;AAC/E,eAAO,MAAM,eAAe,GAAI,SAAS,MAAM,KAAG,MAKjD,CAAC"}

package/dist/examples/exampleCausalId.js

@@ -0,0 +1,8 @@
+const LOCAL_CAUSAL_ID = /^[a-z0-9][a-z0-9._-]{0,255}$/u;
+/** Namespaces caller-authored example wakes for the shared causal contract. */
+export const exampleCausalId = (localId) => {
+    if (!LOCAL_CAUSAL_ID.test(localId)) {
+        throw new Error("Daimon example causal id must be a bounded local id");
+    }
+    return `daimon:${localId}`;
+};

package/dist/examples/jungian-play-org.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from "node:url";
 import { JsonlMemoryStore } from "@noopolis/mneme";
 import { OrgObserver } from "../observability/index.js";
 import { beatsFor, defaultDialogueTurns, selectVoicesForBeat } from "./jungianConversationPlan.js";
+import { exampleCausalId } from "./exampleCausalId.js";
 import { JungianVoice, runLimited } from "./jungianPlayAgent.js";
 import { jungianSelves, playScenario } from "./jungianProfiles.js";
 import { JungianTrace, parseInnerUsed, parseSpeakLine } from "./jungianTrace.js";
@@ -132,7 +133,7 @@ const runCouncil = async (self, eventId, focus, transcript, voices) => {
     console.log(`\n== ${self.profile.name} inner council: ${focus} ==`);
     const turns = await runLimited(voices, councilConcurrency, async (voice) => {
         const event = {
-            id: `${eventId}-${voice.config.id}`,
+            id: exampleCausalId(`${eventId}-${voice.config.id}`),
             kind: "manual",
             context: roomContext,
             text: councilPrompt(self.profile, focus, transcript)
@@ -155,7 +156,7 @@ const runCouncil = async (self, eventId, focus, transcript, voices) => {
 };
 const runRepresentative = async (self, eventId, focus, transcript, counsel) => {
     const event = {
-        id: eventId,
+        id: exampleCausalId(eventId),
         kind: "manual",
         context: roomContext,
         text: representativePrompt(self.profile, focus, transcript, counsel)

package/dist/examples/jungian-triad-org.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from "node:url";
 import { JsonlMemoryStore } from "@noopolis/mneme";
 import { OrgObserver } from "../observability/index.js";
 import { PiHarnessAdapter } from "../pi/piHarness.js";
+import { exampleCausalId } from "./exampleCausalId.js";
 import { JungianPiRepresentative, seedPiCodexAuth } from "./jungianPiRepresentative.js";
 import { JungianVoice, runLimited } from "./jungianPlayAgent.js";
 import { JungianTrace, parseInnerUsed, parseSpeakLine } from "./jungianTrace.js";
@@ -134,7 +135,7 @@ const runCouncil = async (self, eventBase, focus, transcript, voices) => {
     console.log(`\n== ${self.profile.name} inner counsel ==`);
     return runLimited(voices, 2, async (voice) => {
         const event = {
-            id: `${eventBase}-council-${voice.config.id}`,
+            id: exampleCausalId(`${eventBase}-council-${voice.config.id}`),
             kind: "manual",
             context: roomContext,
             text: councilPrompt(self.profile, focus, transcript)
@@ -171,7 +172,7 @@ const assertUsedCounsel = (self, eventId, output, counsel) => {
 };
 const runRepresentative = async (self, eventBase, focus, transcript, counsel) => {
     const event = {
-        id: `${eventBase}-speaks`,
+        id: exampleCausalId(`${eventBase}-speaks`),
         kind: "manual",
         context: roomContext,
         text: representativePrompt(self.profile, focus, transcript, counsel)

package/dist/examples/jungianPlayAgent.d.ts

@@ -1,6 +1,6 @@
 import type { WakeEvent } from "../core/types.js";
 import type { MemoryRecallAudit } from "@noopolis/mneme";
-import { type EngineKind, type EngineRunResult } from "./mixedEngineCli.js";
+import { type CliEngineKind as EngineKind, type EngineRunResult } from "../pi/cliSession.js";
 export interface JungianVoiceConfig {
     archetype?: string;
     engine: EngineKind;

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,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE/F,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;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"}

package/dist/examples/jungianPlayAgent.js

@@ -1,7 +1,7 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { createMemoryRuntime } from "@noopolis/mneme";
-import { runEngineDetailed } from "./mixedEngineCli.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]`;
 const memorySections = (turnPrompt) => truncate(turnPrompt, maxMemoryChars);

package/dist/examples/jungianProfiles.d.ts

@@ -1,4 +1,4 @@
-import type { EngineKind } from "./mixedEngineCli.js";
+import type { CliEngineKind as EngineKind } from "../pi/cliSession.js";
 export interface JungianArchetypeProfile {
     agenda: string;
     archetype: string;

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

@@ -1 +1 @@
-{"version":3,"file":"jungianProfiles.d.ts","sourceRoot":"","sources":["../../src/examples/jungianProfiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,uBAAuB,EAAE,CAAC;CACnC;AA+JD,eAAO,MAAM,aAAa,EAAE,kBAAkB,EAiC7C,CAAC;AAEF,eAAO,MAAM,YAAY;;;;CAMxB,CAAC"}
+{"version":3,"file":"jungianProfiles.d.ts","sourceRoot":"","sources":["../../src/examples/jungianProfiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEvE,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,uBAAuB,EAAE,CAAC;CACnC;AA+JD,eAAO,MAAM,aAAa,EAAE,kBAAkB,EAiC7C,CAAC;AAEF,eAAO,MAAM,YAAY;;;;CAMxB,CAAC"}

package/dist/examples/jungianTriadProfiles.d.ts

@@ -1,4 +1,4 @@
-import type { EngineKind } from "./mixedEngineCli.js";
+import type { CliEngineKind as EngineKind } from "../pi/cliSession.js";
 export type RepresentativeEngine = EngineKind | "pi";
 export interface TriadArchetypeProfile {
     agenda: string;

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

@@ -1 +1 @@
-{"version":3,"file":"jungianTriadProfiles.d.ts","sourceRoot":"","sources":["../../src/examples/jungianTriadProfiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,IAAI,CAAC;AAErD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,oBAAoB,CAAC;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC;AAsDD,eAAO,MAAM,WAAW,EAAE,gBAAgB,EAqCzC,CAAC;AAEF,eAAO,MAAM,aAAa;;;;CAMzB,CAAC"}
+{"version":3,"file":"jungianTriadProfiles.d.ts","sourceRoot":"","sources":["../../src/examples/jungianTriadProfiles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEvE,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,IAAI,CAAC;AAErD,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,oBAAoB,CAAC;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE;QACd,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,qBAAqB,EAAE,CAAC;CACjC;AAsDD,eAAO,MAAM,WAAW,EAAE,gBAAgB,EAqCzC,CAAC;AAEF,eAAO,MAAM,aAAa;;;;CAMzB,CAAC"}

package/dist/examples/pi-agent.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { seedPiOpenAICodexAuthFromCodex } from "../pi/auth.js";
 import { PiHarnessAdapter } from "../pi/piHarness.js";
+import { exampleCausalId } from "./exampleCausalId.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const daimonRoot = path.resolve(__dirname, "../..");
 const runtimeRoot = path.join(daimonRoot, ".runtime", "pi-agent");
@@ -66,7 +67,7 @@ const run = async () => {
     try {
         console.log("started", JSON.stringify([mapper.status(), reviewer.status()], null, 2));
         const mapped = await mapper.wake({
-            id: "wake-mapper-1",
+            id: exampleCausalId("wake-mapper-1"),
             kind: "manual",
             from: "caller",
             text: [
@@ -78,7 +79,7 @@ const run = async () => {
         });
         console.log("mapper", JSON.stringify(mapped, null, 2));
         const reviewed = await reviewer.wake({
-            id: "wake-reviewer-1",
+            id: exampleCausalId("wake-reviewer-1"),
             kind: "message",
             from: "mapper",
             text: [

package/dist/examples/pi-memory-org.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from "node:url";
 import { JsonlMemoryStore } from "@noopolis/mneme";
 import { seedPiOpenAICodexAuthFromCodex } from "../pi/auth.js";
 import { PiHarnessAdapter } from "../pi/piHarness.js";
+import { exampleCausalId } from "./exampleCausalId.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const daimonRoot = path.resolve(__dirname, "../..");
 const runtimeRoot = path.join(daimonRoot, ".runtime", "pi-memory-org");
@@ -92,7 +93,7 @@ const seedPrivateMemories = async (handles) => {
     console.log("\n== Private seed phase ==");
     for (const agent of demoAgents) {
         const result = await handles.get(agent.id)?.wake({
-            id: `seed-${agent.id}`,
+            id: exampleCausalId(`seed-${agent.id}`),
             kind: "manual",
             text: [
                 "Private memory seed.",
@@ -107,7 +108,7 @@ const runRoomConversation = async (handles) => {
     console.log("\n== Room recall phase ==");
     const transcript = [];
     const atlas = await wake(handles.get("atlas"), {
-        id: "room-atlas-1",
+        id: exampleCausalId("room-atlas-1"),
         kind: "manual",
         context: roomContext,
         text: [
@@ -121,7 +122,7 @@ const runRoomConversation = async (handles) => {
     assertIncludes("atlas room reply", atlas.text, "ATLAS_BLUE_17");
     transcript.push(`atlas: ${atlas.text}`);
     const oracle = await wake(handles.get("oracle"), {
-        id: "room-oracle-1",
+        id: exampleCausalId("room-oracle-1"),
         kind: "manual",
         context: roomContext,
         text: [
@@ -135,7 +136,7 @@ const runRoomConversation = async (handles) => {
     assertIncludes("oracle room reply", oracle.text, "ATLAS_BLUE_17");
     transcript.push(`oracle: ${oracle.text}`);
     const keeper = await wake(handles.get("keeper"), {
-        id: "room-keeper-1",
+        id: exampleCausalId("room-keeper-1"),
         kind: "manual",
         context: roomContext,
         text: [
@@ -162,7 +163,7 @@ const verifyFreshSessionRecall = async (adapter, previousKeeper) => {
     const keeper = await startAgent(adapter, demoAgents.find((agent) => agent.id === "keeper"));
     try {
         const event = {
-            id: "room-keeper-2",
+            id: exampleCausalId("room-keeper-2"),
             kind: "manual",
             context: roomContext,
             text: [

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./core/types.js";
 export * from "./observability/index.js";
+export * from "./mcp/toolServer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC"}

package/dist/index.js

@@ -1,2 +1,3 @@
 export * from "./core/types.js";
 export * from "./observability/index.js";
+export * from "./mcp/toolServer.js";

package/dist/mcp/toolServer.d.ts

@@ -0,0 +1,31 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+export declare class McpToolTurnLimitError extends Error {
+    constructor(maxToolTurns: number);
+}
+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;
+}
+export declare const createPiToolMcpServer: (tools: ToolDefinition[], options: PiToolMcpServerOptions) => Server;
+//# sourceMappingURL=toolServer.d.ts.map

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

@@ -0,0 +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;;;;;;;;;;;;;;;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"}