@astrosheep/keiyaku 4.5.26 → 4.5.28

package/build/src/akuma/fleet-request.js

@@ -1,10 +1,10 @@
 import { akumaIdSchema } from "./akuma.js";
 import { requestBodyCommand } from "./request-rendezvous.js";
 import { eraseRequestCommand, } from "./request-wire.js";
-import { fleetResultSchemas, isKillResult, isTellResult, isWaitResult, } from "./fleet-observation.js";
+import { fleetResultSchemas, isKillResult, isTellResult, isTellWaitResult, isWaitResult, } from "./fleet-observation.js";
 import { z } from "zod";
 import { schemaJsonText } from "./schema.js";
-import { AkumaDecodeError } from "./akuma-errors.js";
+import { AkumaDecodeError, AkumaNotBornError, AkumaObservationError } from "./akuma-errors.js";
 const nonblankTextSchema = z.string().refine((value) => value.trim() !== "");
 const fleetTargetsSchema = z
     .array(akumaIdSchema)
@@ -39,6 +39,17 @@ const tellAnswerRequestSchema = z
 })
     .strict()
     .transform((request) => ({ action: "akuma.tell-answer", ...request }));
+const tellWaitRequestSchema = z
+    .object({
+    target: akumaIdSchema,
+    body: z.string(),
+    timeoutMs: z.number().int().nonnegative(),
+    schemaJson: nonblankTextSchema.optional(),
+    initiator: nonblankTextSchema.optional(),
+    interrupt: z.boolean().optional(),
+})
+    .strict()
+    .transform((request) => ({ action: "akuma.tell-wait", ...request }));
 const killRequestSchema = z
     .object({ targets: fleetTargetsSchema })
     .strict()
@@ -47,12 +58,49 @@ const waitServiceSchema = z.object({ action: z.literal("akuma.wait") }).strict()
 const tellServiceSchema = z
     .object({ action: z.literal("akuma.tell"), target: akumaIdSchema, tellId: nonblankTextSchema })
     .strict();
+const tellWaitServiceSchema = z
+    .object({ action: z.literal("akuma.tell-wait"), target: akumaIdSchema, tellId: nonblankTextSchema })
+    .strict();
 const killServiceSchema = z
     .object({
     action: z.literal("akuma.kill"),
     results: z.array(z.object({ id: akumaIdSchema, evidence: fleetResultSchemas.killEvidence }).strict()),
 })
     .strict();
