@noopolis/daimon 0.1.2 → 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/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);
         }

package/dist/observability/causalEvents.d.ts

@@ -62,9 +62,9 @@ export declare const turnOutputCompletedEventId: (turnId: string) => string;
 export declare const replyCauseEventIds: (turnId: string) => string[];
 /**
  * Allocates the next contiguous seq number for `(run_id, stream_id)`,
- * persisted under `runtimeHome/telemetry/causal.seq.json`. Daimon runs at
- * most one wake at a time per agent (`PiAgentHandle.wakeQueue` serializes
- * them), so read-modify-write here does not need extra locking.
+ * persisted under `runtimeHome/telemetry/causal.seq.json`. Allocation is
+ * serialized in-process and mutually excluded across processes by a lock
+ * file; the counter is written atomically and fsynced.
  */
 export declare const nextCausalSeq: (input: {
     runId: string;

package/dist/observability/causalEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"causalEvents.d.ts","sourceRoot":"","sources":["../../src/observability/causalEvents.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"causalEvents.d.ts","sourceRoot":"","sources":["../../src/observability/causalEvents.ts"],"names":[],"mappings":"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"}

package/dist/observability/causalEvents.js

@@ -1,6 +1,8 @@
-import { createHash } from "node:crypto";
-import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { appendFile, open, readFile, rename, stat, unlink } from "node:fs/promises";
 import path from "node:path";
+import { ensureRuntimeHomeDirectory } from "../runtime/runtimeHomeLayout.js";
 /**
  * Daimon's own copy of the `noopolis.causal-event.v1` wire envelope. Field-
  * for-field the canonical shape in `specs/causal-event.v1.schema.json` and
@@ -43,6 +45,8 @@ export const replyCauseEventIds = (turnId) => [turnOutputCompletedEventId(turnId
 const telemetryDir = (runtimeHomePath) => path.join(runtimeHomePath, "telemetry");
 const seqFilePath = (runtimeHomePath) => path.join(telemetryDir(runtimeHomePath), "causal.seq.json");
 const jsonlFilePath = (runtimeHomePath) => path.join(telemetryDir(runtimeHomePath), "causal.jsonl");
+const STALE_LOCK_MS = 30_000;
+const seqAllocationQueues = new Map();
 const readSeqStore = async (runtimeHomePath) => {
     try {
         const raw = await readFile(seqFilePath(runtimeHomePath), "utf8");
@@ -56,27 +60,111 @@ const readSeqStore = async (runtimeHomePath) => {
     }
 };
 const writeSeqStore = async (runtimeHomePath, store) => {
-    await mkdir(telemetryDir(runtimeHomePath), { recursive: true });
-    await writeFile(seqFilePath(runtimeHomePath), `${JSON.stringify(store, null, 2)}\n`, "utf8");
+    const directory = await ensureRuntimeHomeDirectory(runtimeHomePath, "telemetry");
+    const file = seqFilePath(runtimeHomePath);
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    const handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+    try {
+        await handle.writeFile(`${JSON.stringify(store, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await rename(temporary, file);
+        await syncDirectory(directory);
+    }
+    finally {
+        await unlink(temporary).catch((error) => {
+            if (error.code !== "ENOENT")
+                throw error;
+        });
+    }
+};
+const syncDirectory = async (directory) => {
+    const handle = await open(directory, constants.O_RDONLY);
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};
+const acquireSeqLock = async (lockPath) => {
+    const startedAt = Date.now();
+    let backoffMs = 2;
+    while (Date.now() - startedAt < 5_000) {
+        try {
+            const handle = await open(lockPath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+            await handle.close();
+            return;
+        }
+        catch (error) {
+            if (!(error && typeof error === "object" && "code" in error && error.code === "EEXIST"))
+                throw error;
+        }
+        try {
+            const observed = await stat(lockPath);
+            if (Date.now() - observed.mtimeMs > STALE_LOCK_MS) {
+                const confirmed = await stat(lockPath);
+                if (confirmed.mtimeMs === observed.mtimeMs) {
+                    await unlink(lockPath).catch((error) => {
+                        if (error.code !== "ENOENT")
+                            throw error;
+                    });
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT"))
+                throw error;
+            continue;
+        }
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+        backoffMs = Math.min(backoffMs * 2, 25);
+    }
+    throw new Error(`Timed out acquiring causal sequence lock: ${lockPath}`);
 };
 /**
  * Allocates the next contiguous seq number for `(run_id, stream_id)`,
- * persisted under `runtimeHome/telemetry/causal.seq.json`. Daimon runs at
- * most one wake at a time per agent (`PiAgentHandle.wakeQueue` serializes
- * them), so read-modify-write here does not need extra locking.
+ * persisted under `runtimeHome/telemetry/causal.seq.json`. Allocation is
+ * serialized in-process and mutually excluded across processes by a lock
+ * file; the counter is written atomically and fsynced.
  */
 export const nextCausalSeq = async (input) => {
-    const store = await readSeqStore(input.runtimeHomePath);
-    const forRun = store[input.runId] ?? {};
-    const next = (forRun[input.streamId] ?? 0) + 1;
-    forRun[input.streamId] = next;
-    store[input.runId] = forRun;
-    await writeSeqStore(input.runtimeHomePath, store);
-    return next;
+    const lockPath = path.resolve(telemetryDir(input.runtimeHomePath), "causal.seq.lock");
+    const previous = seqAllocationQueues.get(lockPath) ?? Promise.resolve();
+    const allocation = previous.catch(() => undefined).then(async () => {
+        await ensureRuntimeHomeDirectory(input.runtimeHomePath, "telemetry");
+        await acquireSeqLock(lockPath);
+        try {
+            const store = await readSeqStore(input.runtimeHomePath);
+            const forRun = store[input.runId] ?? {};
+            const next = (forRun[input.streamId] ?? 0) + 1;
+            forRun[input.streamId] = next;
+            store[input.runId] = forRun;
+            await writeSeqStore(input.runtimeHomePath, store);
+            return next;
+        }
+        finally {
+            await unlink(lockPath).catch((error) => {
+                if (error.code !== "ENOENT")
+                    throw error;
+            });
+        }
+    });
+    seqAllocationQueues.set(lockPath, allocation);
+    void allocation.finally(() => {
+        if (seqAllocationQueues.get(lockPath) === allocation)
+            seqAllocationQueues.delete(lockPath);
+    }).catch(() => undefined);
+    return allocation;
 };
 /** Appends one CausalEvent record as a line of `runtimeHome/telemetry/causal.jsonl`. */
 export const appendCausalEvent = async (runtimeHomePath, event) => {
-    await mkdir(telemetryDir(runtimeHomePath), { recursive: true });
+    await ensureRuntimeHomeDirectory(runtimeHomePath, "telemetry");
     await appendFile(jsonlFilePath(runtimeHomePath), `${JSON.stringify(event)}\n`, "utf8");
 };
 /**

package/dist/observability/orgObserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orgObserver.d.ts","sourceRoot":"","sources":["../../src/observability/orgObserver.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"orgObserver.d.ts","sourceRoot":"","sources":["../../src/observability/orgObserver.ts"],"names":[],"mappings":"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"}

package/dist/observability/orgObserver.js

@@ -1,5 +1,6 @@
-import { mkdir, writeFile } from "node:fs/promises";
+import { writeFile } from "node:fs/promises";
 import path from "node:path";
+import { ensureRuntimeHomeDirectory } from "../runtime/runtimeHomeLayout.js";
 const maxExcerptChars = 280;
 const excerpt = (text) => text.length <= maxExcerptChars ? text : `${text.slice(0, maxExcerptChars).trim()}...`;
 export const mentionsFrom = (text) => [...new Set([...text.matchAll(/@([a-z0-9-]+)/gi)].map((match) => match[1].toLowerCase()))];
@@ -110,8 +111,7 @@ export class OrgObserver {
         };
     }
     async write(runtimeRoot) {
-        const telemetryDir = path.join(runtimeRoot, "telemetry");
-        await mkdir(telemetryDir, { recursive: true });
+        const telemetryDir = await ensureRuntimeHomeDirectory(runtimeRoot, "telemetry");
         const summaryRecord = {
             assertions: this.assertions,
             behavior: this.behaviorSummary(),