@noopolis/daimon 0.1.0 → 0.1.2

package/dist/pi/worldTools.js

@@ -0,0 +1,373 @@
+import { types } from "node:util";
+import { Type } from "@earendil-works/pi-ai";
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { createWorldClaimRequestBody, createWorldRequestBody, parseWorldClaimResponse } from "./worldToolProtocol.js";
+export const PI_WORLD_TOOL_NAMES = Object.freeze([
+    "world_claim",
+    "world_status",
+    "world_capabilities",
+    "world_observe",
+    "world_affordances",
+    "world_act",
+    "world_ledger"
+]);
+export const PI_WORLD_TOOL_LIMITS = Object.freeze({
+    requestBytes: 64 * 1024,
+    responseBytes: 1024 * 1024,
+    timeoutMs: 5_000
+});
+export { WORLD_ACTION_RESULT_PAGE_REQUEST_VERSION } from "./worldToolProtocol.js";
+const ERROR_MESSAGES = Object.freeze({
+    world_auth_unavailable: "World tool authentication is unavailable.",
+    world_request_cancelled: "World tool request was cancelled.",
+    world_request_denied: "World tool request was denied.",
+    world_request_invalid: "World tool request is invalid.",
+    world_request_rejected: "World tool request was rejected.",
+    world_request_timeout: "World tool request timed out.",
+    world_response_invalid: "World tool returned an invalid response.",
+    world_transport_unavailable: "World tool transport is unavailable."
+});
+export class PiWorldToolError extends Error {
+    code;
+    constructor(code) {
+        super(ERROR_MESSAGES[code]);
+        this.name = "PiWorldToolError";
+        this.code = code;
+    }
+}
+class BodyReadCancelled extends Error {
+}
+class RequestInterrupted extends Error {
+}
+const UTF8 = new TextEncoder();
+const fail = (code) => { throw new PiWorldToolError(code); };
+const text = (value, maximum = 256) => typeof value === "string"
+    && value.length > 0 && value.length <= maximum && value === value.trim();
+const token = (value) => text(value, 1_024)
+    && /^[A-Za-z0-9._~+\/-]+={0,2}$/u.test(value);
+const binding = (value) => {
+    try {
+        if (value === null || typeof value !== "object" || types.isProxy(value)
+            || Object.getPrototypeOf(value) !== Object.prototype)
+            return undefined;
+        const keys = Reflect.ownKeys(value);
+        if (keys.length !== 2 || !keys.includes("url") || !keys.includes("tokenEnv"))
+            return undefined;
+        const url = Object.getOwnPropertyDescriptor(value, "url");
+        const tokenEnv = Object.getOwnPropertyDescriptor(value, "tokenEnv");
+        if (!url?.enumerable || !("value" in url) || !tokenEnv?.enumerable || !("value" in tokenEnv)
+            || typeof url.value !== "string" || url.value !== url.value.trim() || url.value.length > 2_048
+            || url.value.includes("?") || url.value.includes("#")
+            || typeof tokenEnv.value !== "string" || !/^[A-Z_][A-Z0-9_]{0,127}$/u.test(tokenEnv.value))
+            return undefined;
+        const parsed = new URL(url.value);
+        if (parsed.href !== url.value || (parsed.protocol !== "http:" && parsed.protocol !== "https:") || parsed.username !== ""
+            || parsed.password !== "" || parsed.search !== "" || parsed.hash !== ""
+            || !parsed.pathname.endsWith("/v1/world") || parsed.pathname.endsWith("/"))
+            return undefined;
+        return Object.freeze({ url: url.value, tokenEnv: tokenEnv.value });
+    }
+    catch {
+        return undefined;
+    }
+};
+const result = (details, secrets) => {
+    const pending = [details];
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (typeof value === "string") {
+            if (secrets.some((secret) => value.includes(secret)))
+                return fail("world_response_invalid");
+        }
+        else if (Array.isArray(value)) {
+            pending.push(...value);
+        }
+        else if (value !== null && typeof value === "object") {
+            for (const [key, nested] of Object.entries(value)) {
+                if (secrets.some((secret) => key.includes(secret)))
+                    return fail("world_response_invalid");
+                pending.push(nested);
+            }
+        }
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(details);
+    }
+    catch {
+        return fail("world_response_invalid");
+    }
+    if (secrets.some((secret) => serialized.includes(secret)))
+        return fail("world_response_invalid");
+    return { content: [{ type: "text", text: serialized }], details };
+};
+const serialize = (value) => {
+    try {
+        const output = JSON.stringify(value);
+        if (output === undefined || UTF8.encode(output).byteLength > PI_WORLD_TOOL_LIMITS.requestBytes)
+            return fail("world_request_invalid");
+        return output;
+    }
+    catch {
+        return fail("world_request_invalid");
+    }
+};
+const fetchResponse = async (fetchWorld, url, init, signal) => {
+    if (signal.aborted)
+        throw new RequestInterrupted();
+    let interrupted;
+    const interruption = new Promise((_resolve, reject) => {
+        interrupted = () => reject(new RequestInterrupted());
+        signal.addEventListener("abort", interrupted, { once: true });
+    });
+    try {
+        return await Promise.race([fetchWorld(url, init), interruption]);
+    }
+    finally {
+        if (interrupted !== undefined)
+            signal.removeEventListener("abort", interrupted);
+    }
+};
+const readChunk = async (reader, signal) => {
+    if (signal.aborted)
+        throw new BodyReadCancelled();
+    let cancelled;
+    const interruption = new Promise((_resolve, reject) => {
+        cancelled = () => reject(new BodyReadCancelled());
+        signal.addEventListener("abort", cancelled, { once: true });
+    });
+    try {
+        return await Promise.race([reader.read(), interruption]);
+    }
+    finally {
+        if (cancelled !== undefined)
+            signal.removeEventListener("abort", cancelled);
+    }
+};
+const readResponse = async (response, signal, maximum) => {
+    const contentType = response.headers.get("content-type")?.toLowerCase();
+    const contentLength = response.headers.get("content-length");
+    if (contentType === undefined || contentType.split(";", 1)[0]?.trim() !== "application/json"
+        || contentLength !== null && (!/^(?:0|[1-9][0-9]*)$/u.test(contentLength) || Number(contentLength) > maximum)
+        || response.body === null)
+        return fail("world_response_invalid");
+    const reader = response.body.getReader();
+    const chunks = [];
+    let length = 0;
+    try {
+        while (true) {
+            const next = await readChunk(reader, signal);
+            if (next.done)
+                break;
+            length += next.value.byteLength;
+            if (length > maximum)
+                return fail("world_response_invalid");
+            chunks.push(next.value.slice());
+        }
+    }
+    catch (error) {
+        if (error instanceof BodyReadCancelled)
+            throw error;
+        return fail("world_response_invalid");
+    }
+    finally {
+        const release = () => {
+            try {
+                reader.releaseLock();
+            }
+            catch { /* A failed read must not mask the fixed error. */ }
+        };
+        if (length > maximum || signal.aborted) {
+            try {
+                void reader.cancel().then(release, release);
+            }
+            catch {
+                release();
+            }
+        }
+        else
+            release();
+    }
+    const bytes = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch {
+        return fail("world_response_invalid");
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return fail("world_response_invalid");
+    return parsed;
+};
+const cancelBody = (response) => {
+    try {
+        const body = response.body;
+        if (body !== null)
+            void body.cancel().catch(() => { });
+    }
+    catch { /* Never surface response diagnostics. */ }
+};
+const boundSchemas = Object.freeze({
+    claim: Type.Object({}, { additionalProperties: false }),
+    status: Type.Object({}, { additionalProperties: false }),
+    capabilities: Type.Object({}, { additionalProperties: false }),
+    observe: Type.Object({
+        sense: Type.String({ description: "Granted world sense address." })
+    }, { additionalProperties: false }),
+    affordances: Type.Object({}, { additionalProperties: false }),
+    act: Type.Object({
+        affordance: Type.String({ description: "Granted world affordance address." }),
+        target: Type.String({ description: "World target entity address." }),
+        input: Type.Unknown({ description: "Typed input declared by the selected affordance." })
+    }, { additionalProperties: false }),
+    ledger: Type.Object({
+        limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 100 })),
+        result_after: Type.Optional(Type.Unknown({ description: "Opaque result cursor returned by a previous ledger call." }))
+    }, { additionalProperties: false })
+});
+const descriptors = Object.freeze([
+    { name: "world_claim", operation: "claim", label: "Claim world authority", description: "Privately bind world authority to this organization-owned wake." },
+    { name: "world_status", operation: "status", label: "World status", description: "Read authenticated world orientation and decision status." },
+    { name: "world_capabilities", operation: "capabilities", label: "World capabilities", description: "Read the authenticated caller's world capability manifest." },
+    { name: "world_observe", operation: "observe", label: "Observe world", description: "Invoke one granted world sense against current state." },
+    { name: "world_affordances", operation: "affordances", label: "World affordances", description: "List currently available granted world actions." },
+    { name: "world_act", operation: "act", label: "Act in world", description: "Attempt one world affordance with a stable request id." },
+    { name: "world_ledger", operation: "ledger", label: "World ledger", description: "Read authenticated terminal action results." }
+]);
+export const createPiWorldTools = (input) => {
+    const world = binding(input.world);
+    const timeoutMs = input.timeoutMs ?? PI_WORLD_TOOL_LIMITS.timeoutMs;
+    const maximum = input.maxResponseBytes ?? PI_WORLD_TOOL_LIMITS.responseBytes;
+    const fetchWorld = input.fetch ?? globalThis.fetch;
+    const readEnvironment = input.readEnvironment ?? ((name) => process.env[name]);
+    if (world === undefined || typeof fetchWorld !== "function" || typeof readEnvironment !== "function"
+        || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 30_000
+        || !Number.isSafeInteger(maximum) || maximum < 128 || maximum > PI_WORLD_TOOL_LIMITS.responseBytes) {
+        throw new TypeError("invalid Pi world tool configuration");
+    }
+    const available = input.contextRef === undefined
+        ? descriptors.filter((descriptor) => descriptor.operation !== "claim")
+        : descriptors;
+    return available.map((descriptor) => defineTool({
+        name: descriptor.name,
+        label: descriptor.label,
+        description: descriptor.description,
+        promptSnippet: descriptor.description,
+        promptGuidelines: ["Treat world tool values as scoped current state; never invent caller identity or world authority fields."],
+        parameters: boundSchemas[descriptor.operation],
+        async execute(_toolCallId, params, callerSignal) {
+            if (callerSignal?.aborted)
+                return fail("world_request_cancelled");
+            if (input.contextRef === undefined)
+                return fail("world_request_denied");
+            let bearer;
+            try {
+                bearer = readEnvironment(world.tokenEnv);
+            }
+            catch {
+                return fail("world_auth_unavailable");
+            }
+            if (!token(bearer))
+                return fail("world_auth_unavailable");
+            const serialized = serialize(descriptor.operation === "claim"
+                ? createWorldClaimRequestBody(input.contextRef.current) ?? fail("world_request_invalid")
+                : createWorldRequestBody(descriptor.operation, params, input.contextRef.current)
+                    ?? fail("world_request_invalid"));
+            const controller = new AbortController();
+            let timedOut = false;
+            const cancel = () => controller.abort();
+            if (callerSignal !== undefined)
+                callerSignal.addEventListener("abort", cancel, { once: true });
+            const timer = setTimeout(() => { timedOut = true; controller.abort(); }, timeoutMs);
+            try {
+                let response;
+                for (let attempt = 0; attempt < 2; attempt += 1) {
+                    if (callerSignal?.aborted)
+                        return fail("world_request_cancelled");
+                    if (controller.signal.aborted)
+                        return fail(timedOut ? "world_request_timeout" : "world_request_cancelled");
+                    try {
+                        response = await fetchResponse(fetchWorld, `${world.url}/${descriptor.operation}`, {
+                            method: "POST",
+                            headers: { authorization: `Bearer ${bearer}`, "content-type": "application/json" },
+                            body: serialized,
+                            signal: controller.signal
+                        }, controller.signal);
+                    }
+                    catch (error) {
+                        if (callerSignal?.aborted)
+                            return fail("world_request_cancelled");
+                        if (controller.signal.aborted)
+                            return fail(timedOut ? "world_request_timeout" : "world_request_cancelled");
+                        if (descriptor.operation !== "act" || !(error instanceof TypeError) || attempt === 1) {
+                            return fail("world_transport_unavailable");
+                        }
+                        continue;
+                    }
+                    let status;
+                    try {
+                        status = response.status;
+                    }
+                    catch {
+                        return fail("world_response_invalid");
+                    }
+                    if (descriptor.operation === "act" && status === 408 && attempt === 0) {
+                        cancelBody(response);
+                        response = undefined;
+                        continue;
+                    }
+                    break;
+                }
+                if (response === undefined)
+                    return fail("world_transport_unavailable");
+                try {
+                    const status = response.status;
+                    if (!response.ok) {
+                        cancelBody(response);
+                        if (status === 401 || status === 403)
+                            return fail("world_request_denied");
+                        return fail("world_request_rejected");
+                    }
+                    const details = await readResponse(response, controller.signal, maximum);
+                    if (descriptor.operation === "claim") {
+                        if (input.contextRef === undefined || input.contextRef.current === undefined) {
+                            return fail("world_response_invalid");
+                        }
+                        const claimed = parseWorldClaimResponse(details) ?? fail("world_response_invalid");
+                        input.contextRef.current = Object.freeze({
+                            ...input.contextRef.current,
+                            decisionToken: claimed.decisionToken,
+                            tick: claimed.issuedAtTick,
+                        });
+                        return result({
+                            claimed: true,
+                            issued_at_tick: claimed.issuedAtTick,
+                            valid_through_tick: claimed.validThroughTick,
+                        }, [bearer, claimed.decisionToken]);
+                    }
+                    return result(details, [bearer, input.contextRef.current?.decisionToken ?? ""]
+                        .filter((value) => value.length > 0));
+                }
+                catch (error) {
+                    if (error instanceof BodyReadCancelled)
+                        return fail(timedOut ? "world_request_timeout" : "world_request_cancelled");
+                    if (error instanceof PiWorldToolError)
+                        throw error;
+                    return fail("world_response_invalid");
+                }
+            }
+            finally {
+                clearTimeout(timer);
+                if (callerSignal !== undefined)
+                    callerSignal.removeEventListener("abort", cancel);
+            }
+        }
+    }));
+};
+export const piWorldToolNames = (tools) => tools.map((tool) => tool.name);