+/**
+ * A forwarded Fleet request leaves selection and observation to the parent, so
+ * the parent's typed refusal is the only evidence the child can classify on.
+ * Transporting it is the codec's own duty: an unencoded failure reaches the
+ * caller as an anonymous request error and loses the identity it names.
+ *
+ * The transport voids a begun request only when the encoded failure proves no
+ * product effect. A refused selection or an unreadable observation never
+ * reached an action, so Fleet proves that through the same refusal envelope
+ * the Contract codec uses; a genuinely failed action stays unencoded and
+ * keeps its existing anonymous classification.
+ */
+const fleetRefusalSchema = z.union([
+    z.object({ kind: z.literal("akuma-not-born"), id: akumaIdSchema }).strict(),
+    z.object({ kind: z.literal("akuma-observation"), id: akumaIdSchema, diagnostic: z.string() }).strict(),
+]);
+const fleetLiveFailureSchema = z.object({ kind: z.literal("refused"), failure: fleetRefusalSchema }).strict();
+export function encodeFleetLiveFailure(error) {
+    const failure = error instanceof AkumaNotBornError
+        ? { kind: "akuma-not-born", id: error.id }
+        : error instanceof AkumaObservationError
+            ? { kind: "akuma-observation", id: error.id, diagnostic: error.diagnostic }
+            : null;
+    return failure === null ? null : { kind: "refused", failure };
+}
+export function decodeFleetLiveFailure(value) {
+    const parsed = fleetLiveFailureSchema.safeParse(value);
+    if (!parsed.success)
+        return null;
+    const failure = parsed.data.failure;
+    return failure.kind === "akuma-not-born"
+        ? new AkumaNotBornError(failure.id)
+        : new AkumaObservationError(failure.id, failure.diagnostic);
+}
 function decodeFleetRequest(action, value) {
     const schema = action === "akuma.wait"
         ? waitRequestSchema
@@ -60,7 +108,9 @@ function decodeFleetRequest(action, value) {
             ? tellRequestSchema
             : action === "akuma.tell-answer"
                 ? tellAnswerRequestSchema
-                : killRequestSchema;
+                : action === "akuma.tell-wait"
+                    ? tellWaitRequestSchema
+                    : killRequestSchema;
     const parsed = schema.safeParse(value);
     return parsed.success ? parsed.data : null;
 }
@@ -69,7 +119,9 @@ function decodeFleetService(action, value) {
         ? waitServiceSchema
         : action === "akuma.tell" || action === "akuma.tell-answer"
             ? tellServiceSchema
-            : killServiceSchema;
+            : action === "akuma.tell-wait"
+                ? tellWaitServiceSchema
+                : killServiceSchema;
     const parsed = schema.safeParse(value);
     if (!parsed.success)
         throw new Error("malformed stored Fleet service evidence");
@@ -82,7 +134,9 @@ function decodedFleetResult(action, value) {
         ? fleetResultSchemas.wait
         : action === "akuma.tell"
             ? fleetResultSchemas.tell
-            : fleetResultSchemas.kill;
+            : action === "akuma.tell-wait"
+                ? fleetResultSchemas.tellWait
+                : fleetResultSchemas.kill;
     const parsed = schema.safeParse(value);
     if (!parsed.success)
         throw new Error(`Akuma body request returned an invalid live result for ${action}`);
@@ -100,9 +154,12 @@ export function fleetRequestProtocol(action) {
         decodeRequest: (payload) => decodeFleetRequest(action, payload),
         encodeResult: (result) => result,
         decodeResult: (result) => decodedFleetResult(action, result),
+        encodeFailure: encodeFleetLiveFailure,
+        decodeFailure: decodeFleetLiveFailure,
         decodeReference: (reference) => decodeFleetService(action, reference),
         isPermitted: (allowed) => action === "akuma.wait" ||
-            ((action === "akuma.tell" || action === "akuma.tell-answer") && allowed.includes("akuma.tell")) ||
+            ((action === "akuma.tell" || action === "akuma.tell-answer" || action === "akuma.tell-wait") &&
+                allowed.includes("akuma.tell")) ||
             (action === "akuma.kill" && allowed.includes("akuma.kill")),
     };
 }
@@ -148,6 +205,24 @@ export function fleetRequestCommand(action, port) {
                     service: { action: "akuma.tell", target: request.target, tellId: facts.id },
                 };
             }
+            if (request.action === "akuma.tell-wait") {
+                if (port.tellWait === undefined)
+                    throw new Error("bounded Tell Fleet port is unavailable");
+                return {
+                    result: await port.tellWait({
+                        target: request.target,
+                        body: request.body,
+                        tellId: facts.id,
+                        recordedAt: facts.admittedAt,
+                        timeoutMs: request.timeoutMs,
+                        ...(request.schemaJson === undefined ? {} : { schemaJson: request.schemaJson }),
+                        ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
+                        ...(request.interrupt === undefined ? {} : { interrupt: request.interrupt }),
+                        signal: facts.signal,
+                    }),
+                    service: { action: request.action, target: request.target, tellId: facts.id },
+                };
+            }
             const result = await port.kill({ targets: request.targets, signal: facts.signal });
             if ("result" in result)
                 return { result: result.result, service: { action: request.action, results: result.service } };
@@ -163,6 +238,7 @@ export function fleetRequestCommands(port) {
         "akuma.wait": eraseRequestCommand(fleetRequestCommand("akuma.wait", port)),
         "akuma.tell": eraseRequestCommand(fleetRequestCommand("akuma.tell", port)),
         "akuma.tell-answer": eraseRequestCommand(fleetRequestCommand("akuma.tell-answer", port)),
+        "akuma.tell-wait": eraseRequestCommand(fleetRequestCommand("akuma.tell-wait", port)),
         "akuma.kill": eraseRequestCommand(fleetRequestCommand("akuma.kill", port)),
     };
 }
