@astrosheep/keiyaku 4.5.26 → 4.5.28

package/build/src/akuma/providers/opencode-sdk/events.js

@@ -1,4 +1,4 @@
-import { noteEvent } from "../../provider.js";
+import { noteEvent, otherToolCall } from "../../provider.js";
 export const OPENCODE_EVENT_DISPOSITIONS = {
     "server.instance.disposed": "dropped",
     "installation.updated": "dropped",
@@ -115,6 +115,10 @@ function strongerCall(previous, next) {
         return previous;
     if (previous?.kind === "fileChange" && next.kind !== "fileChange")
         return previous;
+    // The correlated start's admitted preview is authority: a later update never
+    // overwrites it, empty or conflicting, while a start without one adopts supplied evidence.
+    if (next.kind === "other" && previous?.kind === "other" && previous.input !== undefined)
+        return { ...next, input: previous.input };
     return next;
 }
 function runCall(name, value) {
@@ -163,12 +167,12 @@ function callFor(name, input, metadata) {
     if (lower === "grep" || lower === "glob" || lower === "search")
         return searchCall(lower, value);
     if (lower === "edit")
-        return editCall(value, meta) ?? { kind: "other", display: name };
+        return editCall(value, meta) ?? otherToolCall(name, input);
     if (lower === "write")
-        return writeCall(value, meta) ?? { kind: "other", display: name };
+        return writeCall(value, meta) ?? otherToolCall(name, input);
     if (lower === "apply_patch")
-        return applyPatchCall(meta) ?? { kind: "other", display: name };
-    return { kind: "other", display: name };
+        return applyPatchCall(meta) ?? otherToolCall(name, input);
+    return otherToolCall(name, input);
 }
 function belongs(part, state) {
     return state.sessionId === undefined || part.sessionID === state.sessionId;

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

@@ -1,4 +1,4 @@
-import { noteEvent, unknownEvent } from "../../provider.js";
+import { noteEvent, otherToolCall, unknownEvent } from "../../provider.js";
 import { diffstatFromUnifiedPatch } from "../unified-patch.js";
 export const PI_EVENT_DISPOSITIONS = {
     agent_end: "drop",
@@ -112,7 +112,8 @@ function toolCall(name, args) {
     return (runCall(name, value) ??
         readCall(name, value) ??
         searchCall(name, value) ??
-        fileChangeCall(name, value) ?? { kind: "other", display: name });
+        fileChangeCall(name, value) ??
+        otherToolCall(name, args));
 }
 function translateNote(event) {
     if (event.type === "compaction_end")
@@ -129,7 +130,7 @@ function translateToolEnd(event, state) {
     const started = state.tools.get(event.toolCallId);
     state.tools.delete(event.toolCallId);
     const name = started?.name ?? event.toolName;
-    const call = started?.call ?? { kind: "other", display: name };
+    const call = started?.call ?? otherToolCall(name);
     return [
         {
             type: "tool",

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/alias/index.js

@@ -4,7 +4,7 @@ import { parseAkuId } from "../akuma/identity.js";
 import { replaceFileDurably } from "../coordination/durable-file.js";
 import { acquireSqliteTransactionLock } from "../coordination/sqlite-transaction-lock.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { parseAkumaAlias } from "../identity/selector.js";
+import { parseAkumaAlias, parseReadableAkumaAlias } from "../identity/selector.js";
 const VERSION = 1;
 function paths(world) {
     if (typeof world !== "string" || world.trim().length === 0) {
@@ -56,7 +56,7 @@ function decode(path, bytes) {
         if (typeof rawAkuId !== "string")
             corruption(`Alias target must be an AkuId: ${path}`);
         try {
-            bindings.push({ alias: parseAkumaAlias(rawAlias), akuId: parseAkuId(rawAkuId).id });
+            bindings.push({ alias: parseReadableAkumaAlias(rawAlias), akuId: parseAkuId(rawAkuId).id });
         }
         catch (error) {
             return corruption(`Alias binding is invalid: ${path}`, error);
@@ -114,7 +114,7 @@ export async function readAliases(world) {
     return await read(paths(world).authority);
 }
 export async function resolveAlias(world, value) {
-    const alias = parseAkumaAlias(value);
+    const alias = parseReadableAkumaAlias(value);
     return (await readAliases(world)).find((binding) => binding.alias === alias)?.akuId ?? null;
 }
 export async function moveAlias(input) {

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, tellWaitProgressStream } 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,77 @@ 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 alias = inputAlias(command.akuma);
+    const progress = command.output === "text" ? tellWaitProgressStream(undefined, alias, resultContext()) : undefined;
+    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 }),
+        ...(progress === undefined
+            ? {}
+            : {
+                observe: {
+                    admitted: (tell, id) => writeProgress(progress.admitted(tell, id).join("\n")),
+                    observe: (observation) => writeProgress(progress.observe(observation).join("\n")),
+                },
+            }),
+    }, input.execution ?? localExecutionContext());
+    const rendered = schema === undefined ? result : decodeWaitedTellSchema(result, schema);
+    if (progress !== undefined)
+        writeProgress(progress.conclude(rendered).join("\n"));
+    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: {
@@ -12,23 +11,23 @@ const AKUMA_COMMAND_SPECS = {
             contract: "value",
             alias: "value",
             wait: "value",
-            detach: "boolean",
             allowed: "repeatable",
             json: "boolean",
             schema: "value",
         },
-        usage: "call <akuma-name> [--contract <kei/...>] [--workdir <path>] [--alias @name] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] (<prompt> | -)",
+        usage: "call <akuma-name> [--contract <kei/...>] [--workdir <path>] [--alias <name>] [--allowed <product.action>]... [--schema <file>] [--wait <duration>] (<prompt> | -)",
         purpose: "Birth an Akuma from <akuma-name> with one prompt.",
         details: [
             "Give <prompt> as one argument, or use - to read stdin.",
-            "Default: --wait 5m. An explicit --wait replaces that duration; -d and --detach return after birth.",
-            "--contract dispatches the born Akuma to that Contract.",
+            "Default: return after birth without waiting for the first answer. Explicit --wait observes the first work for that duration.",
+            "--contract associates the born Akuma with that Contract for Dispatch; it never selects a workdir.",
             "--workdir selects the execution directory; a relative path is relative to the invocation cwd.",
-            "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.",
+            "Without --workdir, the call uses the invocation cwd whether or not --contract is present.",
+            "--alias <name> assigns the world-local @name selector to the born Akuma; @name is also accepted.",
             `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 +53,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: {
@@ -155,11 +155,7 @@ function scanAkuma(action, argv, fail) {
             stdin = true;
         }
         else if (token === "-d") {
-            if (action !== "call")
-                fail(`option ${token} is not valid for ${action}`);
-            if (flags.detach !== undefined)
-                fail("duplicate option: --detach");
-            flags.detach = true;
+            fail(`option ${token} is not valid for ${action}`);
         }
         else if (!token.startsWith("--")) {
             if (isBlankInput(token))
@@ -180,16 +176,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 +276,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,
     };
@@ -308,15 +298,14 @@ function parseCall(flags, archetype, prompt, output, fail) {
     let alias;
     if (flags.alias !== undefined) {
         try {
-            alias = parseAkumaAlias(stringFlag(flags.alias, "--alias requires @name", fail));
+            const name = stringFlag(flags.alias, "--alias requires a name", fail);
+            alias = parseAkumaAlias(name.startsWith("@") ? name : `@${name}`);
         }
         catch (error) {
             fail(error instanceof Error ? error.message : "invalid Akuma alias");
         }
     }
-    if (flags.detach === true && flags.wait !== undefined)
-        fail("call --wait and --detach are mutually exclusive");
-    const mode = flags.detach === true ? "detach" : "wait";
+    const mode = flags.wait === undefined ? "detach" : "wait";
     const timeoutMs = flags.wait === undefined ? undefined : parseDuration(flags.wait, "--wait", fail);
     const allowed = parseAllowedFlag(flags.allowed, fail);
     const schema = flags.schema === undefined ? undefined : stringFlag(flags.schema, "call --schema requires a file", fail);

package/build/src/cli/commands/contract-help.d.ts

@@ -94,6 +94,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
         };
         readonly usage: "status [<contract>|@name|<aku/...>]...";
         readonly purpose: "Read the world status board or one or more Contract and Akuma projections.";
+        readonly details: "An Akuma projection reports that Akuma's frozen execution workdir; --contract associates a Contract without selecting one.";
     };
     readonly show: {
         readonly positional: "optional";

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'.",
             "",
@@ -163,6 +166,7 @@ export const CONTRACT_COMMAND_SPECS = {
         flags: { json: "boolean" },
         usage: "status [<contract>|@name|<aku/...>]...",
         purpose: "Read the world status board or one or more Contract and Akuma projections.",
+        details: "An Akuma projection reports that Akuma's frozen execution workdir; --contract associates a Contract without selecting one.",
     },
     show: {
         positional: "optional",

package/build/src/cli/invoke.js

@@ -348,7 +348,7 @@ async function callExecutionCwd(input) {
     if (input.workdir !== undefined) {
         return await canonicalBirthCwd(resolve(input.cwd, input.workdir), `workdir is not an existing directory: ${input.workdir}`);
     }
-    return input.command.contract === undefined ? input.cwd : undefined;
+    return input.cwd;
 }
 async function invokeParsedAkuma(input) {
     const executionCwd = await callExecutionCwd({

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