@noopolis/daimon 0.1.2 → 0.2.1

package/dist/runtime/attentionDispatcher.js

@@ -0,0 +1,365 @@
+import { randomUUID } from "node:crypto";
+import { taskClockAttentionMessages } from "./attention.js";
+import { engineFailureDetail } from "./organizationRuntimeHost.js";
+import { WakeExecutionClaimLostError } from "./wakeAcceptanceStore.js";
+import { sanitizeExecutionError } from "./wakeAcceptanceRecord.js";
+import { STALE_QUEUED_DELIVERY_MS } from "./wakeAcceptanceRetention.js";
+import { ORGANIZATION_RUNTIME_MAX_STRING_CODEPOINTS, ORGANIZATION_RUNTIME_MAX_WAKE_TEXT_BYTES } from "../contracts/organizationRuntimeContract.js";
+import { grokDaimonToolName } from "../contracts/grokWorkerContract.js";
+import { verifyHostRecordingStore, wakeFromDurableInbox } from "./organizationRuntimeAdmission.js";
+import { recordWakeMoment } from "./wakeMomentRecorder.js";
+/** Durable deliveries wait here; only a selected execution reserves a budget slot. */
+export class AttentionDispatcher {
+    options;
+    owner = randomUUID();
+    work = new Map();
+    observed = new Map();
+    generations = new Map();
+    waiters = new Set();
+    active = new Map();
+    errors = new Map();
+    stopping = false;
+    /** Reversible drain: no new execution starts; durable deliveries stay queued. */
+    paused = false;
+    /** Agents whose inbox loop gave up its turn to a drain; resume owes each one a pass. */
+    pausedOut = new Set();
+    fatal;
+    constructor(options) {
+        this.options = options;
+    }
+    notify(agentId, fresh = false) {
+        if (fresh)
+            this.generations.set(agentId, (this.generations.get(agentId) ?? 0) + 1);
+        if (this.stopping)
+            return;
+        // Every pass a drain withholds is owed back on resume.
+        if (this.paused) {
+            this.pausedOut.add(agentId);
+            return;
+        }
+        if (this.work.has(agentId))
+            return;
+        // An owed pass is not new input: it starts from the generation already seen, so
+        // deferred deliveries stay deferred unless something really arrived meanwhile.
+        const baseline = this.pausedOut.delete(agentId) ? this.observed.get(agentId) ?? 0 : 0;
+        const task = this.drain(agentId, baseline).catch((error) => { this.observed.set(agentId, this.generations.get(agentId) ?? 0); this.errors.set(agentId, engineFailureDetail(error) ?? "inbox_storage_unavailable"); }).finally(() => {
+            this.work.delete(agentId);
+            // A resume that landed while this loop was still unwinding its paused exit found it busy; run the owed pass now.
+            if (!this.stopping && ((this.generations.get(agentId) ?? 0) > (this.observed.get(agentId) ?? 0) || this.pausedOut.has(agentId)))
+                this.notify(agentId);
+            this.options.onIdle(agentId);
+        });
+        this.work.set(agentId, task);
+    }
+    fatalReason() { return this.fatal; }
+    busy(agentId) { return this.work.has(agentId); }
+    activeExecutions() { return [...this.active].map(([agent_id, value]) => ({ agent_id, ...value, state: "running" })); }
+    failure(agentId) { return this.errors.get(agentId); }
+    async stop() {
+        this.stopping = true;
+        for (const finish of this.waiters)
+            finish();
+        await Promise.allSettled(this.work.values());
+        await this.options.store.releaseClaims(this.owner);
+    }
+    halt() { this.stopping = true; for (const finish of this.waiters)
+        finish(); }
+    /** Stops admitting executions; a running turn finishes and its records settle as usual. */
+    pause() { this.paused = true; for (const finish of this.waiters)
+        finish(); }
+    /** Admits again and revisits every agent whose inbox moved while paused. */
+    resume(queued = []) {
+        this.paused = false;
+        // Agents with queued work get an owed pass too: a delivery parked before the
+        // drain (a budget pause, say) has no generation of its own to wake it.
+        for (const agentId of queued)
+            this.pausedOut.add(agentId);
+        for (const agent of this.options.agents)
+            if ((this.generations.get(agent.id) ?? 0) > (this.observed.get(agent.id) ?? 0) || this.pausedOut.has(agent.id))
+                this.notify(agent.id);
+    }
+    /** True once no inbox loop is alive: nothing runs, and nothing can start until resume. */
+    quiescent() { return this.work.size === 0; }
+    async drain(agentId, baseline = 0) {
+        const agent = this.options.agents.find((value) => value.id === agentId);
+        let observedGeneration = baseline;
+        while (!this.stopping) {
+            if (this.paused) {
+                this.pausedOut.add(agentId);
+                return;
+            }
+            const generation = this.generations.get(agentId) ?? 0;
+            const stale = [];
+            const records = (await this.options.store.recoverable(new Set(this.options.agents.map((value) => value.id)), (record) => { if (record.agent_id === agentId)
+                stale.push(record); })).filter((record) => record.agent_id === agentId);
+            for (const record of stale)
+                await expireStaleDelivery(this.options.store, record);
+            const selected = selectBatch(records, agent, generation > observedGeneration);
+            observedGeneration = generation;
+            this.observed.set(agentId, generation);
+            this.errors.delete(agentId);
+            if (!selected.length)
+                return;
+            const budget = await this.options.fuse.snapshot(agentId, agent.attention);
+            if (budget.state !== "available")
+                return;
+            if (this.paused) {
+                this.pausedOut.add(agentId);
+                return;
+            }
+            const executionId = selected[0].execution_id ?? randomUUID();
+            const acquired = await this.options.store.acquireClaim(selected[0].acceptance_id, this.owner, selected.map((record) => record.acceptance_id), executionId);
+            if (acquired.state === "held") {
+                await this.waitUntil(acquired.retry_at);
+                continue;
+            }
+            if (acquired.state === "terminal")
+                continue;
+            const claimed = selected.map((record) => ({ record, claim: acquired.claim, done: false }));
+            for (const item of claimed)
+                item.record = await this.options.store.transitionClaimed(item.record.acceptance_id, item.claim, "running", undefined, undefined, agent.attention === undefined ? undefined : { execution_id: executionId, deferred: false });
+            // A member ended between selection and claim (another host's expiry or stop
+            // reached it first): never wake cognition on a batch that includes it.
+            if (claimed.some((item) => item.record.state !== "running")) {
+                for (const item of claimed.filter((value) => value.record.state === "running"))
+                    await this.options.store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted");
+                await this.options.store.releaseClaim(claimed[0].claim);
+                continue;
+            }
+            // A drain that arrived after the claim releases it before any budget is spent.
+            // Admission is the drain's linearization point: a turn the fuse admitted before
+            // the loop saw the drain is a running turn, and keeps the host "draining".
+            const pausedBeforeAdmit = this.paused;
+            const verdict = pausedBeforeAdmit ? undefined : await this.options.fuse.admit(agentId, randomUUID(), agent.attention);
+            if (verdict?.state !== "admitted" || this.stopping) {
+                if (pausedBeforeAdmit)
+                    this.pausedOut.add(agentId);
+                for (const item of claimed)
+                    await this.options.store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted");
+                await this.options.store.releaseClaim(claimed[0].claim);
+                return;
+            }
+            await this.execute(agent, claimed, executionId);
+        }
+    }
+    async execute(agent, claimed, executionId) {
+        const { store, registry, host, token, fuse } = this.options;
+        // Serialize tool disposition and lease renewal against the same current claim.
+        let mutation = Promise.resolve();
+        const serialize = (operation) => {
+            const result = mutation.then(operation);
+            mutation = result.then(() => undefined, () => undefined);
+            void result.catch((error) => { if (error instanceof WakeExecutionClaimLostError)
+                this.failClosed(agent.id, error); });
+            return result;
+        };
+        const heartbeat = setInterval(() => {
+            void serialize(async () => {
+                const renewed = await store.renewClaim(claimed[0].claim.acceptance_id, claimed[0].claim);
+                for (const item of claimed)
+                    item.claim = renewed;
+                for (const item of claimed.filter((value) => !value.done))
+                    await store.transitionClaimed(item.record.acceptance_id, item.claim, "running");
+            }).catch((error) => this.failClosed(agent.id, error));
+        }, store.claimHeartbeatIntervalMs());
+        this.active.set(agent.id, { execution_id: agent.attention === undefined ? claimed[0].record.delivery_id : executionId, delivery_ids: claimed.map((item) => item.record.delivery_id) });
+        let result;
+        try {
+            const messages = taskClockAttentionMessages(claimed.map(({ record }) => record));
+            if (agent.attention !== undefined)
+                registry.set(agent.id, {
+                    executionId, messages, budget: () => fuse.snapshot(agent.id, agent.attention),
+                    disposition: (deliveryId, disposition) => serialize(async () => {
+                        const item = claimed.find((value) => value.record.delivery_id === deliveryId);
+                        if (!item)
+                            throw new Error("Delivery is outside this agent's selected inbox turn");
+                        if (item.done && item.record.state === "completed") {
+                            if (disposition !== "complete")
+                                throw new Error("A completed delivery cannot be deferred");
+                            return;
+                        }
+                        if (item.done && disposition === "defer")
+                            return;
+                        item.record = await store.transitionClaimed(item.record.acceptance_id, item.claim, disposition === "complete" ? "completed" : "accepted", undefined, disposition === "complete" ? "" : undefined, disposition === "defer" ? { deferred: true, clear_execution: true, execution_error: null } : { execution_id: executionId, deferred: false, execution_error: null });
+                        item.done = true;
+                    })
+                });
+            const first = claimed[0].record;
+            if (agent.recording) {
+                await recordWakeMoment(agent, agent.attention === undefined ? first.delivery_id : executionId, claimed.map(({ record }) => record), { ...this.options.recordingOptionsForTest, verifyStore: () => verifyHostRecordingStore(host, agent.id) });
+            }
+            result = await wakeFromDurableInbox(host, { token, agentId: agent.id, event: {
+                    version: "noopolis.daimon.wake.v1", id: agent.attention === undefined ? first.delivery_id : executionId, kind: first.event.kind,
+                    occurredAt: messages[0].occurred_at,
+                    text: agent.attention === undefined ? first.event.text : inboxPrompt(messages, agent.engine.kind, agent.attention.maxBatchBytes)
+                } });
+        }
+        catch (error) {
+            result = { version: "noopolis.daimon.wake-result.v1", status: "failed", agentId: agent.id, wakeId: executionId, code: "engine_failed", detail: engineFailureDetail(error) };
+        }
+        finally {
+            clearInterval(heartbeat);
+        }
+        try {
+            await mutation;
+            const executionError = result.status === "rejected" ? `wake rejected: ${result.code}`
+                : result.status === "failed" ? `engine_failed: ${result.detail ?? "engine execution failed"}` : null;
+            for (const item of claimed.filter((value) => !value.done)) {
+                // Returned to the inbox for restart, and recording WHY. Only a WAKE OUTCOME
+                // decides this: `stopped` — which an aborted in-flight wake also carries, with
+                // its own code — is the runtime reclaiming work nobody read. The dispatcher's
+                // own halt is not an outcome and must not stand in for one; it guards the
+                // pre-wake path, where it belongs. Keying on it here discarded a completed
+                // wake's evidence because the host happened to be halting, leaving a record
+                // byte-identical to "never ran". Production tolerated it because a restart
+                // re-delivers; a one-shot isolated trial has no restart and simply lost it.
+                if (result.status === "stopped") {
+                    await store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted", result.code);
+                }
+                else if (agent.attention !== undefined) {
+                    // Successful reading is not completion: an undisposed delivery of a
+                    // completed execution waits, deferred, for new input.
+                    //
+                    // A failed execution is retried ONCE, at once, under a fresh execution
+                    // id. Keeping its id made every retry the same broker turn — a sealed
+                    // failure replays forever and a changed prompt is a turn conflict — and
+                    // deferring it left work a turn died on (a token ceiling after a
+                    // validated revision) waiting for mail that might never come. The
+                    // record's `execution_error` is the bound: it is set by the failure and
+                    // cleared only by a disposition or a completed execution, so a delivery
+                    // that fails again is deferred like any other.
+                    const retry = result.status === "failed" && item.record.execution_error === undefined;
+                    await store.transitionClaimed(item.record.acceptance_id, item.claim, "accepted", undefined, undefined, { deferred: !retry, clear_execution: result.status !== "rejected", execution_error: executionError });
+                    if (retry)
+                        console.error(`daimon: wake requeued once agent=${agent.id} delivery=${item.record.delivery_id} after ${sanitizeExecutionError(executionError ?? "engine_failed")}`);
+                }
+                else if (result.status === "completed")
+                    await store.transitionClaimed(item.record.acceptance_id, item.claim, "completed", undefined, result.text);
+                else
+                    await store.transitionClaimed(item.record.acceptance_id, item.claim, "failed", "engine_failed", result.status === "failed" ? result.detail : undefined);
+            }
+        }
+        finally {
+            this.active.delete(agent.id);
+            registry.delete(agent.id);
+            await store.releaseClaim(claimed[0].claim);
+        }
+    }
+    failClosed(agentId, error) {
+        this.errors.set(agentId, engineFailureDetail(error) ?? "execution_claim_lost");
+        this.fatal = "ledger_unavailable";
+        this.options.registry.clear();
+        this.active.clear();
+        this.halt();
+        // Losing a fence revokes runtime/tool authority before stopping cognition.
+        // This host has no per-agent abort lifecycle, so fail closed.
+        void this.options.host.stop().catch(() => undefined);
+    }
+    async waitUntil(timestamp) {
+        if (this.stopping || this.paused)
+            return;
+        await new Promise((resolve) => {
+            const finish = () => { clearTimeout(timer); this.waiters.delete(finish); resolve(); };
+            const timer = setTimeout(finish, Math.max(1, Date.parse(timestamp) - Date.now()));
+            this.waiters.add(finish);
+        });
+    }
+}
+/**
+ * A delivery past `STALE_QUEUED_DELIVERY_MS` is stopped `queued_wake_stopped`
+ * where the dispatcher meets it, and the stop is logged: an expiry nobody can
+ * see reads, in every artifact, like work that was never sent. Stopping goes
+ * through the store's accepted-only seam, so a delivery claimed in the meantime
+ * is left alone; a failure to stop is logged and retried on the next drain.
+ */
+async function expireStaleDelivery(store, record) {
+    try {
+        const stopped = await store.transitionAcceptedToStopped(record.acceptance_id, "queued_wake_stopped");
+        if (stopped.state === "stopped")
+            console.error(`daimon: wake expired agent=${record.agent_id} delivery=${record.delivery_id} accepted_at=${record.accepted_at} unhandled past ${STALE_QUEUED_DELIVERY_MS / 3_600_000}h; stopped queued_wake_stopped${record.execution_error === undefined ? "" : ` (last failure: ${record.execution_error})`}`);
+    }
+    catch (error) {
+        console.error(`daimon: wake expiry failed agent=${record.agent_id} delivery=${record.delivery_id}: ${error instanceof Error ? error.message : "unknown error"}`);
+    }
+}
+export function selectBatch(records, agent, revisitDeferred) {
+    const eligible = records.filter((record) => !record.deferred || revisitDeferred);
+    const first = eligible[0];
+    if (!first)
+        return [];
+    // A durable execution identity survives a crash and partially completed batch.
+    if (first.execution_id !== undefined)
+        return records.filter((record) => record.execution_id === first.execution_id);
+    if (agent.attention === undefined || first.event.kind !== "message")
+        return [first];
+    const selected = [];
+    const count = agent.attention.maxBatchMessages ?? 8;
+    const bytes = agent.attention.maxBatchBytes ?? 12000;
+    for (const record of eligible) {
+        if (record.event.kind !== "message" || record.execution_id !== undefined || selected.length >= count)
+            break;
+        const next = [...selected, record];
+        if (Buffer.byteLength(JSON.stringify(next.map((value) => ({ acceptance_id: value.acceptance_id, delivery_id: value.delivery_id, ...value.event })))) > bytes)
+            break;
+        selected.push(record);
+    }
+    // Oversized individual payloads remain intact in daimon_inbox, not a silently
+    // truncated synthetic wake. The prompt references its durable delivery id.
+    return selected.length ? selected : [first];
+}
+/** One claimed delivery, rendered as the task it is. */
+function deliveryBlock(message, index) {
+    if (message === null || typeof message !== "object")
+        return undefined;
+    const row = message;
+    const text = typeof row.text === "string" ? row.text : undefined;
+    if (text === undefined)
+        return undefined;
+    const from = typeof row.from === "string" ? row.from : undefined;
+    const kind = typeof row.kind === "string" ? row.kind : "delivery";
+    const id = typeof row.delivery_id === "string" ? row.delivery_id : `#${index + 1}`;
+    return [`<delivery id="${id}" kind="${kind}"${from === undefined ? "" : ` from="${from}"`}>`, text, "</delivery>"].join("\n");
+}
+/**
+ * The inbox turn, task first.
+ *
+ * A delivery's own text *is* the work. Leading with bookkeeping and handing the
+ * model `JSON.stringify(messages)` buried the task: an agent read the JSON, did
+ * the accounting and deferred without doing the job (observed on Grok: nine
+ * model requests, no tool calls, nothing filed). The deliveries are therefore
+ * rendered as labelled blocks and the `daimon_inbox` accounting follows them as
+ * what to do *after* the work, with the machine-readable payload kept as a
+ * trailing appendix while it fits the same budget.
+ *
+ * Both tools are named the way the agent's own engine can call them. On Grok a
+ * Daimon tool is an MCP tool of server `daimon` and its bare name reaches
+ * nothing (`grokDaimonToolName`, the same contract module the worker's system
+ * prompt and identity envelope render from), so an agent handed the bare name
+ * cannot mark its work complete — and an unmarked, finished wake is recorded as
+ * deferred.
+ */
+export function inboxPrompt(messages, engine, maxBytes = 12000) {
+    const body = JSON.stringify(messages);
+    const blocks = messages.map(deliveryBlock).filter((block) => block !== undefined);
+    const tool = (name) => engine === "grok" ? grokDaimonToolName(name) : name;
+    const accounting = `\nWhen the work above is done, record each delivery with ${tool("daimon_inbox_disposition")} (complete), or defer the ones you could not finish; use ${tool("daimon_inbox")} for deliveries and remaining allowances. Reading or ending this turn never completes a delivery, and deferred work waits for a later external wake.\n`;
+    const header = blocks.length === 1 ? "Carry out this delivery.\n" : `Carry out these ${blocks.length} deliveries.\n`;
+    const fits = (value) => Buffer.byteLength(value) <= ORGANIZATION_RUNTIME_MAX_WAKE_TEXT_BYTES
+        && [...value].length <= ORGANIZATION_RUNTIME_MAX_STRING_CODEPOINTS;
+    if (blocks.length > 0 && Buffer.byteLength(blocks.join("\n\n")) <= maxBytes) {
+        const task = header + blocks.join("\n\n") + accounting;
+        const withPayload = `${task}\nMachine-readable payload: ${body}`;
+        // The inbox budget bounds selection; the v1 execution boundary independently
+        // bounds the complete prompt, including metadata, escaping, and instructions.
+        if (Buffer.byteLength(body) <= maxBytes && fits(withPayload))
+            return withPayload;
+        if (fits(task))
+            return task;
+    }
+    const prefix = `Handle this inbox turn. Use ${tool("daimon_inbox")} for deliveries and remaining allowances. Explicitly call ${tool("daimon_inbox_disposition")} for each handled delivery (complete) or unfinished delivery (defer). Reading or ending this turn never completes a delivery. Deferred work waits for a later external wake.\n`;
+    const prompt = prefix + body;
+    if (Buffer.byteLength(body) > maxBytes || !fits(prompt)) {
+        return prefix + `The selected payload exceeds the prompt budget; read it with ${tool("daimon_inbox")}.`;
+    }
+    return prompt;
+}

