@noopolis/daimon 0.1.1 → 0.2.0

package/dist/pi/piHarness.js

@@ -1,228 +1,16 @@
 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, createBashTool, 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 { DAIMON_WAKE_ID_ENV } from "./cliEnvironment.js";
+import { createPiWorldTools, piWorldToolNames } from "./worldTools.js";
+import { ensureRuntimeHome, ensureRuntimeHomeDirectory } from "../runtime/runtimeHomeLayout.js";
+import { bindPiRawTrainingCapture, validatePiRawTrainingCaptureOptions } from "./rawTrainingCapture.js";
 export class PiHarnessAdapter {
     options;
     authStorage;
@@ -231,12 +19,17 @@ 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) {
-        await mkdir(input.runtimeHomePath, { recursive: true });
+        validatePiRawTrainingCaptureOptions(this.options.rawTrainingCapture);
+        await ensureRuntimeHome(input.runtimeHomePath);
+        await Promise.all([".config", ".local/share", ".local/state", ".cache", ".tmp", "tool-state"]
+            .map((relative) => ensureRuntimeHomeDirectory(input.runtimeHomePath, relative)));
         await mkdir(input.workspacePath, { recursive: true });
+        const memoryRuntimeHomePath = this.options.memory?.runtimeHomePath ?? input.runtimeHomePath;
+        await ensureRuntimeHome(memoryRuntimeHomePath);
         const modelSpec = this.options.model ?? {
             auth: { method: "codex" },
             provider: "openai",
@@ -247,38 +40,140 @@ 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 wakeEnvironmentContext = this.options.wakeEnvironmentContext ?? {};
+        // Fixed for the life of this agent, not per wake: whether it can publish
+        // through `moltnet_send` at all. Gates the terminal-text fallback in
+        // `PiAgentHandle.runWake` (see `PiWakeEnvironmentContextRef.hasSendCapability`).
+        wakeEnvironmentContext.hasSendCapability = (this.options.productionTools ?? []).some((tool) => tool.name === "moltnet_send");
+        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
+                });
+            // Every child tool inherits the same denylist: host control values,
+            // Daimon-held world/model secrets, and caller-protected names.
+            const protectedNames = [...new Set([
+                    ...(this.options.protectedEnvironmentNames ?? []),
+                    ...(this.options.world === undefined ? [] : [this.options.world.tokenEnv])
+                ])];
+            const requestedTools = this.options.toolNames ?? input.tools;
+            const protectedBash = protectedNames.length === 0 || requestedTools?.includes("bash") === false
+                ? []
+                : [createProtectedBashTool(input.workspacePath, input.runtimeHomePath, protectedNames, wakeEnvironmentContext)];
+            const toolNames = [
+                ...(requestedTools ?? ["read", "write", "edit", "bash", "grep", "find", "ls"]),
+                ...piMemoryToolNames(memoryTools),
+                ...(worldTools === undefined ? [] : piWorldToolNames(worldTools)),
+                ...(this.options.productionTools ?? []).map((tool) => tool.name)
+            ];
+            return {
+                cwd: input.workspacePath,
+                agentDir: input.runtimeHomePath,
+                runtimeHomePath: 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
+                    ? [...protectedBash, ...memoryTools, ...(this.options.productionTools ?? [])]
+                    : [...protectedBash, ...memoryTools, ...worldTools, ...(this.options.productionTools ?? [])],
+                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, wakeEnvironmentContext);
+        }
+        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, wakeEnvironmentContext);
     }
 }
+function createProtectedBashTool(workspacePath, runtimeHomePath, protectedNames, wakeEnvironmentContext) {
+    const bash = createBashTool(workspacePath, {
+        spawnHook: (context) => ({
+            ...context,
+            env: {
+                ...Object.fromEntries(Object.entries(context.env).filter(([name]) => !protectedNames.includes(name))),
+                HOME: runtimeHomePath,
+                XDG_CONFIG_HOME: `${runtimeHomePath}/.config`,
+                XDG_DATA_HOME: `${runtimeHomePath}/.local/share`,
+                XDG_STATE_HOME: `${runtimeHomePath}/.local/state`,
+                XDG_CACHE_HOME: `${runtimeHomePath}/.cache`,
+                TMPDIR: `${runtimeHomePath}/.tmp`,
+                ...(wakeEnvironmentContext.current === undefined
+                    ? {}
+                    : { [DAIMON_WAKE_ID_ENV]: wakeEnvironmentContext.current })
+            }
+        })
+    });
+    return {
+        name: bash.name,
+        label: bash.label,
+        description: bash.description,
+        parameters: bash.parameters,
+        ...(bash.prepareArguments === undefined ? {} : { prepareArguments: bash.prepareArguments }),
+        ...(bash.executionMode === undefined ? {} : { executionMode: bash.executionMode }),
+        async execute(toolCallId, params, signal, onUpdate) {
+            return bash.execute(toolCallId, params, signal, onUpdate);
+        }
+    };
+}

package/dist/pi/prompts.d.ts

@@ -0,0 +1,10 @@
+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 preserveModelFacingWakeIdentity: (promptText: string, event: WakeEvent, memoryEventId: string) => 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;AAYf,eAAO,MAAM,+BAA+B,GAC1C,YAAY,MAAM,EAClB,OAAO,SAAS,EAChB,eAAe,MAAM,KACpB,MAiBF,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,63 @@
+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}`;
+const WAKE_HEADER_PATTERN = /(^|\r?\n)## Wake\r?\nid: ([^\r\n]*)(?=\r?\n|$)/u;
+const formatAuthoritativeWakeIdentity = (event) => [
+    "Wake identity:",
+    "Use this exact wake id as the delivery id/event key when a tool asks for event_key.",
+    `- id: ${event.id}`,
+    `- kind: ${event.kind}`,
+    `- from: ${event.from === undefined ? "[no attribution supplied] (absence)" : JSON.stringify(event.from)}`
+].join("\n");
+export const preserveModelFacingWakeIdentity = (promptText, event, memoryEventId) => {
+    if (event.id === memoryEventId)
+        return promptText;
+    const match = WAKE_HEADER_PATTERN.exec(promptText);
+    if (match === null) {
+        return `${formatAuthoritativeWakeIdentity(event)}\n\n${promptText}`;
+    }
+    const currentId = match[2];
+    if (currentId === event.id)
+        return promptText;
+    if (currentId !== memoryEventId) {
+        throw new Error("memory-prepared wake prompt carried an unexpected wake id");
+    }
+    const idStart = match.index + match[0].length - currentId.length;
+    return `${promptText.slice(0, idStart)}${event.id}${promptText.slice(idStart + currentId.length)}`;
+};
+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"}