@noopolis/daimon 0.1.1 → 0.2.0

package/dist/pi/memoryTools.js

@@ -1,35 +1,122 @@
 import { Type } from "@earendil-works/pi-ai";
 import { defineTool } from "@earendil-works/pi-coding-agent";
-import { createMemoryToolDescriptors } from "@noopolis/mneme";
-const fallbackContext = (agentId) => ({
-    wakeId: "manual",
-    threadId: "manual",
-    principal: { agentId, scope: "global" },
-    conversationScope: "global",
-    audienceKey: agentId,
-    transport: "in_process"
-});
+import { canonicalScopeKey, createMemoryToolDescriptors, memoryScopeId, schemaForModelToolName } from "@noopolis/mneme";
+const MAX_ALLOWED_SCOPES = 32;
+const MEMORY_PRINCIPAL_SCOPES = new Set([
+    "artifact",
+    "global",
+    "pair",
+    "role",
+    "room",
+    "task",
+    "team"
+]);
+const trustedAllowedScopes = (agentId, prepared) => {
+    if (!Array.isArray(prepared.allowedScopes)
+        || prepared.allowedScopes.length === 0
+        || prepared.allowedScopes.length > MAX_ALLOWED_SCOPES) {
+        throw new Error("prepared memory turn requires a bounded finite scope set");
+    }
+    const scopes = prepared.allowedScopes.map((scope) => {
+        if (typeof scope !== "string" || scope !== canonicalScopeKey(scope)
+            || scope.length > 512 || /[\u0000-\u001f\u007f]/u.test(scope)) {
+            throw new Error("prepared memory turn contains an invalid scope");
+        }
+        return scope;
+    });
+    const agentPrefix = canonicalScopeKey(`agent:${agentId}/scope:`);
+    if (new Set(scopes).size !== scopes.length || scopes.some((scope) => !scope.startsWith(agentPrefix))) {
+        throw new Error("prepared memory turn contains a foreign or duplicate scope");
+    }
+    const activeScope = canonicalScopeKey(memoryScopeId(prepared.principal));
+    if (!scopes.includes(activeScope)) {
+        throw new Error("prepared memory turn omits its active principal scope");
+    }
+    return Object.freeze([...scopes]);
+};
+export const createTrustedPiMemoryToolContext = (input) => {
+    if (input.prepared.principal.agentId !== input.agentId
+        || input.memory.authority.bankId !== input.agentId) {
+        throw new Error("prepared memory authority does not match the Pi agent");
+    }
+    if (!MEMORY_PRINCIPAL_SCOPES.has(input.prepared.principal.scope)) {
+        throw new Error("prepared memory turn contains an invalid principal scope");
+    }
+    const principal = Object.freeze({ ...input.prepared.principal });
+    const activeScope = canonicalScopeKey(memoryScopeId(principal));
+    return Object.freeze({
+        allowedScopes: trustedAllowedScopes(input.agentId, input.prepared),
+        audienceKey: activeScope,
+        authority: input.memory.authority,
+        conversationScope: activeScope,
+        mode: input.mode,
+        principal,
+        threadId: input.threadId,
+        transport: "in_process",
+        wakeId: input.wakeId
+    });
+};
+const requireTrustedContext = (agentId, contextRef) => {
+    const context = contextRef.current;
+    if (context === undefined
+        || context.principal.agentId !== agentId
+        || context.authority?.bankId !== agentId
+        || !Array.isArray(context.allowedScopes)) {
+        throw new Error("Pi memory tool requires the active trusted turn context");
+    }
+    return context;
+};
 const textContent = (result) => ({
     content: [{ type: "text", text: JSON.stringify(result) }],
     details: result
 });
