@noopolis/daimon 0.1.0 → 0.1.2

package/dist/pi/piHarness.js

@@ -1,128 +1,31 @@
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
-import { AuthStorage, createAgentSession, createExtensionRuntime, ModelRegistry, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { AuthStorage, createAgentSession, SessionManager, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { createMemoryRuntime } from "@noopolis/mneme";
 import { resolvePiHarnessModel } from "./modelConfig.js";
-const createModelRegistry = (authStorage, options) => {
-    const registry = options.modelsPath
-        ? ModelRegistry.create(authStorage, options.modelsPath)
-        : ModelRegistry.inMemory(authStorage);
-    if (!options.modelsPath && options.model?.endpoint) {
-        const { modelsConfig } = resolvePiHarnessModel(options.model);
-        for (const [provider, config] of Object.entries(modelsConfig.providers)) {
-            registry.registerProvider(provider, {
-                api: config.api,
-                apiKey: config.apiKey,
-                baseUrl: config.baseUrl,
-                models: config.models
-            });
-        }
-    }
-    return registry;
-};
-class PiAgentHandle {
-    id;
-    session;
-    state = "idle";
-    lastWakeAt;
-    lastError;
-    constructor(id, session) {
-        this.id = id;
-        this.session = session;
-    }
-    async wake(event) {
-        const startedAt = Date.now();
-        const chunks = [];
-        this.state = "running";
-        this.lastWakeAt = new Date().toISOString();
-        this.lastError = undefined;
-        const unsubscribe = this.session.subscribe((piEvent) => {
-            if (piEvent.type !== "turn_end") {
-                return;
-            }
-            const message = piEvent.message;
-            const content = message.content;
-            if (typeof content === "string") {
-                chunks.push(content);
-            }
-            else if (Array.isArray(content)) {
-                chunks.push(content
-                    .filter((item) => {
-                    const candidate = item;
-                    return candidate.type === "text" && typeof candidate.text === "string";
-                })
-                    .map((item) => item.text)
-                    .join(""));
-            }
-        });
-        try {
-            await this.session.prompt(formatWakePrompt(event), { expandPromptTemplates: false });
-            this.state = "idle";
-            return {
-                agentId: this.id,
-                text: chunks.join("\n").trim(),
-                durationMs: Date.now() - startedAt
-            };
-        }
-        catch (error) {
-            this.state = "failed";
-            this.lastError = error instanceof Error ? error.message : String(error);
-            throw error;
-        }
-        finally {
-            unsubscribe();
-        }
-    }
-    status() {
-        return {
-            agentId: this.id,
-            state: this.state,
-            lastWakeAt: this.lastWakeAt,
-            lastError: this.lastError
-        };
-    }
-    async stop() {
-        this.session.dispose();
-        this.state = "stopped";
-    }
-}
-const formatWakePrompt = (event) => `Wake event:
-- id: ${event.id}
-- kind: ${event.kind}
-- from: ${event.from ?? "operator"}
-
-${event.text}`;
-const createResourceLoader = (input) => {
-    const systemPrompt = [
-        `You are ${input.name} (${input.id}).`,
-        input.instructions,
-        "You are running inside a harnessed workspace prepared by the caller.",
-        "Use the available coding tools when asked to read, write, edit, or inspect files.",
-        "Keep responses brief and report the exact files you created or modified."
-    ].join("\n\n");
-    return {
-        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
-        getSkills: () => ({ skills: [], diagnostics: [] }),
-        getPrompts: () => ({ prompts: [], diagnostics: [] }),
-        getThemes: () => ({ themes: [], diagnostics: [] }),
-        getAgentsFiles: () => ({ agentsFiles: [] }),
-        getSystemPrompt: () => systemPrompt,
-        getAppendSystemPrompt: () => [],
-        extendResources: () => { },
-        reload: async () => { }
-    };
-};
+import { createPiModelRegistry } from "./modelRegistry.js";
+import { createPiMemoryTools, piMemoryToolNames } from "./memoryTools.js";
+import { createResourceLoader } from "./prompts.js";
+import { PiAgentHandle } from "./piAgentHandle.js";
+import { createPiWorldTools, piWorldToolNames } from "./worldTools.js";
+import { bindPiRawTrainingCapture, validatePiRawTrainingCaptureOptions } from "./rawTrainingCapture.js";
 export class PiHarnessAdapter {
     options;
     authStorage;
     modelRegistry;
+    sessionFactory;
     constructor(options) {
         this.options = options;
         this.authStorage = AuthStorage.create(options.authPath);
-        this.modelRegistry = createModelRegistry(this.authStorage, options);
+        this.modelRegistry = createPiModelRegistry(this.authStorage, options);
+        this.sessionFactory = options.sessionFactory ?? createAgentSession;
     }
     async startAgent(input) {
+        validatePiRawTrainingCaptureOptions(this.options.rawTrainingCapture);
         await mkdir(input.runtimeHomePath, { recursive: true });
         await mkdir(input.workspacePath, { recursive: true });
+        const memoryRuntimeHomePath = this.options.memory?.runtimeHomePath ?? input.runtimeHomePath;
+        await mkdir(memoryRuntimeHomePath, { recursive: true });
         const modelSpec = this.options.model ?? {
             auth: { method: "codex" },
             provider: "openai",
@@ -133,21 +36,91 @@ export class PiHarnessAdapter {
         if (!model) {
             throw new Error(`Pi model not found: ${resolvedModel.provider}/${resolvedModel.name}`);
         }
-        const { session } = await createAgentSession({
-            cwd: input.workspacePath,
-            agentDir: input.runtimeHomePath,
-            authStorage: this.authStorage,
-            modelRegistry: this.modelRegistry,
-            model,
-            thinkingLevel: "off",
-            resourceLoader: createResourceLoader(input),
-            tools: input.tools ?? ["read", "write", "edit", "bash", "grep", "find", "ls"],
-            sessionManager: SessionManager.create(input.workspacePath, path.join(input.runtimeHomePath, "sessions")),
-            settingsManager: SettingsManager.inMemory({
-                compaction: { enabled: false },
-                retry: { enabled: true, maxRetries: 1 }
-            })
-        });
-        return new PiAgentHandle(input.id, session);
+        const memory = this.options.memory === undefined
+            ? undefined
+            : createMemoryRuntime({
+                agentId: input.id,
+                authority: this.options.memory.authority,
+                embeddingProvider: this.options.memory.embeddingProvider,
+                runtimeHomePath: memoryRuntimeHomePath,
+                source: this.options.memory.source,
+                tokenBudget: this.options.memory.tokenBudget
+            });
+        const memoryToolContext = memory === undefined ? undefined : {};
+        const worldToolContext = this.options.world === undefined ? undefined : {};
+        const rawTrainingCaptureRef = this.options.rawTrainingCapture === undefined ? undefined : {};
+        const sessionInput = (mode, sessionDirectory) => {
+            const memoryTools = memory === undefined || memoryToolContext === undefined
+                ? []
+                : createPiMemoryTools({
+                    agentId: input.id,
+                    memory,
+                    contextRef: memoryToolContext,
+                    mode
+                });
+            const worldTools = this.options.world === undefined
+                ? undefined
+                : createPiWorldTools({
+                    world: this.options.world,
+                    contextRef: worldToolContext
+                });
+            const toolNames = [
+                ...(input.tools ?? ["read", "write", "edit", "bash", "grep", "find", "ls"]),
+                ...piMemoryToolNames(memoryTools),
+                ...(worldTools === undefined ? [] : piWorldToolNames(worldTools))
+            ];
+            return {
+                cwd: input.workspacePath,
+                agentDir: input.runtimeHomePath,
+                daimonSecretEnvironmentNames: this.options.world === undefined ? [] : [this.options.world.tokenEnv],
+                authStorage: this.authStorage,
+                modelRegistry: this.modelRegistry,
+                model,
+                thinkingLevel: this.options.thinkingLevel ?? "off",
+                resourceLoader: createResourceLoader(input, mode, {
+                    memory: memory !== undefined,
+                    world: worldTools !== undefined
+                }),
+                tools: [...new Set(toolNames)],
+                customTools: worldTools === undefined ? memoryTools : [...memoryTools, ...worldTools],
+                sessionManager: SessionManager.create(input.workspacePath, sessionDirectory),
+                settingsManager: SettingsManager.inMemory({
+                    compaction: { enabled: false },
+                    retry: { enabled: true, maxRetries: 1 }
+                })
+            };
+        };
+        if (this.options.rawTrainingCapture !== undefined) {
+            const createSession = async (mode, sessionDirectory) => {
+                const { session } = await createAgentSession(sessionInput(mode, sessionDirectory));
+                if (rawTrainingCaptureRef !== undefined) {
+                    bindPiRawTrainingCapture(session, rawTrainingCaptureRef);
+                }
+                return session;
+            };
+            const session = await createSession("awake", path.join(input.runtimeHomePath, "sessions"));
+            return new PiAgentHandle(input.id, session, createSession, input.runtimeHomePath, {
+                authMethod: modelSpec.auth?.method ?? "none",
+                model: resolvedModel.name,
+                provider: resolvedModel.provider
+            }, memory, memoryToolContext, {}, worldToolContext, rawTrainingCaptureRef, this.options.rawTrainingCapture, worldToolContext === undefined
+                ? undefined
+                : { instructions: input.instructions, thinkingLevel: this.options.thinkingLevel ?? "off" }, session);
+        }
+        const createSession = async (mode, sessionDirectory) => {
+            const { session } = await (this.options.sessionFactory ?? createAgentSession)(sessionInput(mode, sessionDirectory));
+            return session;
+        };
+        const session = await createSession("awake", path.join(input.runtimeHomePath, "sessions"));
+        return new PiAgentHandle(input.id, session, createSession, input.runtimeHomePath, {
+            authMethod: modelSpec.auth?.method ?? "none",
+            model: resolvedModel.name,
+            provider: resolvedModel.provider
+        }, memory, memoryToolContext, {}, worldToolContext, undefined, undefined, worldToolContext === undefined
+            ? undefined
+            : {
+                instructions: input.instructions,
+                thinkingLevel: this.options.thinkingLevel ?? "off"
+            }, undefined);
     }
 }

package/dist/pi/prompts.d.ts

@@ -0,0 +1,9 @@
+import { type ResourceLoader } from "@earendil-works/pi-coding-agent";
+import { type MemoryWakeMode } from "@noopolis/mneme";
+import type { AgentStartInput, WakeEvent } from "../core/types.js";
+export declare const formatWakePrompt: (event: WakeEvent) => string;
+export declare const createResourceLoader: (input: AgentStartInput, mode: MemoryWakeMode, capabilities: Readonly<{
+    memory: boolean;
+    world: boolean;
+}>) => ResourceLoader;
+//# sourceMappingURL=prompts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/pi/prompts.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAEnE,eAAO,MAAM,gBAAgB,GAAI,OAAO,SAAS,KAAG,MAKtC,CAAC;AAEf,eAAO,MAAM,oBAAoB,GAC/B,OAAO,eAAe,EACtB,MAAM,cAAc,EACpB,cAAc,QAAQ,CAAC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC,KAC1D,cA+BF,CAAC"}

package/dist/pi/prompts.js

@@ -0,0 +1,39 @@
+import { createExtensionRuntime } from "@earendil-works/pi-coding-agent";
+import { getMemorySkillTextForMode } from "@noopolis/mneme";
+export const formatWakePrompt = (event) => `Wake event:
+- id: ${event.id}
+- kind: ${event.kind}
+- from: ${event.from === undefined ? "[no attribution supplied] (absence)" : JSON.stringify(event.from)}
+
+${event.text}`;
+export const createResourceLoader = (input, mode, capabilities) => {
+    const systemPrompt = [
+        `You are ${input.name} (${input.id}).`,
+        input.instructions,
+        "You are running inside a harnessed workspace prepared by the caller.",
+        ...(input.tools === undefined || input.tools.length > 0
+            ? [
+                "Use the available coding tools when asked to read, write, edit, or inspect files.",
+                "Keep responses brief and report the exact files you created or modified."
+            ]
+            : []),
+        ...(capabilities.memory ? [getMemorySkillTextForMode(mode)] : []),
+        ...(capabilities.world
+            ? [
+                "Use only the authenticated world tools and standing instructions to perceive and act. "
+                    + "The harness binds wake authority and request identity; choose only the sense, affordance, target, and typed action input exposed by tool schemas."
+            ]
+            : [])
+    ].filter((section) => section.length > 0).join("\n\n");
+    return {
+        getExtensions: () => ({ extensions: [], errors: [], runtime: createExtensionRuntime() }),
+        getSkills: () => ({ skills: [], diagnostics: [] }),
+        getPrompts: () => ({ prompts: [], diagnostics: [] }),
+        getThemes: () => ({ themes: [], diagnostics: [] }),
+        getAgentsFiles: () => ({ agentsFiles: [] }),
+        getSystemPrompt: () => systemPrompt,
+        getAppendSystemPrompt: () => [],
+        extendResources: () => { },
+        reload: async () => { }
+    };
+};

package/dist/pi/rawTrainingCapture.d.ts

@@ -0,0 +1,59 @@
+import type { createAgentSession } from "@earendil-works/pi-coding-agent";
+import type { PiWorldTurnContext } from "./worldNudge.js";
+export declare const PI_RAW_TRAINING_CAPTURE_SCHEMA: "daimon.pi.raw_training_capture.v2";
+export interface PiRawTrainingCaptureOptions {
+    enabled: true;
+    retention: {
+        maxTurns: number;
+    };
+}
+export interface PiRawTrainingCapture {
+    readonly events: string[];
+    readonly requests: Array<{
+        model: unknown;
+        payload: unknown;
+        requested_at: string;
+        response?: unknown;
+        response_at?: string;
+        sequence: number;
+    }>;
+}
+export interface PiRawTrainingCaptureRef {
+    current?: PiRawTrainingCapture;
+}
+type PiNativeSession = Awaited<ReturnType<typeof createAgentSession>>["session"];
+type PiRawTrainingSession = Pick<PiNativeSession, "agent" | "model" | "sessionFile" | "sessionId" | "thinkingLevel">;
+export interface PersistPiRawTrainingCaptureInput {
+    agentId: string;
+    capture: PiRawTrainingCapture;
+    completedAt: Date;
+    options: PiRawTrainingCaptureOptions;
+    runtimeHomePath: string;
+    session: PiRawTrainingSession;
+    startedAt: Date;
+    status: "completed" | "failed";
+    totalMs: number;
+    turnId: string;
+    world?: PiWorldTurnContext;
+}
+/**
+ * Installs a transparent recorder at Pi's native provider-payload seam.
+ *
+ * The recorder returns the exact result of any pre-existing hook, so enabling
+ * capture cannot alter the request sent to the model.
+ */
+export declare const bindPiRawTrainingCapture: (session: PiRawTrainingSession, ref: PiRawTrainingCaptureRef) => void;
+export declare const createPiRawTrainingCapture: () => PiRawTrainingCapture;
+export declare const capturePiRawTrainingEvent: (capture: PiRawTrainingCapture, event: unknown, now?: Date) => void;
+export declare const validatePiRawTrainingCaptureOptions: (options: PiRawTrainingCaptureOptions | undefined) => void;
+/**
+ * Persists a deliberately private, unredacted training artifact.
+ *
+ * `pi-session.jsonl` is copied byte-for-byte from Pi's SessionManager. The
+ * request payloads come from Pi AI's `onPayload` seam after any prior payload
+ * transform, so they contain the exact structured provider input, including
+ * system/character prompts, messages, tool schemas, and sampling fields.
+ */
+export declare const persistPiRawTrainingCapture: (input: PersistPiRawTrainingCaptureInput) => Promise<string>;
+export {};
+//# sourceMappingURL=rawTrainingCapture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rawTrainingCapture.d.ts","sourceRoot":"","sources":["../../src/pi/rawTrainingCapture.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAG1D,eAAO,MAAM,8BAA8B,EACzC,mCAA4C,CAAC;AAE/C,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,IAAI,CAAC;IACd,SAAS,EAAE;QACT,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC;QACvB,KAAK,EAAE,OAAO,CAAC;QACf,OAAO,EAAE,OAAO,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED,KAAK,eAAe,GAClB,OAAO,CAAC,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;AAC5D,KAAK,oBAAoB,GAAG,IAAI,CAC9B,eAAe,EACf,OAAO,GAAG,OAAO,GAAG,aAAa,GAAG,WAAW,GAAG,eAAe,CAClE,CAAC;AAEF,MAAM,WAAW,gCAAgC;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,WAAW,EAAE,IAAI,CAAC;IAClB,OAAO,EAAE,2BAA2B,CAAC;IACrC,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,SAAS,EAAE,IAAI,CAAC;IAChB,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAMD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,GACnC,SAAS,oBAAoB,EAC7B,KAAK,uBAAuB,KAC3B,IA4BF,CAAC;AAEF,eAAO,MAAM,0BAA0B,QAAO,oBAG5C,CAAC;AAEH,eAAO,MAAM,yBAAyB,GACpC,SAAS,oBAAoB,EAC7B,OAAO,OAAO,EACd,UAAgB,KACf,IAKF,CAAC;AAEF,eAAO,MAAM,mCAAmC,GAC9C,SAAS,2BAA2B,GAAG,SAAS,KAC/C,IAUF,CAAC;AAaF;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,GACtC,OAAO,gCAAgC,KACtC,OAAO,CAAC,MAAM,CAoIhB,CAAC"}

package/dist/pi/rawTrainingCapture.js

@@ -0,0 +1,175 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, readFile, readdir, rename, rm, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { sanitizeTraceFileId } from "./turnTrace.js";
+export const PI_RAW_TRAINING_CAPTURE_SCHEMA = "daimon.pi.raw_training_capture.v2";
+const json = (value) => JSON.stringify(value);
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+/**
+ * Installs a transparent recorder at Pi's native provider-payload seam.
+ *
+ * The recorder returns the exact result of any pre-existing hook, so enabling
+ * capture cannot alter the request sent to the model.
+ */
+export const bindPiRawTrainingCapture = (session, ref) => {
+    const previousPayload = session.agent.onPayload;
+    const previousResponse = session.agent.onResponse;
+    session.agent.onPayload = async (payload, model) => {
+        const transformed = await previousPayload?.(payload, model);
+        const effectivePayload = transformed === undefined ? payload : transformed;
+        const capture = ref.current;
+        if (capture !== undefined) {
+            capture.requests.push({
+                model: structuredClone(model),
+                payload: structuredClone(effectivePayload),
+                requested_at: new Date().toISOString(),
+                sequence: capture.requests.length
+            });
+        }
+        return transformed;
+    };
+    session.agent.onResponse = async (response, model) => {
+        await previousResponse?.(response, model);
+        const capture = ref.current;
+        const request = capture?.requests.at(-1);
+        if (request !== undefined) {
+            request.response = structuredClone(response);
+            request.response_at = new Date().toISOString();
+        }
+    };
+};
+export const createPiRawTrainingCapture = () => ({
+    events: [],
+    requests: []
+});
+export const capturePiRawTrainingEvent = (capture, event, now = new Date()) => {
+    // Serialize at event time so later mutation cannot change the captured event.
+    capture.events.push(`{"recorded_at":${json(now.toISOString())},"event":${json(event)}}`);
+};
+export const validatePiRawTrainingCaptureOptions = (options) => {
+    if (options === undefined)
+        return;
+    if (options.enabled !== true
+        || !Number.isSafeInteger(options.retention.maxTurns)
+        || options.retention.maxTurns < 1
+        || options.retention.maxTurns > 100_000) {
+        throw new Error("Pi raw training capture requires enabled: true and retention.maxTurns between 1 and 100000");
+    }
+};
+const pruneTurns = async (turnsPath, maxTurns) => {
+    const names = (await readdir(turnsPath, { withFileTypes: true }))
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name)
+        .sort();
+    await Promise.all(names.slice(0, Math.max(0, names.length - maxTurns))
+        .map((name) => rm(path.join(turnsPath, name), { force: true, recursive: true })));
+};
+/**
+ * Persists a deliberately private, unredacted training artifact.
+ *
+ * `pi-session.jsonl` is copied byte-for-byte from Pi's SessionManager. The
+ * request payloads come from Pi AI's `onPayload` seam after any prior payload
+ * transform, so they contain the exact structured provider input, including
+ * system/character prompts, messages, tool schemas, and sampling fields.
+ */
+export const persistPiRawTrainingCapture = async (input) => {
+    validatePiRawTrainingCaptureOptions(input.options);
+    if (input.session.sessionFile === undefined) {
+        throw new Error("Pi raw training capture requires a persisted native session");
+    }
+    const nativeSessionBytes = await readFile(input.session.sessionFile);
+    const privateTrainingPath = path.join(input.runtimeHomePath, "private-training");
+    const piPath = path.join(privateTrainingPath, "pi");
+    const root = path.join(piPath, "raw");
+    const turnsPath = path.join(root, "turns");
+    const turnPath = path.join(turnsPath, `${String(input.startedAt.getTime()).padStart(13, "0")}-${sanitizeTraceFileId(input.turnId)}`);
+    const partialTurnPath = path.join(turnsPath, `.partial-${path.basename(turnPath)}-${randomUUID()}`);
+    await mkdir(turnsPath, { mode: 0o700, recursive: true });
+    await Promise.all([privateTrainingPath, piPath, root, turnsPath]
+        .map((directory) => chmod(directory, 0o700)));
+    await mkdir(partialTurnPath, { mode: 0o700 });
+    const providerExchange = {
+        model: structuredClone(input.session.model),
+        requests: input.capture.requests,
+        session_id: input.session.sessionId,
+        thinking_level: input.session.thinkingLevel
+    };
+    const eventsBytes = Buffer.from(input.capture.events.length === 0 ? "" : `${input.capture.events.join("\n")}\n`, "utf8");
+    const providerExchangeBytes = Buffer.from(`${JSON.stringify(providerExchange, null, 2)}\n`, "utf8");
+    const manifest = {
+        access: {
+            classification: "private_raw_training",
+            export_by_default: false,
+            contains_unredacted_model_context: true
+        },
+        agent_id: input.agentId,
+        completed_at: input.completedAt.toISOString(),
+        files: {
+            events: "events.ndjson",
+            native_pi_session: "pi-session.jsonl",
+            provider_exchange: "provider-exchange.json"
+        },
+        integrity: {
+            capture_boundary: "post_turn",
+            files: {
+                events: {
+                    bytes: eventsBytes.byteLength,
+                    records: input.capture.events.length,
+                    sha256: sha256(eventsBytes)
+                },
+                native_pi_session: {
+                    bytes: nativeSessionBytes.byteLength,
+                    sha256: sha256(nativeSessionBytes)
+                },
+                provider_exchange: {
+                    bytes: providerExchangeBytes.byteLength,
+                    requests: input.capture.requests.length,
+                    sha256: sha256(providerExchangeBytes)
+                }
+            }
+        },
+        join: input.world === undefined ? undefined : {
+            run_id: input.world.runId,
+            tick: input.world.tick,
+            wake_id: input.world.wakeId
+        },
+        native_session: {
+            id: input.session.sessionId
+        },
+        retention: {
+            max_turns: input.options.retention.maxTurns
+        },
+        schema: PI_RAW_TRAINING_CAPTURE_SCHEMA,
+        started_at: input.startedAt.toISOString(),
+        terminal_status: input.status,
+        timings_ms: {
+            total: input.totalMs
+        },
+        turn_id: input.turnId
+    };
+    const files = [
+        "manifest.json",
+        "provider-exchange.json",
+        "events.ndjson",
+        "pi-session.jsonl"
+    ];
+    try {
+        await Promise.all([
+            writeFile(path.join(partialTurnPath, "manifest.json"), `${JSON.stringify(manifest, null, 2)}\n`, { encoding: "utf8", mode: 0o600 }),
+            writeFile(path.join(partialTurnPath, "provider-exchange.json"), providerExchangeBytes, { mode: 0o600 }),
+            writeFile(path.join(partialTurnPath, "events.ndjson"), eventsBytes, { mode: 0o600 }),
+            writeFile(path.join(partialTurnPath, "pi-session.jsonl"), nativeSessionBytes, { mode: 0o600 })
+        ]);
+        await Promise.all([
+            chmod(partialTurnPath, 0o700),
+            ...files.map((name) => chmod(path.join(partialTurnPath, name), 0o600))
+        ]);
+        await rename(partialTurnPath, turnPath);
+    }
+    catch (error) {
+        await rm(partialTurnPath, { force: true, recursive: true });
+        throw error;
+    }
+    await pruneTurns(turnsPath, input.options.retention.maxTurns);
+    return turnPath;
+};

package/dist/pi/turnCausal.d.ts

@@ -0,0 +1,73 @@
+import type { MemoryPrepareTurnResult } from "@noopolis/mneme";
+import type { WakeEvent } from "../core/types.js";
+import { type CausalEvent, type TurnInputSubmittedPayload, type TurnOutputCompletedPayload } from "../observability/causalEvents.js";
+/**
+ * Principal grammar per `specs/CAUSAL.md` §3
+ * (`^(agent|operator|system):.+`): the authenticated agent identity this
+ * harness instance was started under, never a bare id and never model
+ * output. See `stampTurnInputSubmitted`/`stampTurnOutputCompleted` below for
+ * why `agentId` itself is trustworthy at this layer.
+ */
+export declare const agentPrincipalId: (agentId: string) => string;
+export interface StampTurnInputSubmittedInput {
+    agentId: string;
+    event: WakeEvent;
+    prepared?: MemoryPrepareTurnResult;
+    promptText: string;
+    runtimeHomePath: string;
+}
+/**
+ * Stamps `turn.input.submitted` for one Pi turn, wiring piHarness's own
+ * variables into `@noopolis/daimon`'s causal envelope (`../observability/
+ * causalEvents.ts`).
+ *
+ * - `principal_id` is `agent:<agentId>` (`agentPrincipalId`, per the
+ *   `specs/CAUSAL.md` §3 principal grammar). `src/pi/auth.ts` scopes LLM
+ *   provider auth (Codex / Claude / API key) per harness instance rather
+ *   than exposing a separate network identity token, so `agentId` — the
+ *   identity this harness instance was started under (`AgentStartInput.id`,
+ *   which also scopes its own `authPath`/`runtimeHomePath`) — is the
+ *   truthful authenticated identity available at this layer.
+ * - `cause_event_ids` chains to `event.id` (the WakeEvent id) plus any mneme
+ *   recall ids from `prepared.recalledCausalEventIds`. `event.id` is no
+ *   longer a same-process stand-in for the upstream moltnet
+ *   `message.accepted` id: moltnet's bridge control POST now carries a real
+ *   `event_id` (`protocol.MessageEventID`-shaped, `"moltnet:<messageID>"`)
+ *   for every non-bootstrap wake, and the Pi control source
+ *   (`src/runtime/pi/appControlSource.ts` `formatControlEventId`) threads
+ *   that value verbatim into `WakeEvent.id` in preference to its own
+ *   `context_id`+timestamp fallback. `WakeEvent` still does not carry a
+ *   separately namespaced moltnet field — Daimon stays detached from
+ *   Moltnet wiring (see repo `AGENTS.md`) — but `event.id` is now the same
+ *   id moltnet itself stamped on `message.accepted`, so this chain is
+ *   id-joined across authorities rather than merely locally consistent.
+ *   `prepared.recalledCausalEventIds` (not `prepared.recall.selectedEventIds`)
+ *   for the same reason: `recall.selectedEventIds` are mneme's raw
+ *   kernel-log recall ids (`evt_<...>`), a different id namespace than the
+ *   `mneme:<uuid>` ids mneme's own `memory.recalled` causal events are
+ *   stamped under (`contract/causal.ts` `mnemeCausalEventId`). Chaining the
+ *   raw recall id would never resolve against mneme's causal stream; the
+ *   `recalledCausalEventIds` mneme exposes on `MemoryPrepareTurnResult` are
+ *   the actual `event_id`s of the `memory.recalled` events it appended for
+ *   this turn, so this cause link is id-joined the same way the moltnet
+ *   link above is.
+ * - `run_id` always comes from `resolveRunId()` (`NOOPOLIS_RUN_ID`), never
+ *   from `event` or model output.
+ */
+export declare const stampTurnInputSubmitted: (input: StampTurnInputSubmittedInput) => Promise<CausalEvent<TurnInputSubmittedPayload>>;
+export interface StampTurnOutputCompletedInput {
+    agentId: string;
+    causeEventId: string;
+    outputText: string;
+    runtimeHomePath: string;
+    turnId: string;
+}
+/**
+ * Stamps `turn.output.completed` once a Pi turn finishes successfully,
+ * chained back via `cause_event_ids` to the `turn.input.submitted` id for
+ * the same turn. `output_sha256` is over the harness-extracted reply text;
+ * the model has no path to influence `cause_event_ids`, `run_id`, or
+ * `principal_id` here.
+ */
+export declare const stampTurnOutputCompleted: (input: StampTurnOutputCompletedInput) => Promise<CausalEvent<TurnOutputCompletedPayload>>;
+//# sourceMappingURL=turnCausal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"turnCausal.d.ts","sourceRoot":"","sources":["../../src/pi/turnCausal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,yBAAyB,EAC9B,KAAK,0BAA0B,EAChC,MAAM,kCAAkC,CAAC;AAG1C;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,MAAM,KAAG,MAA4B,CAAC;AAEhF,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,SAAS,CAAC;IACjB,QAAQ,CAAC,EAAE,uBAAuB,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,4BAA4B,KAClC,OAAO,CAAC,WAAW,CAAC,yBAAyB,CAAC,CAW7C,CAAC;AAEL,MAAM,WAAW,6BAA6B;IAC5C,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,GACnC,OAAO,6BAA6B,KACnC,OAAO,CAAC,WAAW,CAAC,0BAA0B,CAAC,CAS9C,CAAC"}