@astrosheep/keiyaku 4.6.6 → 4.6.8

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

@@ -10,6 +10,11 @@ export declare function isHeartAbsent(error: unknown): error is HeartAbsentError
 export declare function classifyHeartSchema(paths: AkumaPaths): Promise<"current" | "unsupported">;
 export declare function withReadOnlyHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T, signal?: AbortSignal): Promise<T>;
 export declare function withHeartTransaction<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T, signal?: AbortSignal): Promise<T>;
+/** Insert one already-admitted pending Tell into an already-open Heart transaction. */
+export declare function recordPendingTell(heart: DatabaseSync, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">): Readonly<{
+    kind: "recorded";
+    tell: TellFact;
+}>;
 export declare function initializeHeart(paths: AkumaPaths): Promise<void>;
 export declare class HeldAkumaLeash {
     private readonly database;

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

@@ -142,6 +142,12 @@ function finishTransaction(database, body) {
         throw error;
     }
 }
+/** Insert one already-admitted pending Tell into an already-open Heart transaction. */
+export function recordPendingTell(heart, tell) {
+    const sequence = insertTellFact(heart, tell);
+    pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+}
 export async function initializeHeart(paths) {
     const heart = new DatabaseSync(paths.heart);
     try {
@@ -258,9 +264,7 @@ export class HeldAkumaLeash {
             deletePauseControl(heart);
             if (soulFact(heart) === null)
                 return { kind: "not-born" };
-            const sequence = insertTellFact(heart, tell);
-            pruneActivityFacts(heart, ACTIVITY_LIMIT);
-            return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+            return recordPendingTell(heart, tell);
         });
     }
     release() {

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

@@ -18,7 +18,6 @@ export type AllocatedAkuma = Readonly<{
     suffix: string;
     paths: AkumaPaths;
 }>;
-export declare function archetypeName(value: string): string;
 export declare function akuId(input: Readonly<{
     archetype: string;
     suffix: string;

package/build/src/akuma/identity.js

@@ -22,9 +22,6 @@ export const akumaPathsSchema = z
     requests: pathText,
 })
     .strict();
-export function archetypeName(value) {
-    return validateAkumaName(value);
-}
 function suffixSegment(value) {
     if (!HEX8.test(value))
         throw new TypeError("Akuma suffix must be lower hex8");
@@ -33,7 +30,7 @@ function suffixSegment(value) {
 export function akuId(input) {
     return identityCoordinate({
         family: "aku",
-        segments: [archetypeName(input.archetype), suffixSegment(input.suffix)],
+        segments: [validateAkumaName(input.archetype), suffixSegment(input.suffix)],
     });
 }
 export function parseAkuId(value) {
@@ -94,7 +91,7 @@ export async function ensureAkumaRunRoot(worldRoot) {
     return runRoot;
 }
 export async function allocateAkumaDirectory(input) {
-    const archetype = archetypeName(input.archetype);
+    const archetype = validateAkumaName(input.archetype);
     const runRoot = await ensureAkumaRunRoot(input.worldRoot);
     for (;;) {
         const suffix = suffixSegment(input.draw?.() ?? randomBytes(4).toString("hex"));

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

@@ -1,7 +1,10 @@
-export type { WorldRoot } from "../world.js";
+export type { AkumaCaller } from "./caller.js";
+export type { AkumaOrigin } from "./heart/index.js";
+export { AkumaArchetypeError, listArchetypeDefinitions } from "./archetype.js";
+export type { ArchetypeCatalog, ArchetypeCatalogInput, ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
-export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
+export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaHostOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
 export type { InterruptReceipt } from "./akuma-owner.js";
 export type { AkumaStatus } from "./akuma.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";

package/build/src/akuma/index.js

@@ -1,3 +1,4 @@
+export { AkumaArchetypeError, listArchetypeDefinitions } from "./archetype.js";
 export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";

package/build/src/akuma/nuke.js

@@ -1,10 +1,11 @@
 import { lstat, readdir, rm, rmdir } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { nukeAliases } from "../alias/index.js";
+import { knownAkuma } from "./akuma.js";
 import { settleAkumaKill } from "./akuma-owner.js";
 import { acquireLeash } from "./control.js";
 import { classifyHeartSchema, readHeart } from "./heart/index.js";
-import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot } from "./identity.js";
+import { akumaRunRoot } from "./identity.js";
 export class AkumaResetStopError extends Error {
     constructor(message) {
         super(message);
@@ -105,6 +106,7 @@ async function removeKnownRequestChannel(path) {
 async function removeAkumaEntry(entry) {
     await removeKnownRequestChannel(entry.paths.requests);
     for (const path of [
+        join(entry.paths.directory, "request-entry.json"),
         entry.paths.log,
         `${entry.paths.heart}-wal`,
         `${entry.paths.heart}-shm`,
@@ -136,34 +138,10 @@ async function removeEmptyAkumaRunRoot(world) {
     await removeEmptyDirectory(dirname(runRoot));
 }
 async function nukeAkumaEntries(world) {
-    const runRoot = akumaRunRoot(world);
-    let names;
-    try {
-        names = (await readdir(runRoot, { withFileTypes: true }))
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            names = [];
-        else
-            throw error;
-    }
     const entries = [];
-    for (const name of names) {
-        let physical;
-        try {
-            physical = akuIdFromDirectoryName(name);
-        }
-        catch {
-            // The run root can contain bytes not produced by Keiyaku. Preserve them.
-            continue;
-        }
-        const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
-        if (!(await hasAkumaCustody(paths)))
-            continue;
-        entries.push({ id: physical.id, paths });
+    for (const entry of (await knownAkuma(world)).rows) {
+        if (await hasAkumaCustody(entry.paths))
+            entries.push(entry);
     }
     return entries;
 }

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

@@ -56,15 +56,6 @@ export declare const tellRowSchema: z.ZodObject<{
         receipt?: "unavailable" | "required" | undefined;
     }>>>>;
 }, z.core.$strict>;
-declare const outcomeSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"answered">;
-    historyId: z.ZodString;
-    answer: z.ZodString;
-}, z.core.$strict>, z.ZodObject<{
-    kind: z.ZodLiteral<"failed">;
-    historyId: z.ZodString;
-    diagnostic: z.ZodString;
-}, z.core.$strict>]>;
 declare const outcomeRowSchema: z.ZodObject<{
     kind: z.ZodLiteral<"outcome">;
     sequence: z.ZodNumber;
@@ -920,7 +911,6 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>]>>>;
     omitted: z.ZodNumber;
 }, z.core.$strict>]>;
-export type TurnOutcome = z.infer<typeof outcomeSchema>;
 export type TurnStartRow = z.infer<typeof turnRowSchema>;
 type CallRow = z.infer<typeof callRowSchema>;
 type SaidRow = z.infer<ReturnType<typeof textRowSchema>>;
@@ -952,7 +942,6 @@ export type IdleSnapshotRow = z.infer<typeof idleSnapshotRowSchema>;
 export type SnapshotRow = OpenSnapshotRow | IdleSnapshotRow;
 export type ActivitySnapshotEntry<Row extends SnapshotRow = SnapshotRow> = z.infer<ReturnType<typeof snapshotEntrySchema<z.ZodType<Row>>>>;
 export type ReportedFileChange = z.infer<typeof reportedFileChangeSchema>;
-export type Snapshot = z.infer<typeof activitySnapshotSchema>;
 export type ActivitySnapshot = z.infer<typeof activitySnapshotSchema>;
 export type ActivityHistory = Readonly<{
     rows: readonly ActivityRow[];

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

@@ -1,7 +1,7 @@
 import { z } from "zod";
 declare const systemPromptModeSchema: z.ZodEnum<{
-    append: "append";
     replace: "replace";
+    append: "append";
 }>;
 export type SystemPromptMode = z.infer<typeof systemPromptModeSchema>;
 export declare const providerOptionsSchema: z.ZodPipe<z.ZodObject<{
@@ -13,11 +13,11 @@ export declare const providerOptionsSchema: z.ZodPipe<z.ZodObject<{
     }>>;
     systemPrompt: z.ZodOptional<z.ZodString>;
     systemPromptMode: z.ZodOptional<z.ZodEnum<{
-        append: "append";
         replace: "replace";
+        append: "append";
     }>>;
 }, z.core.$strip>, z.ZodTransform<Readonly<{
-    systemPromptMode?: "append" | "replace";
+    systemPromptMode?: "replace" | "append";
     systemPrompt?: string;
     network?: "disabled" | "enabled";
     effort?: string;
@@ -27,7 +27,7 @@ export declare const providerOptionsSchema: z.ZodPipe<z.ZodObject<{
     effort?: string | undefined;
     network?: "disabled" | "enabled" | undefined;
     systemPrompt?: string | undefined;
-    systemPromptMode?: "append" | "replace" | undefined;
+    systemPromptMode?: "replace" | "append" | undefined;
 }>>;
 export type ProviderOptions = z.infer<typeof providerOptionsSchema>;
 export declare const providerRecipeSchema: z.ZodPipe<z.ZodObject<{
@@ -38,6 +38,7 @@ export declare const providerRecipeSchema: z.ZodPipe<z.ZodObject<{
         "codex-app-server": "codex-app-server";
         "grok-build": "grok-build";
         "opencode-sdk": "opencode-sdk";
+        paseo: "paseo";
         pi: "pi";
     }>;
     executable: z.ZodOptional<z.ZodString>;
@@ -48,10 +49,10 @@ export declare const providerRecipeSchema: z.ZodPipe<z.ZodObject<{
     config?: Readonly<Record<string, unknown>>;
     executable?: string;
     name: string;
-    kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+    kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
 }>, {
     name: string;
-    kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+    kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
     executable?: string | undefined;
     config?: Record<string, unknown> | undefined;
     env?: Record<string, string> | undefined;

package/build/src/akuma/provider-recipe.js

@@ -35,7 +35,7 @@ function snapshot(value) {
 export const providerRecipeSchema = z
     .object({
     name: z.string().refine((value) => value.trim() !== "", "provider execution name must be a nonblank string"),
-    kind: z.enum(["acp", "claude-agent-sdk", "codex-app-server", "grok-build", "opencode-sdk", "pi"], {
+    kind: z.enum(["acp", "claude-agent-sdk", "codex-app-server", "grok-build", "opencode-sdk", "paseo", "pi"], {
         error: "provider execution has unknown kind",
     }),
     executable: z

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

@@ -1,13 +1,10 @@
 import { type ResumeCoordinate } from "./coordinate.js";
 import type { ProviderOptions } from "./provider-recipe.js";
 export type { ResumeCoordinate } from "./coordinate.js";
-export { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
-export { AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
-export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
-export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
+export { AKUMA_REQUESTS_ENV, AKUMA_REQUESTS_ENTRY_ENV } from "./providers/execution-environment.js";
 export declare const AGENT_EVENT_QUEUE_LIMIT = 256;
-export { agentEventSchema, decodeAgentEvent } from "./heart/activity-schema.js";
-export type { AgentEvent, SearchScope, ToolCall, ToolEvent, ToolInput, ToolResult } from "./heart/activity-schema.js";
+export { decodeAgentEvent } from "./heart/activity-schema.js";
+export type { AgentEvent, SearchScope, ToolCall, ToolResult } from "./heart/activity-schema.js";
 import type { AgentEvent, ToolCall, ToolInput } from "./heart/activity-schema.js";
 export declare function encodeAgentEvent(event: AgentEvent): AgentEvent;
 /**
@@ -19,8 +16,6 @@ export declare function boundedToolInput(input: unknown): ToolInput | undefined;
 export declare function otherToolCall(display: string, input?: unknown): Extract<ToolCall, {
     kind: "other";
 }>;
-export declare function boundedEventText(value: string): string;
-export declare function boundedThoughtText(value: string): string;
 export declare function noteEvent(note: string): Extract<AgentEvent, {
     type: "note";
 }>;
@@ -45,7 +40,7 @@ export type TurnResult = Readonly<{
     kind: "failed";
     diagnostic: string;
 }>;
-export type ProviderFence = string;
+type ProviderFence = string;
 export type TellReceipt = Readonly<{
     evidence: "exact";
     tellId: string;
@@ -87,7 +82,7 @@ export type ProviderAttempt<Result> = Readonly<{
     abort(): Promise<void>;
     forceDispose(): Promise<void>;
 }>;
-export type AttemptResource = Readonly<{
+type AttemptResource = Readonly<{
     /** Resolves only when this physical resource has retired. */
     closed: Promise<void>;
     abort?(): Promise<void>;
@@ -115,6 +110,7 @@ export type DriveInput = Readonly<{
     signal: AbortSignal;
     requests: Readonly<{
         dir: string;
+        entry?: string;
     }>;
     schemaJson?: string;
 }>;

package/build/src/akuma/provider.js

@@ -1,9 +1,8 @@
-export { decodeResumeCoordinate, encodeResumeCoordinate } from "./coordinate.js";
-export { AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
-export const AGENT_EVENT_TEXT_LIMIT = 16_384;
-export const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
+export { AKUMA_REQUESTS_ENV, AKUMA_REQUESTS_ENTRY_ENV } from "./providers/execution-environment.js";
+const AGENT_EVENT_TEXT_LIMIT = 16_384;
+const AGENT_THOUGHT_TEXT_LIMIT = 4_000;
 export const AGENT_EVENT_QUEUE_LIMIT = 256;
-export { agentEventSchema, decodeAgentEvent } from "./heart/activity-schema.js";
+export { decodeAgentEvent } from "./heart/activity-schema.js";
 function boundedToolCall(call) {
     switch (call.kind) {
         case "run":
@@ -156,10 +155,10 @@ function boundedToolInputJson(value) {
     }
     return { value: prefix, truncated: true };
 }
-export function boundedEventText(value) {
+function boundedEventText(value) {
     return value.slice(0, AGENT_EVENT_TEXT_LIMIT);
 }
-export function boundedThoughtText(value) {
+function boundedThoughtText(value) {
     return value.slice(0, AGENT_THOUGHT_TEXT_LIMIT);
 }
 export function noteEvent(note) {

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

@@ -1,4 +1,5 @@
 import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
+import { nonblank, object, positiveLine } from "../decode.js";
 export const EMPTY_ACP_EVENT_STATE = Object.freeze({
     answer: "",
     assistantMessageId: null,
@@ -27,20 +28,6 @@ function appendBlock(state, type, text, messageId) {
         },
     };
 }
-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, input) {
-    return otherToolCall(name, input);
-}
 function locationFact(locations) {
     if (locations === null || locations === undefined)
         return {};
@@ -57,7 +44,7 @@ function standardCall(update, name) {
     const location = locationFact(update.locations);
     if (update.kind === "read") {
         return location.path === undefined
-            ? otherCall(name, update.rawInput)
+            ? otherToolCall(name, update.rawInput)
             : {
                 kind: "read",
                 path: location.path,
@@ -67,12 +54,12 @@ function standardCall(update, name) {
     const input = object(update.rawInput);
     if (update.kind === "execute") {
         const command = nonblank(input?.command);
-        return command === undefined ? otherCall(name, update.rawInput) : { kind: "run", command };
+        return command === undefined ? otherToolCall(name, update.rawInput) : { kind: "run", command };
     }
     if (update.kind === "search") {
         const query = nonblank(input?.query);
         if (query === undefined)
-            return otherCall(name, update.rawInput);
+            return otherToolCall(name, update.rawInput);
         const path = nonblank(input?.path);
         const glob = nonblank(input?.glob);
         const scope = input?.scope;
@@ -85,7 +72,7 @@ function standardCall(update, name) {
             ...(glob === undefined ? {} : { glob }),
         };
     }
-    return otherCall(name, update.rawInput);
+    return otherToolCall(name, update.rawInput);
 }
 function strongest(previous, next) {
     if (previous === undefined || previous.kind === "other")

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

@@ -1,4 +1,4 @@
-import { createProviderAttempt } from "../../provider.js";
+import { providerLifecycle } from "../lifecycle.js";
 import { decodeAcpConfig } from "./config.js";
 import { startAcpSession } from "./core.js";
 export { decodeAcpConfig } from "./config.js";
@@ -63,7 +63,6 @@ export function createAcpProvider(execution, dependencies = {}) {
     };
     return {
         admitOptions: (options) => optionAdmission(options, config),
-        start: (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody)),
-        resume: (input) => createProviderAttempt(input.signal, async (custody) => await drive({ ...input, signal: custody.signal }, custody)),
+        ...providerLifecycle(drive),
     };
 }

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

@@ -1,4 +1,5 @@
 import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
+import { finiteNumber, object, positiveLine, searchToolCall, trimmed } from "../decode.js";
 export const CLAUDE_MESSAGE_DISPOSITIONS = {
     assistant: "assistant",
     auth_status: "auth",
@@ -42,20 +43,6 @@ export const CLAUDE_SYSTEM_DISPOSITIONS = {
     thinking_tokens: "drop",
     worker_shutting_down: "note",
 };
-function object(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-function nonblank(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function number(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function positiveLine(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
-}
 function readRange(value) {
     const offset = positiveLine(value.offset);
     const limit = positiveLine(value.limit);
@@ -64,21 +51,10 @@ function readRange(value) {
         ...(limit === undefined ? {} : { limit }),
     };
 }
-function contentSearch(value, query) {
-    const path = nonblank(value.path);
-    const glob = nonblank(value.glob);
-    return {
-        kind: "search",
-        query,
-        scope: "content",
-        ...(path === undefined ? {} : { path }),
-        ...(glob === undefined ? {} : { glob }),
-    };
-}
 const CLAUDE_SYSTEM_NOTES = {
     api_retry: (message) => {
-        const attempt = number(message.attempt);
-        const maximum = number(message.max_retries);
+        const attempt = finiteNumber(message.attempt);
+        const maximum = finiteNumber(message.max_retries);
         return attempt === undefined || maximum === undefined
             ? "Retrying request"
             : `Retrying request ${attempt}/${maximum}`;
@@ -90,24 +66,24 @@ const CLAUDE_SYSTEM_NOTES = {
         const failed = Array.isArray(message.failed) ? message.failed.length : 0;
         return failed === 0 ? `Persisted ${files} files` : `Persisted ${files} files; ${failed} failed`;
     },
-    informational: (message) => nonblank(message.content) ?? "Informational notice",
-    mirror_error: (message) => `Transcript mirror warning: ${nonblank(message.error) ?? nonblank(message.message) ?? "unknown error"}`,
+    informational: (message) => trimmed(message.content) ?? "Informational notice",
+    mirror_error: (message) => `Transcript mirror warning: ${trimmed(message.error) ?? trimmed(message.message) ?? "unknown error"}`,
     model_refusal_fallback: () => "Model refusal; using fallback",
     model_refusal_no_fallback: () => "Model refusal; no fallback available",
-    notification: (message) => nonblank(message.message) ?? nonblank(message.content) ?? "Notification",
-    permission_denied: (message) => `Permission refused${nonblank(message.message) === undefined ? "" : `: ${nonblank(message.message)}`}`,
-    plugin_install: (message) => `Plugin install ${nonblank(message.status) ?? "updated"}${nonblank(message.name) === undefined ? "" : `: ${nonblank(message.name)}`}`,
-    status: (message) => `Status: ${nonblank(message.status) ?? "idle"}${nonblank(message.error) === undefined ? "" : ` (${nonblank(message.error)})`}`,
-    task_notification: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} ${nonblank(message.status) ?? "updated"}`,
-    task_progress: (message) => nonblank(message.description) ?? `Task ${nonblank(message.task_id) ?? "unknown"} progressed`,
-    task_started: (message) => nonblank(message.description) ?? `Task ${nonblank(message.task_id) ?? "unknown"} started`,
-    task_updated: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} updated`,
-    worker_shutting_down: (message) => `Worker stopping: ${nonblank(message.reason) ?? "unknown reason"}`,
+    notification: (message) => trimmed(message.message) ?? trimmed(message.content) ?? "Notification",
+    permission_denied: (message) => `Permission refused${trimmed(message.message) === undefined ? "" : `: ${trimmed(message.message)}`}`,
+    plugin_install: (message) => `Plugin install ${trimmed(message.status) ?? "updated"}${trimmed(message.name) === undefined ? "" : `: ${trimmed(message.name)}`}`,
+    status: (message) => `Status: ${trimmed(message.status) ?? "idle"}${trimmed(message.error) === undefined ? "" : ` (${trimmed(message.error)})`}`,
+    task_notification: (message) => `Task ${trimmed(message.task_id) ?? "unknown"} ${trimmed(message.status) ?? "updated"}`,
+    task_progress: (message) => trimmed(message.description) ?? `Task ${trimmed(message.task_id) ?? "unknown"} progressed`,
+    task_started: (message) => trimmed(message.description) ?? `Task ${trimmed(message.task_id) ?? "unknown"} started`,
+    task_updated: (message) => `Task ${trimmed(message.task_id) ?? "unknown"} updated`,
+    worker_shutting_down: (message) => `Worker stopping: ${trimmed(message.reason) ?? "unknown reason"}`,
 };
 function runCall(name, value, input) {
     if (name !== "Bash")
         return undefined;
-    const command = nonblank(value.command);
+    const command = trimmed(value.command);
     return command === undefined ? otherToolCall(name, input) : { kind: "run", command };
 }
 function readCall(name, path, value) {
@@ -115,19 +91,18 @@ function readCall(name, path, value) {
 }
 function searchCall(name, value) {
     if (name === "Grep") {
-        const query = nonblank(value.pattern) ?? nonblank(value.query);
-        return query === undefined ? undefined : contentSearch(value, query);
-    }
-    if (name === "Glob") {
-        const query = nonblank(value.pattern);
-        const globPath = nonblank(value.path);
+        const query = trimmed(value.pattern) ?? trimmed(value.query);
         return query === undefined
             ? undefined
-            : { kind: "search", query, scope: "files", ...(globPath === undefined ? {} : { path: globPath }) };
+            : searchToolCall(query, "content", { path: trimmed(value.path), glob: trimmed(value.glob) });
+    }
+    if (name === "Glob") {
+        const query = trimmed(value.pattern);
+        return query === undefined ? undefined : searchToolCall(query, "files", { path: trimmed(value.path) });
     }
     if (name === "WebSearch") {
-        const query = nonblank(value.query);
-        return query === undefined ? undefined : { kind: "search", query, scope: "web" };
+        const query = trimmed(value.query);
+        return query === undefined ? undefined : searchToolCall(query, "web");
     }
     return undefined;
 }
@@ -143,8 +118,8 @@ function fileChangeCall(name, path) {
 }
 function startedPath(name, value) {
     if (name === "NotebookEdit")
-        return nonblank(value.notebook_path);
-    return nonblank(value.file_path) ?? (name === "Read" ? nonblank(value.path) : undefined);
+        return trimmed(value.notebook_path);
+    return trimmed(value.file_path) ?? (name === "Read" ? trimmed(value.path) : undefined);
 }
 function nonnegativeInt(value) {
     return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : undefined;
@@ -163,7 +138,7 @@ function writeResult(result) {
     const value = object(result);
     if (value === undefined || (value.type !== "create" && value.type !== "update"))
         return undefined;
-    const path = nonblank(value.filePath);
+    const path = trimmed(value.filePath);
     if (path === undefined)
         return undefined;
     const op = value.type === "create" ? "add" : "update";
@@ -173,14 +148,14 @@ function editResult(result) {
     const value = object(result);
     if (value === undefined || value.type === "create" || value.type === "update")
         return undefined;
-    const path = nonblank(value.filePath);
+    const path = trimmed(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);
+    const path = trimmed(object(result)?.notebook_path);
     return path === undefined ? undefined : { kind: "fileChange", changes: [{ op: "update", path }] };
 }
 function structuredFileChange(name, result) {
@@ -232,7 +207,7 @@ function toolResultEvents(message, events, state) {
         const value = object(block);
         if (value?.type !== "tool_result")
             continue;
-        const id = nonblank(value.tool_use_id);
+        const id = trimmed(value.tool_use_id);
         if (id === undefined)
             continue;
         const observed = state.tools.get(id);
@@ -252,15 +227,15 @@ function toolResultEvents(message, events, state) {
     }
 }
 function hookResponseNote(value) {
-    const outcome = nonblank(value.outcome);
+    const outcome = trimmed(value.outcome);
     if (outcome !== "error" && outcome !== "cancelled")
         return undefined;
-    const hook = nonblank(value.hook_name) ?? "unknown";
-    const exitCode = number(value.exit_code);
+    const hook = trimmed(value.hook_name) ?? "unknown";
+    const exitCode = finiteNumber(value.exit_code);
     return `Hook ${hook} ${outcome}${exitCode === undefined ? "" : ` (exit ${exitCode})`}`;
 }
 function emitSystemMessage(value, events) {
-    const subtype = nonblank(value?.subtype) ?? "unknown";
+    const subtype = trimmed(value?.subtype) ?? "unknown";
     if (!Object.hasOwn(CLAUDE_SYSTEM_DISPOSITIONS, subtype)) {
         events.emit(unknownEvent(subtype));
         return;
@@ -281,7 +256,7 @@ function emitSystemMessage(value, events) {
 }
 export function emitClaudeMessage(message, events, state) {
     const value = object(message) ?? {};
-    const kind = nonblank(value.type) ?? "unknown";
+    const kind = trimmed(value.type) ?? "unknown";
     if (!Object.hasOwn(CLAUDE_MESSAGE_DISPOSITIONS, kind))
         return events.emit(unknownEvent(kind));
     const disposition = CLAUDE_MESSAGE_DISPOSITIONS[kind];
@@ -292,7 +267,7 @@ export function emitClaudeMessage(message, events, state) {
         toolResultEvents(message, events, state);
     }
     else if (disposition === "auth") {
-        const error = nonblank(value.error);
+        const error = trimmed(value.error);
         if (error !== undefined)
             events.emit(noteEvent(`Authentication warning: ${error}`));
     }

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

@@ -2,13 +2,12 @@ import type { Options, Query, SDKUserMessage } from "@anthropic-ai/claude-agent-
 import { type ProviderAdapter, type Session } from "../../provider.js";
 import type { ProviderOptions } from "../../provider-recipe.js";
 import type { ResumeCoordinate } from "../../provider.js";
-export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
 type ClaudeExecution = Readonly<{
     executable?: string;
     config?: Readonly<Record<string, unknown>>;
     env?: Readonly<Record<string, string>>;
 }>;
-export type ClaudeSdk = Readonly<{
+type ClaudeSdk = Readonly<{
     query(input: Readonly<{
         prompt: string | AsyncIterable<SDKUserMessage>;
         options?: Options;
@@ -42,3 +41,4 @@ export declare const claudeProvider: Readonly<{
         }>;
     }>): import("../../provider.js").ProviderAttempt<Session>;
 }>;
+export {};

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

@@ -2,9 +2,9 @@ import { randomUUID } from "node:crypto";
 import { abortable } from "../../abort.js";
 import { AgentEventChannel, createProviderAttempt, } from "../../provider.js";
 import { akumaExecutionEnvironment } from "../execution-environment.js";
+import { providerLifecycle } from "../lifecycle.js";
 import { emitClaudeMessage } from "./events.js";
 import { claudeUserMessage, createClaudeInput, isClaudeTurnEnded } from "./input.js";
-export { CLAUDE_MESSAGE_DISPOSITIONS, CLAUDE_SYSTEM_DISPOSITIONS } from "./events.js";
 class ReceiptChannel {
     queued = [];
     waiters = [];
@@ -364,8 +364,7 @@ export function createClaudeProvider(loadOrExecution = async () => (await import
     return {
         admitOptions: admitClaudeOptions,
         fork: (input) => createProviderAttempt(new AbortController().signal, async () => await forkClaude(load, selectedExecution, input)),
-        start: (input) => createProviderAttempt(input.signal, async (custody) => await driveClaude(load, selectedExecution, { ...input, signal: custody.signal }, custody)),
-        resume: (input) => createProviderAttempt(input.signal, async (custody) => await driveClaude(load, selectedExecution, { ...input, signal: custody.signal }, custody)),
+        ...providerLifecycle((input, custody) => driveClaude(load, selectedExecution, input, custody)),
     };
 }
 export const claudeProvider = createClaudeProvider(async () => (await import("@anthropic-ai/claude-agent-sdk")));