@geminixiang/mikan 1.0.0-beta.87 → 1.0.0-beta.89

package/dist/harness/session.js

@@ -1,43 +1,39 @@
-import { TODO_CONTEXT, OperationMismatch, getOrThrow, DEFAULT_COMPACTION_SETTINGS, estimateContextTokens, } from "@earendil-works/pi-agent-core";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+import { AgentDoc, DEFAULT_COMPACTION_POLICY, CompactionTask, GenerationTask, LiveDoc, ToolTask, defineExtension, hook, section, watchEvents, } from "@earendil-works/pi-durable";
 import * as log from "../log.js";
 import { ToolLoopGuard } from "./loop-guard.js";
 import { adaptAgentTool, isHarnessTool } from "./tools/pi-tools.js";
 import { START_TASK_TOOL, TASK_STATUS_TOOL } from "./tools/task.js";
+import { createCodemodeTool } from "./tools/codemode.js";
+import { createToolSearchTool } from "./tools/tool-search.js";
+import { withSecretRedaction } from "./tools/secret-redaction.js";
 import { errorMessage } from "../unknown-values.js";
-const IDLE_COMPACTION_FRACTION_OF_PI_THRESHOLD = 0.8;
-const FORWARDED_EVENTS = [
-    "run_start",
-    "run_end",
-    "message_start",
-    "message_update",
-    "entry_added",
-    "turn_start",
-    "turn_end",
-    "tool_start",
-    "tool_update",
-    "tool_end",
-    "retry_scheduled",
-    "retry_end",
-    "compaction_start",
-    "compaction_end",
-    "usage",
-    "fault",
-];
+const context = BACKGROUND_CONTEXT;
+const COMPACTION_REQUEST = Symbol("compaction-request");
+function deferred() {
+    let resolve;
+    const promise = new Promise((done) => {
+        resolve = done;
+    });
+    return { promise, resolve };
+}
 export class MikanAgentSession {
     constructor(options) {
         this.options = options;
         this.listeners = new Set();
-        this.transcript = [];
         this.runActive = false;
         this.runAborted = false;
         this.runBudget = {};
         this.retryAttempt = 0;
-        this.latestAssistantNeedsCall = false;
-        this.latestAssistantErrored = false;
         this.runMessages = [];
         this.toolArgs = new Map();
         this.loopGuard = new ToolLoopGuard();
         this.loopNotices = new Map();
+        this.runStarted = false;
+        this.runEndSeen = false;
+        this.observedUsage = createEmptyUsage();
+        this.runEnded = deferred();
         this.tally = {
             usage: createEmptyUsage(),
             llmCalls: 0,
@@ -50,8 +46,8 @@ export class MikanAgentSession {
         this.systemPrompt = options.systemPrompt;
         this.settings = resolveHarnessSettings(options.settings);
     }
-    get messages() {
-        return this.transcript;
+    get lastRunMessages() {
+        return this.runMessages;
     }
     get isActiveRun() {
         return this.runActive;
@@ -71,6 +67,7 @@ export class MikanAgentSession {
             toolCallCounts: { ...this.tally.toolCallCounts },
             durationMs: this.tally.startedAt > 0 ? (this.tally.endedAt ?? Date.now()) - this.tally.startedAt : 0,
             budgetExceededReason: this.budgetExceededReason || undefined,
+            status: this.lastSessionRunStatus,
         };
     }
     captureExternalUsageSink() {
@@ -84,86 +81,38 @@ export class MikanAgentSession {
                 await this.exceedBudget(reason);
         };
     }
-    async foldExternalUsage(usage) {
-        await this.captureExternalUsageSink()(usage);
-    }
     subscribe(listener) {
         this.listeners.add(listener);
         return () => this.listeners.delete(listener);
     }
-    async reloadFromSession() {
-        this.transcript = (await this.sessionStore.buildSessionContext()).messages;
-        return this.transcript.length;
-    }
     async prompt(text, options) {
         await this.run(text, options);
     }
     async steer(text) {
-        if (!this.runActive || this.runAborted || !this.lane)
+        if (!this.runActive || this.runAborted || !this.attached)
             return false;
-        getOrThrow(await this.lane.steer(text, undefined, TODO_CONTEXT));
+        await this.attached.conversation.submit({ type: "input", content: text, whenBusy: "steer" }, context);
         return true;
     }
-    async resume(options) {
-        await this.run(undefined, options);
-    }
-    compactWhenNearLimit() {
-        if (this.runActive || this.idleCompaction || !this.lane)
-            return;
-        const { enabled, reserveTokens } = this.settings.compaction;
-        if (!enabled)
-            return;
-        const threshold = (this.model.contextWindow - reserveTokens) * IDLE_COMPACTION_FRACTION_OF_PI_THRESHOLD;
-        const { tokens } = estimateContextTokens(this.transcript);
-        if (tokens < threshold)
-            return;
-        const lane = this.lane;
-        log.logInfo(`Idle compaction started ${JSON.stringify({ tokens, threshold })}`);
-        const compaction = lane
-            .compact(undefined, TODO_CONTEXT)
-            .then(async (result) => {
-            if (!result.ok) {
-                log.logInfo(`Idle compaction skipped: ${result.error.message}`);
-                return;
-            }
-            log.logInfo(`Idle compaction ${result.value.compaction.status}`);
-            await this.reloadFromSession();
-        })
-            .catch((error) => {
-            log.logWarning("Idle compaction failed", errorMessage(error));
-        })
-            .finally(() => {
-            if (this.idleCompaction === compaction)
-                this.idleCompaction = undefined;
-        });
-        this.idleCompaction = compaction;
-    }
-    async cancelIdleCompaction() {
-        const compaction = this.idleCompaction;
-        if (!compaction || !this.lane)
-            return;
-        const aborted = await this.lane.abort(TODO_CONTEXT);
-        if (!aborted.ok)
-            log.logInfo(`Idle compaction abort: ${aborted.error.message}`);
-        await compaction;
-    }
     async run(text, options) {
         if (this.runActive)
             throw new Error("Agent is already processing a prompt");
         this.runActive = true;
         this.runAborted = false;
-        this.pendingProviderRequest = undefined;
-        this.currentProviderRequest = undefined;
-        this.activeProviderRequest = undefined;
         this.budgetExceededReason = undefined;
+        this.cancellation = undefined;
         this.cancellationError = undefined;
         this.retryAttempt = 0;
-        this.latestAssistantNeedsCall = false;
-        this.latestAssistantErrored = false;
         this.runMessages = [];
+        this.runStarted = false;
+        this.runEndSeen = false;
+        this.runEnded = deferred();
+        this.activeRequest = undefined;
+        this.requestRunId = undefined;
         this.loopGuard = new ToolLoopGuard();
         this.loopNotices.clear();
         this.runBudget = { ...this.settings.budget, ...options?.budget };
+        this.lastSessionRunStatus = undefined;
         this.tally = {
             usage: createEmptyUsage(),
             llmCalls: 0,
@@ -172,8 +121,9 @@ export class MikanAgentSession {
             startedAt: Date.now(),
         };
         let runFailure;
+        let stream;
+        let status = "completed";
         try {
-            await this.idleCompaction;
             if (!(await this.checkCallBudget()))
                 return;
             this.armDeadline();
@@ -182,57 +132,63 @@ export class MikanAgentSession {
                 return;
             if (!auth)
                 throw new Error(`No credentials for provider "${this.model.provider}". Set the provider API key environment variable.`);
-            await this.initialize();
+            const attached = await this.attach();
             if (this.runAborted)
                 return;
-            const harness = this.harness;
-            const lane = this.lane;
             const tools = this.toHarnessTools(options?.tools ?? this.options.tools).filter((tool) => (tool.name !== START_TASK_TOOL || options?.allowTaskHandoff === true) &&
                 (tool.name !== TASK_STATUS_TOOL || options?.allowTaskStatus === true));
-            await harness.setTools(tools, TODO_CONTEXT);
-            await lane.setActiveTools(tools.map((tool) => tool.name), TODO_CONTEXT);
-            await this.reloadFromSession();
+            await this.installRunTools(attached, tools);
             if (!(await this.checkCallBudget()))
                 return;
-            await this.driveOperation(lane, text, options?.images);
+            await this.sessionStore.recordRun({});
+            stream = await watchEvents(attached.harness, attached.conversation.id, context);
+            this.observedUsage = sumUsageState(stream.snapshot.usage);
+            stream.start((events) => this.handleDurableEvents(events));
+            status = await this.drive(attached, text, options?.images);
         }
         catch (error) {
             runFailure = { error };
+            status = "failed";
             throw error;
         }
         finally {
-            await this.cleanupRun(runFailure);
+            if (status !== "failed" && this.runAborted)
+                status = "aborted";
+            await this.cleanupRun(runFailure, stream, status);
         }
     }
-    async driveOperation(lane, text, images) {
-        if (text === undefined) {
-            const current = await lane.inspectExecution(TODO_CONTEXT);
-            this.operationId = current.current?.id;
-            if (this.runAborted)
-                this.requestCancellation();
-            const result = getOrThrow(await lane.resume(TODO_CONTEXT));
-            if (result.status === "failed")
-                throw new Error(result.error?.message ?? "Pi run failed");
-            return;
+    async drive({ harness, conversation }, text, images) {
+        const interrupted = (await harness.snapshot(LiveDoc, conversation.id, context))?.run;
+        if (interrupted) {
+            log.logWarning("Aborting a run interrupted before this process started");
+            await conversation.abort(context);
         }
-        const admission = getOrThrow(await lane.accept({ kind: "prompt", prompt: text, images }, TODO_CONTEXT));
-        this.operationId = admission.operationId;
+        const content = images && images.length > 0 ? [{ type: "text", text }, ...images] : text;
+        const submission = await conversation.submit({ type: "input", content, whenBusy: "reject" }, context);
         if (this.runAborted)
             this.requestCancellation();
-        const result = getOrThrow(await lane.drive({ operationId: admission.operationId, waitForRetry: true }, TODO_CONTEXT));
-        if (result.kind === "settled" &&
-            result.outcome.status === "failed" &&
-            !this.latestAssistantErrored) {
-            throw new Error(result.outcome.error?.message ?? "Pi run failed");
-        }
-    }
-    async cleanupRun(runFailure) {
+        const settled = await submission.wait(context);
+        if (this.runStarted)
+            await this.runEnded.promise;
+        if (settled.status === "done")
+            return "completed";
+        if (this.runAborted || settled.reason === "aborted")
+            return "aborted";
+        if (settled.reason === "model_error")
+            return "failed";
+        throw new Error(`Pi run failed: ${settled.reason}`);
+    }
+    async cleanupRun(runFailure, stream, status) {
         clearTimeout(this.deadlineTimer);
         this.deadlineTimer = undefined;
         let cleanupFailure;
         try {
             await this.cancellation;
             await this.deadlineNotification;
+            await stream?.stop();
+            if (this.attached) {
+                await this.sessionStore.recordRun({ endedAt: Date.now(), status });
+            }
             if (this.cancellationError)
                 throw this.cancellationError;
         }
@@ -242,13 +198,10 @@ export class MikanAgentSession {
         finally {
             this.toolArgs.clear();
             this.loopNotices.clear();
-            this.pendingProviderRequest = undefined;
-            this.currentProviderRequest = undefined;
-            this.activeProviderRequest = undefined;
-            this.operationId = undefined;
             this.cancellation = undefined;
             this.deadlineNotification = undefined;
             this.tally.endedAt = Date.now();
+            this.lastSessionRunStatus = status;
             this.runActive = false;
         }
         if (!cleanupFailure)
@@ -265,103 +218,71 @@ export class MikanAgentSession {
         this.runAborted = true;
         clearTimeout(this.deadlineTimer);
         this.deadlineTimer = undefined;
-        if (firstAbort && this.activeProviderRequest) {
-            log.logInfo(`LLM request aborted ${JSON.stringify({
-                abort_reason: reason,
-                run_id: this.activeProviderRequest.runId,
-            })}`);
+        if (firstAbort && this.activeRequest !== undefined) {
+            log.logInfo(`LLM request aborted ${JSON.stringify({ abort_reason: reason, run_id: this.activeRequest.runId })}`);
         }
         this.requestCancellation();
     }
     requestCancellation() {
-        if (!this.lane || !this.operationId || this.cancellation)
+        if (!this.attached || this.cancellation)
             return;
-        this.cancellation = this.lane
-            .requestAbort(this.operationId, TODO_CONTEXT)
-            .then((result) => {
-            if (!result.ok && !(result.error instanceof OperationMismatch))
-                throw result.error;
-        })
-            .catch((error) => {
+        this.cancellation = this.attached.conversation.abort(context).catch((error) => {
             this.cancellationError = error;
         });
     }
-    beginProviderRequest() {
-        const request = this.pendingProviderRequest;
-        this.pendingProviderRequest = undefined;
-        if (request)
-            this.currentProviderRequest = request;
-        return request;
-    }
-    endProviderRequest(request) {
-        if (!request)
-            return;
-        if (this.currentProviderRequest?.token === request.token) {
-            this.currentProviderRequest = undefined;
-        }
-        if (this.activeProviderRequest?.token === request.token) {
-            this.activeProviderRequest = undefined;
-        }
+    async attach() {
+        if (this.attached)
+            return this.attached;
+        const { retry, compaction } = this.settings;
+        this.attached = await this.sessionStore.bindHarness({
+            models: this.options.models.models,
+            requestModels: this.trackedModels(this.options.models.models),
+            env: () => this.options.toolContext?.env,
+            settings: { retry, compaction },
+            onReport: (error) => log.logWarning("Durable harness report", errorMessage(error)),
+        });
+        return this.attached;
     }
-    withProviderActivation(options, request) {
-        if (!request)
-            return options;
-        const onPayload = options?.onPayload;
-        return {
+    trackedModels(models) {
+        const track = (options, token) => {
+            const onPayload = options?.onPayload;
+            const tracked = {
+                ...options,
+                onPayload: async (...args) => {
+                    const transformed = await onPayload?.(...args);
+                    if (this.runActive) {
+                        this.activeRequest = { token, runId: this.requestRunId ?? "background" };
+                    }
+                    return transformed;
+                },
+            };
+            return tracked;
+        };
+        const withSession = (options) => ({
             ...options,
-            onPayload: async (payload, model) => {
-                const transformed = await onPayload?.(payload, model);
-                if (this.currentProviderRequest?.token === request.token) {
-                    this.activeProviderRequest = request;
-                }
-                return transformed;
-            },
+            sessionId: options.sessionId ?? this.sessionStore.getSessionId(),
+        });
+        const finish = (token) => {
+            if (this.activeRequest?.token === token)
+                this.activeRequest = undefined;
+        };
+        const stream = (start) => {
+            const token = Symbol("provider-request");
+            const result = start(token);
+            void result.result().then(() => finish(token), () => finish(token));
+            return result;
         };
-    }
-    trackProviderStream(start) {
-        const request = this.beginProviderRequest();
-        try {
-            const stream = start(request);
-            if (request) {
-                void stream.result().then(() => this.endProviderRequest(request), () => this.endProviderRequest(request));
-            }
-            return stream;
-        }
-        catch (error) {
-            this.endProviderRequest(request);
-            throw error;
-        }
-    }
-    trackProviderPromise(start) {
-        const request = this.beginProviderRequest();
-        try {
-            const promise = start(request);
-            if (!request)
-                return promise;
-            return promise.then((result) => {
-                this.endProviderRequest(request);
-                return result;
-            }, (error) => {
-                this.endProviderRequest(request);
-                throw error;
-            });
-        }
-        catch (error) {
-            this.endProviderRequest(request);
-            throw error;
-        }
-    }
-    trackedModels(models) {
         return new Proxy(models, {
             get: (target, property) => {
                 if (property === "streamSimple") {
-                    return (...[model, context, options]) => this.trackProviderStream((request) => target.streamSimple(model, context, this.withProviderActivation(options, request)));
-                }
-                if (property === "completeSimple") {
-                    return (...[model, context, options]) => this.trackProviderPromise((request) => target.completeSimple(model, context, this.withProviderActivation(options, request)));
-                }
-                if (property === "streamDeferred") {
-                    return (...[model, handle, options]) => this.trackProviderStream((request) => target.streamDeferred(model, handle, this.withProviderActivation(options, request)));
+                    return (...[model, request, options]) => {
+                        const over = this.runActive ? this.callOverBudgetReason() : undefined;
+                        if (over || this.runAborted)
+                            return abortedStream(model, over ?? "Operation aborted");
+                        if (this.runActive)
+                            this.tally.llmCalls += 1;
+                        return stream((token) => target.streamSimple(model, request, withSession(track(options, token))));
+                    };
                 }
                 const value = Reflect.get(target, property, target);
                 return typeof value === "function" ? value.bind(target) : value;
@@ -371,69 +292,130 @@ export class MikanAgentSession {
     toHarnessTools(tools) {
         return tools.map((tool) => (isHarnessTool(tool) ? tool : adaptAgentTool(tool)));
     }
-    async initialize() {
-        if (this.harness)
-            return;
-        this.harness = await this.sessionStore.createHarness({
-            models: this.trackedModels(this.options.models.models),
-            model: this.model,
+    async installRunTools(attached, selected) {
+        const tools = [...selected];
+        const deferredTools = tools.filter((tool) => tool.exposure === "deferred");
+        const authorized = new Set(deferredTools.map((tool) => tool.name));
+        const { harness, conversation, registry, extensionName } = attached;
+        const stored = (await harness.snapshot(AgentDoc, conversation.id, context))?.tools;
+        const loaded = new Set(Array.isArray(stored) ? stored.filter((name) => authorized.has(name)) : []);
+        if (tools.length > 0)
+            tools.push(withSecretRedaction(createCodemodeTool({
+                tools,
+                executeNested: (tool, call) => this.executeNestedTool(tool, call),
+            })));
+        if (deferredTools.length > 0) {
+            tools.push(withSecretRedaction(createToolSearchTool({
+                tools: deferredTools,
+                loaded,
+                load: async (names) => {
+                    for (const name of names)
+                        if (authorized.has(name))
+                            loaded.add(name);
+                },
+            })));
+        }
+        const registered = tools;
+        registry.install(defineExtension({
+            name: extensionName,
+            tools: registered,
+            sections: [
+                section("mikan", () => this.sessionStore.withMcpInstructions(this.systemPrompt), {
+                    tag: false,
+                }),
+            ],
+            hooks: [
+                hook(GenerationTask, {
+                    beforeRequest: async (request, api) => {
+                        await this.beforeRequest(String(api.taskId));
+                        return { messages: attached.tagRequest(request.messages) };
+                    },
+                }),
+                hook(CompactionTask, {
+                    beforeCompact: (_compaction, api) => this.beforeCompact(String(api.taskId)),
+                }),
+                hook(ToolTask, {
+                    beforeTool: async (call, api) => this.beforeTool(call, api),
+                    afterTool: (call, result) => this.afterTool(call.id, result),
+                }),
+            ],
+        }));
+        await conversation.configure({
+            model: { provider: this.model.provider, modelId: this.model.id },
             thinkingLevel: this.options.thinkingLevel,
-            tools: this.toHarnessTools(this.options.tools),
-            toolContext: this.options.toolContext,
-            systemPrompt: () => this.sessionStore.withMcpInstructions(this.systemPrompt),
-            retry: this.settings.retry,
-            compaction: this.settings.compaction,
-        });
-        this.lane = await this.harness.lane("main", TODO_CONTEXT);
-        await this.lane.setModel({ provider: this.model.provider, modelId: this.model.id }, TODO_CONTEXT);
-        await this.lane.setThinkingLevel(this.options.thinkingLevel, TODO_CONTEXT);
-        this.harness.hooks.on("before_request", async (event) => {
-            if (!(await this.checkCallBudget()))
-                return undefined;
-            this.pendingProviderRequest = { token: Symbol("provider-request"), runId: event.runId };
-            this.tally.llmCalls += 1;
+            extensions: [registry.snapshot().extension(extensionName)],
+            tools: registered.filter((tool) => tool.exposure !== "deferred" || loaded.has(tool.name)),
+        }, context);
+    }
+    beforeCompact(taskId) {
+        if (!this.runActive)
             return undefined;
-        });
-        this.harness.hooks.on("before_tool", () => {
-            const assistant = this.transcript.findLast((message) => message.role === "assistant");
-            const calls = assistant?.role === "assistant"
-                ? assistant.content.filter((part) => part.type === "toolCall")
-                : [];
-            if (calls.length > 1 && calls.some((call) => call.name === START_TASK_TOOL)) {
-                return {
-                    block: {
-                        reason: `Call ${START_TASK_TOOL} alone, without other tools in the same batch.`,
-                    },
-                };
-            }
+        if (this.runAborted || this.budgetExceededReason || this.callOverBudgetReason()) {
+            return { decline: true };
+        }
+        this.tally.llmCalls += 1;
+        this.activeRequest = { token: COMPACTION_REQUEST, runId: taskId };
+        return undefined;
+    }
+    async beforeRequest(runId) {
+        if (!(await this.checkCallBudget()))
             return undefined;
-        });
-        this.harness.hooks.on("before_tool", async (event) => {
-            const verdict = this.loopGuard.observe(event.toolName, event.args);
-            switch (verdict.kind) {
-                case "allow":
-                    return undefined;
-                case "notice":
-                    this.loopNotices.set(event.toolCallId, verdict.text);
-                    return undefined;
-                case "block":
-                    return { block: { reason: verdict.reason } };
-                case "stop":
-                    await this.exceedBudget(verdict.reason);
-                    return { block: { reason: verdict.reason, terminate: true } };
-                default:
-                    return verdict;
-            }
-        });
-        this.harness.hooks.on("after_tool", (event) => {
-            const notice = this.loopNotices.get(event.toolCallId);
-            if (notice === undefined)
+        this.requestRunId = runId;
+        return undefined;
+    }
+    async beforeTool(call, api) {
+        const round = (await api.snapshot(LiveDoc, api.conversationId, context))?.tools ?? [];
+        if (round.length > 1 && round.some((slot) => slot.name === START_TASK_TOOL)) {
+            return { block: `Call ${START_TASK_TOOL} alone, without other tools in the same batch.` };
+        }
+        return this.checkToolLoop(call.id, call.name, call.arguments);
+    }
+    afterTool(callId, result) {
+        const notice = this.loopNotices.get(callId);
+        if (notice === undefined)
+            return undefined;
+        this.loopNotices.delete(callId);
+        return { ...result, content: [...(result.content ?? []), { type: "text", text: notice }] };
+    }
+    async executeNestedTool(tool, call) {
+        const [args, api, toolContext] = call;
+        const id = api.callId;
+        if (this.runAborted || toolContext.abortSignal?.aborted)
+            throw new Error("Operation aborted");
+        await this.emitToolStart(id, tool.name, args);
+        let result;
+        try {
+            const verdict = await this.checkToolLoop(id, tool.name, args);
+            if (verdict?.block)
+                throw new Error(verdict.block);
+            toolContext.abortSignal?.throwIfAborted();
+            result = await tool.execute(args, api, toolContext);
+            result = this.afterTool(id, result) ?? result;
+        }
+        catch (error) {
+            result = { content: [{ type: "text", text: errorMessage(error) }], isError: true };
+        }
+        finally {
+            this.loopNotices.delete(id);
+        }
+        await this.emitToolEnd(id, tool.name, { content: result.content ?? [], details: result.details }, result.isError === true);
+        return result;
+    }
+    async checkToolLoop(toolCallId, toolName, args) {
+        const verdict = this.loopGuard.observe(toolName, args);
+        switch (verdict.kind) {
+            case "allow":
                 return undefined;
-            this.loopNotices.delete(event.toolCallId);
-            return { content: [...event.content, { type: "text", text: notice }] };
-        });
-        for (const type of FORWARDED_EVENTS) {
-            this.harness.events.on(type, (event) => this.handlePiEvent(event));
+            case "notice":
+                this.loopNotices.set(toolCallId, verdict.text);
+                return undefined;
+            case "block":
+                return { block: verdict.reason };
+            case "stop":
+                await this.exceedBudget(verdict.reason);
+                return { block: verdict.reason };
+            default:
+                return verdict;
         }
     }
     async emit(event) {
@@ -446,174 +428,147 @@ export class MikanAgentSession {
             }
         }
     }
-    async handlePiEvent(event) {
-        if (!this.runActive)
-            return;
-        if ("lane" in event && event.lane !== undefined && event.lane !== "main")
-            return;
+    async handleDurableEvents(events) {
+        for (const event of events) {
+            try {
+                await this.handleDurableEvent(event);
+            }
+            catch (error) {
+                log.logWarning("Durable event handling failed", errorMessage(error));
+            }
+        }
+        if (this.runEndSeen)
+            this.runEnded.resolve();
+    }
+    async handleDurableEvent(event) {
         switch (event.type) {
-            case "entry_added":
-                if (event.entry.type !== "message")
-                    return;
-                this.transcript.push(event.entry.message);
-                this.runMessages.push(event.entry.message);
-                if (event.entry.message.role === "assistant") {
-                    const message = event.entry.message;
-                    this.latestAssistantErrored = message.stopReason === "error";
-                    this.latestAssistantNeedsCall =
-                        message.stopReason === "error" ||
-                            message.content.some((part) => part.type === "toolCall");
-                }
-                await this.emit({ type: "message_end", message: event.entry.message });
+            case "run_start":
+                this.runStarted = true;
+                return;
+            case "run_end":
+                await this.endRetry(this.runAborted ? "Retry cancelled" : undefined);
+                this.runEndSeen = true;
                 return;
             case "message_start":
+                if (event.message.role === "system")
+                    return;
                 await this.emit({ type: "message_start", message: event.message });
                 return;
             case "message_update":
-                await this.emit({
-                    type: "message_update",
-                    message: event.message,
-                    assistantMessageEvent: event.event,
-                });
-                return;
-            case "turn_start":
-                await this.emit({ type: "turn_start" });
-                return;
-            case "turn_end":
-                await this.emit({
-                    type: "turn_end",
-                    message: event.message,
-                    toolResults: event.toolResults,
-                });
-                return;
-            case "tool_start":
-            case "tool_update":
-            case "tool_end":
-                return this.handlePiToolEvent(event);
-            case "usage":
-                return this.recordUsage(event.row.usage);
-            case "run_start":
-            case "run_end":
-            case "retry_scheduled":
-            case "retry_end":
-            case "compaction_start":
-            case "compaction_end":
-                return this.handlePiLifecycleEvent(event);
-            case "fault":
-                throw new Error(event.message);
-        }
-    }
-    async recordUsage(usage) {
-        addUsage(this.tally.usage, usage);
-        const reason = (this.latestAssistantNeedsCall && this.callOverBudgetReason()) ||
-            this.resourceOverBudgetReason();
-        if (reason)
-            await this.exceedBudget(reason);
-    }
-    async handlePiToolEvent(event) {
-        switch (event.type) {
-            case "tool_start":
-                this.toolArgs.set(event.toolCallId, event.args);
-                this.tally.toolCalls += 1;
-                this.tally.toolCallCounts[event.toolName] =
-                    (this.tally.toolCallCounts[event.toolName] ?? 0) + 1;
-                await this.emit({
-                    type: "tool_execution_start",
-                    toolCallId: event.toolCallId,
-                    toolName: event.toolName,
-                    args: event.args,
-                });
+                for (const change of event.changes) {
+                    if (change.type === "text_delta" && change.delta) {
+                        await this.emit({ type: "text_delta", delta: change.delta });
+                    }
+                }
                 return;
-            case "tool_update":
+            case "message_end":
+                return this.endMessage(event.entry.model?.[0]);
+            case "tool_execution_start":
+                return this.emitToolStart(event.toolCallId, event.toolName, event.args);
+            case "tool_execution_update":
+                if (event.details === undefined)
+                    return;
                 await this.emit({
                     type: "tool_execution_update",
                     toolCallId: event.toolCallId,
                     toolName: event.toolName,
-                    args: this.toolArgs.get(event.toolCallId) ?? {},
-                    partialResult: event.partialResult,
+                    details: event.details,
                 });
                 return;
-            case "tool_end":
-                this.toolArgs.delete(event.toolCallId);
-                await this.emit({
-                    type: "tool_execution_end",
-                    toolCallId: event.toolCallId,
-                    toolName: event.toolName,
-                    result: event.result,
-                    isError: event.isError,
-                });
-                return;
-            default:
-                event;
-        }
-    }
-    async handlePiLifecycleEvent(event) {
-        switch (event.type) {
-            case "run_start":
-                this.operationId = event.runId;
-                if (this.runAborted)
-                    this.requestCancellation();
-                await this.emit({ type: "agent_start" });
+            case "tool_execution_end": {
+                const message = event.entry?.model?.[0];
+                const toolResult = message?.role === "toolResult" ? message : undefined;
+                await this.emitToolEnd(event.toolCallId, event.toolName, { content: toolResult?.content ?? [], details: toolResult?.details }, toolResult?.isError ?? true);
                 return;
-            case "retry_scheduled":
-                this.retryAttempt = event.attempt - 1;
+            }
+            case "auto_retry_start":
+                this.retryAttempt = event.attempt;
                 await this.emit({
                     type: "auto_retry_start",
-                    attempt: this.retryAttempt,
-                    maxAttempts: event.maxAttempts - 1,
-                    delayMs: event.delayMs,
+                    attempt: event.attempt,
+                    maxAttempts: this.settings.retry.maxRetries,
+                    delayMs: Math.max(0, event.at - Date.now()),
                     errorMessage: event.errorMessage,
                 });
                 return;
-            case "retry_end":
+            case "auto_retry_end":
                 this.retryAttempt = 0;
                 await this.emit({
                     type: "auto_retry_end",
-                    attempt: event.attempt - 1,
-                    success: event.success,
-                    finalError: event.finalError,
+                    attempt: event.attempt,
+                    success: !this.runAborted,
+                    finalError: this.runAborted ? "Retry cancelled" : undefined,
                 });
                 return;
             case "compaction_start":
                 await this.emit({ type: "compaction_start", reason: event.reason });
                 return;
             case "compaction_end": {
-                const entry = event.status === "completed"
-                    ? await this.sessionStore.getEntry(event.entryId)
-                    : undefined;
-                if (entry?.type === "compaction")
-                    await this.reloadFromSession();
+                if (this.activeRequest?.token === COMPACTION_REQUEST)
+                    this.activeRequest = undefined;
+                const outcome = await this.compactionOutcome(event.taskId);
                 await this.emit({
                     type: "compaction_end",
                     reason: event.reason,
-                    aborted: event.status === "aborted",
-                    errorMessage: event.status === "failed" ? event.error.message : undefined,
-                    result: entry?.type === "compaction"
-                        ? {
-                            summary: entry.summary,
-                            retainedMessages: entry.retainedTail.length,
-                            tokensBefore: entry.tokensBefore,
-                        }
-                        : undefined,
+                    aborted: outcome?.status === "aborted",
+                    errorMessage: outcome?.status === "failed" ? outcome.error.message : undefined,
                 });
                 return;
             }
-            case "run_end":
-                if (this.retryAttempt > 0) {
-                    await this.emit({
-                        type: "auto_retry_end",
-                        attempt: this.retryAttempt,
-                        success: false,
-                        finalError: event.status === "aborted" ? "Retry cancelled" : event.error?.message,
-                    });
-                    this.retryAttempt = 0;
-                }
-                await this.emit({ type: "agent_end", messages: this.runMessages });
+            case "usage_changed":
+                return this.recordUsage(event.usage);
+            case "task_failed":
+                log.logWarning(`Durable task ${event.kind} failed`, event.message);
                 return;
             default:
-                event;
+                return;
         }
     }
+    async compactionOutcome(taskId) {
+        const task = await this.attached?.harness.getTask(taskId, context);
+        return task?.state.outcome;
+    }
+    async recordUsage(state) {
+        const total = sumUsageState(state);
+        addUsage(this.tally.usage, subtractUsage(total, this.observedUsage));
+        this.observedUsage = total;
+        const reason = this.resourceOverBudgetReason();
+        if (reason)
+            await this.exceedBudget(reason);
+    }
+    async endRetry(finalError) {
+        if (this.retryAttempt === 0)
+            return;
+        await this.emit({
+            type: "auto_retry_end",
+            attempt: this.retryAttempt,
+            success: false,
+            finalError,
+        });
+        this.retryAttempt = 0;
+    }
+    async endMessage(message) {
+        if (!message || message.role === "system")
+            return;
+        this.runMessages.push(message);
+        await this.emit({ type: "message_end", message });
+        if (message.role !== "assistant")
+            return;
+        const needsCall = message.stopReason === "error" || message.content.some((part) => part.type === "toolCall");
+        const reason = (needsCall && this.callOverBudgetReason()) || this.resourceOverBudgetReason();
+        if (reason)
+            await this.exceedBudget(reason);
+    }
+    async emitToolStart(toolCallId, toolName, args) {
+        this.toolArgs.set(toolCallId, args);
+        this.tally.toolCalls += 1;
+        this.tally.toolCallCounts[toolName] = (this.tally.toolCallCounts[toolName] ?? 0) + 1;
+        await this.emit({ type: "tool_execution_start", toolCallId, toolName, args });
+    }
+    async emitToolEnd(toolCallId, toolName, result, isError) {
+        this.toolArgs.delete(toolCallId);
+        await this.emit({ type: "tool_execution_end", toolCallId, toolName, result, isError });
+    }
     async exceedBudget(reason) {
         if (this.budgetExceededReason)
             return;
@@ -669,6 +624,26 @@ export class MikanAgentSession {
         }, Math.min(Math.max(0, remaining), 2_147_483_647));
     }
 }
+function abortedAssistant(model, reason) {
+    return {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: createEmptyUsage(),
+        stopReason: "aborted",
+        errorMessage: reason,
+        timestamp: Date.now(),
+    };
+}
+function abortedStream(model, reason) {
+    const stream = createAssistantMessageEventStream();
+    const error = abortedAssistant(model, reason);
+    stream.push({ type: "error", reason: "aborted", error });
+    stream.end(error);
+    return stream;
+}
 export const DEFAULT_RETRY_SETTINGS = {
     enabled: true,
     maxRetries: 3,
@@ -682,7 +657,7 @@ export const DEFAULT_EVENT_BUDGET = {
 };
 export function resolveHarnessSettings(overrides) {
     return {
-        compaction: { ...DEFAULT_COMPACTION_SETTINGS, ...overrides?.compaction },
+        compaction: { ...DEFAULT_COMPACTION_POLICY, ...overrides?.compaction },
         retry: { ...DEFAULT_RETRY_SETTINGS, ...overrides?.retry },
         budget: { ...DEFAULT_BUDGET_SETTINGS, ...overrides?.budget },
     };
@@ -715,6 +690,30 @@ function addUsage(total, usage) {
         total.reasoning = (total.reasoning ?? 0) + usage.reasoning;
     }
 }
+function sumUsageState(state) {
+    const total = createEmptyUsage();
+    for (const usage of [...Object.values(state.models), ...Object.values(state.tools)]) {
+        addUsage(total, usage);
+    }
+    return total;
+}
+function subtractUsage(total, base) {
+    return {
+        input: total.input - base.input,
+        output: total.output - base.output,
+        cacheRead: total.cacheRead - base.cacheRead,
+        cacheWrite: total.cacheWrite - base.cacheWrite,
+        totalTokens: total.totalTokens - base.totalTokens,
+        cost: {
+            input: total.cost.input - base.cost.input,
+            output: total.cost.output - base.cost.output,
+            cacheRead: total.cost.cacheRead - base.cost.cacheRead,
+            cacheWrite: total.cost.cacheWrite - base.cost.cacheWrite,
+            total: total.cost.total - base.cost.total,
+        },
+        reasoning: total.reasoning === undefined ? undefined : total.reasoning - (base.reasoning ?? 0),
+    };
+}
 export function copyUsage(usage) {
     return { ...usage, cost: { ...usage.cost } };
 }