@astrosheep/keiyaku 4.5.27 → 4.5.28

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

@@ -4,7 +4,7 @@ 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, waitedTellProgress } from "../render/akuma.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";
@@ -188,6 +188,8 @@ function decodeWaitedTellSchema(result, schema) {
 }
 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,
@@ -198,11 +200,18 @@ async function invokeWaitedTell(command, input, body) {
         ...(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);
-    const alias = inputAlias(command.akuma);
-    if (command.output === "text")
-        writeProgress(waitedTellProgress(rendered, alias, resultContext()));
+    if (progress !== undefined)
+        writeProgress(progress.conclude(rendered).join("\n"));
     return {
         kind: "akuma",
         action: "tell",

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

@@ -11,20 +11,19 @@ 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.",
@@ -156,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))
@@ -303,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

@@ -166,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.js

@@ -872,6 +872,7 @@ function answeredBlock(observation, answer, alias, columns) {
 function snapshotCore(view, context, options) {
     const activity = snapshotActivityLines(view.status.timeline, context);
     const facts = [
+        ...(view.status.cwd === undefined ? [] : [`cwd  ${safeText(view.status.cwd)}`]),
         ...(options.showAllowed === true ? [`allowed  ${view.status.allowed.join(", ") || "none"}`] : []),
         ...(view.status.readonly?.enforcement === "none" ? [`! ${safeText(view.status.readonly.diagnostic)}`] : []),
         ...contractFacts(view.contract),
@@ -1050,7 +1051,11 @@ export function historyText(command, result, context) {
 export function tellText(result, context) {
     const wake = result.result.tell.wake;
     const target = identity(result.result.akuma, result.alias);
-    const row = groupedRows([result.result.tell.row], context).join("\n");
+    const row = groupedRows([result.result.tell.row], context, false, {
+        ...plainLayout(),
+        head: (time, _glyph, _verb, columns) => eventPrefix(wake.kind === "held" ? "⧗" : "⧖", "tell", time, columns),
+        singleLine: true,
+    }).join("\n");
     if (wake.kind === "failed") {
         const child = "child" in wake ? wake.child : undefined;
         const failure = `! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;

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

@@ -2,7 +2,16 @@ import type { AkumaInvocationResult } from "../commands/akuma-invoke.js";
 import type { ParsedCommand } from "../parse.js";
 import { type ObservedCallHead } from "./akuma-activity.js";
 import type { AkumaTellWaitResult } from "../../akuma/fleet-observation.js";
+import type { AkuId } from "../../akuma/identity.js";
+import type { LiveStatusObservation } from "../../akuma/akuma-observe.js";
+import type { TellResult } from "../../akuma/akuma.js";
 import { type TextRenderContext } from "./terminal.js";
+export type TellWaitProgress = Readonly<{
+    admitted: (tell: TellResult, id: AkuId) => readonly string[];
+    observe: (observation: LiveStatusObservation) => readonly string[];
+    conclude: (result: AkumaTellWaitResult) => readonly string[];
+}>;
+export declare function tellWaitProgressStream(akuma: AkuId | undefined, alias: string | undefined, context: TextRenderContext): TellWaitProgress;
 export declare function waitedTellProgress(result: AkumaTellWaitResult, alias: string | undefined, context: TextRenderContext): string;
 export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
 /**

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

@@ -1,6 +1,52 @@
 import { parseAkumaStatus } from "../../akuma/akuma.js";
-import { DEFAULT_CONTEXT, akumaRawAnswer as akumaActivityRawAnswer, associatedIdentity, historyText, killResultText, mutationObservationStageText, snapshotHeading, snapshotText, tellText, waitText, } from "./akuma-activity.js";
+import { activityStream, DEFAULT_CONTEXT, akumaRawAnswer as akumaActivityRawAnswer, associatedIdentity, historyText, killResultText, mutationObservationStageText, snapshotHeading, snapshotText, tellText, waitText, } from "./akuma-activity.js";
 import { safeText } from "./terminal.js";
+function tellWaitConclusion(result) {
+    return result.observation.reason === "answered"
+        ? "✓ answered"
+        : result.observation.reason === "failed"
+            ? `! failed · ${safeText(result.observation.diagnostic)}`
+            : result.observation.reason === "unanswered"
+                ? "○ unanswered"
+                : "⧖ deadline";
+}
+export function tellWaitProgressStream(akuma, alias, context) {
+    let target = akuma;
+    const stream = activityStream(context);
+    let opened = false;
+    return {
+        admitted: (tell, id) => {
+            target = id;
+            if (target === undefined)
+                throw new Error("Tell progress admitted without identity");
+            return [
+                tellText({
+                    kind: "akuma",
+                    action: "tell",
+                    mode: "ordinary",
+                    result: { akuma: target, tell },
+                    body: "",
+                    ...(alias === undefined ? {} : { alias }),
+                }, context),
+            ];
+        },
+        observe: (observation) => {
+            const lines = [];
+            if (target === undefined)
+                throw new Error("Tell progress observed before admission");
+            if (!opened) {
+                opened = true;
+                lines.push(...snapshotHeading(target, alias, undefined));
+                lines.push(...stream.seed({ snapshot: observation.status.timeline, rows: observation.rows }));
+            }
+            else {
+                lines.push(...stream({ snapshot: observation.status.timeline, rows: observation.rows }));
+            }
+            return lines;
+        },
+        conclude: (result) => [...stream.flush(), tellWaitConclusion(result)],
+    };
+}
 export function waitedTellProgress(result, alias, context) {
     const receipt = tellText({
         kind: "akuma",
@@ -10,13 +56,7 @@ export function waitedTellProgress(result, alias, context) {
         body: "",
         ...(alias === undefined ? {} : { alias }),
     }, context);
-    const conclusion = result.observation.reason === "answered"
-        ? "✓ answered"
-        : result.observation.reason === "failed"
-            ? `! failed · ${safeText(result.observation.diagnostic)}`
-            : result.observation.reason === "unanswered"
-                ? "○ unanswered"
-                : "⧖ deadline";
+    const conclusion = tellWaitConclusion(result);
     return `${receipt}\n${conclusion}`;
 }
 function waitedTellRawAnswer(result) {

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

@@ -1,3 +1,6 @@
+export declare const MAX_AKUMA_NAME_BYTES = 64;
+export declare function isCanonicalAkumaName(value: string): boolean;
+export declare function validateAkumaName(value: string): string;
 export declare function normalizeIdentityStem(input: Readonly<{
     source: string;
 }>): string;

package/build/src/identity/normalize.js

@@ -5,6 +5,16 @@ const SUFFIX = /^[\p{Letter}\p{Number}]+$/u;
 function graphemes(value) {
     return [...GRAPHEMES.segment(value)].map(({ segment }) => segment);
 }
+export const MAX_AKUMA_NAME_BYTES = 64;
+export function isCanonicalAkumaName(value) {
+    return value.length > 0 && normalizeIdentityStem({ source: value }) === value;
+}
+export function validateAkumaName(value) {
+    if (!isCanonicalAkumaName(value) || Buffer.byteLength(value, "utf8") > MAX_AKUMA_NAME_BYTES) {
+        throw new TypeError(`Akuma name must be one normalized human identity segment of at most ${MAX_AKUMA_NAME_BYTES} UTF-8 bytes`);
+    }
+    return value;
+}
 export function normalizeIdentityStem(input) {
     const source = input.source.normalize("NFKC").toLowerCase().normalize("NFKC");
     let result = "";

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

@@ -6,6 +6,7 @@ export type AkumaAlias = string & {
 export type AkumaGlob = string & {
     readonly [AKUMA_GLOB]: true;
 };
+export declare function parseReadableAkumaAlias(value: string): AkumaAlias;
 export declare function parseAkumaAlias(value: string): AkumaAlias;
 export declare function parseAkumaGlob(value: string): AkumaGlob;
 export declare function matchesAkumaGlob(glob: AkumaGlob, value: string): boolean;

package/build/src/identity/selector.js

@@ -1,8 +1,20 @@
-const AKUMA_ALIAS_PATTERN = /^@[a-z][a-z0-9-]{0,63}$/u;
+import { MAX_AKUMA_NAME_BYTES, normalizeIdentityStem, validateAkumaName } from "./normalize.js";
 const AKUMA_GLOB_SUFFIX = /^[0-9a-f*]+$/u;
+const LEGACY_AKUMA_ALIAS_PATTERN = /^@[a-z][a-z0-9-]{0,63}$/u;
+// Old alias spellings remain readable, but new bindings use canonical Akuma names.
+export function parseReadableAkumaAlias(value) {
+    if (LEGACY_AKUMA_ALIAS_PATTERN.test(value))
+        return value;
+    return parseAkumaAlias(value);
+}
 export function parseAkumaAlias(value) {
-    if (!AKUMA_ALIAS_PATTERN.test(value)) {
-        throw new TypeError("Akuma alias must match ^@[a-z][a-z0-9-]{0,63}$");
+    if (!value.startsWith("@"))
+        throw new TypeError("Akuma alias selector must start with @");
+    try {
+        validateAkumaName(value.slice(1));
+    }
+    catch {
+        throw new TypeError(`Akuma alias name must be a normalized Akuma name of at most ${MAX_AKUMA_NAME_BYTES} UTF-8 bytes`);
     }
     return value;
 }
@@ -26,4 +38,3 @@ export function matchesAkumaGlob(glob, value) {
         .replaceAll("*", "[^/]*");
     return new RegExp(`^${pattern}$`, "u").test(value);
 }
-import { normalizeIdentityStem } from "./normalize.js";

package/build/src/library/address.js

@@ -5,7 +5,7 @@ import { akumaAddressability, requireBornAkuma } from "../akuma/akuma-probe.js";
 import { parseAkuId } from "../akuma/identity.js";
 import { contractId } from "../core/facts/types.js";
 import { readDispatches } from "../dispatch/index.js";
-import { matchesAkumaGlob, parseAkumaAlias, parseAkumaGlob, } from "../identity/selector.js";
+import { matchesAkumaGlob, parseReadableAkumaAlias, parseAkumaGlob, } from "../identity/selector.js";
 import { World } from "../world.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
@@ -34,7 +34,7 @@ function nonblank(value, label) {
 }
 function parseAddressAlias(selector) {
     try {
-        return parseAkumaAlias(selector);
+        return parseReadableAkumaAlias(selector);
     }
     catch (error) {
         if (!(error instanceof TypeError))

package/build/src/library/akuma-creation.d.ts

@@ -73,7 +73,7 @@ export type CallResult = Readonly<{
     readonly?: ReadonlyRestraint;
     execution: Readonly<{
         cwd: string;
-        source: "input" | "contract-worktree" | "caller" | "process" | "world";
+        source: "input" | "caller" | "process" | "world";
     }>;
     dispatch: DispatchStage;
     alias: AliasStage;

package/build/src/library/akuma-creation.js

@@ -9,7 +9,6 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
 import { emitCalledPluginSignal } from "../plugin/akuma-signals.js";
-import { readManagedWorktreeAppointment } from "../workspace-place.js";
 import { World } from "../world.js";
 import { Akuma as PublicAkuma } from "../akuma/akuma-instance.js";
 import { requestForwardedFleetTellAnswer } from "../akuma/fleet-request.js";
@@ -17,7 +16,6 @@ import { localExecutionContext } from "../akuma/requests.js";
 import { callReadonly, canonicalBirthCwd } from "../akuma/call-input.js";
 import { requireInput } from "./input.js";
 import { addressAkuma } from "./address.js";
-import { KeiyakuRefused } from "./contract.js";
 import { seatForKeiyaku } from "./contract-handle.js";
 import { scopeForRepo } from "./repo.js";
 function nonblank(value, label) {
@@ -67,10 +65,10 @@ function integrationFailure(error) {
     };
 }
 function callMode(value) {
-    if (value === undefined || value === "wait")
-        return "wait";
-    if (value === "detach")
+    if (value === undefined || value === "detach")
         return "detach";
+    if (value === "wait")
+        return "wait";
     throw new TypeError("mode must be wait or detach");
 }
 function callTimeout(value, mode) {
@@ -196,49 +194,13 @@ async function forkDispatchStage(input) {
         return { kind: "failed", failure: integrationFailure(error) };
     }
 }
-function unavailableWorkspace(contractId, detail) {
-    return new Error(`Contract workspace is unavailable: ${contractId} ${detail}`);
-}
-async function currentManagedContract(contract, contractId) {
-    let state;
-    try {
-        state = await contract.state();
-    }
-    catch (error) {
-        if (error instanceof Error && error.message === `contract does not exist: ${contractId}`) {
-            throw new KeiyakuRefused({ kind: "contract-missing", contractId });
-        }
-        throw error;
-    }
-    if (state.terminal !== null)
-        throw new KeiyakuRefused({ kind: "terminal", contractId: state.id });
-    return state;
-}
 async function resolveCallExecution(input) {
-    if (input.cwd !== undefined) {
-        return {
-            cwd: await canonicalBirthCwd(input.cwd),
-            source: "input",
-        };
-    }
-    if (input.contract !== undefined) {
-        const seat = seatForKeiyaku(input.contract);
-        if (seat === null)
-            throw new TypeError("contract must be a Keiyaku");
-        const state = await currentManagedContract(input.contract, seat.id);
-        const appointment = await readManagedWorktreeAppointment(seat.scope, state.id);
-        if (appointment.kind === "unappointed") {
-            throw unavailableWorkspace(state.id, "is unappointed; use reconcile");
-        }
-        if (appointment.kind === "failed") {
-            throw new Error(`${appointment.diagnostic}; use reconcile`);
-        }
-        return {
-            cwd: await canonicalBirthCwd(appointment.path, `Contract workspace is unavailable: ${appointment.path}`),
-            source: "contract-worktree",
-        };
-    }
-    return undefined;
+    if (input.cwd === undefined)
+        return undefined;
+    return {
+        cwd: await canonicalBirthCwd(input.cwd),
+        source: "input",
+    };
 }
 async function resolveAliasStage(path, alias, dispatch, akuma) {
     if (alias === undefined)
@@ -326,11 +288,7 @@ function schemaTell(input) {
 }
 async function prepareCall(input, context) {
     const parsed = await parseCallInput(input);
-    const execution = await resolveCallExecution({
-        path: parsed.path,
-        ...(parsed.cwd === undefined ? {} : { cwd: parsed.cwd }),
-        ...(parsed.seat === undefined ? {} : { contract: parsed.values.contract }),
-    });
+    const execution = await resolveCallExecution(parsed.cwd === undefined ? {} : { cwd: parsed.cwd });
     const world = akumaWorld(parsed.path, parsed.home, parsed.settings, context);
     const { born, akuma } = await admitCall({
         path: parsed.path,

package/build/src/library/composition.d.ts

@@ -16,7 +16,7 @@ export declare function composeLibrary(context?: ExecutionContext, composition?:
         readonly?: import("../akuma/provider-recipe.js").ReadonlyRestraint;
         execution: Readonly<{
             cwd: string;
-            source: "input" | "contract-worktree" | "caller" | "process" | "world";
+            source: "input" | "caller" | "process" | "world";
         }>;
         dispatch: import("./akuma-creation.js").DispatchStage;
         alias: import("./akuma-creation.js").AliasStage;
@@ -357,6 +357,7 @@ export declare function composeLibrary(context?: ExecutionContext, composition?:
                         };
                     } | undefined;
                 };
+                cwd?: string | undefined;
                 readonly?: {
                     enforcement: "native";
                 } | {

package/build/src/library/fleet.d.ts

@@ -1,7 +1,7 @@
 /** @architectureCompositionRoot */
 import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt } from "../akuma/akuma.js";
 import { type ExecutionContext } from "../akuma/requests.js";
-import type { WaitObserver } from "../akuma/fleet-execution.js";
+import type { TellWaitObserver, WaitObserver } from "../akuma/fleet-execution.js";
 import { type DispatchAssociation } from "../dispatch/index.js";
 import { type Schema } from "../akuma/schema.js";
 import { type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
@@ -23,6 +23,7 @@ export type AkumaTellWaitInput = AkumaAddressInput & Readonly<{
     interrupt?: boolean;
     initiator?: string;
     signal?: AbortSignal;
+    observe?: TellWaitObserver;
 }>;
 export type { TellResult, TellWake } from "../akuma/akuma.js";
 export type { CreatedTaskObservation } from "../task/created-observation.js";

package/build/src/library/fleet.js

@@ -285,10 +285,9 @@ export async function tellAkuma(input, execution = localExecutionContext()) {
         ...(callerSignal === undefined ? {} : { signal: callerSignal }),
     });
 }
-export async function tellWaitAkuma(input, execution = localExecutionContext()) {
-    const values = requireInput(input, "Keiyaku tell wait input");
+function validateTellWaitInput(values) {
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "body", "repo", "timeoutMs", "schema", "interrupt", "initiator", "signal"].includes(key)) {
+        if (!["path", "akuma", "body", "repo", "timeoutMs", "schema", "interrupt", "initiator", "signal", "observe"].includes(key)) {
             throw new TypeError(`Keiyaku tell wait input has unknown field: ${key}`);
         }
     }
@@ -302,6 +301,10 @@ export async function tellWaitAkuma(input, execution = localExecutionContext())
     }
     if (values.interrupt !== undefined && typeof values.interrupt !== "boolean")
         throw new TypeError("interrupt must be a boolean");
+}
+export async function tellWaitAkuma(input, execution = localExecutionContext()) {
+    const values = requireInput(input, "Keiyaku tell wait input");
+    validateTellWaitInput(values);
     const callerSignal = signal(values.signal);
     const channel = executionChannel(execution);
     if (channel.kind === "body-request") {
@@ -328,6 +331,7 @@ export async function tellWaitAkuma(input, execution = localExecutionContext())
         ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
         ...(input.interrupt === true ? { interrupt: true } : {}),
         ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+        ...(input.observe === undefined ? {} : { onObserve: input.observe }),
         ...(callerSignal === undefined ? {} : { signal: callerSignal }),
     });
 }

package/build/src/library/keiyaku.d.ts

@@ -48,7 +48,7 @@ export declare const Keiyaku: Readonly<{
         readonly?: import("../akuma/provider-recipe.js").ReadonlyRestraint;
         execution: Readonly<{
             cwd: string;
-            source: "input" | "contract-worktree" | "caller" | "process" | "world";
+            source: "input" | "caller" | "process" | "world";
         }>;
         dispatch: import("./akuma-creation.js").DispatchStage;
         alias: import("./akuma-creation.js").AliasStage;
@@ -389,6 +389,7 @@ export declare const Keiyaku: Readonly<{
                         };
                     } | undefined;
                 };
+                cwd?: string | undefined;
                 readonly?: {
                     enforcement: "native";
                 } | {

package/build/src/protocol/completion.js

@@ -3,6 +3,7 @@ import { admitPlacement, observeTargetPlacement } from "./placement.js";
 import { reintegrateOperation } from "./reintegrate.js";
 import { contractCheckpoint, executionStop, } from "./progress.js";
 import { placementStop, timestamp, unpackVerificationOutcome } from "./operations.js";
+import { VERIFIED } from "../verification/declaration.js";
 const MAX_REINTEGRATION_CYCLES = 3;
 function reintegrationStop(result) {
     if (result.kind === "placement-failed")
@@ -154,15 +155,21 @@ async function placeCurrentCandidate(input, cursor) {
     }
     return result;
 }
+/** Verification blocks completion only when the Contract selected the verified gate; placement owns gate eligibility. */
+function verificationBlocks(state) {
+    return state.terms.gates.includes(VERIFIED);
+}
 async function verifyCandidateReadiness(input, cursor) {
     const observedPlacement = await observeCandidateTarget(input, cursor);
     await verifyCurrentCandidate(input, cursor);
-    if (cursor.evidence.verification !== undefined || observedPlacement !== undefined) {
+    const verification = cursor.evidence.verification;
+    const blocking = verification !== undefined && verificationBlocks(cursor.checkpoint.state);
+    if (blocking || observedPlacement !== undefined) {
         return {
             kind: "stopped",
             checkpoint: cursor.checkpoint,
             evidence: { ...cursor.evidence, ...(observedPlacement === undefined ? {} : { placement: observedPlacement }) },
-            stop: cursor.evidence.verification ?? observedPlacement,
+            stop: blocking ? verification : observedPlacement,
         };
     }
     return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.27",
+  "version": "4.5.28",
   "workspaces": [
     "plugins/*"
   ],