@astrosheep/keiyaku 4.5.26 → 4.5.27

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

@@ -45,7 +45,16 @@ export class BodyRequestPump {
                 if (this.handled.has(transportId))
                     continue;
                 const path = join(this.directory, name);
-                const claim = decodeEnvelope(await readFile(path, "utf8"), transportId);
+                let serialized;
+                try {
+                    serialized = await readFile(path, "utf8");
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                    continue;
+                }
+                const claim = decodeEnvelope(serialized, transportId);
                 if (claim === null) {
                     await rm(path, { force: true });
                     this.handled.add(transportId);

package/build/src/akuma-body.js

@@ -1,9 +1,7 @@
 import { LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
 import { World } from "./world.js";
-import { executeKillAkuma, executeTellAkuma, executeWaitAkuma } from "./akuma/fleet-execution.js";
-import { Akuma as PublicAkuma } from "./akuma/akuma-instance.js";
-import { Schema } from "./akuma/schema.js";
+import { fleetRequestPort } from "./akuma/fleet-owner-port.js";
 import { fleetRequestCommands } from "./akuma/fleet-request.js";
 import { worktreeHooksFrom } from "./git/hooks.js";
 import { contractRequestCommands, executeForwardedAudit, executeForwardedDeliver, executeForwardedReview, } from "./library/contract-operations.js";
@@ -71,36 +69,6 @@ function contractUpstream(processConfiguration) {
         },
     };
 }
-function fleetRequestPort(world) {
-    return {
-        wait: async (input) => await executeWaitAkuma({
-            path: world,
-            ids: input.targets,
-            completion: input.completion,
-            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
-            signal: input.signal,
-        }),
-        tell: async (input) => await executeTellAkuma({
-            path: world,
-            id: input.target,
-            body: input.body,
-            tellId: input.tellId,
-            recordedAt: input.recordedAt,
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            signal: input.signal,
-        }),
-        tellAnswer: async (input) => await PublicAkuma.select(world, input.target).tell(input.body, {
-            schema: Schema.json(JSON.parse(input.schemaJson), (value) => value),
-            ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            signal: input.signal,
-        }),
-        kill: async (input) => {
-            const result = await executeKillAkuma({ path: world, ids: input.targets, signal: input.signal });
-            return result;
-        },
-    };
-}
 function taskMutationRequestPort() {
     return {
         task: async (input) => await executeTaskMutation({

package/build/src/cli/commands/akuma-invoke.d.ts

@@ -6,6 +6,7 @@ import type { Settings } from "../../settings.js";
 import type { WorldRoot } from "../../world.js";
 import type { InvokedAkumaCommand } from "./akuma.js";
 import { type ExecutionContext } from "../../akuma/requests.js";
+import type { AkumaTellWaitResult } from "../../akuma/fleet-observation.js";
 export type AkumaInvocationResult = Readonly<{
     kind: "akuma";
     action: "call";
@@ -42,6 +43,13 @@ export type AkumaInvocationResult = Readonly<{
     result: unknown;
     body: string;
     alias?: string;
+}> | Readonly<{
+    kind: "akuma";
+    action: "tell";
+    mode: "wait";
+    result: AkumaTellWaitResult;
+    body: string;
+    alias?: string;
 }> | Readonly<{
     kind: "akuma";
     action: "tell";

package/build/src/cli/commands/akuma-invoke.js

@@ -4,12 +4,13 @@ import { emitInitiatingPluginSignal } from "../../plugin/akuma-signals.js";
 import { observeAkumaStatus } from "../../akuma/akuma-observe.js";
 import { AuthorityCorruptionError, Keiyaku, } from "../../index.js";
 import { callObservationStream, waitObservationStream } from "../render/akuma-activity.js";
-import { callObservationHead } from "../render/akuma.js";
-import { killAkuma, tellAkuma, waitAkuma } from "../../library/fleet.js";
+import { callObservationHead, waitedTellProgress } from "../render/akuma.js";
+import { killAkuma, tellAkuma, tellWaitAkuma, waitAkuma } from "../../library/fleet.js";
 import { localExecutionContext } from "../../akuma/requests.js";
 import { Akuma, Schema } from "../../akuma/index.js";
-import { addressAkuma } from "../../library/address.js";
+import { addressAkuma, resolveAkuma } from "../../library/address.js";
 import { executionChannel } from "../../akuma/requests.js";
+import { AkumaDecodeError } from "../../akuma/akuma-errors.js";
 import { requestForwardedFleetTellAnswer } from "../../akuma/fleet-request.js";
 /** The window a call observes for when the caller gives no `--wait` duration. */
 const CALL_TIMEOUT_MS = 300_000;
@@ -165,17 +166,68 @@ async function inputInitiator(input) {
     }
     return { initiator };
 }
+function decodeWaitedTellSchema(result, schema) {
+    if (result.observation.reason !== "answered")
+        return result;
+    if (typeof result.observation.answer !== "string") {
+        throw new AkumaDecodeError("Answer is not valid JSON", String(result.observation.answer));
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.observation.answer);
+    }
+    catch (error) {
+        throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer is not valid JSON", result.observation.answer);
+    }
+    try {
+        return { ...result, observation: { reason: "answered", answer: schema.decode(parsed) } };
+    }
+    catch (error) {
+        throw new AkumaDecodeError(error instanceof Error ? error.message : "Answer failed schema decode", result.observation.answer);
+    }
+}
+async function invokeWaitedTell(command, input, body) {
+    const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
+    const result = await tellWaitAkuma({
+        ...(await inputInitiator(input)),
+        path: input.path,
+        akuma: command.akuma,
+        body,
+        timeoutMs: command.timeoutMs,
+        ...(schema === undefined ? {} : { schema }),
+        ...(command.interrupt ? { interrupt: true } : {}),
+        ...(input.repo === undefined ? {} : { repo: input.repo }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    }, input.execution ?? localExecutionContext());
+    const rendered = schema === undefined ? result : decodeWaitedTellSchema(result, schema);
+    const alias = inputAlias(command.akuma);
+    if (command.output === "text")
+        writeProgress(waitedTellProgress(rendered, alias, resultContext()));
+    return {
+        kind: "akuma",
+        action: "tell",
+        mode: "wait",
+        result: rendered,
+        body,
+        ...(alias === undefined ? {} : { alias }),
+    };
+}
 async function invokeTell(command, input) {
     const body = await promptBody(command, input);
+    if (command.timeoutMs !== undefined)
+        return await invokeWaitedTell(command, input, body);
     if (command.schema !== undefined) {
         const schema = await schemaFromFile(command.schema);
-        const addressed = await addressAkuma({
+        const channel = executionChannel(input.execution);
+        const values = {
             path: input.path,
             akuma: command.akuma,
             ...(input.repo === undefined ? {} : { repo: input.repo }),
-        });
+        };
+        // A forwarded answer lets the parent Fleet prove the target, so it resolves
+        // coordinates here and never reads this process's own Heart files.
+        const addressed = channel.kind === "body-request" ? await resolveAkuma(values) : await addressAkuma(values);
         const initiator = await inputInitiator(input);
-        const channel = executionChannel(input.execution);
         const answer = channel.kind === "body-request"
             ? await requestForwardedFleetTellAnswer({
                 directory: channel.directory,

package/build/src/cli/commands/akuma.d.ts

@@ -37,6 +37,7 @@ export type ParsedAkumaCommand = Output & ((Readonly<{
     command: "tell";
     interrupt: boolean;
     schema?: string;
+    timeoutMs?: number;
 }> & Addressed & Prompted) | (Readonly<{
     command: "history";
     last: boolean;

package/build/src/cli/commands/akuma.js

@@ -1,8 +1,7 @@
 import { CliUsageError, commandGuide, isBlankInput, usageLine } from "../usage.js";
-import { parseAkuId } from "../../akuma/identity.js";
 import { parseDuration as decodeDuration } from "../../duration.js";
 import { parseAkumaAlias, parseAkumaGlob } from "../../identity/selector.js";
-import { ALLOWED_ACTIONS, decodeAllowedActions } from "../../akuma/allowed.js";
+import { ALLOWED_ACTIONS, DEFAULT_ALLOWED_ACTIONS, decodeAllowedActions, } from "../../akuma/allowed.js";
 import { parsePublicHistoryId } from "../../akuma/identity.js";
 const AKUMA_COMMAND_SPECS = {
     call: {
@@ -27,8 +26,9 @@ const AKUMA_COMMAND_SPECS = {
             "Without --workdir, a Contract call uses its appointed worktree; an unassociated call uses the invocation cwd.",
             "--alias assigns the world-local @name selector to the born Akuma.",
             `Legal actions: ${ALLOWED_ACTIONS.join(", ")}.`,
+            `Default actions: ${DEFAULT_ALLOWED_ACTIONS.join(", ")}.`,
             "Repeated --allowed adds actions to the selected Akuma's defaults; it never narrows them.",
-            "An omitted Archetype default permits every legal action; an explicit empty default permits none.",
+            "An omitted Archetype uses the default actions above; an explicit empty default permits none.",
             "A nested birth is clipped to its direct parent's frozen actions. status <aku/...|@alias> shows the born effective set.",
             "--schema reads a JSON Schema file for the answer contract; stdin remains the prompt source.",
             "With --contract, Dispatch succeeds first. If @name exists, the alias then moves.",
@@ -54,13 +54,14 @@ const AKUMA_COMMAND_SPECS = {
     tell: {
         arity: 1,
         stdin: true,
-        flags: { interrupt: "boolean", schema: "value", json: "boolean" },
-        usage: "tell <aku/...|@alias> [--interrupt] [--schema <file>] (<prompt> | -)",
+        flags: { interrupt: "boolean", schema: "value", wait: "value", json: "boolean" },
+        usage: "tell <aku/...|@alias> [--interrupt] [--schema <file>] [--wait <duration>] (<prompt> | -)",
         purpose: "Send one prompt to an existing Akuma and wake it.",
         details: [
             "Give <prompt> as one argument, or use - to read stdin.",
             "--interrupt ends the current Body before recording the prompt and waking its successor.",
             "--schema reads a JSON Schema file for the answer contract; stdin remains the prompt source.",
+            "--wait observes this exact Tell for the supplied duration after it is admitted.",
         ].join("\n"),
     },
     history: {
@@ -180,16 +181,9 @@ function positiveIndex(raw, option, fail) {
         fail(`${option} exceeds the safe integer range`);
     return value;
 }
-function validateDirect(value, fail) {
-    try {
-        if (value.startsWith("@"))
-            parseAkumaAlias(value);
-        else
-            parseAkuId(value);
-    }
-    catch (error) {
-        fail(error instanceof Error ? error.message : "invalid Akuma selector");
-    }
+function validateDirect(value, _fail) {
+    // Address validation belongs to the operation boundary so callers receive
+    // the compact Akuma refusal instead of a generic usage page.
     return value;
 }
 function validateSet(value, fail) {
@@ -287,6 +281,7 @@ function parseTell(flags, subject, prompt, output, fail) {
         akuma: validateDirect(subject, fail),
         interrupt: flags.interrupt === true,
         ...(schema === undefined ? {} : { schema }),
+        ...(flags.wait === undefined ? {} : { timeoutMs: parseDuration(flags.wait, "--wait", fail) }),
         prompt,
         output,
     };

package/build/src/cli/commands/contract-help.js

@@ -25,14 +25,17 @@ export const CONTRACT_COMMAND_SPECS = {
             "  # <title>",
             "  ## Context       motivation, authority, baseline, and boundaries",
             "  ## Objective    one observable end state",
-            "  ## Design       closed decisions and ordering",
-            "  ## Region       intended path patterns as fenced lines, list items, or bare lines",
+            "  ## Design       existing owner modules/entry points, reuse or change, implementation approach, and critical ordering",
+            "                  unresolved architectural choices are settled before binding; private helper names",
+            "                  and equivalent control flow remain Deliverer freedom",
+            "  ## Region       narrowest justified intended writes for this approach, one pattern per line",
             "  ## Criteria     one or more ### <criterion> entries",
             "  ## Verification optional fenced executor declarations",
             "",
-            "Region accepts intended path patterns as fenced lines, list items, or bare",
-            "lines; the three forms union. Put one repository-relative path pattern on",
-            "each nonblank line. A trailing '/' is directory shorthand for 'path/**'.",
+            "Region accepts the narrowest justified intended writes for this approach, not every potentially",
+            "involved file. Do not use broad directory fallbacks or redundant parent/child patterns. Patterns",
+            "are fenced lines, list items, or bare lines; the three forms union. Put one repository-relative",
+            "path pattern on each nonblank line. A trailing '/' is directory shorthand for 'path/**'.",
             "A pattern containing whitespace binds with a warning. A fence carries no",
             "info string or exactly 'txt'.",
             "",

package/build/src/cli/render/akuma-activity.d.ts

@@ -25,9 +25,15 @@ export declare function snapshotHeading(id: string, alias: string | undefined, c
  * source column a plural wait aligns across its selected set.
  */
 type RowLayout = Readonly<{
-    head: (time: string | undefined, glyph: string, verb: string) => string;
+    head: (time: string | undefined, glyph: string, verb: string, columns: number) => string;
     continuation: () => string;
     marker: (count: number) => string;
+    /** A plural wait shares one minute clock across all of its attributed rows. */
+    clock?: {
+        previous?: string;
+    };
+    /** Plural wait rows spend their full remaining width on one terminal line. */
+    singleLine?: true;
 }>;
 /**
  * Shared snapshot activity rendering. Full snapshots render the selected