@astrosheep/keiyaku 4.5.28 → 4.5.29

package/build/src/akuma/call-initial-tell.js

@@ -0,0 +1,32 @@
+import { defaultWaitComplete, bornStatus, readWaitComplete, waitForObservation } from "./akuma-observe.js";
+import { recordTell } from "./heart/index.js";
+import { pathsForAkuId } from "./identity.js";
+import { BIRTH_TIMEOUT_MS } from "./publication.js";
+export async function admitCallInitialTell(input) {
+    const paths = pathsForAkuId(input.world, input.id);
+    const birth = await waitForObservation({
+        timeoutMs: BIRTH_TIMEOUT_MS,
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        probe: async () => await readWaitComplete(input.world, input.id),
+        observe: async () => (await bornStatus(paths, input.id, { aperture: "receipt" })).status,
+        complete: defaultWaitComplete,
+    });
+    if (birth.reason !== "completed" || birth.value.life !== "asleep") {
+        return {
+            kind: "birth-failed",
+            diagnostic: `Akuma ${input.id} prompt-free birth did not settle cleanly`,
+        };
+    }
+    input.signal?.throwIfAborted();
+    const recorded = await recordTell(paths, {
+        kind: "tell",
+        id: input.initialTell.tellId,
+        body: input.initialTell.body,
+        recordedAt: input.now?.() ?? new Date().toISOString(),
+        ...(input.initialTell.schemaJson === undefined ? {} : { schemaJson: input.initialTell.schemaJson }),
+        ...(input.initialTell.initiator === undefined ? {} : { initiator: input.initialTell.initiator }),
+    });
+    if (recorded.kind === "not-born")
+        return recorded;
+    return { kind: "admitted", tell: recorded.tell, wake: input.wake(recorded.tell) };
+}

package/build/src/akuma/call-input.d.ts

@@ -1,4 +1 @@
-export declare function callReadonly(value: unknown, diagnostic?: string): Readonly<{
-    readonly?: true;
-}>;
 export declare function canonicalBirthCwd(input: string, diagnostic?: string): Promise<string>;

package/build/src/akuma/call-input.js

@@ -1,12 +1,5 @@
 import { realpath, stat } from "node:fs/promises";
 import { resolve } from "node:path";