package/dist/pi/worldTrajectory.d.ts

@@ -0,0 +1,52 @@
+import type { PiTurnTraceModel } from "./turnTrace.js";
+import type { PiWorldTurnContext } from "./worldNudge.js";
+export declare const WORLD_TRAJECTORY_SCHEMA: "daimon.world_trajectory.v1";
+/**
+ * Pi's SessionManager remains the private raw session recorder. This module
+ * derives a minimized public/evaluation projection from the same subscribed
+ * session events. Raw training capture is deliberately separate; see
+ * docs/WORLD_TRAJECTORIES.md.
+ */
+export interface PiWorldTrajectoryToolCall {
+    arguments?: unknown;
+    completed_at?: string;
+    duration_ms?: number;
+    name: string;
+    result?: unknown;
+    sequence: number;
+    started_at?: string;
+    status: "running" | "completed" | "failed";
+    tool_call_id: string;
+}
+export interface PiWorldTrajectoryCapture {
+    readonly calls: PiWorldTrajectoryToolCall[];
+    readonly starts: Map<string, number>;
+}
+export interface PiWorldTrajectoryIdentity {
+    readonly instructions: string;
+    readonly thinkingLevel: string;
+}
+export interface PersistPiWorldTrajectoryInput {
+    agentId: string;
+    capture: PiWorldTrajectoryCapture;
+    completedAt: Date;
+    context: PiWorldTurnContext;
+    instructions: string;
+    model: PiTurnTraceModel;
+    promptText: string;
+    runtimeHomePath: string;
+    startedAt: Date;
+    status: "completed" | "failed";
+    thinkingLevel: string;
+    totalMs: number;
+    turnId: string;
+}
+/**
+ * Keeps the scoped world projection exact while removing authority, hidden
+ * reasoning, private memory, credentials, and host diagnostics.
+ */
+export declare const redactWorldTrajectoryValue: (value: unknown, depth?: number) => unknown;
+export declare const createPiWorldTrajectoryCapture: () => PiWorldTrajectoryCapture;
+export declare const capturePiWorldTrajectoryEvent: (capture: PiWorldTrajectoryCapture, event: unknown, now?: Date) => void;
+export declare const persistPiWorldTrajectory: (input: PersistPiWorldTrajectoryInput) => Promise<void>;
+//# sourceMappingURL=worldTrajectory.d.ts.map