@@ -195,6 +271,8 @@ function forwardedFleetCommandResult(response, action) {
             return response.result;
         if (action === "akuma.tell" && isTellResult(response.result))
             return response.result;
+        if (action === "akuma.tell-wait" && isTellWaitResult(response.result))
+            return response.result;
         if (action === "akuma.kill" && isKillResult(response.result))
             return response.result;
         throw new Error(`transport integrity: request Fleet ${action} returned an invalid live result`);
@@ -229,6 +307,23 @@ export async function requestForwardedFleetTell(input) {
     });
     return forwardedFleetCommandResult(response, "akuma.tell");
 }
+export async function requestForwardedFleetTellWait(input) {
+    const response = await requestBodyCommand({
+        directory: input.directory,
+        command: fleetRequestProtocol("akuma.tell-wait"),
+        value: {
+            action: "akuma.tell-wait",
+            target: input.target,
+            body: input.body,
+            timeoutMs: input.timeoutMs,
+            ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+            ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
+        },
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    return forwardedFleetCommandResult(response, "akuma.tell-wait");
+}
 export async function requestForwardedFleetKill(input) {
     const response = await requestBodyCommand({
         directory: input.directory,

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

@@ -94,6 +94,7 @@ export declare function failOpenBoundTurns(paths: AkumaPaths, input: Readonly<{
     completedAt: string;
 }>): Promise<readonly number[]>;
 export declare function readTurn(paths: AkumaPaths, sequence: number): Promise<TurnFact | null>;
+export declare function readLatestTurnForBody(paths: AkumaPaths, bodySequence: number): Promise<TurnFact | null>;
 export declare function endTurn(paths: AkumaPaths, input: Readonly<{
     turnSequence: number;
     outcome: TurnOutcome;

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

@@ -1,5 +1,5 @@
 import { parsePublicHistoryId } from "../identity.js";
-import { answeredTurnFact, endBodyFact, finishBodyFact, deleteStopControl, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertKillFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
+import { answeredTurnFact, endBodyFact, finishBodyFact, deleteStopControl, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertKillFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, latestTurnFactForBody, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
 import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, } from "./tells.js";
 import { activityFactSlice, statusFacts, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, withHeartTransaction, withReadOnlyHeart } from "./storage.js";
@@ -264,6 +264,9 @@ export async function failOpenBoundTurns(paths, input) {
 export async function readTurn(paths, sequence) {
     return await withReadOnlyHeart(paths, (heart) => turnFact(heart, sequence));
 }
+export async function readLatestTurnForBody(paths, bodySequence) {
+    return await withReadOnlyHeart(paths, (heart) => latestTurnFactForBody(heart, bodySequence));
+}
 export async function endTurn(paths, input) {
     return await withHeartTransaction(paths, (heart) => {
         const fact = insertTurnEndFact(heart, { kind: "turn-end", ...input });

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

@@ -122,4 +122,5 @@ export declare function latestKillFact(database: DatabaseSync): KillFact | null;
 export declare function killFactForBody(database: DatabaseSync, bodySequence: number): KillFact | null;
 export declare function lastAnsweredTurnFact(database: DatabaseSync): TurnFact | null;
 export declare function answeredTurnFact(database: DatabaseSync, turnSequence: number): TurnFact | null;
+export declare function latestTurnFactForBody(database: DatabaseSync, bodySequence: number): TurnFact | null;
 export declare function turnFact(database: DatabaseSync, turnSequence: number): TurnFact | null;

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

@@ -299,6 +299,14 @@ export function answeredTurnFact(database, turnSequence) {
         .get(turnSequence);
     return row === undefined ? null : decodeTurnRow(row);
 }
+export function latestTurnFactForBody(database, bodySequence) {
+    const row = database
+        .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
+    session_json, answer, answer_json, schema_json, initiator, diagnostic, completed_at
+    FROM turns WHERE body_sequence = ? ORDER BY sequence DESC LIMIT 1`)
+        .get(bodySequence);
+    return row === undefined ? null : decodeTurnRow(row);
+}
 export function turnFact(database, turnSequence) {
     const row = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,

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

@@ -1,6 +1,6 @@
 import { parseAkuId } from "../identity.js";
 import { decodeProviderOptions, decodeProviderRecipe, decodeReadonlyRestraint } from "../provider-recipe.js";
-import { effectiveAllowedActions } from "../allowed.js";
+import { historicalAllowedActions } from "../allowed.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -68,7 +68,7 @@ function validateSoul(value) {
         ...(restraint === undefined ? {} : { readonly: restraint }),
         cwd: nonblank(soul.cwd, "cwd"),
         origin: decodeOrigin(soul.origin),
-        allowed: effectiveAllowedActions(soul.allowed),
+        allowed: historicalAllowedActions(soul.allowed),
         createdAt: nonblank(soul.createdAt, "createdAt"),
     };
 }

package/build/src/akuma/identity.js

@@ -2,7 +2,7 @@ import { randomBytes } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { identityCoordinate, identitySegments } from "../identity/coordinates.js";
-import { normalizeIdentityStem } from "../identity/normalize.js";
+import { isCanonicalAkumaName, validateAkumaName } from "../identity/normalize.js";
 const HEX8 = /^[0-9a-f]{8}$/u;
 export function parsePublicHistoryId(value) {
     const match = /^turn\/([1-9][0-9]*)$/u.exec(value);
@@ -12,10 +12,7 @@ export function parsePublicHistoryId(value) {
     return Number.isSafeInteger(sequence) ? sequence : null;
 }
 export function archetypeName(value) {
-    if (value.length === 0 || normalizeIdentityStem({ source: value }) !== value) {
-        throw new TypeError("Akuma name must be one normalized human identity segment");
-    }
-    return value;
+    return validateAkumaName(value);
 }
 function suffixSegment(value) {
     if (!HEX8.test(value))
@@ -32,15 +29,20 @@ export function parseAkuId(value) {
     const segments = identitySegments({ family: "aku", value });
     if (segments.length !== 2)
         throw new TypeError("Akuma identity must be aku/<akuma>/<hex8>");
-    const archetype = archetypeName(segments[0]);
+    const archetype = segments[0];
+    // Existing identities remain addressable after new births gain a name limit.
+    if (!isCanonicalAkumaName(archetype))
+        throw new TypeError("Akuma name must be one normalized human identity segment");
     const suffix = suffixSegment(segments[1]);
-    return { id: akuId({ archetype, suffix }), archetype, suffix };
+    return { id: value, archetype, suffix };
 }
 export function akumaRunRoot(worldRoot) {
     return join(worldRoot, ".keiyaku", "akuma", "run");
 }
 export function akumaPaths(input) {
-    const directory = join(input.runRoot, `${archetypeName(input.archetype)}-${suffixSegment(input.suffix)}`);
+    if (!isCanonicalAkumaName(input.archetype))
+        throw new TypeError("Akuma name must be one normalized human identity segment");
+    const directory = join(input.runRoot, `${input.archetype}-${suffixSegment(input.suffix)}`);
     return {
         directory,
         heart: join(directory, "heart.db"),
@@ -54,7 +56,7 @@ export function akuIdFromDirectoryName(name) {
         throw new Error(`invalid Akuma run directory ${name}`);
     const archetype = name.slice(0, -9);
     const suffix = name.slice(-8);
-    return { id: akuId({ archetype, suffix }), archetype, suffix };
+    return parseAkuId(`aku/${archetype}/${suffix}`);
 }
 export async function ensureAkumaRunRoot(worldRoot) {
     const runRoot = akumaRunRoot(worldRoot);

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

@@ -122,6 +122,10 @@ declare const activeToolRowSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
         display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
     }, z.core.$strict>]>;
     state: z.ZodLiteral<"active">;
     truncated: z.ZodOptional<z.ZodLiteral<true>>;
@@ -170,6 +174,10 @@ declare const completedToolRowSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
         display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
     }, z.core.$strict>]>;
     state: z.ZodObject<{
         status: z.ZodEnum<{
@@ -223,6 +231,10 @@ declare const unsettledToolRowSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
         display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
     }, z.core.$strict>]>;
     state: z.ZodLiteral<"unsettled">;
     truncated: z.ZodOptional<z.ZodLiteral<true>>;
@@ -328,6 +340,10 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
         display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
     }, z.core.$strict>]>;
     state: z.ZodLiteral<"active">;
     truncated: z.ZodOptional<z.ZodLiteral<true>>;
@@ -375,6 +391,10 @@ declare const openSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
         display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
     }, z.core.$strict>]>;
     state: z.ZodObject<{
         status: z.ZodEnum<{
@@ -489,6 +509,10 @@ declare const idleSnapshotRowSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
         display: z.ZodString;
+        input: z.ZodOptional<z.ZodObject<{
+            json: z.ZodString;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>>;
     }, z.core.$strict>]>;
     state: z.ZodObject<{
         status: z.ZodEnum<{
@@ -673,6 +697,10 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"other">;
                 display: z.ZodString;
+                input: z.ZodOptional<z.ZodObject<{
+                    json: z.ZodString;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
             }, z.core.$strict>]>;
             state: z.ZodLiteral<"active">;
             truncated: z.ZodOptional<z.ZodLiteral<true>>;
@@ -720,6 +748,10 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"other">;
                 display: z.ZodString;
+                input: z.ZodOptional<z.ZodObject<{
+                    json: z.ZodString;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
             }, z.core.$strict>]>;
             state: z.ZodObject<{
                 status: z.ZodEnum<{
@@ -875,6 +907,10 @@ export declare const activitySnapshotSchema: z.ZodUnion<readonly [z.ZodObject<{
             }, z.core.$strict>, z.ZodObject<{
                 kind: z.ZodLiteral<"other">;
                 display: z.ZodString;
+                input: z.ZodOptional<z.ZodObject<{
+                    json: z.ZodString;
+                    truncated: z.ZodBoolean;
+                }, z.core.$strict>>;
             }, z.core.$strict>]>;
             state: z.ZodObject<{
                 status: z.ZodEnum<{

package/build/src/akuma/projection.js

@@ -13,6 +13,7 @@ const fileChangeSchema = z
     diffstat: diffstatSchema.optional(),
 })
     .strict();
+const toolInputSchema = z.object({ json: z.string(), truncated: z.boolean() }).strict();
 const toolCallSchema = z.union([
     z.object({ kind: z.literal("run"), command: z.string() }).strict(),
     z
@@ -33,7 +34,7 @@ const toolCallSchema = z.union([
     })
         .strict(),
     z.object({ kind: z.literal("fileChange"), changes: z.array(fileChangeSchema).readonly() }).strict(),
-    z.object({ kind: z.literal("other"), display: z.string() }).strict(),
+    z.object({ kind: z.literal("other"), display: z.string(), input: toolInputSchema.optional() }).strict(),
 ]);
 const toolResultSchema = z
     .object({ status: z.enum(["ok", "error"]), message: z.string().optional(), exitCode: z.number().int().optional() })

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

@@ -6,6 +6,10 @@ export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
 export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
 export declare const AGENT_EVENT_QUEUE_LIMIT = 256;
 export type SearchScope = "content" | "files" | "web";
+export type ToolInput = Readonly<{
+    json: string;
+    truncated: boolean;
+}>;
 export type ToolCall = Readonly<{
     kind: "run";
     command: string;
@@ -33,6 +37,7 @@ export type ToolCall = Readonly<{
 }> | Readonly<{
     kind: "other";
     display: string;
+    input?: ToolInput;
 }>;
 export type ToolResult = Readonly<{
     status: "ok" | "error";
@@ -75,6 +80,15 @@ export type AgentEvent = Readonly<{
 export { decodeResumeCoordinate, encodeResumeCoordinate };
 export declare function decodeAgentEvent(value: unknown): AgentEvent;
 export declare function encodeAgentEvent(event: AgentEvent): unknown;
+/**
+ * Admit only a compact JSON view of structured tool invocation input.  This
+ * deliberately receives adapter start evidence, never result or delta bodies.
+ */
+export declare function boundedToolInput(input: unknown): ToolInput | undefined;
+/** Build one generic call from the provider's structured invocation evidence. */
+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, {

package/build/src/akuma/provider.js

@@ -107,8 +107,19 @@ function decodeFileChangeCall(call) {
     const changes = call.changes.map(decodeFileChangeMember);
     return changes.every((change) => change !== null) ? { kind: "fileChange", changes } : null;
 }
+function decodeToolInput(value) {
+    if (value === undefined)
+        return undefined;
+    const input = object(value);
+    if (input === null || typeof input.json !== "string" || typeof input.truncated !== "boolean")
+        return null;
+    return { json: input.json, truncated: input.truncated };
+}
 function decodeOtherCall(call) {
-    return typeof call.display === "string" ? { kind: "other", display: call.display } : null;
+    if (typeof call.display !== "string")
+        return null;
+    const input = decodeToolInput(call.input);
+    return input === null ? null : { kind: "other", display: call.display, ...(input === undefined ? {} : { input }) };
 }
 function decodeToolCall(value) {
     const call = object(value);
@@ -242,11 +253,22 @@ function boundedToolCall(call) {
                 },
                 truncated: call.changes.some((change) => change.path.length > AGENT_EVENT_TEXT_LIMIT),
             };
-        case "other":
+        case "other": {
+            const input = call.input;
+            const display = boundedEventText(call.display);
+            const bounded = input === undefined ? undefined : boundedToolInputJson(input.json);
             return {
-                value: { kind: call.kind, display: boundedEventText(call.display) },
-                truncated: call.display.length > AGENT_EVENT_TEXT_LIMIT,
+                value: {
+                    kind: call.kind,
+                    display,
+                    ...(bounded === undefined || input === undefined
+                        ? {}
+                        : { input: { json: bounded.value, truncated: input.truncated || bounded.truncated } }),
+                },
+                truncated: call.display.length > AGENT_EVENT_TEXT_LIMIT ||
+                    (input !== undefined && (input.truncated || bounded?.truncated === true)),
             };
+        }
         default:
             return call;
     }
@@ -302,6 +324,46 @@ export function encodeAgentEvent(event) {
             return event;
     }
 }
+/**
+ * Admit only a compact JSON view of structured tool invocation input.  This
+ * deliberately receives adapter start evidence, never result or delta bodies.
+ */
+export function boundedToolInput(input) {
+    if (input === undefined)
+        return undefined;
+    let json;
+    try {
+        const encoded = JSON.stringify(input);
+        if (encoded === undefined)
+            return undefined;
+        json = encoded;
+    }
+    catch {
+        return undefined;
+    }
+    const bounded = boundedToolInputJson(json);
+    return { json: bounded.value, truncated: bounded.truncated };
+}
+/** Build one generic call from the provider's structured invocation evidence. */
+export function otherToolCall(display, input) {
+    const preview = boundedToolInput(input);
+    return { kind: "other", display, ...(preview === undefined ? {} : { input: preview }) };
+}
+function boundedToolInputJson(value) {
+    if (new TextEncoder().encode(value).length <= AGENT_EVENT_TEXT_LIMIT)
+        return { value, truncated: false };
+    let bytes = 0;
+    let prefix = "";
+    const encoder = new TextEncoder();
+    for (const codePoint of value) {
+        const length = encoder.encode(codePoint).length;
+        if (bytes + length > AGENT_EVENT_TEXT_LIMIT)
+            break;
+        prefix += codePoint;
+        bytes += length;
+    }
+    return { value: prefix, truncated: true };
+}
 export function boundedEventText(value) {
     return value.slice(0, AGENT_EVENT_TEXT_LIMIT);
 }

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

@@ -1,4 +1,4 @@
-import { noteEvent, unknownEvent } from "../../provider.js";
+import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
 export const EMPTY_ACP_EVENT_STATE = Object.freeze({
     answer: "",
     assistantMessageId: null,
@@ -38,8 +38,8 @@ function object(value) {
 function positiveLine(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value >= 1 ? value : undefined;
 }
-function otherCall(name) {
-    return { kind: "other", display: name };
+function otherCall(name, input) {
+    return otherToolCall(name, input);
 }
 function locationFact(locations) {
     if (locations === null || locations === undefined)
@@ -57,7 +57,7 @@ function standardCall(update, name) {
     const location = locationFact(update.locations);
     if (update.kind === "read") {
         return location.path === undefined
-            ? otherCall(name)
+            ? otherCall(name, update.rawInput)
             : {
                 kind: "read",
                 path: location.path,
@@ -67,12 +67,12 @@ function standardCall(update, name) {
     const input = object(update.rawInput);
     if (update.kind === "execute") {
         const command = nonblank(input?.command);
-        return command === undefined ? otherCall(name) : { kind: "run", command };
+        return command === undefined ? otherCall(name, update.rawInput) : { kind: "run", command };
     }
     if (update.kind === "search") {
         const query = nonblank(input?.query);
         if (query === undefined)
-            return otherCall(name);
+            return otherCall(name, update.rawInput);
         const path = nonblank(input?.path);
         const glob = nonblank(input?.glob);
         const scope = input?.scope;
@@ -85,7 +85,7 @@ function standardCall(update, name) {
             ...(glob === undefined ? {} : { glob }),
         };
     }
-    return otherCall(name);
+    return otherCall(name, update.rawInput);
 }
 function strongest(previous, next) {
     if (previous === undefined || previous.kind === "other")
@@ -96,7 +96,15 @@ 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) };
+    const call = strongest(previous?.call, dialect ?? standard);
+    if (call.kind !== "other")
+        return { name, call };
+    // The correlated start's admitted preview is authority: a later update never
+    // overwrites it, empty or not, while a start without one adopts first supplied evidence.
+    const started = previous?.call.kind === "other" ? previous.call.input : undefined;
+    const supplied = standard.kind === "other" ? standard.input : undefined;
+    const input = started ?? supplied;
+    return { name, call: input === undefined ? call : { kind: "other", display: call.display, input } };
 }
 export function mapAcpUpdate(update, previous, interpret) {
     switch (update.sessionUpdate) {

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

@@ -1,4 +1,4 @@
-import { noteEvent, unknownEvent } from "../../provider.js";
+import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
 export const CLAUDE_MESSAGE_DISPOSITIONS = {
     assistant: "assistant",
     auth_status: "auth",
@@ -104,11 +104,11 @@ const CLAUDE_SYSTEM_NOTES = {
     task_updated: (message) => `Task ${nonblank(message.task_id) ?? "unknown"} updated`,
     worker_shutting_down: (message) => `Worker stopping: ${nonblank(message.reason) ?? "unknown reason"}`,
 };
-function runCall(name, value) {
+function runCall(name, value, input) {
     if (name !== "Bash")
         return undefined;
     const command = nonblank(value.command);
-    return command === undefined ? { kind: "other", display: name } : { kind: "run", command };
+    return command === undefined ? otherToolCall(name, input) : { kind: "run", command };
 }
 function readCall(name, path, value) {
     return name === "Read" && path !== undefined ? { kind: "read", path, ...readRange(value) } : undefined;
@@ -192,13 +192,11 @@ function structuredFileChange(name, result) {
 }
 function toolCall(name, input) {
     const value = object(input) ?? {};
-    const run = runCall(name, value);
+    const run = runCall(name, value, input);
     if (run !== undefined)
         return run;
     const path = startedPath(name, value);
-    return (readCall(name, path, value) ??
-        searchCall(name, value) ??
-        fileChangeCall(name, path) ?? { kind: "other", display: name });
+    return (readCall(name, path, value) ?? searchCall(name, value) ?? fileChangeCall(name, path) ?? otherToolCall(name, input));
 }
 function assistantEvents(message, events, state) {
     if (message.aborted === true)