package/dist/runtime/cli.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+export declare function runOrganizationRuntimeCli(arguments_: readonly string[], environment?: NodeJS.ProcessEnv): Promise<void>;
+export declare function parseOrganizationRuntimeCliArguments(arguments_: readonly string[]): Readonly<{
+    configPath: string;
+    kind: "agy-login" | "run";
+}>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/runtime/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/runtime/cli.ts"],"names":[],"mappings":";AAkBA,wBAAsB,yBAAyB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,EAAE,WAAW,oBAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAiDvH;AASD,wBAAgB,oCAAoC,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,QAAQ,CAAC;IAC5F,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,WAAW,GAAG,KAAK,CAAC;CAC3B,CAAC,CASD"}

package/dist/runtime/cli.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+import { mkdir, open, readFile, realpath, rename, stat } from "node:fs/promises";
+import { createHash, timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { pathToFileURL } from "node:url";
+import path from "node:path";
+import { createOrganizationRuntimeHost } from "./organizationRuntimeHost.js";
+import { createOrganizationRuntimeControlHost } from "./organizationRuntimeControl.js";
+import { runAgySubscriptionBootstrap } from "./agySubscriptionBootstrap.js";
+import { parseOrganizationRuntimeConfig, parseOrganizationRuntimeWakeRequest } from "./organizationRuntime.js";
+import { runEngineBrokerServiceCli } from "./engineBrokerServiceCli.js";
+const MAX_BODY_BYTES = 1_048_576;
+const MAX_CONFIG_BYTES = 1_048_576;
+const ACCEPTANCE_STORE_ENV = "DAIMON_RUNTIME_ACCEPTANCE_STORE";
+const READINESS_RECEIPT_ENV = "DAIMON_RUNTIME_READINESS_RECEIPT";
+export async function runOrganizationRuntimeCli(arguments_, environment = process.env) {
+    if (arguments_.length === 2 && arguments_[0] === "engine-broker" && arguments_[1] === "serve") {
+        await runEngineBrokerServiceCli();
+        return;
+    }
+    const command = parseArguments(arguments_);
+    const config = parseOrganizationRuntimeConfig(JSON.parse(await readBoundedFile(command.configPath)));
+    if (command.kind === "agy-login") {
+        await runAgySubscriptionBootstrap(config);
+        return;
+    }
+    const storePath = environment[ACCEPTANCE_STORE_ENV];
+    const control = storePath === undefined || !storePath.trim()
+        ? undefined
+        : createOrganizationRuntimeControlHost(config, { acceptanceStorePath: storePath, controlToken: environment[config.host.controlTokenEnv] });
+    const host = control ?? createOrganizationRuntimeHost(config);
+    await host.start();
+    const server = createServer((request, response) => {
+        void handleRequest(request, response, host, control, environment[config.host.controlTokenEnv]);
+    });
+    try {
+        if (environment[READINESS_RECEIPT_ENV])
+            await writeReadinessReceipt(environment[READINESS_RECEIPT_ENV], config);
+        await listen(server, config.host.bindHost, config.host.port);
+    }
+    catch (error) {
+        await host.stop();
+        throw error;
+    }
+    const sockets = new Set();
+    server.on("connection", (socket) => { sockets.add(socket); socket.once("close", () => sockets.delete(socket)); });
+    // Signals can arrive together (Docker stop commonly sends TERM then KILL).
+    // Every path shares one shutdown outcome and only the first initiates it.
+    let shutdown;
+    let serverClosed = false;
+    const stop = () => {
+        if (shutdown !== undefined)
+            return shutdown;
+        const attempt = (async () => {
+            if (!serverClosed) {
+                await closeServer(server, sockets);
+                serverClosed = true;
+            }
+            await host.stop();
+            process.removeListener("SIGINT", onSignal);
+            process.removeListener("SIGTERM", onSignal);
+        })();
+        shutdown = attempt;
+        void attempt.catch(() => { if (shutdown === attempt)
+            shutdown = undefined; });
+        return attempt;
+    };
+    const onSignal = () => { void stop().catch((error) => { process.stderr.write(`${error instanceof Error ? error.message : "runtime shutdown failed"}\n`); process.exitCode = 1; }); };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+}
+async function writeReadinessReceipt(file, config) {
+    const value = `${JSON.stringify({ version: "noopolis.daimon.readiness-receipt.v1", agents: config.agents.map((agent) => ({ agent_id: agent.id, engine: agent.engine.kind })).sort((left, right) => left.agent_id.localeCompare(right.agent_id)) })}\n`;
+    await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+    const temporary = `${file}.${process.pid}.tmp`;
+    const handle = await open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(value);
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await rename(temporary, file);
+    const directory = await open(path.dirname(file), "r");
+    try {
+        await directory.sync();
+    }
+    finally {
+        await directory.close();
+    }
+}
+export function parseOrganizationRuntimeCliArguments(arguments_) {
+    if (arguments_.length === 3 && arguments_[0] === "run" && arguments_[1] === "--config" && arguments_[2]) {
+        return { configPath: arguments_[2], kind: "run" };
+    }
+    if (arguments_.length === 5 && arguments_[0] === "auth" && arguments_[1] === "agy" && arguments_[2] === "login"
+        && arguments_[3] === "--config" && arguments_[4]) {
+        return { configPath: arguments_[4], kind: "agy-login" };
+    }
+    throw new Error("usage: daimon-runtime run --config <path> | daimon-runtime auth agy login --config <path>");
+}
+const parseArguments = parseOrganizationRuntimeCliArguments;
+async function handleRequest(request, response, host, control, expectedToken) {
+    try {
+        const url = new URL(request.url ?? "/", "http://runtime.invalid");
+        if (request.method === "GET" && url.pathname === "/healthz" && url.search === "") {
+            return respond(response, 200, { status: "ok" });
+        }
+        if (!authorized(request, expectedToken))
+            return respond(response, 401, { error: "unauthorized" });
+        if (request.method === "POST" && url.pathname === "/v1/wake") {
+            if (request.headers["content-type"] !== "application/json")
+                throw new TypeError("content-type must be application/json");
+            const result = await host.wake(parseOrganizationRuntimeWakeRequest({ ...bodyRecord(await readJson(request)), token: expectedToken }));
+            return respond(response, result.status === "completed" ? 200 : result.status === "failed" ? 502 : 409, result);
+        }
+        if (request.method === "GET" && url.pathname === "/v1/health") {
+            return respond(response, 200, await host.health(parseHealthQuery(url)));
+        }
+        if (request.method === "GET" && url.pathname === "/v1/activity") {
+            return respond(response, 200, await host.activity(parseActivityQuery(url)));
+        }
+        if (control !== undefined && request.method === "POST" && url.pathname === "/v2/wakes") {
+            if (request.headers["content-type"] !== "application/json")
+                throw new TypeError("content-type must be application/json");
+            const result = await control.accept({ ...bodyRecord(await readJson(request)), token: expectedToken });
+            const status = result.state === "accepted" ? 202 : result.state === "stopped" ? 409 : result.code === "invalid_request" ? 400 : result.code === "unauthorized" ? 401 : 409;
+            return respond(response, status, result);
+        }
+        if (control !== undefined && request.method === "GET" && /^\/v2\/wake-receipts\/[0-9a-f-]+$/iu.test(url.pathname)) {
+            assertQuery(url, []);
+            const acceptanceId = url.pathname.slice("/v2/wake-receipts/".length);
+            const receipt = await control.wakeReceipt(expectedToken, acceptanceId);
+            return receipt === undefined ? respond(response, 404, { error: "not_found" }) : respond(response, 200, receipt);
+        }
+        if (control !== undefined && request.method === "GET" && url.pathname === "/v2/availability") {
+            assertQuery(url, []);
+            const availability = await control.availability(expectedToken);
+            return availability === undefined ? respond(response, 404, { error: "not_found" }) : respond(response, 200, availability);
+        }
+        if (control !== undefined && request.method === "POST" && (url.pathname === "/v2/drain" || url.pathname === "/v2/resume")) {
+            assertQuery(url, []);
+            const availability = url.pathname === "/v2/drain" ? await control.drain(expectedToken) : await control.resume(expectedToken);
+            return availability === undefined ? respond(response, 404, { error: "not_found" }) : respond(response, 200, availability);
+        }
+        if (control !== undefined && request.method === "GET" && url.pathname === "/v2/activity") {
+            assertQuery(url, []);
+            const activity = await control.activityV2(expectedToken);
+            return activity === undefined ? respond(response, 404, { error: "not_found" }) : respond(response, 200, activity);
+        }
+        return respond(response, 404, { error: "not_found" });
+    }
+    catch (error) {
+        return respond(response, 400, { error: error instanceof Error ? error.message : "invalid_request" });
+    }
+}
+function authorized(request, token) {
+    if (token === undefined || !token.trim())
+        return false;
+    const actual = request.headers.authorization;
+    if (actual === undefined)
+        return false;
+    const digest = (value) => createHash("sha256").update(value).digest();
+    return timingSafeEqual(digest(`Bearer ${token}`), digest(actual));
+}
+async function readJson(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += value.length;
+        if (size > MAX_BODY_BYTES)
+            throw new TypeError("request body is too large");
+        chunks.push(value);
+    }
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+function bodyRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError("request body must be an object");
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        throw new TypeError("request body must be a plain own-properties object");
+    return value;
+}
+function parseHealthQuery(url) {
+    assertQuery(url, ["agentId"]);
+    return url.searchParams.has("agentId") ? nonBlank(url.searchParams.get("agentId"), "agentId") : undefined;
+}
+function parseActivityQuery(url) {
+    assertQuery(url, ["agentId", "cursor", "limit"]);
+    const rawLimit = url.searchParams.get("limit");
+    const limit = rawLimit === null ? 50 : Number(rawLimit);
+    if (!Number.isInteger(limit))
+        throw new TypeError("limit must be an integer");
+    return {
+        ...(url.searchParams.has("agentId") ? { agentId: nonBlank(url.searchParams.get("agentId"), "agentId") } : {}),
+        ...(url.searchParams.has("cursor") ? { cursor: nonBlank(url.searchParams.get("cursor"), "cursor") } : {}),
+        limit
+    };
+}
+function assertQuery(url, allowed) {
+    const seen = new Set();
+    for (const [key] of url.searchParams) {
+        if (!allowed.includes(key) || seen.has(key))
+            throw new TypeError("query contains an unsupported or duplicate parameter");
+        seen.add(key);
+    }
+}
+function nonBlank(value, label) {
+    if (typeof value !== "string")
+        throw new TypeError(`${label} must be a string`);
+    const result = value;
+    if (!result.trim())
+        throw new TypeError(`${label} must not be blank`);
+    return result;
+}
+async function readBoundedFile(filePath) {
+    if ((await stat(filePath)).size > MAX_CONFIG_BYTES)
+        throw new TypeError("runtime config is too large");
+    const bytes = await readFile(filePath);
+    if (bytes.length > MAX_CONFIG_BYTES)
+        throw new TypeError("runtime config is too large");
+    return bytes.toString("utf8");
+}
+function respond(response, status, value) {
+    response.writeHead(status, { "content-type": "application/json; charset=utf-8" });
+    response.end(`${JSON.stringify(value)}\n`);
+}
+function listen(server, host, port) {
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(port, host, () => resolve());
+    });
+}
+async function closeServer(server, sockets) {
+    const closed = new Promise((resolve, reject) => server.close((error) => error === undefined ? resolve() : reject(error)));
+    const timeout = setTimeout(() => { for (const socket of sockets)
+        socket.destroy(); }, 10_000);
+    try {
+        await closed;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+const invokedPath = process.argv[1] === undefined
+    ? undefined
+    : await realpath(process.argv[1]).catch(() => process.argv[1]);
+if (invokedPath !== undefined && import.meta.url === pathToFileURL(invokedPath).href) {
+    void runOrganizationRuntimeCli(process.argv.slice(2)).catch((error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : "daimon-runtime failed"}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/runtime/codexSandboxProjection.d.ts

@@ -0,0 +1,17 @@
+export declare const CODEX_SANDBOX_PROJECTION_VERSION = "noopolis.daimon.codex-sandbox-projection.v1";
+export type OrganizationCodexSandboxProjection = Readonly<{
+    version: typeof CODEX_SANDBOX_PROJECTION_VERSION;
+    agentId: string;
+    workspacePath: string;
+    runtimeHomePath: string;
+    engineHomePath: string;
+    executablePath: string;
+    profileName: string;
+    permissionConfig: string;
+    sandboxArgs: readonly string[];
+}>;
+/** Resolves the production command policy without importing auth or accepting a wake. */
+export declare function resolveOrganizationCodexSandboxProjection(config: unknown, agentId: string, options: Readonly<{
+    acceptanceStorePath: string;
+}>): Promise<OrganizationCodexSandboxProjection>;
+//# sourceMappingURL=codexSandboxProjection.d.ts.map

package/dist/runtime/codexSandboxProjection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codexSandboxProjection.d.ts","sourceRoot":"","sources":["../../src/runtime/codexSandboxProjection.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,gCAAgC,gDAAgD,CAAC;AAC9F,MAAM,MAAM,kCAAkC,GAAG,QAAQ,CAAC;IACxD,OAAO,EAAE,OAAO,gCAAgC,CAAC;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,SAAS,MAAM,EAAE,CAAC;CAChC,CAAC,CAAC;AAEH,yFAAyF;AACzF,wBAAsB,yCAAyC,CAAC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAC9F,OAAO,EAAE,QAAQ,CAAC;IAAE,mBAAmB,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,OAAO,CAAC,kCAAkC,CAAC,CA2BjG"}