@noopolis/daimon 0.1.1 → 0.1.2

package/dist/pi/piHarness.js

@@ -1,228 +1,14 @@
 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";
+import { createPiModelRegistry } from "./modelRegistry.js";
 import { createPiMemoryTools, piMemoryToolNames } from "./memoryTools.js";
-import { createMemoryRuntime, memoryScopeId, readMemoryContext } from "@noopolis/mneme";
-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;
-};
-const fallbackPacket = (input) => ({
-    principal: {
-        agentId: "unknown",
-        scope: "global"
-    },
-    sections: [{ heading: "Wake event", text: formatWakePrompt(input) }],
-    rawHint: "memory bypass active"
-});
-const extractOutputText = (chunks) => chunks.join("\n").trim();
-class PiAgentHandle {
-    id;
-    session;
-    memory;
-    memoryToolContext;
-    state = "idle";
-    lastWakeAt;
-    lastError;
-    wakeQueue = Promise.resolve();
-    constructor(id, session, memory, memoryToolContext) {
-        this.id = id;
-        this.session = session;
-        this.memory = memory;
-        this.memoryToolContext = memoryToolContext;
-    }
-    async wake(event) {
-        const queued = this.wakeQueue.then(() => this.runWake(event), () => this.runWake(event));
-        this.wakeQueue = queued.then(() => undefined, () => undefined);
-        return queued;
-    }
-    async runWake(event) {
-        const startedAt = Date.now();
-        const chunks = [];
-        const toolEvents = [];
-        this.state = "running";
-        this.lastWakeAt = new Date().toISOString();
-        this.lastError = undefined;
-        const unsubscribe = this.session.subscribe((piEvent) => {
-            if (piEvent && typeof piEvent === "object" && "type" in piEvent && piEvent.type !== "turn_end") {
-                toolEvents.push(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(""));
-            }
-        });
-        const memoryContext = readMemoryContext({
-            kind: event.kind,
-            id: event.id,
-            from: event.from,
-            text: event.text,
-            context: event.context
-        });
-        const request = {
-            eventId: event.id,
-            kind: event.kind,
-            text: event.text,
-            from: event.from,
-            context: memoryContext
-        };
-        let prepared;
-        let promptText = formatWakePrompt(event);
-        try {
-            if (this.memory) {
-                prepared = await this.memory.prepareTurn(request);
-                promptText = prepared.promptText;
-                if (this.memoryToolContext) {
-                    this.memoryToolContext.current = {
-                        wakeId: event.id,
-                        threadId: `${memoryContext.networkId ?? "local"}:${memoryContext.roomId ?? event.from ?? "manual"}`,
-                        principal: prepared.principal,
-                        conversationScope: memoryScopeId(prepared.principal),
-                        audienceKey: memoryContext.roomId ?? event.from ?? this.id,
-                        transport: "in_process"
-                    };
-                }
-            }
-            await this.session.prompt(promptText, { expandPromptTemplates: false });
-            this.state = "idle";
-            const outputText = extractOutputText(chunks);
-            if (this.memory) {
-                const promptPacket = prepared?.packet ?? fallbackPacket(event);
-                await this.memory.recordTurn({
-                    principal: {
-                        agentId: this.id,
-                        scope: prepared?.principal.scope ?? "global",
-                        qualifier: prepared?.principal.qualifier
-                    },
-                    prompt: {
-                        ...promptPacket,
-                        principal: {
-                            agentId: this.id,
-                            scope: prepared?.principal.scope ?? "global",
-                            qualifier: prepared?.principal.qualifier
-                        }
-                    },
-                    request,
-                    recall: prepared?.recall,
-                    result: "completed",
-                    outputText,
-                    toolEvents
-                });
-            }
-            return {
-                agentId: this.id,
-                text: outputText,
-                durationMs: Date.now() - startedAt
-            };
-        }
-        catch (error) {
-            this.state = "failed";
-            this.lastError = error instanceof Error ? error.message : String(error);
-            if (this.memory) {
-                try {
-                    const promptPacket = prepared?.packet ?? fallbackPacket(event);
-                    await this.memory.recordTurn({
-                        principal: {
-                            agentId: this.id,
-                            scope: prepared?.principal.scope ?? "global",
-                            qualifier: prepared?.principal.qualifier
-                        },
-                        prompt: {
-                            ...promptPacket,
-                            principal: {
-                                agentId: this.id,
-                                scope: prepared?.principal.scope ?? "global",
-                                qualifier: prepared?.principal.qualifier
-                            }
-                        },
-                        request,
-                        recall: prepared?.recall,
-                        result: "failed",
-                        outputText: extractOutputText(chunks),
-                        toolEvents,
-                        error: this.lastError
-                    });
-                }
-                catch {
-                    // Memory write-back is best-effort when waking fails.
-                }
-            }
-            throw error;
-        }
-        finally {
-            if (this.memoryToolContext) {
-                this.memoryToolContext.current = undefined;
-            }
-            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.",
-        "Use memory_search, memory_locate, memory_register, memory_summarize, and memory_forget when scoped memory matters.",
-        "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 { 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;
@@ -231,12 +17,15 @@ export class PiHarnessAdapter {
     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",
@@ -247,38 +36,91 @@ export class PiHarnessAdapter {
         if (!model) {
             throw new Error(`Pi model not found: ${resolvedModel.provider}/${resolvedModel.name}`);
         }
-        const memory = createMemoryRuntime({
-            agentId: input.id,
-            runtimeHomePath: input.runtimeHomePath,
-            source: this.options.memory?.source,
-            tokenBudget: this.options.memory?.tokenBudget
-        });
-        const memoryToolContext = {};
-        const memoryTools = createPiMemoryTools({
-            agentId: input.id,
-            memory,
-            contextRef: memoryToolContext
-        });
-        const toolNames = [
-            ...(input.tools ?? ["read", "write", "edit", "bash", "grep", "find", "ls"]),
-            ...piMemoryToolNames(memoryTools)
-        ];
-        const { session } = await this.sessionFactory({
-            cwd: input.workspacePath,
-            agentDir: input.runtimeHomePath,
-            authStorage: this.authStorage,
-            modelRegistry: this.modelRegistry,
-            model,
-            thinkingLevel: "off",
-            resourceLoader: createResourceLoader(input),
-            tools: [...new Set(toolNames)],
-            customTools: memoryTools,
-            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, memory, memoryToolContext);
+        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;
+};