+export function canonicalToolFieldNames(name, representation) {
+    const source = arguments.length >= 2 ? representation : schemaForModelToolName(name);
+    if (source !== null && typeof source === "object") {
+        const candidate = source;
+        const fields = candidate.shape !== undefined ? candidate.shape : source;
+        if (fields !== null && typeof fields === "object" && !Array.isArray(fields)) {
+            const names = Object.keys(fields);
+            if (names.length > 0) {
+                return names;
+            }
+        }
+    }
+    throw new Error(`@noopolis/mneme returned no usable field contract for memory tool ${name}`);
+}
+export const MEMORY_TOOL_ARGUMENT_FIELDS = Object.fromEntries(createMemoryToolDescriptors({}, { mode: "dream" })
+    .map(({ modelName }) => [modelName, new Set(canonicalToolFieldNames(modelName))]));
+const requireExactModelArguments = (toolName, params) => {
+    if (typeof params !== "object" || params === null || Array.isArray(params)) {
+        throw new Error("Pi memory tool arguments must be an object");
+    }
+    const allowed = MEMORY_TOOL_ARGUMENT_FIELDS[toolName];
+    if (allowed === undefined) {
+        throw new Error(`Pi memory tool ${toolName} has no argument contract`);
+    }
+    for (const field of Reflect.ownKeys(params)) {
+        if (typeof field !== "string" || !allowed.has(field)) {
+            throw new Error(`Pi memory tool ${toolName} received unexpected top-level argument ${String(field)}`);
+        }
+    }
+};
 const contentSchema = Type.Object({
     kind: Type.String({ description: "Memory content kind: text, claim, decision, artifact, or relationship." })
 }, { additionalProperties: true });
-const schemaFor = (name) => {
+export const schemaFor = (name) => {
     if (name === "memory_search") {
         return Type.Object({
             scope: Type.String({ description: "Scope alias or canonical scope id. Use current, global, or all when appropriate." }),
             query: Type.String({ description: "Search query." }),
             limit: Type.Optional(Type.Number({ description: "Maximum result count." }))
-        });
+        }, { additionalProperties: false });
     }
     if (name === "memory_locate") {
         return Type.Object({
             query: Type.String({ description: "What to locate in memory." }),
             limit: Type.Optional(Type.Number({ description: "Maximum candidate count." })),
             active_scope: Type.Optional(Type.String({ description: "Optional active scope hint." }))
-        });
+        }, { additionalProperties: false });
     }
     if (name === "memory_register") {
         return Type.Object({
@@ -38,24 +125,34 @@ const schemaFor = (name) => {
             content: contentSchema,
             visibility: Type.String({ description: "private, pair, team, room, global, public, or sealed." }),
             sensitivity: Type.String({ description: "normal, sensitive, or secret." }),
-            evidence_event_ids: Type.Array(Type.String(), { description: "Event ids that justify the memory." }),
             source_type: Type.String({ description: "Source label for the registered memory." }),
-            confidence: Type.Optional(Type.Number({ description: "Confidence from 0 to 1." }))
-        });
+            confidence: Type.Optional(Type.Number({ description: "Confidence from 0 to 1." })),
+            memory_id: Type.Optional(Type.String({ description: "Existing memory chain id for a new revision." }))
+        }, { additionalProperties: false });
     }
     if (name === "memory_summarize") {
         return Type.Object({
             scope: Type.String({ description: "Scope alias or canonical scope id to summarize." }),
             horizon: Type.Optional(Type.Number({ description: "Approximate number of recent memories to include." }))
-        });
+        }, { additionalProperties: false });
     }
-    return Type.Object({
-        scope: Type.String({ description: "Scope alias or canonical scope id for the tombstone." }),
-        event_ids: Type.Array(Type.String(), { description: "Memory event ids to tombstone." }),
-        reason: Type.Optional(Type.String({ description: "Why these memories should be forgotten." }))
-    });
+    if (name === "memory_promote") {
+        return Type.Object({
+            scope: Type.String({ description: "Scope alias or canonical scope id the memory belongs to." }),
+            memory_id: Type.String({ description: "Current memory chain head to promote." }),
+            reason: Type.Optional(Type.String({ description: "Why this memory is being promoted." }))
+        }, { additionalProperties: false });
+    }
+    if (name === "memory_forget") {
+        return Type.Object({
+            scope: Type.String({ description: "Scope alias or canonical scope id for the tombstone." }),
+            event_ids: Type.Array(Type.String(), { description: "Memory event ids to tombstone." }),
+            reason: Type.Optional(Type.String({ description: "Why these memories should be forgotten." }))
+        }, { additionalProperties: false });
+    }
+    throw new Error(`Unknown Pi memory tool: ${name}`);
 };
