@astrosheep/keiyaku 4.5.26 → 4.5.28

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

@@ -1,7 +1,75 @@
 import { parseAkumaStatus } from "../../akuma/akuma.js";
-import { DEFAULT_CONTEXT, akumaRawAnswer, 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";
-export { akumaRawAnswer } from "./akuma-activity.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",
+        action: "tell",
+        mode: "ordinary",
+        result: { akuma: result.akuma, tell: result.tell },
+        body: "",
+        ...(alias === undefined ? {} : { alias }),
+    }, context);
+    const conclusion = tellWaitConclusion(result);
+    return `${receipt}\n${conclusion}`;
+}
+function waitedTellRawAnswer(result) {
+    if (result.result.observation.reason !== "answered")
+        return "";
+    const answer = result.result.observation.answer;
+    return typeof answer === "string" ? answer : JSON.stringify(answer);
+}
+export function akumaRawAnswer(result) {
+    if (result.action === "tell" && result.mode === "wait")
+        return waitedTellRawAnswer(result);
+    return akumaActivityRawAnswer(result);
+}
 function dispatchLines(stage) {
     if (stage.kind === "none")
         return [];
@@ -83,6 +151,8 @@ export function renderAkumaText(command, result, context = DEFAULT_CONTEXT) {
         case "wait":
             return waitText(result, context);
         case "tell":
+            if (result.mode === "wait")
+                return "";
             return result.mode === "ordinary"
                 ? tellText(result, context)
                 : mutationObservationStageText(result.result.id, result.result.observation, context, {
@@ -125,6 +195,8 @@ function killExitCode(result) {
 function tellExitCode(result) {
     if (result.mode === "schema")
         return 0;
+    if (result.mode === "wait")
+        return result.result.observation.reason === "failed" ? 2 : 0;
     return result.mode === "ordinary"
         ? result.result.tell.wake.kind === "failed"
             ? 2

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

@@ -1,4 +1,4 @@
-import { abbreviateGitIds, afterWording, candidateFact, dependentWording, gateFact, gitIdsInRow, verificationFact, targetFacts, } from "./contract-observation.js";
+import { abbreviateGitIds, afterWording, candidateIntegrationFacts, dependentWording, gateFact, gitIdsInRow, targetFacts, } from "./contract-observation.js";
 import { safeText } from "./terminal.js";
 import { dispositionText, taskMark } from "./task.js";
 function akumaMark(life) {
@@ -87,10 +87,9 @@ function renderContractCatalog(catalog) {
     const blocks = rows.map((row) => {
         const lines = [
             `${catalogMark(row)} ${safeText(row.id)} · ${row.phase} · ${formatAge(row.phaseAt, catalog.observedAt)} · ${safeText(row.title ?? "title unavailable")}`,
-            `  ${candidateFact(row.delivery)}`,
+            ...candidateIntegrationFacts(row.delivery, row.verification, abbreviations).map((fact) => `  ${safeText(fact)}`),
             ...targetFacts(row, abbreviations).map((fact) => `  ${safeText(fact)}`),
             ...[],
-            ...(verificationFact(row.verification) === undefined ? [] : [`  ${verificationFact(row.verification)}`]),
             ...row.after.map((edge) => `  ${afterWording(edge)}`),
             ...(row.dependents.length === 0 ? [] : [`  dependents  ${row.dependents.map(dependentWording).join(" · ")}`]),
             ...(row.gates.reports.length === 0 ? [] : [`  ${row.gates.reports.map(gateFact).join("  ")}`]),

package/build/src/cli/render/contract-observation.d.ts

@@ -3,6 +3,7 @@ export declare function gateGlyph(report: ContractGateReport): string;
 export declare function gateFact(report: ContractGateReport): string;
 export declare function candidateFact(delivery: ContractRow["delivery"]): string;
 export declare function verificationFact(status: ContractRow["verification"]): string | undefined;
+export declare function candidateIntegrationFacts(delivery: ContractRow["delivery"], verification: ContractRow["verification"], abbreviations: ReadonlyMap<string, string>): readonly string[];
 export declare function afterWording(edge: ContractAfterEdge): string;
 export declare function dependentWording(dependent: ContractDependent): string;
 export declare function mergeSummary(observation: ContractWorkspaceObservation): string | undefined;

package/build/src/cli/render/contract-observation.js

@@ -19,9 +19,28 @@ export function verificationFact(status) {
     if (status === undefined)
         return undefined;
     if (status.kind === "recorded")
-        return `verification ${status.verdict}${status.snapshot === undefined ? "" : ` · on ${shortGitId(status.snapshot)}`}`;
+        return `verification ${status.verdict}${status.snapshot === undefined ? "" : ` · snapshot ${shortGitId(status.snapshot)}`}`;
     return `verification ${status.kind}`;
 }
+export function candidateIntegrationFacts(delivery, verification, abbreviations) {
+    const verificationLine = verificationFact(verification);
+    if (delivery === null) {
+        return [candidateFact(delivery), ...(verificationLine === undefined ? [] : [verificationLine])];
+    }
+    const integration = displayGitId(delivery.integration.snapshot, abbreviations);
+    const foldedVerification = verification?.kind === "recorded" && verification.snapshot === delivery.integration.snapshot
+        ? ` · verification ${verification.verdict}`
+        : "";
+    return [
+        candidateFact(delivery),
+        `tender commit  ${displayGitId(delivery.tenderSnapshot, abbreviations)}`,
+        `integration result  ${integration}${foldedVerification}`,
+        `predecessor  ${displayGitId(delivery.integration.predecessor, abbreviations)}`,
+        `method  ${delivery.method}`,
+        `content identity (not commit)  ${delivery.integration.changeId}`,
+        ...(foldedVerification.length === 0 && verificationLine !== undefined ? [verificationLine] : []),
+    ];
+}
 export function afterWording(edge) {
     if (edge.endpoint.kind === "claimed")
         return `after  ${edge.contractId} · claimed`;

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

@@ -152,9 +152,9 @@ function shortGitId(value) {
 /**
  * Shared presentation of a completed placement, so a deliver and a review that placed the same candidate read
  * identically: one git-shaped target movement row, naming the reference it advanced, then the final lifecycle
- * state. Satisfied Verification adds one fact row naming the commit the verdict ran against; placement made that
- * commit the reference's new head, so the two rows share one sha. Verification mode words stay in JSON and
- * `history`, never in ordinary receipt text. A completion without an advanced reference states no movement.
+ * state. Satisfied Verification adds one fact row naming the integrated result; placement made that commit the
+ * reference's new head, so the movement and integrated-result rows share one sha. Verification mode words stay in
+ * JSON and `history`, never in ordinary receipt text. A completion without an advanced reference states no movement.
  * Journal ULIDs stay in JSON and `history`, never in ordinary receipt text.
  */
 function completedPlacementLines(result, columns) {
@@ -169,7 +169,7 @@ function completedPlacementLines(result, columns) {
         ], columns);
     }
     if (completion.verification?.verdict === "satisfied") {
-        receiptRow(lines, " ", "verification", [{ text: "satisfied" }, { text: `· on ${shortGitId(completion.integration)}` }], columns);
+        receiptRow(lines, " ", "integration result", [{ text: `${shortGitId(completion.integration)} · verification satisfied` }], columns);
     }
     lines.push(...nonGatingVerificationLines(result, columns));
     // Placement admission always admits the claim entry beside the movement, so a completed placement is claimed.

package/build/src/cli/render/execution-progress.d.ts

@@ -16,6 +16,7 @@ export declare class ExecutionProgressRenderer {
     private declarationFailed;
     private phaseFailed;
     private phaseUnknown;
+    private readonly liveOutput;
     constructor(input: ExecutionProgressOptions);
     consume(event: ExecutionEvent): Promise<void>;
     finish(): void;

package/build/src/cli/render/execution-progress.js

@@ -1,12 +1,12 @@
 import { renderOpaqueBlock, safeText } from "./terminal.js";
 import { StatusLine } from "./status-line.js";
 const LIVE_OUTPUT_BYTES = 4 * 1024;
-function boundedUtf8Prefix(value) {
+function boundedUtf8Prefix(value, maximumBytes = LIVE_OUTPUT_BYTES) {
     let bytes = 0;
     let text = "";
     for (const character of value) {
         const size = Buffer.byteLength(character);
-        if (bytes + size > LIVE_OUTPUT_BYTES)
+        if (bytes + size > maximumBytes)
             return { text, truncated: true };
         bytes += size;
         text += character;
@@ -47,6 +47,74 @@ function outputLines(observation, context) {
         ...(output.truncated ? ["  [live output truncated]"] : []),
     ];
 }
+class VerificationLiveOutput {
+    streams = new Map();
+    activeStream;
+    reset() {
+        this.streams.clear();
+        this.activeStream = undefined;
+    }
+    lines(observation, context) {
+        const stream = observation.stream;
+        const lines = this.flushOtherStreams(stream, context);
+        const previous = this.streams.get(stream);
+        const state = previous ?? { bytes: 0, truncated: false, pending: "", prefix: "  " };
+        if (this.activeStream !== stream) {
+            state.prefix = "  ";
+            lines.push(stream);
+            this.activeStream = stream;
+        }
+        this.streams.set(stream, state);
+        if (state.truncated)
+            return lines;
+        const output = boundedUtf8Prefix(observation.text, LIVE_OUTPUT_BYTES - state.bytes);
+        state.bytes += Buffer.byteLength(output.text);
+        state.pending += output.text;
+        lines.push(...this.drainCompleteLines(state, context));
+        this.streams.set(stream, state);
+        if (output.truncated) {
+            lines.push(...this.drainPartialLine(state, context));
+            state.truncated = true;
+            lines.push("  [live output truncated]");
+        }
+        return lines;
+    }
+    finish(context) {
+        const lines = [];
+        for (const state of this.streams.values())
+            lines.push(...this.drainPartialLine(state, context));
+        this.streams.clear();
+        this.activeStream = undefined;
+        return lines;
+    }
+    flushOtherStreams(stream, context) {
+        const lines = [];
+        for (const [otherStream, state] of this.streams)
+            if (otherStream !== stream)
+                lines.push(...this.drainPartialLine(state, context));
+        return lines;
+    }
+    drainCompleteLines(state, context) {
+        const lines = [];
+        for (;;) {
+            const newline = state.pending.indexOf("\n");
+            if (newline < 0)
+                break;
+            const line = state.pending.slice(0, newline);
+            state.pending = state.pending.slice(newline + 1);
+            lines.push(...renderOpaqueBlock(line, state.prefix, context.columns));
+            state.prefix = "    ";
+        }
+        return lines;
+    }
+    drainPartialLine(state, context) {
+        if (state.pending.length === 0)
+            return [];
+        const lines = renderOpaqueBlock(state.pending, state.prefix, context.columns);
+        state.pending = "";
+        return lines;
+    }
+}
 /** Sparse rendering for consumers that do not own a live stream. */
 export function executionProgressLines(event, context) {
     switch (event.kind) {
@@ -75,6 +143,7 @@ export class ExecutionProgressRenderer {
     declarationFailed = false;
     phaseFailed = false;
     phaseUnknown = false;
+    liveOutput = new VerificationLiveOutput();
     constructor(input) {
         this.input = input;
         this.status = new StatusLine(input.stream, input);
@@ -101,10 +170,12 @@ export class ExecutionProgressRenderer {
     async consumeVerification(event) {
         const observation = event.observation;
         if (observation.kind === "output") {
-            await this.write(outputLines(observation, this.input.context));
+            await this.write(this.liveOutput.lines(observation, this.input.context));
             return;
         }
         if (observation.state === "started") {
+            await this.write(this.liveOutput.finish(this.input.context));
+            this.liveOutput.reset();
             this.verificationStartedAt ??= (this.input.now ?? (() => performance.now()))();
             if (this.status.isTTY)
                 this.status.show((duration) => `verify  ● ${phaseDetail(observation)} · ${elapsed(duration)}`);
@@ -112,6 +183,7 @@ export class ExecutionProgressRenderer {
                 await this.write([phaseStartLine(observation)]);
             return;
         }
+        await this.write(this.liveOutput.finish(this.input.context));
         const mark = phaseMark(observation.outcome);
         this.phaseFailed ||= mark === "×";
         this.phaseUnknown ||= mark === "?";
@@ -127,6 +199,8 @@ export class ExecutionProgressRenderer {
             await this.write([phaseFinishLine(observation)]);
     }
     write(lines) {
+        if (lines.length === 0)
+            return Promise.resolve();
         if (this.status.isTTY) {
             this.status.writeBlock(lines);
             return Promise.resolve();

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

@@ -1,4 +1,4 @@
-import { abbreviateGitIds, afterWording, candidateFact, dependentWording, displayGitId, gateFact, gitIdsInRow, mergeSummary, verificationFact, targetFacts, } from "./contract-observation.js";
+import { abbreviateGitIds, afterWording, candidateIntegrationFacts, dependentWording, displayGitId, gateFact, gitIdsInRow, mergeSummary, targetFacts, } from "./contract-observation.js";
 import { entityLines, elapsedMilliseconds, identityLine, plumbFacts, RECENT_TONE_MS, renderSectionBlock, linkedEntityLines, safeText, tone, } from "./terminal.js";
 import { akumaMark, endpointFact, formatAge, NARROW_COLUMNS, renderAkuma } from "./kanshi-akuma.js";
 import { dispositionText } from "./task.js";
@@ -179,7 +179,7 @@ function renderSelectedContractRow(row, report, context, abbreviations) {
             : []),
     ]);
     lines.push(...semanticBlock("gates", gateFacts, context));
-    lines.push(...semanticBlock("candidate/integration", candidateFacts(row, abbreviations), context));
+    lines.push(...semanticBlock("candidate/integration", candidateIntegrationFacts(row.delivery, row.verification, abbreviations), context));
     lines.push(...semanticBlock("target", targetFacts(row, abbreviations), context));
     const workspaceFacts = [workspaceState(row)];
     if (row.workspaceObservation.kind !== "unappointed" &&
@@ -199,31 +199,17 @@ function renderSelectedContractRow(row, report, context, abbreviations) {
     }
     return lines;
 }
-function candidateFacts(row, abbreviations) {
-    const verification = verificationFact(row.verification);
-    if (row.delivery === null)
-        return [candidateFact(row.delivery), ...(verification === undefined ? [] : [verification])];
-    const delivery = row.delivery;
-    return [
-        candidateFact(delivery),
-        `tender commit  ${displayGitId(delivery.tenderSnapshot, abbreviations)}`,
-        `integration commit  ${displayGitId(delivery.integration.snapshot, abbreviations)} · predecessor ${displayGitId(delivery.integration.predecessor, abbreviations)}`,
-        `method  ${delivery.method}`,
-        `content identity (not commit)  ${delivery.integration.changeId}`,
-        ...(verification === undefined ? [] : [verification]),
-    ];
-}
 function renderWorldContractRow(row, report, context) {
     const title = row.title ?? "title unavailable";
+    const abbreviations = gitAbbreviations(report);
     const contractFacts = [
-        candidateFact(row.delivery),
-        ...targetFacts(row, gitAbbreviations(report)),
+        ...candidateIntegrationFacts(row.delivery, row.verification, abbreviations),
+        ...targetFacts(row, abbreviations),
         ...[],
         ...(linkedAkumaSummary(row, report) === undefined ? [] : [linkedAkumaSummary(row, report)]),
         ...row.after.map(afterWording),
         ...(row.dependents.length === 0 ? [] : [`dependents  ${row.dependents.map(dependentWording).join(" · ")}`]),
         ...row.gates.reports.map(gateFact),
-        ...(verificationFact(row.verification) === undefined ? [] : [verificationFact(row.verification)]),
     ];
     const linkedFacts = [
         ...(row.holder.kind === "held" ? [linkedTask(report, row.holder.taskId)] : []),

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

@@ -158,7 +158,9 @@ export function quotedText(value) {
         .join(""));
 }
 export function safeText(value) {
-    return value.replaceAll(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (character) => (/\s/u.test(character) ? " " : "�"));
+    return value.replaceAll(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, (character) => 
+    // ZWJ and ZWNJ are legitimate joiners that carry a grapheme cluster's shape; they move no cursor.
+    character === "\u200c" || character === "\u200d" ? character : /\s/u.test(character) ? " " : "�");
 }
 export function checkoutNotFollowableLines(refusal) {
     const lines = [

package/build/src/cli/runtime.d.ts

@@ -5,4 +5,10 @@ export declare function writeExecutionProgress(events: AsyncIterable<ExecutionEv
 export declare function writeTask(command: Extract<ParsedCommand, {
     command: "task";
 }>, result: TaskInvocationResult): Promise<number>;
+type AkumaFailureProjection = Readonly<{
+    body: string;
+    exitCode: 1 | 3;
+}>;
+export declare function akumaFailureProjection(error: unknown, command: ParsedCommand): Promise<AkumaFailureProjection | undefined>;
 export declare function runCliCommand(invocation: ParsedExecution): Promise<number>;
+export {};

package/build/src/cli/runtime.js

@@ -133,19 +133,37 @@ async function writeResult(command, result) {
     writeCliStream(process.stdout, body);
     return invocationExitCode(contractResult);
 }
-function writeWorldScopeRefusal(error, command) {
-    const guide = usageGuideForCommand(command);
-    const body = command.output === "json"
-        ? JSON.stringify(error.refusal)
-        : [
-            `× selector  ${error.refusal.kind}`,
-            `  world  ${safeText(error.refusal.world)}`,
-            ...error.refusal.ids.map((id) => `  given  ${safeText(id)}`),
-            `  accepts  ${guide.accepts}`,
-            `  help  ${guide.help}`,
-        ].join("\n");
-    writeCliStream(process.stderr, body);
-    return 1;
+export async function akumaFailureProjection(error, command) {
+    const [{ AkumaNotBornError, AkumaObservationError }, { AkumaAddressError, AkumaWorldScopeError }] = await Promise.all([import("../akuma/akuma-errors.js"), import("../library/address.js")]);
+    if (error instanceof AkumaNotBornError) {
+        return {
+            body: command.output === "json" ? error.message : `× Akuma not found  ${safeText(error.id)}`,
+            exitCode: 1,
+        };
+    }
+    if (error instanceof AkumaAddressError) {
+        const body = error.refusal.kind === "akuma-alias-not-found"
+            ? `× Akuma alias not found  ${safeText(error.refusal.alias)}`
+            : `× invalid Akuma  ${safeText(error.refusal.selector)}`;
+        return { body: command.output === "json" ? error.message : body, exitCode: 1 };
+    }
+    if (error instanceof AkumaWorldScopeError) {
+        return {
+            body: command.output === "json"
+                ? JSON.stringify(error.refusal)
+                : error.refusal.ids.map((id) => `× Akuma not in this World  ${safeText(id)}`).join("\n"),
+            exitCode: 1,
+        };
+    }
+    if (error instanceof AkumaObservationError) {
+        return {
+            body: command.output === "json"
+                ? error.message
+                : `× Akuma observation failed  ${safeText(error.id)} — ${safeText(error.diagnostic)}`,
+            exitCode: 3,
+        };
+    }
+    return undefined;
 }
 async function commandFailureText(error, command) {
     const diagnostic = error instanceof Error ? error.message : String(error);
@@ -189,10 +207,10 @@ export async function runCliCommand(invocation) {
                 : executionFailureLines(receipt, category, diagnostic, displayContext().columns).join("\n"));
             return 3;
         }
-        if (command.command !== "install") {
-            const { AkumaWorldScopeError } = await import("../library/address.js");
-            if (error instanceof AkumaWorldScopeError)
-                return writeWorldScopeRefusal(error, command);
+        const akumaFailure = await akumaFailureProjection(error, command);
+        if (akumaFailure !== undefined) {
+            writeCliStream(process.stderr, akumaFailure.body);
+            return akumaFailure.exitCode;
         }
         if (command.command === "bind") {
             const { BindDraftError } = await import("./draft.js");

package/build/src/core/facts/offer.d.ts

@@ -1,7 +1,6 @@
-import type { ContractHead, ContractId, JournalEntry, SnapshotId } from "./types.js";
+import type { ContractId, JournalEntry, SnapshotId } from "./types.js";
 export type ContractJournalAppend = Readonly<{
     readonly contractId: ContractId;
-    readonly expectedHead: ContractHead | null;
     readonly entries: readonly JournalEntry[];
 }>;
 /** A target operation is optional because claim can be journal-only. */

package/build/src/core/verbs/abandon.js

@@ -29,5 +29,5 @@ export function decideAbandon({ input, attempt, observation, }) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data: input.note === undefined ? {} : { note: input.note },
     };
-    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: current.head, entries: [abandoned] }] } };
+    return { kind: "offer", offer: { facts: [{ contractId: id, entries: [abandoned] }] } };
 }

package/build/src/core/verbs/amend.js

@@ -57,5 +57,5 @@ export function decideAmend({ input, attempt, observation, }) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data,
     };
-    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: current.head, entries: [entry] }] } };
+    return { kind: "offer", offer: { facts: [{ contractId: id, entries: [entry] }] } };
 }

package/build/src/core/verbs/arc.js

@@ -36,6 +36,6 @@ export function decideArc({ input, attempt, observation }) {
     };
     return {
         kind: "offer",
-        offer: { facts: [{ contractId: id, expectedHead: current.head, entries: [arc] }] },
+        offer: { facts: [{ contractId: id, entries: [arc] }] },
     };
 }

package/build/src/core/verbs/attestation.js

@@ -35,6 +35,6 @@ export function decideAttestation({ input, attempt, observation, }) {
     };
     return {
         kind: "offer",
-        offer: { facts: [{ contractId: input.contractId, expectedHead: state.head, entries: [attestation] }] },
+        offer: { facts: [{ contractId: input.contractId, entries: [attestation] }] },
     };
 }

package/build/src/core/verbs/bind.js

@@ -38,5 +38,5 @@ export function decideBind({ input, attempt, observation, }) {
         ...(input.actor === undefined ? {} : { actor: input.actor }),
         data,
     };
-    return { kind: "offer", offer: { facts: [{ contractId: id, expectedHead: null, entries: [bind] }] } };
+    return { kind: "offer", offer: { facts: [{ contractId: id, entries: [bind] }] } };
 }

package/build/src/core/verbs/deliver.js

@@ -48,5 +48,5 @@ export function decideDeliver({ input, attempt, observation, }) {
         data: input.preparation.data,
     };
     entries.push(deliver);
-    return { kind: "offer", offer: { facts: [{ contractId: input.contractId, expectedHead: state.head, entries }] } };
+    return { kind: "offer", offer: { facts: [{ contractId: input.contractId, entries }] } };
 }

package/build/src/core/verbs/placement.js

@@ -104,7 +104,7 @@ export function decidePlacement({ input, attempt, observation, }) {
     return {
         kind: "offer",
         offer: {
-            facts: [{ contractId: id, expectedHead: current.head, entries: [claimed] }],
+            facts: [{ contractId: id, entries: [claimed] }],
             ...(current.coordinates.target === undefined
                 ? {}
                 : {

package/build/src/core/verbs/reintegrate.js

@@ -19,6 +19,6 @@ export function decideReintegrate({ input, attempt, observation, }) {
     };
     return {
         kind: "offer",
-        offer: { facts: [{ contractId: input.contractId, expectedHead: state.head, entries: [reintegrated] }] },
+        offer: { facts: [{ contractId: input.contractId, entries: [reintegrated] }] },
     };
 }

package/build/src/git/admission.js

@@ -1,4 +1,6 @@
 import { decodeJournal, encodeEntry } from "../core/facts/codec.js";
+import { AuthorityCorruptionError } from "../core/facts/errors.js";
+import { foldJournal } from "../core/facts/fold.js";
 import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, updateGitTreeFromFrozenDirectories, updateRefsAtomically, writeBlob, writeStateCommit, } from "./repository.js";
 import { contractJournalPath, contractJournalPaths, gitObjectIdForSnapshot, mintContractHead, mintSnapshotId, } from "./identity.js";
 import { validPath } from "./tree.js";
@@ -57,6 +59,19 @@ async function buildOffer(repository, admission, appends, companions) {
     const snapshot = admission.snapshot;
     const changes = new Map();
     const heads = {};
+    const candidates = appends.map((append) => {
+        const current = readCanonicalJournal(admission, append.contractId);
+        let journal = current.bytes;
+        for (const entry of append.entries)
+            journal = Buffer.concat([journal, Buffer.from(encodeEntry(entry))]);
+        const entries = decodeJournal(journal.toString("utf8"));
+        const foreign = entries.find((entry) => entry.contract !== append.contractId);
+        if (foreign !== undefined) {
+            throw new AuthorityCorruptionError(`candidate journal entry belongs to ${foreign.contract}, not ${append.contractId}`);
+        }
+        const state = foldJournal(append.contractId, entries);
+        return { append, current, journal, state };
+    });
     if (snapshot.commit === null) {
         changes.set(GIT_FORMAT_PATH, { oid: await writeBlob(repository, GIT_FORMAT_BYTES), mode: "100644", type: "blob" });
     }
@@ -67,14 +82,10 @@ async function buildOffer(repository, admission, appends, companions) {
             type: "blob",
         });
     }
-    for (const append of appends) {
-        const current = readCanonicalJournal(admission, append.contractId);
-        let journal = current.bytes;
-        for (const entry of append.entries)
-            journal = Buffer.concat([journal, Buffer.from(encodeEntry(entry))]);
+    for (const candidate of candidates) {
+        const { append, current, journal, state } = candidate;
         const blob = await writeBlob(repository, journal);
-        const entries = decodeJournal(journal.toString("utf8"));
-        const terminal = entries.some((entry) => entry.kind === "claimed" || entry.kind === "abandoned");
+        const terminal = state.terminal !== null;
         const destination = contractJournalPath(append.contractId, terminal ? "terminal" : "active");
         if (current.path !== null && current.path !== destination)
             changes.set(current.path, null);

package/build/src/identity/coordinates.js

@@ -2,7 +2,7 @@ function prefix(family) {
     return `${family}/`;
 }
 function validSegment(segment) {
-    return segment.length > 0 && !/[\/\s\p{Cc}]/u.test(segment);
+    return segment.length > 0 && segment !== "." && segment !== ".." && !/[\/\s\p{Cc}]/u.test(segment);
 }
 export function identityCoordinate(input) {
     if (input.segments.length === 0 || !input.segments.every(validSegment)) {

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;