@noopolis/daimon 0.1.0 → 0.1.2

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

@@ -0,0 +1,231 @@
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+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");
+const piAuthPath = path.join(runtimeRoot, "auth", "auth.json");
+const codexAuthPath = path.join(process.env.HOME ?? "", ".codex", "auth.json");
+const demoAgents = [
+    { id: "atlas", name: "Atlas", marker: "ATLAS_BLUE_17" },
+    { id: "oracle", name: "Oracle", marker: "ORACLE_GOLD_23" },
+    { id: "keeper", name: "Keeper", marker: "KEEPER_GREEN_31" }
+];
+const roomContext = {
+    networkId: "memory-lab",
+    roomId: "council",
+    teamId: "memory-e2e",
+    participants: demoAgents.map((agent) => agent.id)
+};
+const assertIncludes = (label, content, expected) => {
+    if (!content.includes(expected)) {
+        throw new Error(`${label} did not include ${expected}.\nActual:\n${content}`);
+    }
+};
+const assertCurrentPromptDoesNotLeakMarkers = (event) => {
+    for (const agent of demoAgents) {
+        if (event.text.includes(agent.marker)) {
+            throw new Error(`wake ${event.id} leaked marker ${agent.marker} in current prompt`);
+        }
+    }
+};
+const agentRuntimeHome = (agentId) => path.join(runtimeRoot, "agents", agentId, "runtime");
+const prepareWorkspace = async (agentId) => {
+    const workspacePath = path.join(runtimeRoot, "agents", agentId, "workspace");
+    const runtimeHomePath = agentRuntimeHome(agentId);
+    await mkdir(workspacePath, { recursive: true });
+    await mkdir(runtimeHomePath, { recursive: true });
+    await writeFile(path.join(workspacePath, "AGENTS.md"), [
+        `# ${agentId}`,
+        "",
+        "This workspace is part of the Daimon Pi memory-org E2E.",
+        "The test intentionally disables file tools and verifies persisted Daimon memory."
+    ].join("\n"));
+    return { workspacePath, runtimeHomePath };
+};
+const setupRuntime = async () => {
+    await access(codexAuthPath);
+    await rm(runtimeRoot, { recursive: true, force: true });
+    await mkdir(path.dirname(piAuthPath), { recursive: true });
+    await seedPiOpenAICodexAuthFromCodex({ codexAuthPath, piAuthPath });
+};
+const resetPiSessionHistory = async (agentId) => {
+    await rm(path.join(agentRuntimeHome(agentId), "sessions"), { recursive: true, force: true });
+};
+const startAgent = async (adapter, agent) => {
+    const paths = await prepareWorkspace(agent.id);
+    return adapter.startAgent({
+        id: agent.id,
+        name: agent.name,
+        instructions: [
+            "You are participating in a live Daimon memory E2E.",
+            "Use the Memory context injected above the wake event as authoritative recalled memory.",
+            "When asked to recall marker tokens, copy exact marker tokens from memory.",
+            "Keep every response to one concise line unless the wake explicitly asks otherwise."
+        ].join(" "),
+        tools: [],
+        ...paths
+    });
+};
+const startAllAgents = async (adapter) => {
+    const handles = new Map();
+    for (const agent of demoAgents) {
+        handles.set(agent.id, await startAgent(adapter, agent));
+    }
+    return handles;
+};
+const stopAll = async (handles) => {
+    await Promise.all([...handles.values()].map((handle) => handle.stop()));
+};
+const wake = async (handle, event, options = {}) => {
+    if (options.assertNoMarkerLeak) {
+        assertCurrentPromptDoesNotLeakMarkers(event);
+    }
+    const result = await handle.wake(event);
+    console.log(`[${event.id}] ${result.agentId}: ${result.text}`);
+    return result;
+};
+const seedPrivateMemories = async (handles) => {
+    console.log("\n== Private seed phase ==");
+    for (const agent of demoAgents) {
+        const result = await handles.get(agent.id)?.wake({
+            id: exampleCausalId(`seed-${agent.id}`),
+            kind: "manual",
+            text: [
+                "Private memory seed.",
+                `Remember this exact marker token for later recall: ${agent.marker}`,
+                "Do not write files. Reply with exactly: stored"
+            ].join("\n")
+        });
+        console.log(`[seed-${agent.id}] ${agent.id}: ${result?.text ?? ""}`);
+    }
+};
+const runRoomConversation = async (handles) => {
+    console.log("\n== Room recall phase ==");
+    const transcript = [];
+    const atlas = await wake(handles.get("atlas"), {
+        id: exampleCausalId("room-atlas-1"),
+        kind: "manual",
+        context: roomContext,
+        text: [
+            "Moltnet room simulation. Visible room transcript so far:",
+            transcript.join("\n") || "(empty)",
+            "Recall your private marker token from Daimon memory.",
+            "Reply in one line: @oracle atlas recalls <exact token>",
+            "Do not invent markers for other agents."
+        ].join("\n")
+    }, { assertNoMarkerLeak: true });
+    assertIncludes("atlas room reply", atlas.text, "ATLAS_BLUE_17");
+    transcript.push(`atlas: ${atlas.text}`);
+    const oracle = await wake(handles.get("oracle"), {
+        id: exampleCausalId("room-oracle-1"),
+        kind: "manual",
+        context: roomContext,
+        text: [
+            "Moltnet room simulation. Visible room transcript so far:",
+            transcript.join("\n"),
+            "Recall your private marker token from Daimon memory and acknowledge Atlas from the transcript.",
+            "Reply in one line: @keeper oracle recalls <exact token>; observed atlas=<atlas token>"
+        ].join("\n")
+    });
+    assertIncludes("oracle room reply", oracle.text, "ORACLE_GOLD_23");
+    assertIncludes("oracle room reply", oracle.text, "ATLAS_BLUE_17");
+    transcript.push(`oracle: ${oracle.text}`);
+    const keeper = await wake(handles.get("keeper"), {
+        id: exampleCausalId("room-keeper-1"),
+        kind: "manual",
+        context: roomContext,
+        text: [
+            "Moltnet room simulation. Visible room transcript so far:",
+            transcript.join("\n"),
+            "Recall your private marker token from Daimon memory and acknowledge Atlas and Oracle from the transcript.",
+            "Reply in one line: keeper recalls <exact token>; observed atlas=<atlas token> oracle=<oracle token>"
+        ].join("\n")
+    });
+    assertIncludes("keeper room reply", keeper.text, "KEEPER_GREEN_31");
+    assertIncludes("keeper room reply", keeper.text, "ATLAS_BLUE_17");
+    assertIncludes("keeper room reply", keeper.text, "ORACLE_GOLD_23");
+    transcript.push(`keeper: ${keeper.text}`);
+    console.log("\nRoom transcript:");
+    for (const line of transcript) {
+        console.log(line);
+    }
+    return transcript;
+};
+const verifyFreshSessionRecall = async (adapter, previousKeeper) => {
+    console.log("\n== Fresh session recall phase ==");
+    await previousKeeper.stop();
+    await resetPiSessionHistory("keeper");
+    const keeper = await startAgent(adapter, demoAgents.find((agent) => agent.id === "keeper"));
+    try {
+        const event = {
+            id: exampleCausalId("room-keeper-2"),
+            kind: "manual",
+            context: roomContext,
+            text: [
+                "Fresh session check. You do not get the room transcript in this wake.",
+                "Use only Daimon memory recalled into this turn.",
+                "Report the marker tokens for atlas, oracle, and keeper from your previous memory-lab room turn.",
+                "Reply in one line: final atlas=<token> oracle=<token> keeper=<token>"
+            ].join("\n")
+        };
+        const result = await wake(keeper, event, { assertNoMarkerLeak: true });
+        assertIncludes("fresh keeper recall", result.text, "ATLAS_BLUE_17");
+        assertIncludes("fresh keeper recall", result.text, "ORACLE_GOLD_23");
+        assertIncludes("fresh keeper recall", result.text, "KEEPER_GREEN_31");
+    }
+    finally {
+        await keeper.stop();
+    }
+};
+const printMemoryCounts = async () => {
+    console.log("\nMemory event counts:");
+    for (const agent of demoAgents) {
+        const events = await new JsonlMemoryStore(agentRuntimeHome(agent.id)).read();
+        const counts = events.reduce((memo, event) => {
+            memo[event.type] = (memo[event.type] ?? 0) + 1;
+            return memo;
+        }, {});
+        console.log(`${agent.id}: ${JSON.stringify(counts)}`);
+    }
+};
+const run = async () => {
+    await setupRuntime();
+    const adapter = new PiHarnessAdapter({
+        authPath: piAuthPath,
+        model: {
+            provider: "openai-codex",
+            name: process.env.HARNESS_PI_MODEL ?? "gpt-5.4-mini"
+        },
+        memory: {
+            tokenBudget: 1800
+        }
+    });
+    const seedHandles = await startAllAgents(adapter);
+    await seedPrivateMemories(seedHandles);
+    await stopAll(seedHandles);
+    await Promise.all(demoAgents.map((agent) => resetPiSessionHistory(agent.id)));
+    const roomHandles = await startAllAgents(adapter);
+    try {
+        await runRoomConversation(roomHandles);
+        await verifyFreshSessionRecall(adapter, roomHandles.get("keeper"));
+        await roomHandles.get("atlas")?.stop();
+        await roomHandles.get("oracle")?.stop();
+        await printMemoryCounts();
+        console.log("\ne2e:pi-memory-org ok");
+    }
+    finally {
+        await Promise.all([
+            roomHandles.get("atlas")?.stop(),
+            roomHandles.get("oracle")?.stop()
+        ]);
+    }
+};
+run().catch((error) => {
+    console.error(error instanceof Error ? error.stack ?? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./core/types.js";
-export * from "./pi/auth.js";
-export * from "./pi/modelConfig.js";
-export * from "./pi/piHarness.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,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,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,4 +1,3 @@
 export * from "./core/types.js";
-export * from "./pi/auth.js";
-export * from "./pi/modelConfig.js";
-export * from "./pi/piHarness.js";
+export * from "./observability/index.js";
+export * from "./mcp/toolServer.js";

package/dist/mcp/toolServer.d.ts

@@ -0,0 +1,14 @@
+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();
+}
+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,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"}

package/dist/mcp/toolServer.js

@@ -0,0 +1,105 @@
+import { Ajv2020 } from "ajv/dist/2020.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+export class McpToolTurnLimitError extends Error {
+    constructor(maxToolTurns) {
+        super(`McpToolTurnLimitError: maximum ${maxToolTurns} calls per wake`);
+        this.name = "McpToolTurnLimitError";
+    }
+}
+export class McpWakeDeadlineError extends Error {
+    constructor() {
+        super("McpWakeDeadlineError: wake deadline exceeded");
+        this.name = "McpWakeDeadlineError";
+    }
+}
+const jsonSchema = (parameters) => {
+    if (parameters === null || typeof parameters !== "object" || Array.isArray(parameters)) {
+        throw new TypeError("Pi tool parameters must be a JSON schema object");
+    }
+    return Object.fromEntries(Object.entries(parameters));
+};
+const toolResult = (result) => ({
+    content: result.content,
+    ...(result.details !== undefined && typeof result.details === "object" && result.details !== null
+        ? { structuredContent: Object.fromEntries(Object.entries(result.details)) }
+        : {})
+});
+const toolError = (error) => ({
+    content: [{ type: "text", text: error instanceof Error ? `${error.name}: ${error.message}` : String(error) }],
+    isError: true
+});
+// Pi's ExtensionContext has no meaning outside a Pi session. Mounted tools
+// must not read it; this named value documents the explicit absence.
+// 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) {
+        throw new TypeError("maxToolTurns must be a positive safe integer");
+    }
+    if (!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" });
+    const validators = new Map(tools.map((tool) => {
+        const schema = jsonSchema(tool.parameters);
+        return [tool.name, new Ajv2020({ strict: false }).compile(schema)];
+    }));
+    let toolTurns = 0;
+    server.registerCapabilities({ tools: { listChanged: true } });
+    server.setRequestHandler(ListToolsRequestSchema, () => ({
+        tools: tools.map((tool) => ({
+            name: tool.name,
+            title: tool.label,
+            description: tool.description,
+            inputSchema: jsonSchema(tool.parameters)
+        }))
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+        try {
+            if (Date.now() >= options.wakeDeadline)
+                throw new McpWakeDeadlineError();
+            if (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);
+            if (tool === undefined || validator === undefined) {
+                throw new McpError(ErrorCode.InvalidParams, `Unknown tool: ${request.params.name}`);
+            }
+            const args = request.params.arguments ?? {};
+            if (!validator(args)) {
+                throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for tool ${tool.name}`);
+            }
+            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) => {
+                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
+                ]);
+            }
+            finally {
+                clearTimeout(deadlineTimer);
+            }
+            return toolResult(result);
+        }
+        catch (error) {
+            return toolError(error);
+        }
+    });
+    return server;
+};

package/dist/observability/causalEvents.d.ts

@@ -0,0 +1,118 @@
+/**
+ * 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
+ * `specs/CAUSAL.md` (root repo) — daimon is an independent repo and does not
+ * import that schema, it only conforms to it. The wire JSON emitted by
+ * `appendCausalEvent` is the actual contract; this type is local sugar over
+ * it.
+ */
+export declare const CAUSAL_EVENT_VERSION: "noopolis.causal-event.v1";
+export type CausalEventSystem = "simfile" | "moltnet" | "mneme" | "daimon";
+export interface CausalEventEmitter {
+    system: CausalEventSystem;
+    stream_id: string;
+    seq: number;
+}
+export interface CausalEvent<TPayload = Record<string, unknown>> {
+    cause_event_ids: string[];
+    emitter: CausalEventEmitter;
+    event_id: string;
+    payload: TPayload;
+    principal_id: string;
+    recorded_at: string;
+    run_id: string;
+    type: string;
+    version: typeof CAUSAL_EVENT_VERSION;
+}
+/** Payload for `turn.input.submitted`, stamped just before a Pi session prompt call. */
+export interface TurnInputSubmittedPayload extends Record<string, unknown> {
+    input_content_sha256: string;
+    input_message_ids: string[];
+    prompt_sha256: string;
+    turn_id: string;
+}
+/** Payload for `turn.output.completed`, stamped once a Pi turn finishes successfully. */
+export interface TurnOutputCompletedPayload extends Record<string, unknown> {
+    output_sha256: string;
+    turn_id: string;
+}
+export declare const TURN_INPUT_SUBMITTED_TYPE: "turn.input.submitted";
+export declare const TURN_OUTPUT_COMPLETED_TYPE: "turn.output.completed";
+/** Name of the environment variable every Noopolis authority reads `run_id` from. Never model output. */
+export declare const NOOPOLIS_RUN_ID_ENV = "NOOPOLIS_RUN_ID";
+/**
+ * Resolves `run_id` from the `NOOPOLIS_RUN_ID` environment variable, per
+ * `specs/CAUSAL.md`. Never derived from a WakeEvent, model output, or any
+ * other in-turn data. A causal event cannot be emitted without a real run id.
+ */
+export declare const resolveRunId: (env?: NodeJS.ProcessEnv) => string;
+export declare const sha256Hex: (value: string) => string;
+/** Deterministic, non-model-derived event id for a turn's `turn.input.submitted` record. */
+export declare const turnInputSubmittedEventId: (turnId: string) => string;
+/** Deterministic, non-model-derived event id for a turn's `turn.output.completed` record. */
+export declare const turnOutputCompletedEventId: (turnId: string) => string;
+/**
+ * The `cause_event_ids` an outbound Moltnet reply for `turnId` should carry.
+ * Pure and deterministic from `turn_id` alone — the harness owns this value,
+ * never the model. Daimon does not construct Moltnet `SendMessageRequest`
+ * values itself (see repo AGENTS.md: Moltnet wiring belongs to the caller,
+ * not this package), so this helper is what a caller sending the reply on
+ * Daimon's behalf attaches to that request's `cause_event_ids`.
+ */
+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.
+ */
+export declare const nextCausalSeq: (input: {
+    runId: string;
+    runtimeHomePath: string;
+    streamId: string;
+}) => Promise<number>;
+/** Appends one CausalEvent record as a line of `runtimeHome/telemetry/causal.jsonl`. */
+export declare const appendCausalEvent: (runtimeHomePath: string, event: CausalEvent) => Promise<void>;
+export interface EmitCausalEventInput<TPayload extends Record<string, unknown>> {
+    agentId: string;
+    causeEventIds: string[];
+    eventId: string;
+    payload: TPayload;
+    principalId: string;
+    runId: string;
+    runtimeHomePath: string;
+    type: string;
+}
+/**
+ * Stamps and appends one causal event for this agent's stream
+ * (`agent:<agentId>`). `run_id` and `principal_id` are always caller-
+ * supplied values (never read from `payload` or model output) — see
+ * `piHarness.ts`, which is the only caller and always passes the resolved
+ * `NOOPOLIS_RUN_ID` and the authenticated agent identity.
+ */
+export declare const emitCausalEvent: <TPayload extends Record<string, unknown>>(input: EmitCausalEventInput<TPayload>) => Promise<CausalEvent<TPayload>>;
+export interface EmitTurnInputSubmittedInput {
+    agentId: string;
+    causeEventIds: string[];
+    inputContentSha256: string;
+    inputMessageIds: string[];
+    principalId: string;
+    promptSha256: string;
+    runId: string;
+    runtimeHomePath: string;
+    turnId: string;
+}
+/** Stamps `turn.input.submitted` for one Pi turn, right before the engine prompt call. */
+export declare const emitTurnInputSubmitted: (input: EmitTurnInputSubmittedInput) => Promise<CausalEvent<TurnInputSubmittedPayload>>;
+export interface EmitTurnOutputCompletedInput {
+    agentId: string;
+    causeEventIds: string[];
+    outputSha256: string;
+    principalId: string;
+    runId: string;
+    runtimeHomePath: string;
+    turnId: string;
+}
+/** Stamps `turn.output.completed` once a Pi turn finishes successfully. */
+export declare const emitTurnOutputCompleted: (input: EmitTurnOutputCompletedInput) => Promise<CausalEvent<TurnOutputCompletedPayload>>;
+//# sourceMappingURL=causalEvents.d.ts.map

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

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

package/dist/observability/causalEvents.js

@@ -0,0 +1,135 @@
+import { createHash } from "node:crypto";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+/**
+ * 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
+ * `specs/CAUSAL.md` (root repo) — daimon is an independent repo and does not
+ * import that schema, it only conforms to it. The wire JSON emitted by
+ * `appendCausalEvent` is the actual contract; this type is local sugar over
+ * it.
+ */
+export const CAUSAL_EVENT_VERSION = "noopolis.causal-event.v1";
+export const TURN_INPUT_SUBMITTED_TYPE = "turn.input.submitted";
+export const TURN_OUTPUT_COMPLETED_TYPE = "turn.output.completed";
+/** Name of the environment variable every Noopolis authority reads `run_id` from. Never model output. */
+export const NOOPOLIS_RUN_ID_ENV = "NOOPOLIS_RUN_ID";
+/**
+ * Resolves `run_id` from the `NOOPOLIS_RUN_ID` environment variable, per
+ * `specs/CAUSAL.md`. Never derived from a WakeEvent, model output, or any
+ * other in-turn data. A causal event cannot be emitted without a real run id.
+ */
+export const resolveRunId = (env = process.env) => {
+    const value = env[NOOPOLIS_RUN_ID_ENV];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${NOOPOLIS_RUN_ID_ENV} must be set to a non-blank value`);
+    }
+    return value.trim();
+};
+export const sha256Hex = (value) => createHash("sha256").update(value, "utf8").digest("hex");
+/** Deterministic, non-model-derived event id for a turn's `turn.input.submitted` record. */
+export const turnInputSubmittedEventId = (turnId) => `daimon:${turnId}:turn.input.submitted`;
+/** Deterministic, non-model-derived event id for a turn's `turn.output.completed` record. */
+export const turnOutputCompletedEventId = (turnId) => `daimon:${turnId}:turn.output.completed`;
+/**
+ * The `cause_event_ids` an outbound Moltnet reply for `turnId` should carry.
+ * Pure and deterministic from `turn_id` alone — the harness owns this value,
+ * never the model. Daimon does not construct Moltnet `SendMessageRequest`
+ * values itself (see repo AGENTS.md: Moltnet wiring belongs to the caller,
+ * not this package), so this helper is what a caller sending the reply on
+ * Daimon's behalf attaches to that request's `cause_event_ids`.
+ */
+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 readSeqStore = async (runtimeHomePath) => {
+    try {
+        const raw = await readFile(seqFilePath(runtimeHomePath), "utf8");
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+};
+const writeSeqStore = async (runtimeHomePath, store) => {
+    await mkdir(telemetryDir(runtimeHomePath), { recursive: true });
+    await writeFile(seqFilePath(runtimeHomePath), `${JSON.stringify(store, null, 2)}\n`, "utf8");
+};
+/**
+ * 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.
+ */
+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;
+};
+/** 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 appendFile(jsonlFilePath(runtimeHomePath), `${JSON.stringify(event)}\n`, "utf8");
+};
+/**
+ * Stamps and appends one causal event for this agent's stream
+ * (`agent:<agentId>`). `run_id` and `principal_id` are always caller-
+ * supplied values (never read from `payload` or model output) — see
+ * `piHarness.ts`, which is the only caller and always passes the resolved
+ * `NOOPOLIS_RUN_ID` and the authenticated agent identity.
+ */
+export const emitCausalEvent = async (input) => {
+    const streamId = `agent:${input.agentId}`;
+    const seq = await nextCausalSeq({ runId: input.runId, runtimeHomePath: input.runtimeHomePath, streamId });
+    const event = {
+        cause_event_ids: [...input.causeEventIds],
+        emitter: { system: "daimon", stream_id: streamId, seq },
+        event_id: input.eventId,
+        payload: input.payload,
+        principal_id: input.principalId,
+        recorded_at: new Date().toISOString(),
+        run_id: input.runId,
+        type: input.type,
+        version: CAUSAL_EVENT_VERSION
+    };
+    await appendCausalEvent(input.runtimeHomePath, event);
+    return event;
+};
+/** Stamps `turn.input.submitted` for one Pi turn, right before the engine prompt call. */
+export const emitTurnInputSubmitted = (input) => emitCausalEvent({
+    agentId: input.agentId,
+    causeEventIds: input.causeEventIds,
+    eventId: turnInputSubmittedEventId(input.turnId),
+    payload: {
+        input_content_sha256: input.inputContentSha256,
+        input_message_ids: [...input.inputMessageIds],
+        prompt_sha256: input.promptSha256,
+        turn_id: input.turnId
+    },
+    principalId: input.principalId,
+    runId: input.runId,
+    runtimeHomePath: input.runtimeHomePath,
+    type: TURN_INPUT_SUBMITTED_TYPE
+});
+/** Stamps `turn.output.completed` once a Pi turn finishes successfully. */
+export const emitTurnOutputCompleted = (input) => emitCausalEvent({
+    agentId: input.agentId,
+    causeEventIds: input.causeEventIds,
+    eventId: turnOutputCompletedEventId(input.turnId),
+    payload: {
+        output_sha256: input.outputSha256,
+        turn_id: input.turnId
+    },
+    principalId: input.principalId,
+    runId: input.runId,
+    runtimeHomePath: input.runtimeHomePath,
+    type: TURN_OUTPUT_COMPLETED_TYPE
+});