package/dist/pi/worldTrajectory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worldTrajectory.d.ts","sourceRoot":"","sources":["../../src/pi/worldTrajectory.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D,eAAO,MAAM,uBAAuB,EAAG,4BAAqC,CAAC;AAE7E;;;;;GAKG;AAEH,MAAM,WAAW,yBAAyB;IACxC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC3C,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,EAAE,yBAAyB,EAAE,CAAC;IAC5C,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,wBAAwB,CAAC;IAClC,WAAW,EAAE,IAAI,CAAC;IAClB,OAAO,EAAE,kBAAkB,CAAC;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,gBAAgB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAaD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GACrC,OAAO,OAAO,EACd,cAAS,KACR,OAsBF,CAAC;AAKF,eAAO,MAAM,8BAA8B,QAAO,wBAGhD,CAAC;AAEH,eAAO,MAAM,6BAA6B,GACxC,SAAS,wBAAwB,EACjC,OAAO,OAAO,EACd,UAAgB,KACf,IAqCF,CAAC;AAKF,eAAO,MAAM,wBAAwB,GACnC,OAAO,6BAA6B,KACnC,OAAO,CAAC,IAAI,CAkDd,CAAC"}

package/dist/pi/worldTrajectory.js

@@ -0,0 +1,131 @@
+import { createHash } from "node:crypto";
+import { appendFile, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { redactTraceText, sanitizeTraceFileId } from "./turnTrace.js";
+export const WORLD_TRAJECTORY_SCHEMA = "daimon.world_trajectory.v1";
+const asObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? value
+    : undefined;
+const forbiddenKey = /(?:authorization|bearer|credential|memory|password|prompt|reasoning|secret|thinking|token)/iu;
+const maxArrayItems = 256;
+const maxObjectKeys = 256;
+const maxStringChars = 32_768;
+const maxDepth = 12;
+/**
+ * Keeps the scoped world projection exact while removing authority, hidden
+ * reasoning, private memory, credentials, and host diagnostics.
+ */
+export const redactWorldTrajectoryValue = (value, depth = 0) => {
+    if (depth > maxDepth)
+        return "[TRUNCATED]";
+    if (value === null || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : String(value);
+    if (typeof value === "string") {
+        const redacted = redactTraceText(value);
+        return redacted.length > maxStringChars
+            ? `${redacted.slice(0, maxStringChars)}...[TRUNCATED]`
+            : redacted;
+    }
+    if (Array.isArray(value)) {
+        return value.slice(0, maxArrayItems)
+            .map((entry) => redactWorldTrajectoryValue(entry, depth + 1));
+    }
+    const record = asObject(value);
+    if (record === undefined)
+        return String(value);
+    return Object.fromEntries(Object.entries(record)
+        .filter(([key]) => !forbiddenKey.test(key))
+        .slice(0, maxObjectKeys)
+        .map(([key, nested]) => [key, redactWorldTrajectoryValue(nested, depth + 1)]));
+};
+const text = (value) => typeof value === "string" && value.length > 0 ? value : undefined;
+export const createPiWorldTrajectoryCapture = () => ({
+    calls: [],
+    starts: new Map()
+});
+export const capturePiWorldTrajectoryEvent = (capture, event, now = new Date()) => {
+    const record = asObject(event);
+    const type = text(record?.type);
+    if (type !== "tool_execution_start" && type !== "tool_execution_end")
+        return;
+    const name = text(record?.toolName);
+    const toolCallId = text(record?.toolCallId);
+    if (name === undefined || toolCallId === undefined || !name.startsWith("world_"))
+        return;
+    if (type === "tool_execution_start") {
+        capture.starts.set(toolCallId, now.getTime());
+        capture.calls.push({
+            arguments: redactWorldTrajectoryValue(record?.args),
+            name,
+            sequence: capture.calls.length,
+            started_at: now.toISOString(),
+            status: "running",
+            tool_call_id: toolCallId
+        });
+        return;
+    }
+    const call = capture.calls.findLast((candidate) => candidate.tool_call_id === toolCallId);
+    const resultRecord = asObject(record?.result);
+    const result = record?.isError === true
+        ? record?.result
+        : resultRecord?.details ?? record?.result;
+    const startedAt = capture.starts.get(toolCallId);
+    const completed = call ?? {
+        name,
+        sequence: capture.calls.length,
+        status: "running",
+        tool_call_id: toolCallId
+    };
+    completed.completed_at = now.toISOString();
+    completed.duration_ms = startedAt === undefined ? undefined : Math.max(0, now.getTime() - startedAt);
+    completed.result = redactWorldTrajectoryValue(result);
+    completed.status = record?.isError === true ? "failed" : "completed";
+    if (call === undefined)
+        capture.calls.push(completed);
+    capture.starts.delete(toolCallId);
+};
+const sha256 = (value) => createHash("sha256").update(value, "utf8").digest("hex");
+export const persistPiWorldTrajectory = async (input) => {
+    const chosenAction = input.capture.calls.findLast((call) => call.name === "world_act" && call.status === "completed");
+    const record = {
+        agent_id: input.agentId,
+        chosen_action: chosenAction === undefined ? undefined : {
+            arguments: chosenAction.arguments,
+            result: chosenAction.result,
+            tool_call_id: chosenAction.tool_call_id
+        },
+        completed_at: input.completedAt.toISOString(),
+        engine: {
+            auth_method: input.model.authMethod,
+            kind: "pi",
+            model: input.model.model,
+            provider: input.model.provider,
+            thinking_level: input.thinkingLevel
+        },
+        instruction: { sha256: sha256(input.instructions) },
+        outcome: {
+            status: chosenAction === undefined ? "no_action" : "pending_world_join",
+            join: chosenAction?.result
+        },
+        prompt: { sha256: sha256(input.promptText) },
+        schema: WORLD_TRAJECTORY_SCHEMA,
+        started_at: input.startedAt.toISOString(),
+        terminal_status: input.status,
+        timings_ms: { total: input.totalMs },
+        tool_calls: input.capture.calls,
+        turn_id: input.turnId,
+        world: {
+            run_id: input.context.runId,
+            tick: input.context.tick,
+            wake_id: input.context.wakeId
+        }
+    };
+    const telemetryPath = path.join(input.runtimeHomePath, "telemetry");
+    const trajectoriesPath = path.join(telemetryPath, "world-trajectories");
+    await mkdir(trajectoriesPath, { recursive: true });
+    const bytes = `${JSON.stringify(record, null, 2)}\n`;
+    await writeFile(path.join(trajectoriesPath, `${sanitizeTraceFileId(input.turnId)}.json`), bytes, { encoding: "utf8", mode: 0o600 });
+    await appendFile(path.join(telemetryPath, "world-trajectories.ndjson"), `${JSON.stringify(record)}\n`, { encoding: "utf8", mode: 0o600 });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noopolis/daimon",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Noopolis native per-agent runtime harness built on Pi.",
   "license": "MIT",
   "type": "module",
@@ -10,6 +10,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./pi": {
+      "types": "./dist/pi/index.d.ts",
+      "import": "./dist/pi/index.js"
+    },
+    "./observability": {
+      "types": "./dist/observability/index.d.ts",
+      "import": "./dist/observability/index.js"
     }
   },
   "files": [
@@ -30,14 +38,25 @@
     "prepublishOnly": "npm run typecheck && npm test",
     "typecheck": "tsc --project tsconfig.json --noEmit",
     "test": "node --import tsx --test \"src/**/*.test.ts\"",
-    "e2e:pi-agent": "tsx src/examples/pi-agent.ts"
+    "emit-causal-fixture": "tsx src/observability/emitCausalFixture.ts",
+    "emit-causal-fixture:spoof": "tsx src/observability/emitCausalFixture.ts --spoof",
+    "live:codex-session": "node --import tsx scripts/liveCodexSession.mjs",
+    "e2e:pi-agent": "tsx src/examples/pi-agent.ts",
+    "e2e:pi-memory-org": "tsx src/examples/pi-memory-org.ts",
+    "e2e:jungian-play-org": "tsx src/examples/jungian-play-org.ts",
+    "e2e:jungian-triad-org": "tsx src/examples/jungian-triad-org.ts",
+    "image:runtime:local": "docker build -f Dockerfile.runtime -t noopolis/spawnfile-runtime-daimon:0.1.2-local --build-arg DAIMON_VERSION=0.1.2 --build-arg MNEME_VERSION=0.1.1 --build-arg PI_VERSION=0.79.10 .",
+    "image:runtime:local-source": "node scripts/buildLocalRuntimeImage.mjs"
   },
   "engines": {
     "node": ">=22.19.0"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "^0.79.9",
-    "@earendil-works/pi-coding-agent": "^0.79.9"
+    "@earendil-works/pi-ai": "^0.79.10",
+    "@earendil-works/pi-coding-agent": "^0.79.10",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@noopolis/mneme": "^0.1.1",
+    "ajv": "^8.17.1"
   },
   "devDependencies": {
     "@types/node": "^24.12.4",