-export const createPiMemoryTools = (input) => createMemoryToolDescriptors(input.memory.kernel).map((descriptor) => defineTool({
+export const createPiMemoryTools = (input) => createMemoryToolDescriptors(input.memory.kernel, { mode: input.mode ?? "awake" }).map((descriptor) => defineTool({
     name: descriptor.modelName,
     label: descriptor.label,
     description: descriptor.description,
@@ -63,8 +160,31 @@ export const createPiMemoryTools = (input) => createMemoryToolDescriptors(input.
     promptGuidelines: descriptor.promptGuidelines,
     parameters: schemaFor(descriptor.modelName),
     async execute(_toolCallId, params) {
-        const result = await descriptor.invoke(params, input.contextRef.current ?? fallbackContext(input.agentId));
-        return textContent(result);
+        const startedAt = Date.now();
+        try {
+            requireExactModelArguments(descriptor.modelName, params);
+            const result = await descriptor.invoke(params, requireTrustedContext(input.agentId, input.contextRef));
+            input.contextRef.observeTool?.({
+                contentCount: result.content.length,
+                decision: result.decision,
+                durationMs: Date.now() - startedAt,
+                kind: "memory",
+                name: descriptor.modelName,
+                redactionCount: result.content.reduce((total, content) => total + content.redactions.length, 0),
+                status: "completed"
+            });
+            return textContent(result);
+        }
+        catch (error) {
+            input.contextRef.observeTool?.({
+                durationMs: Date.now() - startedAt,
+                error: error instanceof Error ? error.message : String(error),
+                kind: "memory",
+                name: descriptor.modelName,
+                status: "failed"
+            });
+            throw error;
+        }
     }
 }));
 export const piMemoryToolNames = (tools) => tools.map((tool) => tool.name);

package/dist/pi/modelRegistry.d.ts

@@ -0,0 +1,13 @@
+import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
+import type { HarnessModelSpec } from "../core/types.js";
+export interface PiModelRegistryOptions {
+    model?: {
+        auth?: HarnessModelSpec["auth"];
+        endpoint?: HarnessModelSpec["endpoint"];
+        provider: string;
+        name: string;
+    };
+    modelsPath?: string;
+}
+export declare const createPiModelRegistry: (authStorage: AuthStorage, options: PiModelRegistryOptions) => ModelRegistry;
+//# sourceMappingURL=modelRegistry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"modelRegistry.d.ts","sourceRoot":"","sources":["../../src/pi/modelRegistry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,aAAa,EACd,MAAM,iCAAiC,CAAC;AAEzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAIzD,MAAM,WAAW,sBAAsB;IACrC,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;QAChC,QAAQ,CAAC,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAC;QACxC,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,qBAAqB,GAChC,aAAa,WAAW,EACxB,SAAS,sBAAsB,KAC9B,aAkBF,CAAC"}

package/dist/pi/modelRegistry.js

@@ -0,0 +1,19 @@
+import { ModelRegistry } from "@earendil-works/pi-coding-agent";
+import { resolvePiHarnessModel } from "./modelConfig.js";
+export const createPiModelRegistry = (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;
+};

package/dist/pi/piAgentHandle.d.ts

@@ -0,0 +1,46 @@
+import type { AgentHandle, AgentStatus, WakeEvent, WakeResult } from "../core/types.js";
+import { type PiMemoryToolContextRef } from "./memoryTools.js";
+import { stampTurnInputSubmitted, stampTurnOutputCompleted } from "./turnCausal.js";
+import { type WakeAcceptanceStoreLike } from "./wakeAcceptance.js";
+import { persistPiTurnTrace, type PiTurnTraceModel } from "./turnTrace.js";
+import { type PiRawTrainingCaptureOptions, type PiRawTrainingCaptureRef } from "./rawTrainingCapture.js";
+import { type PiWorldToolContextRef } from "./worldNudge.js";
+import { type PiWorldTrajectoryIdentity } from "./worldTrajectory.js";
+import { type PiNativeSessionCreator, type PiSession, type PiSessionCreator, type PiSessionLike, type PiWakeEnvironmentContextRef } from "./piAgentWakeSupport.js";
+import { type MemoryRuntime } from "@noopolis/mneme";
+export type { PiSession, PiSessionLike, PiSessionCreator, PiNativeSessionCreator } from "./piAgentWakeSupport.js";
+export type WakeAcceptanceInput = {
+    runWake?: typeof stampTurnInputSubmitted;
+    completeTurn?: typeof stampTurnOutputCompleted;
+    traceTurn?: typeof persistPiTurnTrace;
+    createWakeAcceptance?: (runtimeHomePath: string, agentId: string) => WakeAcceptanceStoreLike;
+};
+export declare class PiAgentHandle implements AgentHandle {
+    readonly id: string;
+    private readonly session;
+    private readonly createSession;
+    private readonly runtimeHomePath;
+    private readonly traceModel;
+    private readonly memory?;
+    private readonly memoryToolContext?;
+    private readonly worldToolContext?;
+    private readonly rawTrainingCaptureRef?;
+    private readonly rawTrainingCaptureOptions?;
+    private readonly worldTrajectoryIdentity?;
+    private readonly piSessionForRawCapture?;
+    private readonly wakeEnvironmentContext?;
+    private state;
+    private lastWakeAt;
+    private lastError;
+    private readonly wakeDeliveryQueue;
+    private readonly stampTurnInputSubmitted;
+    private readonly stampTurnOutputCompleted;
+    private readonly persistTrace;
+    constructor(id: string, session: PiSession, createSession: PiNativeSessionCreator, runtimeHomePath: string, traceModel: PiTurnTraceModel, memory?: MemoryRuntime, memoryToolContext?: PiMemoryToolContextRef, dependencies?: WakeAcceptanceInput, worldToolContext?: PiWorldToolContextRef, rawTrainingCaptureRef?: PiRawTrainingCaptureRef, rawTrainingCaptureOptions?: PiRawTrainingCaptureOptions, worldTrajectoryIdentity?: PiWorldTrajectoryIdentity, rawTrainingCaptureSession?: PiSession, wakeEnvironmentContext?: PiWakeEnvironmentContextRef);
+    constructor(id: string, session: PiSessionLike, createSession: PiSessionCreator, runtimeHomePath: string, traceModel: PiTurnTraceModel, memory?: MemoryRuntime, memoryToolContext?: PiMemoryToolContextRef, dependencies?: WakeAcceptanceInput, worldToolContext?: PiWorldToolContextRef, rawTrainingCaptureRef?: never, rawTrainingCaptureOptions?: never, worldTrajectoryIdentity?: PiWorldTrajectoryIdentity, rawTrainingCaptureSession?: never, wakeEnvironmentContext?: PiWakeEnvironmentContextRef);
+    wake(event: WakeEvent): Promise<WakeResult>;
+    private runWake;
+    status(): AgentStatus;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=piAgentHandle.d.ts.map

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

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

package/dist/pi/piAgentHandle.js

@@ -0,0 +1,351 @@
+import { createTrustedPiMemoryToolContext } from "./memoryTools.js";
+import { formatWakePrompt, preserveModelFacingWakeIdentity } from "./prompts.js";
+import { stampTurnInputSubmitted, stampTurnOutputCompleted } from "./turnCausal.js";
+import { WakeAcceptanceStore } from "./wakeAcceptance.js";
+import { persistPiTurnTrace } from "./turnTrace.js";
+import { formatDreamPrompt } from "./wakeModes.js";
+import { createPiRawTrainingCapture } from "./rawTrainingCapture.js";
+import { formatWorldWakePrompt, worldWakeContext } from "./worldNudge.js";
+import { createPiWorldTrajectoryCapture } from "./worldTrajectory.js";
+import { cloneWakeEvent, disposePiSession, persistPiTurnArtifacts, PiWakeDeliveryQueue, selectPiSessionForWake, subscribeToPiTurnEvents } from "./piAgentWakeSupport.js";
+import { readMemoryContext } from "@noopolis/mneme";
+export class PiAgentHandle {
+    id;
+    session;
+    createSession;
+    runtimeHomePath;
+    traceModel;
+    memory;
+    memoryToolContext;
+    worldToolContext;
+    rawTrainingCaptureRef;
+    rawTrainingCaptureOptions;
+    worldTrajectoryIdentity;
+    piSessionForRawCapture;
+    wakeEnvironmentContext;
+    state = "idle";
+    lastWakeAt;
+    lastError;
+    wakeDeliveryQueue;
+    stampTurnInputSubmitted;
+    stampTurnOutputCompleted;
+    persistTrace;
+    constructor(id, session, createSession, runtimeHomePath, traceModel, memory, memoryToolContext, dependencies = {}, worldToolContext, rawTrainingCaptureRef, rawTrainingCaptureOptions, worldTrajectoryIdentity, piSessionForRawCapture, wakeEnvironmentContext) {
+        this.id = id;
+        this.session = session;
+        this.createSession = createSession;
+        this.runtimeHomePath = runtimeHomePath;
+        this.traceModel = traceModel;
+        this.memory = memory;
+        this.memoryToolContext = memoryToolContext;
+        this.worldToolContext = worldToolContext;
+        this.rawTrainingCaptureRef = rawTrainingCaptureRef;
+        this.rawTrainingCaptureOptions = rawTrainingCaptureOptions;
+        this.worldTrajectoryIdentity = worldTrajectoryIdentity;
+        this.piSessionForRawCapture = piSessionForRawCapture;
+        this.wakeEnvironmentContext = wakeEnvironmentContext;
+        this.stampTurnInputSubmitted = dependencies.runWake ?? stampTurnInputSubmitted;
+        this.stampTurnOutputCompleted = dependencies.completeTurn ?? stampTurnOutputCompleted;
+        this.persistTrace = dependencies.traceTurn ?? persistPiTurnTrace;
+        const wakeAcceptance = dependencies.createWakeAcceptance?.(runtimeHomePath, id) ??
+            new WakeAcceptanceStore(runtimeHomePath, id);
+        this.wakeDeliveryQueue = new PiWakeDeliveryQueue(id, wakeAcceptance);
+    }
+    async wake(event) {
+        const wakeEvent = cloneWakeEvent(event);
+        return this.wakeDeliveryQueue.wake(wakeEvent, (queuedEvent, transition) => this.runWake(queuedEvent, transition));
+    }
+    async runWake(event, transitionToInvoking) {
+        const startedAt = new Date();
+        const startedAtMs = Date.now();
+        const chunks = [];
+        const tools = [];
+        let enginePromptMs;
+        let memoryPrepare;
+        let selectedSession;
+        let rawTrainingCapture;
+        let rawTrainingCapturePersistAttempted = false;
+        let unsubscribe;
+        let stage = "select_session";
+        let prepared;
+        this.state = "running";
+        this.lastWakeAt = new Date().toISOString();
+        this.lastError = undefined;
+        const memoryContext = readMemoryContext({
+            kind: event.kind,
+            id: event.id,
+            from: event.from,
+            text: event.text,
+            context: event.context
+        });
+        const worldContext = this.worldToolContext === undefined
+            ? undefined
+            : worldWakeContext(event);
+        const safeWakeText = worldContext === undefined
+            ? event.text
+            : event.kind === "message" && event.delivery !== undefined && event.transportText !== undefined
+                ? `${formatWorldWakePrompt(worldContext)}\n\n${formatWakePrompt(event)}`
+                : formatWorldWakePrompt(worldContext);
+        const worldTrajectory = worldContext?.decisionToken === undefined
+            ? undefined
+            : createPiWorldTrajectoryCapture();
+        const request = {
+            eventId: /^(simfile|moltnet|mneme|daimon):.+$/u.test(event.id) ? event.id : `daimon:${event.id}`,
+            kind: event.kind,
+            text: safeWakeText,
+            from: event.from,
+            context: memoryContext
+        };
+        let promptText = worldContext === undefined
+            ? formatWakePrompt(event)
+            : safeWakeText;
+        try {
+            if (this.wakeEnvironmentContext !== undefined) {
+                this.wakeEnvironmentContext.current = event.id;
+                this.wakeEnvironmentContext.spokeFor = undefined;
+            }
+            if (this.worldToolContext !== undefined) {
+                this.worldToolContext.current = worldContext;
+            }
+            selectedSession = await selectPiSessionForWake({
+                agentId: this.id,
+                createSession: this.createSession,
+                event,
+                memoryContext,
+                runtimeHomePath: this.runtimeHomePath,
+                session: this.session
+            });
+            if (this.rawTrainingCaptureRef !== undefined
+                && this.rawTrainingCaptureOptions !== undefined) {
+                rawTrainingCapture = createPiRawTrainingCapture();
+                this.rawTrainingCaptureRef.current = rawTrainingCapture;
+            }
+            unsubscribe = subscribeToPiTurnEvents({
+                chunks,
+                rawTrainingCapture,
+                session: selectedSession.session,
+                tools,
+                worldTrajectory
+            });
+            if (this.memory !== undefined) {
+                stage = "memory_prepare";
+                const memoryStartedAt = Date.now();
+                try {
+                    prepared = await this.memory.prepareTurn(request);
+                }
+                catch (error) {
+                    memoryPrepare = {
+                        durationMs: Date.now() - memoryStartedAt,
+                        status: "failed"
+                    };
+                    throw error;
+                }
+                memoryPrepare = {
+                    durationMs: Date.now() - memoryStartedAt,
+                    prepared,
+                    status: "completed"
+                };
+                promptText = preserveModelFacingWakeIdentity(prepared.promptText, event, request.eventId);
+                if (this.memoryToolContext !== undefined) {
+                    this.memoryToolContext.observeTool = (toolEvent) => tools.push(toolEvent);
+                    this.memoryToolContext.current = createTrustedPiMemoryToolContext({
+                        agentId: this.id,
+                        memory: this.memory,
+                        mode: selectedSession.mode,
+                        prepared,
+                        threadId: selectedSession.threadId,
+                        wakeId: event.id
+                    });
+                }
+            }
+            if (selectedSession.mode === "dream") {
+                promptText = formatDreamPrompt(promptText, selectedSession.threadId);
+            }
+            stage = "causal_input";
+            const turnInput = await this.stampTurnInputSubmitted({
+                agentId: this.id,
+                event,
+                prepared,
+                promptText,
+                runtimeHomePath: this.runtimeHomePath
+            });
+            stage = "invoking";
+            if (transitionToInvoking !== undefined) {
+                await transitionToInvoking();
+            }
+            stage = "engine_prompt";
+            const engineStartedAt = Date.now();
+            selectedSession.session.bindWake?.(event);
+            await selectedSession.session.prompt(promptText, { expandPromptTemplates: false });
+            enginePromptMs = Date.now() - engineStartedAt;
+            this.state = "idle";
+            const outputText = chunks.join("\n").trim();
+            stage = "causal_output";
+            await this.stampTurnOutputCompleted({
+                agentId: this.id,
+                causeEventId: turnInput.event_id,
+                outputText,
+                runtimeHomePath: this.runtimeHomePath,
+                turnId: event.id
+            });
+            if (this.memory !== undefined && prepared !== undefined) {
+                await this.memory.recordTurn({ principal: prepared.principal, prompt: prepared.packet, request, recall: prepared.recall, result: "completed", outputText, toolEvents: tools })
+                    .catch((recordError) => { this.lastError = `memory record failed: ${recordError instanceof Error ? recordError.message : String(recordError)}`; });
+            }
+            await this.persistTrace({
+                agentId: this.id,
+                enginePromptMs,
+                event,
+                memoryPrepare,
+                memoryEnabled: Boolean(this.memory),
+                model: this.traceModel,
+                outputText,
+                promptText,
+                runtimeHomePath: this.runtimeHomePath,
+                session: selectedSession,
+                startedAt,
+                status: "completed",
+                tools,
+                totalMs: Date.now() - startedAtMs,
+                ...(this.worldToolContext === undefined
+                    ? {}
+                    : { worldContextBound: worldContext !== undefined })
+            });
+            if (rawTrainingCapture !== undefined
+                && this.rawTrainingCaptureOptions !== undefined
+                && this.piSessionForRawCapture !== undefined) {
+                rawTrainingCapturePersistAttempted = true;
+            }
+            await persistPiTurnArtifacts({
+                agentId: this.id,
+                completedAt: new Date(),
+                model: this.traceModel,
+                piSessionForRawCapture: this.piSessionForRawCapture,
+                promptText,
+                rawTrainingCapture,
+                rawTrainingCaptureOptions: this.rawTrainingCaptureOptions,
+                runtimeHomePath: this.runtimeHomePath,
+                startedAt,
+                status: "completed",
+                totalMs: Date.now() - startedAtMs,
+                turnId: event.id,
+                worldContext,
+                worldTrajectory,
+                worldTrajectoryIdentity: this.worldTrajectoryIdentity
+            });
+            // An agent with a mounted `moltnet_send` tool has exactly one
+            // legitimate publication channel; its terminal text is always a
+            // private note to the runtime — whether it spoke, stayed silent, or
+            // narrated a failure back as its reply — never the bridge's
+            // terminal-text fallback (moltnet/internal/bridge/daimon/
+            // receipt_tracker.go), which is reserved for agents with no send tool
+            // at all. `outputText` itself stays intact for the turn trace and
+            // memory record above.
+            const hasSendCapability = this.wakeEnvironmentContext?.hasSendCapability === true;
+            return {
+                agentId: this.id,
+                text: hasSendCapability ? "" : outputText,
+                durationMs: Date.now() - startedAtMs
+            };
+        }
+        catch (error) {
+            this.state = "failed";
+            const message = error instanceof Error ? error.message : String(error);
+            this.lastError = message;
+            if (memoryPrepare === undefined && this.memory !== undefined) {
+                memoryPrepare = {
+                    prepared,
+                    status: "failed"
+                };
+            }
+            await this.persistTrace({
+                agentId: this.id,
+                enginePromptMs,
+                error: {
+                    message,
+                    stage
+                },
+                event,
+                memoryPrepare,
+                memoryEnabled: Boolean(this.memory),
+                model: this.traceModel,
+                outputText: chunks.join("\n").trim(),
+                promptText,
+                runtimeHomePath: this.runtimeHomePath,
+                session: selectedSession,
+                startedAt,
+                status: "failed",
+                tools,
+                totalMs: Date.now() - startedAtMs,
+                ...(this.worldToolContext === undefined
+                    ? {}
+                    : { worldContextBound: worldContext !== undefined })
+            }).catch(() => undefined);
+            if (this.memory !== undefined && prepared !== undefined) {
+                await this.memory.recordTurn({ principal: prepared.principal, prompt: prepared.packet, request, recall: prepared.recall, result: "failed", error: message, outputText: chunks.join("\n").trim(), toolEvents: tools }).catch(() => undefined);
+            }
+            const persistRawCapture = !rawTrainingCapturePersistAttempted
+                && selectedSession !== undefined;
+            if (persistRawCapture && rawTrainingCapture !== undefined) {
+                rawTrainingCapturePersistAttempted = true;
+            }
+            await persistPiTurnArtifacts({
+                agentId: this.id,
+                completedAt: new Date(),
+                model: this.traceModel,
+                piSessionForRawCapture: persistRawCapture
+                    ? this.piSessionForRawCapture
+                    : undefined,
+                promptText,
+                rawTrainingCapture: persistRawCapture ? rawTrainingCapture : undefined,
+                rawTrainingCaptureOptions: persistRawCapture
+                    ? this.rawTrainingCaptureOptions
+                    : undefined,
+                runtimeHomePath: this.runtimeHomePath,
+                startedAt,
+                status: "failed",
+                totalMs: Date.now() - startedAtMs,
+                turnId: event.id,
+                worldContext,
+                worldTrajectory,
+                worldTrajectoryIdentity: this.worldTrajectoryIdentity
+            });
+            throw error;
+        }
+        finally {
+            selectedSession?.session.bindWake?.();
+            if (this.wakeEnvironmentContext !== undefined) {
+                this.wakeEnvironmentContext.current = undefined;
+                this.wakeEnvironmentContext.spokeFor = undefined;
+            }
+            if (this.memoryToolContext !== undefined) {
+                this.memoryToolContext.current = undefined;
+                this.memoryToolContext.observeTool = undefined;
+            }
+            if (this.worldToolContext) {
+                this.worldToolContext.current = undefined;
+            }
+            if (this.rawTrainingCaptureRef) {
+                this.rawTrainingCaptureRef.current = undefined;
+            }
+            unsubscribe?.();
+            if (selectedSession?.disposeAfterWake) {
+                selectedSession.session.dispose();
+            }
+        }
+    }
+    status() {
+        return {
+            agentId: this.id,
+            state: this.state,
+            lastWakeAt: this.lastWakeAt,
+            lastError: this.lastError
+        };
+    }
+    async stop() {
+        // CLI-backed sessions may own a process group, while native Pi remains
+        // source-compatible through the synchronous dispose() hook.
+        await disposePiSession(this.session);
+        this.state = "stopped";
+    }
+}