@astrosheep/keiyaku 4.0.3 → 4.0.5

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-recipe.js

@@ -24,10 +24,6 @@ export function decodeProviderOptions(value) {
     const options = record(value);
     if (options === null)
         throw new TypeError("provider options must be an object");
-    const allowed = ["effort", "model", "network", "readonly", "systemPrompt"];
-    const unknown = Object.keys(options).find((key) => !allowed.includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`provider options have unknown field ${unknown}`);
     const model = optionText(options, "model", "refuse");
     const effort = optionText(options, "effort", "refuse");
     if (options.readonly !== undefined && options.readonly !== true) {
@@ -50,12 +46,10 @@ export function decodeReadonlyRestraint(value) {
     const restraint = record(value);
     if (restraint === null)
         throw new TypeError("readonly restraint must be an object");
-    const keys = Object.keys(restraint).sort();
-    if (restraint.enforcement === "native" && keys.length === 1 && keys[0] === "enforcement") {
+    if (restraint.enforcement === "native") {
         return Object.freeze({ enforcement: "native" });
     }
     if (restraint.enforcement === "none"
-        && keys.length === 2 && keys[0] === "diagnostic" && keys[1] === "enforcement"
         && typeof restraint.diagnostic === "string" && restraint.diagnostic.trim().length > 0) {
         return Object.freeze({ enforcement: "none", diagnostic: restraint.diagnostic });
     }
@@ -69,10 +63,6 @@ export function decodeProviderRecipe(input) {
     const value = record(input);
     if (value === null)
         throw new TypeError("provider execution must be an object");
-    const allowed = ["config", "env", "executable", "kind", "name"];
-    const unknown = Object.keys(value).find((key) => !allowed.includes(key));
-    if (unknown !== undefined)
-        throw new TypeError(`provider execution has unknown field ${unknown}`);
     if (typeof value.name !== "string" || value.name.trim().length === 0) {
         throw new TypeError("provider execution name must be a nonblank string");
     }

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

@@ -1,4 +1,3 @@
-import type { Confinement } from "./heart/index.js";
 import { decodeResumeCoordinate, encodeResumeCoordinate, type ResumeCoordinate } from "./coordinate.js";
 import type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";
 export type { ResumeCoordinate } from "./coordinate.js";
@@ -23,7 +22,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;
@@ -138,7 +137,7 @@ export type DriveInput = Readonly<{
     cwd: string;
     options: ProviderOptions;
     signal: AbortSignal;
-    requests?: Readonly<{
+    requests: Readonly<{
         dir: string;
     }>;
 }>;
@@ -151,10 +150,6 @@ export type ProviderOptionAdmission = Readonly<{
     diagnostic: string;
 }>;
 export type ProviderAdapter = Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): Confinement;
     admitOptions(options: ProviderOptions): ProviderOptionAdmission;
     fork?(input: Readonly<{
         session: ResumeCoordinate;

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

@@ -2,8 +2,8 @@ import * as acp from "@agentclientprotocol/sdk";
 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 { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.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);
@@ -130,7 +130,11 @@ export async function startAcpSession(launch, input, dependencies = {}) {
     const child = (dependencies.spawnProcess ?? spawnStdioProcess)({
         argv: launch.argv,
         cwd: input.cwd,
-        env: { ...globalThis.process.env, ...launch.env },
+        env: {
+            ...globalThis.process.env,
+            ...launch.env,
+            ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+        },
     });
     let sessionId;
     let turn;
@@ -138,7 +142,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/acp/index.js

@@ -86,7 +86,6 @@ export function createAcpProvider(execution, dependencies = {}) {
         return (await startAcpSession(launch, input, dependencies)).session;
     };
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: (options) => optionAdmission(options, config),
         start: async (input) => await drive(input),
         resume: async (input) => await drive(input),

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/claude/index.d.ts

@@ -21,10 +21,6 @@ export type ClaudeSdk = Readonly<{
 }>;
 export declare function createClaudeProvider(load: () => Promise<ClaudeSdk>, execution?: ClaudeExecution): ProviderAdapter;
 export declare const claudeProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../../index.js").Confinement;
     admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
     fork?(input: Readonly<{
         session: ResumeCoordinate;

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

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
-import { AgentEventChannel, } from "../../provider.js";
+import { AKUMA_REQUESTS_ENV, AgentEventChannel, } from "../../provider.js";
 import { emitClaudeMessage, } from "./events.js";
 import { claudeUserMessage, createClaudeInput, isClaudeTurnEnded } from "./input.js";
 export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
@@ -61,8 +61,13 @@ function claudeQueryOptions(input, execution, abortController) {
     return {
         cwd: input.cwd,
         abortController,
+        ...(input.requests === undefined ? {} : { additionalDirectories: [input.requests.dir] }),
         ...(execution.executable === undefined ? {} : { pathToClaudeCodeExecutable: execution.executable }),
-        ...(execution.env === undefined ? {} : { env: { ...process.env, ...execution.env } }),
+        ...((execution.env === undefined && input.requests === undefined) ? {} : { env: {
+                ...process.env,
+                ...execution.env,
+                ...(input.requests === undefined ? {} : { [AKUMA_REQUESTS_ENV]: input.requests.dir }),
+            } }),
         permissionMode: mode,
         ...(mode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {}),
         settingSources: ["user", "project", "local"],
@@ -269,7 +274,6 @@ async function driveClaude(load, execution, drive) {
 }
 export function createClaudeProvider(load, execution = {}) {
     return {
-        confinement: () => ({ kind: "unconfined" }),
         admitOptions: admitClaudeOptions,
         fork: (input) => forkClaude(load, execution, input),
         start: (input) => driveClaude(load, execution, input),

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/codex-app-server/index.d.ts

@@ -1,29 +1,4 @@
-import { type Session, type ProviderAdapter } from "../../provider.js";
-import type { ProviderExecution, ProviderOptions } from "../../provider-recipe.js";
+import { type ProviderAdapter } from "../../provider.js";
+import type { ProviderExecution } from "../../provider-recipe.js";
 export { CODEX_ITEM_DISPOSITIONS, CODEX_NOTIFICATION_DISPOSITIONS } from "./events.js";
 export declare function createCodexAppServerProvider(input?: string | ProviderExecution): ProviderAdapter;
-export declare const codexAppServerProvider: Readonly<{
-    confinement(input: Readonly<{
-        cwd: string;
-        options: ProviderOptions;
-    }>): import("../../index.js").Confinement;
-    admitOptions(options: ProviderOptions): import("../../provider.js").ProviderOptionAdmission;
-    fork?(input: Readonly<{
-        session: import("../../coordinate.js").ResumeCoordinate;
-        at: string;
-        cwd: string;
-    }>): Promise<Readonly<{
-        session: import("../../coordinate.js").ResumeCoordinate;
-    }>>;
-    start(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "fresh";
-        }>;
-    }>): Promise<Session>;
-    resume?(input: import("../../provider.js").DriveInput & Readonly<{
-        session: Readonly<{
-            kind: "resume";
-            coordinate: import("../../coordinate.js").ResumeCoordinate;
-        }>;
-    }>): Promise<Session>;
-}>;

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

@@ -190,7 +190,6 @@ export function createCodexAppServerProvider(input = "codex") {
         ? { name: "codex-app-server", kind: "codex-app-server", executable: input }
         : input;
     return {
-        confinement: ({ cwd }) => ({ kind: "declared", writableRoots: [cwd] }),
         admitOptions(options) {
             return {
                 kind: "admitted",
@@ -203,4 +202,3 @@ export function createCodexAppServerProvider(input = "codex") {
         resume: (input) => startCodex(execution, input),
     };
 }
-export const codexAppServerProvider = createCodexAppServerProvider();

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;