-export function callReadonly(value, diagnostic = "Akuma call readonly must be true") {
-    if (value === undefined)
-        return {};
-    if (value !== true)
-        throw new TypeError(diagnostic);
-    return { readonly: true };
-}
 export async function canonicalBirthCwd(input, diagnostic = `cwd is not an existing directory: ${input}`) {
     const selected = resolve(input);
     try {

package/build/src/akuma/call-request.d.ts

@@ -1,5 +1,6 @@
 import { type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
+import type { CallInitialTell, CallInitialTellAdmission } from "./call-initial-tell.js";
 import { type ChildRequestCommand, type ErasedRequestCommand, type RequestProtocol } from "./request-wire.js";
 import type { OwnedProcess } from "../runtime/proc/run.js";
 import { z } from "zod";
@@ -17,19 +18,20 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
     options: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
         model?: string;
         effort?: string;
-        readonly?: true;
         network?: "disabled" | "enabled";
-        sandbox?: "full-access";
         systemPrompt?: string;
         systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
     }>, unknown>>;
-    readonly: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./provider-recipe.js").ReadonlyRestraint, unknown>>>;
 }, z.core.$strict>;
 declare const akumaCallPayloadSchema: z.ZodObject<{
     world: z.ZodString;
     archetype: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-    body: z.ZodOptional<z.ZodString>;
-    initiator: z.ZodOptional<z.ZodString>;
+    initialTell: z.ZodObject<{
+        tellId: z.ZodString;
+        body: z.ZodString;
+        schemaJson: z.ZodOptional<z.ZodString>;
+        initiator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
     cwd: z.ZodOptional<z.ZodString>;
     recipe: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
@@ -44,13 +46,10 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
         options: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
             model?: string;
             effort?: string;
-            readonly?: true;
             network?: "disabled" | "enabled";
-            sandbox?: "full-access";
             systemPrompt?: string;
             systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
         }>, unknown>>;
-        readonly: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<import("./provider-recipe.js").ReadonlyRestraint, unknown>>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type AkumaCallRecipe = z.infer<typeof akumaCallRecipeSchema>;
@@ -60,14 +59,18 @@ export type AkumaCallRequest = z.infer<typeof akumaCallPayloadSchema> & Readonly
 export type AkumaCallRequestChildLaunch = Readonly<{
     paths: AkumaPaths;
     seed: Omit<Soul, "createdAt">;
-    initialBody?: string;
-    initiator?: string;
+}>;
+export type InitialTellAdmissionRequest = Readonly<{
+    id: AkuId;
+    initialTell: CallInitialTell;
+    signal: AbortSignal;
 }>;
 type AkumaCallRequestCapabilities = Readonly<{
     world: WorldRoot;
     paths: AkumaPaths;
     parent: Soul;
     spawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
+    admitInitialTell(input: InitialTellAdmissionRequest): Promise<CallInitialTellAdmission>;
 }>;
 export declare function decodeAkumaCallRequest(value: unknown): AkumaCallRequest | null;
 export declare function akumaCallRequestProtocol(): RequestProtocol<AkumaCallRequest, AkuId, AkuId>;

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

@@ -3,7 +3,7 @@ import { clipAllowedActions, decodeAllowedActions } from "./allowed.js";
 import { refuseRequest, reserveRequest } from "./heart/index.js";
 import { archetypeName, parseAkuId } from "./identity.js";
 import { publishAkuma } from "./publication.js";
-import { decodeProviderOptions, decodeReadonlyRestraint } from "./provider-recipe.js";
+import { decodeProviderOptions } from "./provider-recipe.js";
 import { decodeProviderExecution, resolveProviderExecution } from "./providers/index.js";
 import { requestBodyCommand } from "./request-rendezvous.js";
 import { eraseRequestCommand, } from "./request-wire.js";
@@ -47,27 +47,27 @@ const archetypeSchema = z.string().transform((value, context) => {
 const allowedActionsSchema = schemaDecode(decodeAllowedActions, "expected allowed actions");
 const providerExecutionSchema = schemaDecode(decodeProviderExecution, "expected provider execution");
 const providerOptionsSchema = schemaDecode(decodeProviderOptions, "expected provider options");
-const readonlyRestraintSchema = schemaDecode(decodeReadonlyRestraint, "expected readonly restraint");
 const akumaCallRecipeSchema = z
     .object({
     description: z.string().trim().min(1).optional(),
     allowed: allowedActionsSchema,
     provider: providerExecutionSchema,
     options: providerOptionsSchema,
-    readonly: readonlyRestraintSchema.optional(),
 })
-    .strict()
-    .superRefine((recipe, context) => {
-    if ((recipe.options.readonly === true) !== (recipe.readonly !== undefined)) {
-        context.addIssue({ code: "custom", message: "readonly recipe fields disagree" });
-    }
-});
+    .strict();
+const initialTellSchema = z
+    .object({
+    tellId: z.string().trim().min(1),
+    body: z.string(),
+    schemaJson: z.string().trim().min(1).optional(),
+    initiator: z.string().min(1).optional(),
+})
+    .strict();
 const akumaCallPayloadSchema = z
     .object({
     world: absolutePathSchema,
     archetype: archetypeSchema,
-    body: z.string().optional(),
-    initiator: z.string().min(1).optional(),
+    initialTell: initialTellSchema,
     cwd: absolutePathSchema.optional(),
     recipe: akumaCallRecipeSchema,
 })
@@ -98,7 +98,6 @@ async function executeAkumaCall(request, facts, capabilities) {
         allowed: clipAllowedActions(request.recipe.allowed, parent.allowed),
         provider: selected.execution,
         options: admission.options,
-        ...(admission.readonly === undefined ? {} : { readonly: admission.readonly }),
     };
     const published = await publishAkuma({
         worldPath: world,
@@ -117,11 +116,24 @@ async function executeAkumaCall(request, facts, capabilities) {
                     cwd: request.cwd ?? parent.cwd,
                     origin: { kind: "request", parent: parent.id, requestId: facts.id },
                 },
-                ...(request.body === undefined ? {} : { initialBody: request.body }),
-                ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
             });
         },
     });
+    const admitted = await capabilities.admitInitialTell({
+        id: published.id,
+        initialTell: {
+            tellId: request.initialTell.tellId,
+            body: request.initialTell.body,
+            ...(request.initialTell.schemaJson === undefined ? {} : { schemaJson: request.initialTell.schemaJson }),
+            ...(request.initialTell.initiator === undefined ? {} : { initiator: request.initialTell.initiator }),
+        },
+        signal: facts.signal,
+    });
+    if (admitted.kind === "birth-failed")
+        throw new Error(admitted.diagnostic);
+    if (admitted.kind === "not-born")
+        throw new Error(`Akuma ${published.id} was not born for its initial Tell`);
+    await admitted.wake;
     return { result: published.id, child: published.id };
 }
 export function akumaCallRequestProtocol() {

package/build/src/akuma/fleet-execution.d.ts

@@ -1,10 +1,11 @@
+import type { Schema } from "./schema.js";
 import { type AkumaStatus, type TellResult } from "./akuma.js";
 import { type LiveStatusObservation } from "./akuma-observe.js";
 import type { ActivityRow } from "./projection.js";
 import { type DispatchAssociation } from "./dispatch-association.js";
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
-import { type AkumaKillResult, type AkumaTellResult, type AkumaTellWaitResult, type AkumaWaitResult } from "./fleet-observation.js";
+import { type AkumaKillResult, type AkumaTellResult, type AkumaTellWaitObservation, type AkumaTellWaitResult, type AkumaWaitResult } from "./fleet-observation.js";
 export type WaitIdentityFacts = Readonly<{
     /** The alias currently addressing this Akuma in its world, when one is bound to it. */
     alias?: AkumaAlias;
@@ -56,6 +57,17 @@ export type TellExecutionInput = Readonly<{
     onObserve?: TellWaitObserver;
 }>;
 export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
+export declare function decodeTellWaitObservation(observation: AkumaTellWaitObservation, schema: Schema<unknown>): AkumaTellWaitObservation;
+export declare function observeAdmittedTellWaitAkuma(input: Readonly<{
+    path: WorldRoot;
+    id: AkumaStatus["id"];
+    tellId: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+    startedAt?: number;
+    wake?: Promise<TellResult>;
+    onObserve?: TellWaitObserver;
+}>): Promise<AkumaTellWaitResult>;
 export declare function executeTellWaitAkuma(input: TellExecutionInput & Readonly<{
     timeoutMs: number;
     schemaJson?: string;

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

@@ -1,4 +1,4 @@
-import { AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";
+import { AkumaProviderError } from "./akuma-errors.js";
 import { AkumaNotBornError, defaultWaitComplete } from "./akuma.js";
 import { createAkumaProduct } from "./akuma-product.js";
 import { readLiveStatus, waitForObservation } from "./akuma-observe.js";
@@ -133,7 +133,65 @@ function tellWaitObservation(observed) {
         return { reason: "answered", answer: observed.outcome.answerJson ?? observed.outcome.answer };
     if (observed.outcome.kind === "failed")
         return { reason: "failed", diagnostic: observed.outcome.diagnostic };
-    throw new AkumaDecodeError(observed.outcome.diagnostic, observed.outcome.answer);
+    return {
+        reason: "invalid-output",
+        diagnostic: observed.outcome.diagnostic,
+        answer: observed.outcome.answer,
+    };
+}
+export function decodeTellWaitObservation(observation, schema) {
+    if (observation.reason !== "answered")
+        return observation;
+    let value = observation.answer;
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch (error) {
+            return {
+                reason: "invalid-output",
+                diagnostic: error instanceof Error ? error.message : "Answer is not valid JSON",
+                answer: typeof observation.answer === "string" ? observation.answer : String(observation.answer),
+            };
+        }
+    }
+    try {
+        return { reason: "answered", answer: schema.decode(value) };
+    }
+    catch (error) {
+        return {
+            reason: "invalid-output",
+            diagnostic: error instanceof Error ? error.message : "Answer failed schema decode",
+            answer: typeof observation.answer === "string" ? observation.answer : String(observation.answer),
+        };
+    }
+}
+export async function observeAdmittedTellWaitAkuma(input) {
+    const handle = source(input.path).selectHandle({ id: input.id });
+    const tell = await handle.admittedReceipt(input.tellId);
+    await input.onObserve?.admitted?.(tell, input.id);
+    let settled;
+    void input.wake?.then((receipt) => {
+        settled = receipt;
+    }, () => undefined);
+    const admittedAt = Date.parse(tell.row.at);
+    const observedAt = performance.timeOrigin + performance.now();
+    const elapsed = input.startedAt === undefined
+        ? Number.isFinite(admittedAt)
+            ? Math.max(0, observedAt - admittedAt)
+            : 0
+        : Math.max(0, performance.now() - input.startedAt);
+    const observed = await handle.tellOutcome(input.tellId, {
+        timeoutMs: Math.max(0, input.timeoutMs - elapsed),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+        ...(input.onObserve?.observe === undefined ? {} : { observe: input.onObserve.observe }),
+    });
+    return fleetResultSchemas.tellWait.parse({
+        akuma: input.id,
+        tell: settled ?? tell,
+        observation: tellWaitObservation(observed),
+        completedAt: observed.completedAt,
+    });
 }
 export async function executeTellWaitAkuma(input) {
     input.signal?.throwIfAborted();
@@ -154,21 +212,16 @@ export async function executeTellWaitAkuma(input) {
         throw new AkumaProviderError(`Tell interrupt unavailable: ${admission.evidence}`);
     if (admission.kind === "not-born")
         throw new AkumaNotBornError(input.id);
-    await input.onObserve?.admitted?.(await handle.admittedReceipt(admission.tell.id), input.id);
-    // The wake runs behind the window; a settled wake is preferred, otherwise the
-    // receipt reports the admitted Tell as it stands when the window closes.
-    let settled;
-    void admission.wake.then((receipt) => {
-        settled = receipt;
-    }, () => undefined);
-    const observed = await handle.tellOutcome(admission.tell.id, {
+    return await observeAdmittedTellWaitAkuma({
+        path: input.path,
+        id: input.id,
+        tellId: admission.tell.id,
         timeoutMs: input.timeoutMs,
+        startedAt: performance.now(),
+        wake: admission.wake,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
-        ...(input.onObserve?.observe === undefined ? {} : { observe: input.onObserve.observe }),
+        ...(input.onObserve === undefined ? {} : { onObserve: input.onObserve }),
     });
-    const observation = tellWaitObservation(observed);
-    const tell = settled ?? (await handle.admittedReceipt(admission.tell.id));
-    return fleetResultSchemas.tellWait.parse({ akuma: input.id, tell, observation });
 }
 export async function executeKillAkuma(input) {
     input.signal?.throwIfAborted();

package/build/src/akuma/fleet-observation.d.ts

@@ -29,12 +29,6 @@ declare const akumaObservationSchema: z.ZodObject<{
             "contract.deliver": "contract.deliver";
             "contract.review": "contract.review";
         }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
-        readonly: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-            enforcement: z.ZodLiteral<"native">;
-        }, z.core.$strict>, z.ZodObject<{
-            enforcement: z.ZodLiteral<"none">;
-            diagnostic: z.ZodString;
-        }, z.core.$strict>]>>;
         timeline: z.ZodUnion<readonly [z.ZodObject<{
             reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 sequence: z.ZodNumber;
@@ -501,12 +495,6 @@ declare const akumaWaitResultSchema: z.ZodObject<{
                 "contract.deliver": "contract.deliver";
                 "contract.review": "contract.review";
             }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
-            readonly: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-                enforcement: z.ZodLiteral<"native">;
-            }, z.core.$strict>, z.ZodObject<{
-                enforcement: z.ZodLiteral<"none">;
-                diagnostic: z.ZodString;
-            }, z.core.$strict>]>>;
             timeline: z.ZodUnion<readonly [z.ZodObject<{
                 reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                     sequence: z.ZodNumber;
@@ -1037,6 +1025,21 @@ declare const akumaTellResultSchema: z.ZodObject<{
         }>>]>;
     }, z.core.$strict>;
 }, z.core.$strict>;
+declare const tellWaitObservationSchema: z.ZodUnion<readonly [z.ZodObject<{
+    reason: z.ZodLiteral<"answered">;
+    answer: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodLiteral<"failed">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodLiteral<"invalid-output">;
+    diagnostic: z.ZodString;
+    answer: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodLiteral<"unanswered">;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodLiteral<"deadline">;
+}, z.core.$strict>]>;
 declare const akumaTellWaitResultSchema: z.ZodObject<{
     akuma: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     tell: z.ZodObject<{
@@ -1131,11 +1134,16 @@ declare const akumaTellWaitResultSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         reason: z.ZodLiteral<"failed">;
         diagnostic: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        reason: z.ZodLiteral<"invalid-output">;
+        diagnostic: z.ZodString;
+        answer: z.ZodString;
     }, z.core.$strict>, z.ZodObject<{
         reason: z.ZodLiteral<"unanswered">;
     }, z.core.$strict>, z.ZodObject<{
         reason: z.ZodLiteral<"deadline">;
     }, z.core.$strict>]>;
+    completedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type AkumaObservation = z.infer<typeof akumaObservationSchema>;
 export type AkumaObservationStage = (Readonly<{
@@ -1148,6 +1156,7 @@ export type AkumaUnobserved = z.infer<typeof akumaUnobservedSchema>;
 export type AkumaWaitResult = z.infer<typeof akumaWaitResultSchema>;
 export type AkumaKillResult = z.infer<typeof akumaKillResultSchema>;
 export type AkumaTellResult = z.infer<typeof akumaTellResultSchema>;
+export type AkumaTellWaitObservation = z.infer<typeof tellWaitObservationSchema>;
 export type AkumaTellWaitResult = z.infer<typeof akumaTellWaitResultSchema>;
 export declare function parseAkumaObservation(value: unknown): AkumaObservation;
 export declare function isWaitResult(value: unknown): value is AkumaWaitResult;
@@ -1194,12 +1203,6 @@ export declare const fleetResultSchemas: {
                     "contract.deliver": "contract.deliver";
                     "contract.review": "contract.review";
                 }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
-                readonly: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-                    enforcement: z.ZodLiteral<"native">;
-                }, z.core.$strict>, z.ZodObject<{
-                    enforcement: z.ZodLiteral<"none">;
-                    diagnostic: z.ZodString;
-                }, z.core.$strict>]>>;
                 timeline: z.ZodUnion<readonly [z.ZodObject<{
                     reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                         sequence: z.ZodNumber;
@@ -1811,11 +1814,16 @@ export declare const fleetResultSchemas: {
         }, z.core.$strict>, z.ZodObject<{
             reason: z.ZodLiteral<"failed">;
             diagnostic: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            reason: z.ZodLiteral<"invalid-output">;
+            diagnostic: z.ZodString;
+            answer: z.ZodString;
         }, z.core.$strict>, z.ZodObject<{
             reason: z.ZodLiteral<"unanswered">;
         }, z.core.$strict>, z.ZodObject<{
             reason: z.ZodLiteral<"deadline">;
         }, z.core.$strict>]>;
+        completedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     }, z.core.$strict>;
     kill: z.ZodObject<{
         results: z.ZodArray<z.ZodObject<{

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

@@ -61,11 +61,17 @@ const akumaTellResultSchema = z.object({ akuma: akumaIdSchema, tell: tellResultS
 const tellWaitObservationSchema = z.union([
     z.object({ reason: z.literal("answered"), answer: z.unknown() }).strict(),
     z.object({ reason: z.literal("failed"), diagnostic: z.string() }).strict(),
+    z.object({ reason: z.literal("invalid-output"), diagnostic: z.string(), answer: z.string() }).strict(),
     z.object({ reason: z.literal("unanswered") }).strict(),
     z.object({ reason: z.literal("deadline") }).strict(),
 ]);
 const akumaTellWaitResultSchema = z
-    .object({ akuma: akumaIdSchema, tell: tellResultSchema, observation: tellWaitObservationSchema })
+    .object({
+    akuma: akumaIdSchema,
+    tell: tellResultSchema,
+    observation: tellWaitObservationSchema,
+    completedAt: z.string().datetime({ offset: true }).nullable().optional(),
+})
     .strict();
 export function parseAkumaObservation(value) {
     return akumaObservationSchema.parse(value);

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

@@ -1,6 +1,6 @@
 import type { AkuId } from "../identity.js";
 import type { ResumeCoordinate } from "../coordinate.js";
-import type { ProviderExecution, ProviderOptions, ReadonlyRestraint } from "../provider-recipe.js";
+import type { ProviderExecution, ProviderOptions } from "../provider-recipe.js";
 import type { AllowedActions } from "../allowed.js";
 export type { ResumeCoordinate } from "../coordinate.js";
 export declare class HeartAuthorityCorruptionError extends Error {
@@ -23,13 +23,12 @@ export type Soul = Readonly<{
     description?: string;
     provider: ProviderExecution;
     options: ProviderOptions;
-    readonly?: ReadonlyRestraint;
     cwd: string;
     origin: AkumaOrigin;
     allowed: AllowedActions;
     createdAt: string;
 }>;
-export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "allowed">;
+export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "allowed">;
 export type BodyEnd = "exited" | "broke-off" | "put-down";
 export type BodyFact = Readonly<{
     sequence: number;

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

@@ -1,5 +1,5 @@
 import { parseAkuId } from "../identity.js";
-import { decodeProviderOptions, decodeProviderRecipe, decodeReadonlyRestraint } from "../provider-recipe.js";
+import { decodeProviderOptions, decodeProviderRecipe } from "../provider-recipe.js";
 import { historicalAllowedActions } from "../allowed.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -55,17 +55,12 @@ function validateSoul(value) {
     const description = soul.description === undefined ? undefined : nonblank(soul.description, "description");
     const provider = decodeProviderRecipe(soul.provider);
     const options = decodeProviderOptions(soul.options);
-    const restraint = soul.readonly === undefined ? undefined : decodeReadonlyRestraint(soul.readonly);
-    if ((options.readonly === true) !== (restraint !== undefined)) {
-        throw new Error("Akuma soul readonly option and restraint must agree");
-    }
     return {
         id,
         archetype,
         ...(description === undefined ? {} : { description }),
         provider,
         options,
-        ...(restraint === undefined ? {} : { readonly: restraint }),
         cwd: nonblank(soul.cwd, "cwd"),
         origin: decodeOrigin(soul.origin),
         allowed: historicalAllowedActions(soul.allowed),

package/build/src/akuma/projection-read.js

@@ -105,8 +105,7 @@ function isActiveTool(row) {
     return row.kind === "tool" && row.state === "active";
 }
 function isProtectedCurrentTurnActivity(row) {
-    return (row.kind === "said" ||
-        (row.kind === "tool" && row.call.kind === "fileChange" && row.state !== "active" && row.state !== "unsettled"));
+    return row.kind === "said";
 }
 function isSettledTellDeliveredTo(row, turnSequence) {
     return (row.kind === "tell" &&

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

@@ -2,19 +2,10 @@ export type SystemPromptMode = "append" | "replace";
 export type ProviderOptions = Readonly<{
     model?: string;
     effort?: string;
-    readonly?: true;
     network?: "disabled" | "enabled";
-    sandbox?: "full-access";
     systemPrompt?: string;
     systemPromptMode?: SystemPromptMode;
 }>;
-export type ReadonlyRestraint = Readonly<{
-    enforcement: "native";
-    diagnostic?: never;
-} | {
-    enforcement: "none";
-    diagnostic: string;
-}>;
 export type ProviderExecution = Readonly<{
     name: string;
     kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
@@ -23,5 +14,4 @@ export type ProviderExecution = Readonly<{
     env?: Readonly<Record<string, string>>;
 }>;
 export declare function decodeProviderOptions(value: unknown): ProviderOptions;
-export declare function decodeReadonlyRestraint(value: unknown): ReadonlyRestraint;
 export declare function decodeProviderRecipe(input: unknown): ProviderExecution;

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

@@ -26,17 +26,10 @@ export function decodeProviderOptions(value) {
         throw new TypeError("provider options must be an object");
     const model = optionText(options, "model", "refuse");
     const effort = optionText(options, "effort", "refuse");
-    if (options.readonly !== undefined && options.readonly !== true) {
-        throw new TypeError("provider option readonly must be true");
-    }
     const network = options.network;
     if (network !== undefined && network !== "disabled" && network !== "enabled") {
         throw new TypeError("provider option network must be disabled, enabled");
     }
-    const sandbox = options.sandbox;
-    if (sandbox !== undefined && sandbox !== "full-access") {
-        throw new TypeError("provider option sandbox must be full-access");
-    }
     const systemPrompt = optionText(options, "systemPrompt", "allow");
     const systemPromptMode = options.systemPromptMode;
     if (systemPromptMode !== undefined) {
@@ -50,27 +43,11 @@ export function decodeProviderOptions(value) {
     return Object.freeze({
         ...(model === undefined ? {} : { model }),
         ...(effort === undefined ? {} : { effort }),
-        ...(options.readonly === undefined ? {} : { readonly: true }),
         ...(network === undefined ? {} : { network }),
-        ...(sandbox === undefined ? {} : { sandbox }),
         ...(systemPrompt === undefined ? {} : { systemPrompt }),
         ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
     });
 }
-export function decodeReadonlyRestraint(value) {
-    const restraint = record(value);
-    if (restraint === null)
-        throw new TypeError("readonly restraint must be an object");
-    if (restraint.enforcement === "native") {
-        return Object.freeze({ enforcement: "native" });
-    }
-    if (restraint.enforcement === "none" &&
-        typeof restraint.diagnostic === "string" &&
-        restraint.diagnostic.trim().length > 0) {
-        return Object.freeze({ enforcement: "none", diagnostic: restraint.diagnostic });
-    }
-    throw new TypeError("readonly restraint must be native or none with a diagnostic");
-}
 function providerKind(value) {
     return (value === "acp" ||
         value === "claude-agent-sdk" ||

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

@@ -1,5 +1,5 @@
 import { decodeResumeCoordinate, encodeResumeCoordinate, type ResumeCoordinate } from "./coordinate.js";
-import type { ProviderOptions, ReadonlyRestraint } from "./provider-recipe.js";
+import type { ProviderOptions } from "./provider-recipe.js";
 export type { ResumeCoordinate } from "./coordinate.js";
 export { AKUMA_REQUESTS_ENV } from "./providers/execution-environment.js";
 export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
@@ -191,7 +191,6 @@ export type DriveInput = Readonly<{
 export type ProviderOptionAdmission = Readonly<{
     kind: "admitted";
     options: ProviderOptions;
-    readonly?: ReadonlyRestraint;
 }> | Readonly<{
     kind: "refused";
     diagnostic: string;

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

@@ -3,9 +3,6 @@ import { decodeAcpConfig } from "./config.js";
 import { startAcpSession } from "./core.js";
 export { decodeAcpConfig } from "./config.js";
 function optionAdmission(options, config) {
-    if (options.sandbox !== undefined) {
-        return { kind: "refused", diagnostic: "ACP provider does not support the sandbox option" };
-    }
     if (options.network !== undefined) {
         return { kind: "refused", diagnostic: "ACP provider does not support the network option" };
     }
@@ -29,14 +26,6 @@ function optionAdmission(options, config) {
     return {
         kind: "admitted",
         options,
-        ...(options.readonly === undefined
-            ? {}
-            : {
-                readonly: {
-                    enforcement: "none",
-                    diagnostic: "ACP cannot remove task-surface mutation capabilities",
-                },
-            }),
     };
 }
 function argv(execution, config, options) {