@astrosheep/keiyaku 4.0.3 → 4.0.4

package/build/src/akuma/heart/schema.js

@@ -1,4 +1,4 @@
-const HEART_SCHEMA_VERSION = 14;
+const HEART_SCHEMA_VERSION = 16;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -108,21 +108,26 @@ export const HEART_SCHEMA = `
   CREATE TABLE IF NOT EXISTS requests (
     sequence INTEGER PRIMARY KEY AUTOINCREMENT,
     id TEXT NOT NULL UNIQUE,
-    archetype TEXT NOT NULL,
-    body TEXT NOT NULL,
-    cwd TEXT,
-    world TEXT NOT NULL,
-    recipe_json TEXT NOT NULL CHECK (json_valid(recipe_json)),
+    requester TEXT NOT NULL,
+    action TEXT NOT NULL CHECK (action IN ('akuma.call', 'akuma.wait', 'akuma.tell', 'akuma.kill')),
+    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),
     admitted_at TEXT NOT NULL,
     state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'served', 'refused', 'voided')),
     child TEXT,
+    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),
     diagnostic TEXT,
     evidence TEXT,
     CHECK (
-      (state = 'admitted' AND child IS NULL AND diagnostic IS NULL AND evidence IS NULL)
-      OR (state IN ('reserved', 'served') AND child IS NOT NULL AND diagnostic IS NULL AND evidence IS NULL)
-      OR (state = 'refused' AND child IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)
-      OR (state = 'voided' AND child IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)
+      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state = 'reserved' AND action = 'akuma.call'
+        AND child IS NOT NULL AND service_json IS NULL
+        AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state = 'served'
+        AND ((action = 'akuma.call' AND child IS NOT NULL AND service_json IS NULL)
+          OR (action != 'akuma.call' AND child IS NULL AND service_json IS NOT NULL))
+        AND diagnostic IS NULL AND evidence IS NULL)
+      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)
+      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)
     )
   ) STRICT;
   CREATE TABLE IF NOT EXISTS control (

package/build/src/akuma/heart/soul.js

@@ -1,5 +1,6 @@
 import { parseAkuId } from "../identity.js";
 import { decodeProviderOptions, decodeProviderRecipe, decodeReadonlyRestraint, } from "../provider-recipe.js";
+import { effectiveAllowedActions } from "../allowed.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -78,7 +79,7 @@ function validateSoul(value) {
     const soul = record(value);
     if (soul === null)
         throw new Error("Akuma soul must be an object");
-    if (unknownKey(soul, ["archetype", "confinement", "createdAt", "cwd", "description", "id", "options", "origin", "provider", "readonly"]) !== undefined) {
+    if (unknownKey(soul, ["allowed", "archetype", "confinement", "createdAt", "cwd", "description", "id", "options", "origin", "provider", "readonly"]) !== undefined) {
         throw new Error("Akuma soul has an unknown field");
     }
     const identity = soulAkuIdentity(soul.id, "id");
@@ -103,6 +104,7 @@ function validateSoul(value) {
         cwd: nonblank(soul.cwd, "cwd"),
         origin: decodeOrigin(soul.origin),
         confinement: decodeConfinement(soul.confinement),
+        allowed: effectiveAllowedActions(soul.allowed),
         createdAt: nonblank(soul.createdAt, "createdAt"),
     };
 }

package/build/src/akuma/heart/storage.d.ts

@@ -9,6 +9,7 @@ export declare class HeartAbsentError extends Error {
 export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
 export declare function withHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T): Promise<T>;
 export declare function transaction<T>(database: DatabaseSync, body: () => T): T;
+export declare function readTransaction<T>(database: DatabaseSync, body: () => T): T;
 export declare function initializeHeart(paths: AkumaPaths): Promise<void>;
 export declare class HeldAkumaLeash {
     private readonly database;

package/build/src/akuma/heart/storage.js

@@ -84,6 +84,21 @@ export function transaction(database, body) {
         throw error;
     }
 }
+export function readTransaction(database, body) {
+    database.exec("BEGIN DEFERRED");
+    try {
+        const result = body();
+        database.exec("COMMIT");
+        return result;
+    }
+    catch (error) {
+        try {
+            database.exec("ROLLBACK");
+        }
+        catch { /* preserve the original failure */ }
+        throw error;
+    }
+}
 export async function initializeHeart(paths) {
     const heart = new DatabaseSync(paths.heart);
     try {

package/build/src/akuma/heart/timeline.d.ts

@@ -8,8 +8,4 @@ export type ActivityFactSlice = Readonly<{
     highest: number | null;
 }>;
 export declare function pruneActivityFacts(database: DatabaseSync, limit: number): void;
-export declare function activityFactSlice(database: DatabaseSync, input: Readonly<{
-    before?: number;
-    since?: number;
-    limit: number;
-}>): ActivityFactSlice;
+export declare function activityFactSlice(database: DatabaseSync): ActivityFactSlice;

package/build/src/akuma/heart/timeline.js

@@ -64,23 +64,14 @@ function decodeTimelineRow(database, row) {
     }
     return decodeTellAtSequence(database, row.sequence);
 }
-export function activityFactSlice(database, input) {
+export function activityFactSlice(database) {
     const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM timeline")
         .get();
-    let rows;
-    if (input.before !== undefined) {
-        rows = database.prepare(`SELECT * FROM (
-      SELECT sequence, kind FROM timeline WHERE sequence < ? ORDER BY sequence DESC LIMIT ?
-    ) ORDER BY sequence`).all(input.before, input.limit);
-    }
-    else if (input.since !== undefined) {
-        rows = database.prepare(`SELECT sequence, kind FROM timeline WHERE sequence > ? ORDER BY sequence LIMIT ?`)
-            .all(input.since, input.limit);
-    }
-    else {
-        rows = database.prepare(`SELECT * FROM (
-      SELECT sequence, kind FROM timeline ORDER BY sequence DESC LIMIT ?
-    ) ORDER BY sequence`).all(input.limit);
-    }
-    return { rows: rows.map((row) => decodeTimelineRow(database, row)), lowestRetained: bounds.lowest, highest: bounds.highest };
+    const rows = database.prepare("SELECT sequence, kind FROM timeline ORDER BY sequence")
+        .all();
+    return {
+        rows: rows.map((row) => decodeTimelineRow(database, row)),
+        lowestRetained: bounds.lowest,
+        highest: bounds.highest,
+    };
 }

package/build/src/akuma/index.d.ts

@@ -1,13 +1,16 @@
 import { type AkuId } from "./identity.js";
 import type { WorldRoot } from "../world.js";
 export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export type { AkumaCallInput } from "./akuma.js";
+export { ALLOWED_ACTIONS } from "./allowed.js";
+export type { AllowedAction, AllowedActions } from "./allowed.js";
 export type { WorldRoot } from "../world.js";
 export declare function probeBornAkuma(worldPath: WorldRoot, id: AkuId): Promise<boolean>;
 export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
 export type { ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBodyRequestError } from "./requests.js";
 export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, UnbornAkumaListRow, } from "./akuma.js";
-export type { ActiveToolRow, ClosedTurn, ClosedTurnRow, CompletedToolRow, HistoryCursor, HistoryPage, IdleSnapshotRow, OpenSnapshotRow, OpenTurn, OpenTurnRow, OutcomeRow, RetainedWindow, Snapshot, SnapshotRow, TellRow, TurnLedger, TurnOutcome, TurnStartRow, UnsettledToolRow, } from "./akuma.js";
+export type { ActiveToolRow, ClosedTurn, ClosedTurnRow, CompletedToolRow, HistoryCursor, HistoryPage, IdleSnapshotRow, OpenSnapshotRow, OpenTurn, OpenTurnRow, OutcomeRow, ReportedFileChange, RetainedWindow, Snapshot, SnapshotRow, TellRow, TurnLedger, TurnOutcome, TurnStartRow, UnsettledToolRow, } from "./akuma.js";
 export type { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
 export type { AkuId } from "./identity.js";
 export type { Confinement, KillEvidence, ResumeCoordinate, TurnFact, } from "./heart/index.js";

package/build/src/akuma/index.js

@@ -1,6 +1,7 @@
 import { readSoul } from "./heart/index.js";
 import { pathsForAkuId } from "./identity.js";
 export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
+export { ALLOWED_ACTIONS } from "./allowed.js";
 export async function probeBornAkuma(worldPath, id) {
     const soul = await readSoul(pathsForAkuId(worldPath, id));
     return soul !== null;

package/build/src/akuma/projection.d.ts

@@ -114,21 +114,35 @@ export type ActivitySnapshotEntry<Row extends SnapshotRow = SnapshotRow> = Reado
     kind: "gap";
     count: number;
 }>;
+export type ReportedFileChange = Readonly<{
+    sequence: number;
+    at: string;
+    op: "add" | "update" | "delete" | "unspecified";
+    path: string;
+    diffstat?: Readonly<{
+        added: number;
+        removed: number;
+    }>;
+}>;
+type ReportedChangeSummary = Readonly<{
+    reportedChanges: readonly ReportedFileChange[];
+    reportedChangesOmitted: number;
+}>;
 export type Snapshot = Readonly<{
     kind: "unborn";
     entries: readonly [];
     omitted: 0;
-}> | Readonly<{
+} & ReportedChangeSummary> | Readonly<{
     kind: "open";
     turn: TurnStartRow;
     entries: readonly ActivitySnapshotEntry<OpenSnapshotRow>[];
     omitted: number;
-}> | Readonly<{
+} & ReportedChangeSummary> | Readonly<{
     kind: "idle";
     outcome?: OutcomeRow;
     entries: readonly ActivitySnapshotEntry<IdleSnapshotRow>[];
     omitted: number;
-}>;
+} & ReportedChangeSummary>;
 export type ActivitySnapshot = Snapshot;
 export type ActivityHistory = Readonly<{
     rows: readonly ActivityRow[];

package/build/src/akuma/projection.js

@@ -1,6 +1,8 @@
 import { decodeAgentEvent } from "./provider.js";
 const DEFAULT_TAIL = 3;
 const DEFAULT_VOICE = 3;
+const REPORTED_CHANGE_LIMIT = 5;
+const EMPTY_REPORTED = { reportedChanges: [], reportedChangesOmitted: 0 };
 function duration(startedAt, completedAt) {
     const start = Date.parse(startedAt);
     const end = Date.parse(completedAt);
@@ -204,11 +206,45 @@ export function ordinarySelectedCount(snapshot) {
         return count + 1;
     }, 0);
 }
+function isSuccessfulFileChange(row) {
+    return row.kind === "tool"
+        && typeof row.state === "object"
+        && row.state.status === "ok"
+        && row.call.kind === "fileChange";
+}
+function flattenReportedChanges(rows) {
+    return rows.flatMap((row) => {
+        if (!isSuccessfulFileChange(row))
+            return [];
+        return row.call.changes.map((change) => ({
+            sequence: row.sequence,
+            at: row.at,
+            op: change.op,
+            path: change.path,
+            ...(change.diffstat === undefined ? {} : { diffstat: change.diffstat }),
+        }));
+    });
+}
+function summarizeReportedChanges(rows) {
+    const eligible = flattenReportedChanges(rows);
+    return {
+        reportedChanges: eligible.slice(-REPORTED_CHANGE_LIMIT),
+        reportedChangesOmitted: Math.max(0, eligible.length - REPORTED_CHANGE_LIMIT),
+    };
+}
+function frontierReportedChanges(ledger) {
+    if (ledger.openTurn !== undefined)
+        return summarizeReportedChanges(ledger.openTurn.rows);
+    const closed = ledger.turns.findLast((turn) => turn.kind === "closed");
+    return closed === undefined ? EMPTY_REPORTED : summarizeReportedChanges(closed.rows);
+}
 /** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
 export function selectSnapshot(ledger, budget = { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE }) {
-    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell"))
-        return { kind: "unborn", entries: [], omitted: 0 };
+    if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell")) {
+        return { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED };
+    }
     const pending = ledger.rows.filter((row) => row.kind === "tell" && row.state === "pending");
+    const reported = frontierReportedChanges(ledger);
     if (ledger.openTurn !== undefined) {
         const window = ledger.openTurn.rows;
         const active = window.filter((row) => row.kind === "tool" && row.state === "active");
@@ -222,13 +258,14 @@ export function selectSnapshot(ledger, budget = { tail: DEFAULT_TAIL, voice: DEF
         const voice = voiceCount === 0 ? [] : voiceCandidates.slice(-voiceCount);
         const selected = new Set([...tail, ...voice, ...active, ...pending]);
         const omitted = window.filter((row) => !selected.has(row)).length;
-        return { kind: "open", turn: ledger.openTurn.turn, entries: openEntries(ledger, window, selected), omitted };
+        return { kind: "open", turn: ledger.openTurn.turn, entries: openEntries(ledger, window, selected), omitted, ...reported };
     }
     return {
         kind: "idle",
         ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
         entries: entries(pending),
         omitted: 0,
+        ...reported,
     };
 }
 /** Apply the one snapshot policy used by every public observation consumer. */

package/build/src/akuma/provider.d.ts

@@ -23,7 +23,7 @@ export type ToolCall = Readonly<{
 }> | Readonly<{
     kind: "fileChange";
     changes: readonly Readonly<{
-        op: "add" | "update" | "delete";
+        op: "add" | "update" | "delete" | "unspecified";
         path: string;
         diffstat?: Readonly<{
             added: number;

package/build/src/akuma/provider.js

@@ -87,7 +87,8 @@ function decodeDiffstat(value) {
 }
 function decodeFileChangeMember(value) {
     const change = object(value);
-    if (change === null || (change.op !== "add" && change.op !== "update" && change.op !== "delete")
+    if (change === null || (change.op !== "add" && change.op !== "update"
+        && change.op !== "delete" && change.op !== "unspecified")
         || typeof change.path !== "string")
         return null;
     const diffstat = decodeDiffstat(change.diffstat);

package/build/src/akuma/providers/acp/core.d.ts

@@ -1,9 +1,12 @@
 import * as acp from "@agentclientprotocol/sdk";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { type ProviderAdapter, type Session } from "../../provider.js";
+import { type AcpToolInterpreter, type AcpToolUpdate } from "./events.js";
+export type { AcpToolInterpreter, AcpToolUpdate };
 export type AcpStartInput = Parameters<ProviderAdapter["start"]>[0] | Parameters<NonNullable<ProviderAdapter["resume"]>>[0];
 export type AcpDependencies = Readonly<{
     spawnProcess?: typeof spawnStdioProcess;
+    interpretTool?: AcpToolInterpreter;
 }>;
 export type AcpLiveSession = Readonly<{
     session: Session;
@@ -16,4 +19,3 @@ type AcpLaunch = Readonly<{
     env?: Readonly<Record<string, string>>;
 }>;
 export declare function startAcpSession(launch: AcpLaunch, input: AcpStartInput, dependencies?: AcpDependencies): Promise<AcpLiveSession>;
-export {};

package/build/src/akuma/providers/acp/core.js

@@ -3,7 +3,7 @@ import { Readable, Writable } from "node:stream";
 import { spawnStdioProcess } from "../../../runtime/proc/stdio.js";
 import { abortable } from "../../abort.js";
 import { AgentEventChannel, } from "../../provider.js";
-import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate } from "./events.js";
+import { EMPTY_ACP_EVENT_STATE, flushAcpEvents, mapAcpUpdate, } from "./events.js";
 function diagnostic(error) {
     if (!(error instanceof Error))
         return String(error);
@@ -46,7 +46,7 @@ async function establishSession(agent, input) {
     await agent.request(acp.methods.agent.session.load, { cwd: input.cwd, mcpServers: [], sessionId });
     return sessionId;
 }
-function createAcpTurn(connection) {
+function createAcpTurn(connection, interpret) {
     const events = new AgentEventChannel();
     let state = EMPTY_ACP_EVENT_STATE;
     let terminal = false;
@@ -55,7 +55,7 @@ function createAcpTurn(connection) {
     const update = (next) => {
         if (terminal)
             return;
-        const mapped = mapAcpUpdate(next, state);
+        const mapped = mapAcpUpdate(next, state, interpret);
         state = mapped.state;
         for (const event of mapped.events)
             events.emit(event);
@@ -138,7 +138,7 @@ export async function startAcpSession(launch, input, dependencies = {}) {
         if (notification.sessionId === sessionId)
             turn.update(notification.update);
     }).connect(acp.ndJsonStream(Writable.toWeb(child.input), Readable.toWeb(child.output)));
-    turn = createAcpTurn(connection);
+    turn = createAcpTurn(connection, dependencies.interpretTool);
     try {
         sessionId = await abortable(establishSession(connection.agent, input), signal);
         turn.events.emit({ type: "session", coordinate: { sessionId } });

package/build/src/akuma/providers/acp/events.d.ts

@@ -1,14 +1,22 @@
 import type { SessionUpdate } from "@agentclientprotocol/sdk";
-import { type AgentEvent } from "../../provider.js";
+import { type AgentEvent, type ToolCall } from "../../provider.js";
 type OpenBlock = Readonly<{
     type: "assistant" | "thought";
     text: string;
 }> | null;
+export type AcpToolObservation = Readonly<{
+    name: string;
+    call: ToolCall;
+}>;
+export type AcpToolUpdate = Extract<SessionUpdate, {
+    sessionUpdate: "tool_call" | "tool_call_update";
+}>;
+export type AcpToolInterpreter = (update: AcpToolUpdate) => ToolCall | undefined;
 export type AcpEventState = Readonly<{
     answer: string;
     assistantMessageId: string | null;
     open: OpenBlock;
-    tools: ReadonlyMap<string, string>;
+    tools: ReadonlyMap<string, AcpToolObservation>;
 }>;
 type AcpEventMapping = Readonly<{
     events: readonly AgentEvent[];
@@ -16,5 +24,5 @@ type AcpEventMapping = Readonly<{
 }>;
 export declare const EMPTY_ACP_EVENT_STATE: AcpEventState;
 export declare function flushAcpEvents(state: AcpEventState, boundary?: readonly AgentEvent[]): AcpEventMapping;
-export declare function mapAcpUpdate(update: SessionUpdate, previous: AcpEventState): AcpEventMapping;
+export declare function mapAcpUpdate(update: SessionUpdate, previous: AcpEventState, interpret?: AcpToolInterpreter): AcpEventMapping;
 export {};

package/build/src/akuma/providers/acp/events.js

@@ -33,7 +33,82 @@ function appendBlock(state, type, text, messageId) {
         },
     };
 }
-export function mapAcpUpdate(update, previous) {
+function nonblank(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function object(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function positiveLine(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1
+        ? value
+        : undefined;
+}
+function otherCall(name) {
+    return { kind: "other", display: name };
+}
+function locationFact(locations) {
+    if (locations === null || locations === undefined)
+        return {};
+    for (const location of locations) {
+        const path = nonblank(location.path);
+        if (path === undefined)
+            continue;
+        const offset = positiveLine(location.line);
+        return offset === undefined ? { path } : { path, offset };
+    }
+    return {};
+}
+function standardCall(update, name) {
+    const location = locationFact(update.locations);
+    if (update.kind === "read") {
+        return location.path === undefined
+            ? otherCall(name)
+            : {
+                kind: "read",
+                path: location.path,
+                ...(location.offset === undefined ? {} : { offset: location.offset }),
+            };
+    }
+    const input = object(update.rawInput);
+    if (update.kind === "execute") {
+        const command = nonblank(input?.command);
+        return command === undefined ? otherCall(name) : { kind: "run", command };
+    }
+    if (update.kind === "search") {
+        const query = nonblank(input?.query);
+        if (query === undefined)
+            return otherCall(name);
+        const path = nonblank(input?.path);
+        const glob = nonblank(input?.glob);
+        const scope = input?.scope;
+        const searchScope = scope === "content" || scope === "files" || scope === "web"
+            ? scope
+            : undefined;
+        return {
+            kind: "search",
+            query,
+            ...(searchScope === undefined ? {} : { scope: searchScope }),
+            ...(path === undefined ? {} : { path }),
+            ...(glob === undefined ? {} : { glob }),
+        };
+    }
+    return otherCall(name);
+}
+function strongest(previous, next) {
+    if (previous === undefined || previous.kind === "other")
+        return next;
+    return next.kind === "other" ? previous : next;
+}
+function observeTool(update, previous, interpret) {
+    const name = nonblank(update.name) ?? nonblank(update.title) ?? previous?.name ?? "ACP tool";
+    const standard = standardCall(update, name);
+    const dialect = standard.kind === "other" ? interpret?.(update) : undefined;
+    return { name, call: strongest(previous?.call, dialect ?? standard) };
+}
+export function mapAcpUpdate(update, previous, interpret) {
     switch (update.sessionUpdate) {
         case "agent_message_chunk":
         case "agent_thought_chunk": {
@@ -47,15 +122,14 @@ export function mapAcpUpdate(update, previous) {
         case "user_message_chunk": return flushAcpEvents(previous);
         case "tool_call":
         case "tool_call_update": {
-            const name = update.title ?? (update.sessionUpdate === "tool_call" ? undefined : previous.tools.get(update.toolCallId)) ?? "ACP tool";
-            const observed = { name, call: { kind: "other", display: name } };
+            const observed = observeTool(update, previous.tools.get(update.toolCallId), interpret);
             const tools = new Map(previous.tools);
             if (update.status === "completed" || update.status === "failed") {
                 tools.delete(update.toolCallId);
                 return flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "completed", id: update.toolCallId, ...observed, result: { status: update.status === "completed" ? "ok" : "error" } }]);
             }
             const started = tools.has(update.toolCallId);
-            tools.set(update.toolCallId, name);
+            tools.set(update.toolCallId, observed);
             return started
                 ? flushAcpEvents({ ...previous, tools })
                 : flushAcpEvents({ ...previous, tools }, [{ type: "tool", phase: "started", id: update.toolCallId, ...observed }]);

package/build/src/akuma/providers/claude/events.js

@@ -141,12 +141,63 @@ function fileChangeCall(name, path) {
     }
     return undefined;
 }
+function startedPath(name, value) {
+    if (name === "NotebookEdit")
+        return nonblank(value.notebook_path);
+    return nonblank(value.file_path) ?? (name === "Read" ? nonblank(value.path) : undefined);
+}
+function nonnegativeInt(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
+}
+function fileChange(op, path, gitDiff) {
+    const diff = object(gitDiff);
+    const added = nonnegativeInt(diff?.additions);
+    const removed = nonnegativeInt(diff?.deletions);
+    const diffstat = added === undefined || removed === undefined ? undefined : { added, removed };
+    return {
+        kind: "fileChange",
+        changes: [{ op, path, ...(diffstat === undefined ? {} : { diffstat }) }],
+    };
+}
+function writeResult(result) {
+    const value = object(result);
+    if (value === undefined || (value.type !== "create" && value.type !== "update"))
+        return undefined;
+    const path = nonblank(value.filePath);
+    if (path === undefined)
+        return undefined;
+    const op = value.type === "create" ? "add" : "update";
+    return fileChange(op, path, value.gitDiff);
+}
+function editResult(result) {
+    const value = object(result);
+    if (value === undefined || value.type === "create" || value.type === "update")
+        return undefined;
+    const path = nonblank(value.filePath);
+    if (path === undefined)
+        return undefined;
+    const status = object(value.gitDiff)?.status;
+    return fileChange(status === "added" ? "add" : "update", path, value.gitDiff);
+}
+function notebookResult(result) {
+    const path = nonblank(object(result)?.notebook_path);
+    return path === undefined
+        ? undefined
+        : { kind: "fileChange", changes: [{ op: "update", path }] };
+}
+function structuredFileChange(name, result) {
+    if (name === "Write")
+        return writeResult(result);
+    if (name === "Edit")
+        return editResult(result);
+    return name === "NotebookEdit" ? notebookResult(result) : undefined;
+}
 function toolCall(name, input) {
     const value = object(input) ?? {};
     const run = runCall(name, value);
     if (run !== undefined)
         return run;
-    const path = nonblank(value.file_path) ?? (name === "Read" ? nonblank(value.path) : undefined);
+    const path = startedPath(name, value);
     return readCall(name, path, value)
         ?? searchCall(name, value)
         ?? fileChangeCall(name, path)
@@ -192,9 +243,17 @@ function toolResultEvents(message, events, state) {
         if (observed === undefined)
             continue;
         state.tools.delete(id);
+        const failed = value.is_error === true;
+        const structured = failed
+            ? undefined
+            : structuredFileChange(observed.name, message.tool_use_result);
         events.emit({
-            type: "tool", phase: "completed", id, name: observed.name, call: observed.call,
-            result: { status: value.is_error === true ? "error" : "ok" },
+            type: "tool",
+            phase: "completed",
+            id,
+            name: observed.name,
+            call: structured ?? observed.call,
+            result: { status: failed ? "error" : "ok" },
         });
     }
 }

package/build/src/akuma/providers/codex-app-server/events.js

@@ -1,4 +1,5 @@
 import { noteEvent, unknownEvent, } from "../../provider.js";
+import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const CODEX_NOTIFICATION_DISPOSITIONS = {
     "account/login/completed": "drop",
     "account/rateLimits/updated": "drop",
@@ -135,19 +136,6 @@ function fileChangeOp(value) {
         ? record.type
         : undefined;
 }
-function diffstatFromUnifiedPatch(patch) {
-    if (!patch.split("\n").some((line) => /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/u.test(line)))
-        return undefined;
-    let added = 0;
-    let removed = 0;
-    for (const line of patch.split("\n")) {
-        if (line.startsWith("+") && !line.startsWith("+++"))
-            added += 1;
-        if (line.startsWith("-") && !line.startsWith("---"))
-            removed += 1;
-    }
-    return { added, removed };
-}
 function itemChanges(item) {
     if (!Array.isArray(item.changes))
         return [];

package/build/src/akuma/providers/grok-build/index.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderAdapter } from "../../provider.js";
 import type { ProviderExecution } from "../../provider-recipe.js";
-import { type AcpDependencies } from "../acp/core.js";
+import { type AcpDependencies, type AcpToolInterpreter } from "../acp/core.js";
+export declare const interpretGrokTool: AcpToolInterpreter;
 export declare function createGrokBuildProvider(execution: ProviderExecution, dependencies?: AcpDependencies): ProviderAdapter;