@astrosheep/keiyaku 4.4.0 → 4.5.1

package/build/src/cli/commands/status-set.js

@@ -0,0 +1,61 @@
+import { CliUsageError } from "../parse.js";
+import { canonicalContractSelector } from "../selectors.js";
+async function statusSetAkuma(selector, id, alias, world, repo) {
+    if (world === null)
+        throw new CliUsageError("no Keiyaku world contains the Akuma selector");
+    const result = await (await import("./akuma-invoke.js")).invokeAkumaStatus(world, id, alias, repo);
+    if (result.action !== "status")
+        throw new Error("status invocation returned a non-status Akuma result");
+    return {
+        selector,
+        kind: "akuma",
+        status: result.status,
+        ...(result.alias === undefined ? {} : { alias: result.alias }),
+    };
+}
+async function statusSetEntry(selector, world, repo, observed) {
+    let resolved = selector;
+    let alias;
+    if (selector.startsWith("@")) {
+        if (observed === undefined)
+            throw new CliUsageError("cannot resolve a named status selector");
+        const { resolveNamedAddress } = await import("../../library/address.js");
+        const address = resolveNamedAddress({ selector, report: observed.report, aliases: observed.aliases });
+        if (address.kind === "akuma")
+            return await statusSetAkuma(selector, address.id, selector, world, repo);
+        resolved = address.id;
+        alias = selector;
+    }
+    if (resolved.startsWith("aku/"))
+        return await statusSetAkuma(selector, resolved, alias, world, repo);
+    if (repo === undefined)
+        throw new CliUsageError("cannot select a contract while the Contract world is absent");
+    if (observed === undefined)
+        throw new CliUsageError("cannot observe Contract status without a Kanshi report");
+    return {
+        selector,
+        kind: "contract",
+        report: (await import("../../kanshi/index.js")).selectKanshi({
+            report: observed.report,
+            contract: canonicalContractSelector(resolved),
+        }),
+    };
+}
+export async function invokeStatusSet(selectors, world, repo) {
+    if (selectors.length < 2)
+        throw new CliUsageError("status requires at least two selectors");
+    if (selectors.some((selector) => !selector.startsWith("aku/") && !selector.startsWith("@")) && repo === undefined) {
+        throw new CliUsageError("cannot select a contract while the Contract world is absent");
+    }
+    const needsKanshi = selectors.some((selector) => !selector.startsWith("aku/"));
+    const observed = needsKanshi
+        ? await (await import("../../kanshi/index.js")).observeKanshi({
+            world,
+            ...(repo === undefined ? {} : { repo }),
+        })
+        : undefined;
+    const entries = [];
+    for (const selector of selectors)
+        entries.push(await statusSetEntry(selector, world, repo, observed));
+    return { kind: "status-set", entries };
+}

package/build/src/cli/invoke.js

@@ -1,4 +1,3 @@
-import { captureRoute } from "@astrosheep/square";
 import { resolveActor } from "./actor.js";
 import { isParsedAkumaCommand } from "./commands/akuma.js";
 import { invokeContractMutation } from "./commands/contract-invoke.js";
@@ -106,14 +105,13 @@ async function invokeAkumaFromEdge(parsed, input) {
         const contract = parsed.command === "call" && parsed.contract !== undefined
             ? (await import("./selectors.js")).contractFromInput(repo, parsed.contract).contract
             : undefined;
-        const resultRoute = parsed.command === "call" ? captureRoute({ cwd: input.invocationCwd, env: edge.environment }) : null;
         return await invokeAkuma(parsed, {
             path,
             ...(statedCwd === undefined ? {} : { statedCwd }),
             ...(home === undefined ? {} : { home }),
             ...(configuration === undefined ? {} : { settings: configuration }),
             ...(contract === undefined ? (repo === undefined ? {} : { repo }) : { contract }),
-            ...(resultRoute === null ? {} : { resultRoute }),
+            environment: edge.environment,
             readStdin: edge.readStdin,
         });
     }
@@ -160,6 +158,11 @@ async function invokeCatalog(parsed, world, repo, home) {
     }
 }
 async function invokeStatus(parsed, world, repo) {
+    const selectors = "selectors" in parsed ? parsed.selectors : undefined;
+    if (selectors !== undefined) {
+        const { invokeStatusSet } = await import("./commands/status-set.js");
+        return await invokeStatusSet(selectors, world, repo);
+    }
     if (parsed.akuma === true) {
         if (world === null)
             throw new CliUsageError("no Keiyaku world contains the invocation cwd");

package/build/src/cli/parse.js

@@ -164,7 +164,7 @@ function scanArgv(argv) {
     if (spec.positional === "none" && state.positionals.length > 0) {
         refuse(command, `${command} accepts no contract`);
     }
-    if (spec.positional === "optional" && state.positionals.length > 1) {
+    if (spec.positional === "optional" && state.positionals.length > 1 && command !== "status") {
         refuse(command, `${command} accepts at most one contract`);
     }
     if (spec.stdin === "required" && !state.stdin) {

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

@@ -316,6 +316,11 @@ export function akumaRawAnswer(result) {
     }
     if (result.action === "wait" && result.result.observations.length === 1)
         return statusAnswer(result.result.observations[0]);
+    if (result.action === "history" && result.mode === "exact" && result.historyResult.kind === "exact") {
+        return result.historyResult.outcome.outcome.kind === "answered"
+            ? result.historyResult.outcome.outcome.answer
+            : result.historyResult.outcome.outcome.diagnostic;
+    }
     return undefined;
 }
 export function waitText(result, context) {
@@ -336,6 +341,12 @@ export function waitText(result, context) {
     return [...blocks, `${done} of ${total} done`].join("\n\n");
 }
 export function historyText(command, result, context) {
+    if (result.mode === "exact") {
+        const exact = result.historyResult;
+        if (exact.kind !== "exact")
+            return `${exact.kind === "unknown-history" ? exact.historyId : "unknown"} has no matching retained outcome`;
+        return exact.outcome.outcome.kind === "answered" ? exact.outcome.outcome.answer : exact.outcome.outcome.diagnostic;
+    }
     if (command.last)
         return result.mode === "last" ? result.answer : "no answer retained";
     if (result.mode !== "page")

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

@@ -123,6 +123,11 @@ function tellExitCode(result) {
 function forkExitCode(result) {
     return result.receipt.kind === "forked" ? 0 : result.receipt.kind === "upstream-forked" ? 2 : 1;
 }
+function historyExitCode(result) {
+    if (result.mode !== "exact")
+        return 0;
+    return result.historyResult.kind === "exact" ? 0 : 1;
+}
 export function akumaExitCode(result) {
     switch (result.action) {
         case "call":
@@ -133,6 +138,8 @@ export function akumaExitCode(result) {
             return tellExitCode(result);
         case "fork":
             return forkExitCode(result);
+        case "history":
+            return historyExitCode(result);
         default:
             return 0;
     }

package/build/src/cli/render/status-set.d.ts

@@ -0,0 +1,5 @@
+import type { InvocationResult } from "../result.js";
+import type { TextRenderContext } from "./terminal.js";
+export declare function renderStatusSetText(result: Extract<InvocationResult, {
+    kind: "status-set";
+}>, context?: TextRenderContext): string;

package/build/src/cli/render/status-set.js

@@ -0,0 +1,14 @@
+import { renderAkumaText } from "./akuma.js";
+import { renderKanshiText } from "./kanshi.js";
+export function renderStatusSetText(result, context) {
+    return result.entries
+        .map((entry) => entry.kind === "contract"
+        ? renderKanshiText(entry.report, context, "contract")
+        : renderAkumaText({ command: "status", contract: entry.selector, akuma: true, output: "text" }, {
+            kind: "akuma",
+            action: "status",
+            status: entry.status,
+            ...(entry.alias === undefined ? {} : { alias: entry.alias }),
+        }, context))
+        .join("\n\n");
+}

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

@@ -5,11 +5,14 @@ import { renderConflictMaterialized, renderRefusal } from "./refusal.js";
 import { renderCatalogText } from "./catalog.js";
 import { renderNukeText } from "./nuke.js";
 import { renderRegionText } from "./region.js";
+import { renderStatusSetText } from "./status-set.js";
 export function renderText(result, context) {
     if (result.kind === "guidance")
         return result.guidance;
     if (result.kind === "status")
         return renderKanshiText(result.report, context, result.selection);
+    if (result.kind === "status-set")
+        return renderStatusSetText(result, context);
     if (result.kind === "catalog")
         return renderCatalogText(result.catalog);
     if (result.kind === "contract-history")

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

@@ -1,5 +1,6 @@
 import type { AuditReport, ContractHistory, ContractId, ContinuationReport, Delivery, Fact, IntegrationConflictMaterialized, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
 import type { KanshiReport } from "../kanshi/index.js";
+import type { AkumaObservation } from "../index.js";
 import type { RegionRead, Section } from "../kanshi/index.js";
 import type { Catalog } from "../index.js";
 import type { AmendRegionObservation, RegionObservation } from "../library/region.js";
@@ -211,6 +212,19 @@ export type StatusResult = Readonly<{
     report: KanshiReport;
     selection: "world" | "contract";
 }>;
+export type StatusSetResult = Readonly<{
+    kind: "status-set";
+    entries: readonly (Readonly<{
+        selector: string;
+        kind: "contract";
+        report: KanshiReport;
+    }> | Readonly<{
+        selector: string;
+        kind: "akuma";
+        status: AkumaObservation;
+        alias?: string;
+    }>)[];
+}>;
 export type RegionResult = Readonly<{
     kind: "region";
     region: Section<RegionRead>;
@@ -227,5 +241,5 @@ export type NukeInvocationResult = Readonly<{
     kind: "nuke";
     result: NukeResult;
 }>;
-export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult | ContractHistoryResult | NukeInvocationResult | IntegrationConflictMaterialized;
+export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | StatusSetResult | RegionResult | CatalogResult | ContractHistoryResult | NukeInvocationResult | IntegrationConflictMaterialized;
 export {};

package/build/src/cli/runtime.js

@@ -79,6 +79,8 @@ function invocationJson(result) {
             return result.history;
         case "status":
             return result.report;
+        case "status-set":
+            return result.entries;
         default:
             return result;
     }

package/build/src/cli/square-edge.d.ts

@@ -0,0 +1,6 @@
+import type { AllocatedAkuma } from "../akuma/identity.js";
+import { type WorldRoot } from "../world.js";
+export declare function recognizeAndListen(worldRoot: WorldRoot, environment: NodeJS.ProcessEnv, allocated: AllocatedAkuma): Promise<{
+    committed: boolean;
+    rollback(): Promise<void>;
+} | void>;

package/build/src/cli/square-edge.js

@@ -0,0 +1,74 @@
+import { bindCurrentParticipant, Square, squareAssignedParticipantName, unbindCurrentParticipant, } from "@astrosheep/square";
+import { keiyakuSquarePath } from "../world.js";
+async function openKeiyakuSquare(path) {
+    try {
+        return await Square.at({ path });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT" && error.code !== "unavailable")
+            throw error;
+        try {
+            return await Square.build({ path, markdown: "" });
+        }
+        catch (buildError) {
+            try {
+                return await Square.at({ path });
+            }
+            catch {
+                throw buildError;
+            }
+        }
+    }
+}
+export async function recognizeAndListen(worldRoot, environment, allocated) {
+    const name = squareAssignedParticipantName(environment);
+    if (name === undefined)
+        return;
+    const path = keiyakuSquarePath(worldRoot);
+    const square = await openKeiyakuSquare(path);
+    let joined = false;
+    let bound = false;
+    let listening = false;
+    const rollback = async () => {
+        if (listening || joined) {
+            const rollbackSquare = await Square.at({ path });
+            try {
+                const rollbackParticipant = await rollbackSquare.join(name);
+                if (listening)
+                    await rollbackParticipant.ignore(allocated.id);
+                if (joined)
+                    await rollbackParticipant.done();
+            }
+            finally {
+                await rollbackSquare.close();
+            }
+        }
+        if (bound)
+            unbindCurrentParticipant(path, name, environment);
+    };
+    try {
+        const joinedResult = await square.joinWithActivity(name);
+        joined = joinedResult.activity !== null;
+        const participant = joinedResult.participant;
+        bound = bindCurrentParticipant(path, name, environment).created;
+        const listener = participant;
+        const change = await listener.listen(allocated.id);
+        listening = change.activity !== null;
+        return {
+            committed: true,
+            rollback,
+        };
+    }
+    catch (error) {
+        try {
+            await rollback();
+        }
+        catch {
+            /* preserve the original Square edge failure */
+        }
+        throw error;
+    }
+    finally {
+        await square.close();
+    }
+}

package/build/src/contract-worktree.js

@@ -50,11 +50,16 @@ const FULFILLMENT = [
     "",
     "### Deliverer",
     "",
+    "Re-read this file on each wake-up; it may have been updated between sessions.",
     "Implement and verify the Objective under the Design, Region, and Criteria in this Contract.",
+    "Region is a rough intent, not a hard boundary — natural ripple outside it is fine and not a blocker.",
     "When an Arc is active, stay within that current chapter.",
-    "For work requiring three or more steps, prefer `keiyaku task -C <worktree>` " + "to organize and manage Tasks.",
+    "If you discover a contradiction with this Contract or an unclosed point in its terms,",
+    "stop and report it before continuing.",
+    "",
+    "For work requiring three or more steps, prefer `keiyaku task -C <worktree>` to organize and manage Tasks.",
     "Promptly update progress for Tasks already present in the current worktree.",
-    "Leave lifecycle decisions to the caller; report the candidate, verification performed, and any unmet term.",
+    "",
     "Deliver from this worktree. A clean worktree delivers HEAD; uncommitted work",
     "needs `deliver --include-dirty`, which captures the final non-ignored tree and",
     "stages or commits nothing. If deliver reports a conflict, run",
@@ -64,9 +69,17 @@ const FULFILLMENT = [
     "",
     "### Reviewer",
     "",
-    "Review this Contract worktree against the complete Contract.",
-    "Review the complete current worktree snapshot, not a named candidate commit.",
-    "Do not modify it; report covered Criteria, findings, and missing evidence.",
+    "Re-read this file on each wake-up; it may have been updated between sessions.",
+    "Review the complete current worktree snapshot against this Contract. Do not modify it.",
+    "Understand the original intent behind the Objective, not just its literal text.",
+    "Region is a rough intent, not a hard boundary — natural ripple outside it is not a blocker.",
+    "Compare each Criterion individually against the delivered work.",
+    "Consolidate findings by root cause — group symptoms that share an underlying issue",
+    "rather than listing each occurrence separately.",
+    "Dig to the architectural or structural root; flag it directly rather than routing around it.",
+    "If you discover a contradiction within the Contract or an unclosed point in its terms,",
+    "report it as a finding.",
+    "Report covered Criteria, findings, and missing evidence.",
 ].join("\n");
 export function renderContractGuidance(state) {
     return [

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

@@ -1,5 +1,6 @@
 import { type AliasBinding } from "../alias/index.js";
-import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint, type ResultRoute } from "../akuma/akuma.js";
+import { type AkumaStatus, type ForkReceipt, type ReadonlyRestraint } from "../akuma/akuma.js";
+import { type AkumaBornCall } from "../akuma/akuma-product.js";
 import type { AkuId } from "../akuma/identity.js";
 import { type Dispatch, type DispatchFailure } from "../dispatch/index.js";
 import { type AkumaAlias } from "../identity/selector.js";
@@ -48,11 +49,9 @@ export type CallInput = Readonly<{
     contract?: Keiyaku;
     alias?: AkumaAlias;
     allowed?: readonly AllowedAction[];
-    resultRoute?: ResultRoute;
 }>;
 export type CallObservation = Readonly<{
     kind: "detached";
-    resultRoute: "captured" | "not-captured";
 }> | Readonly<{
     kind: "observed";
     status: AkumaStatus;
@@ -72,6 +71,16 @@ export type CallResult = Readonly<{
     alias: AliasStage;
     observation: CallObservation;
 }>;
+type CallExecution = CallResult["execution"];
+export type BornCall = Readonly<{
+    path: WorldRoot;
+    born: AkumaBornCall;
+    execution: CallExecution;
+    mode: "wait" | "detach";
+    timeoutMs: number;
+    dispatch: DispatchStage;
+    alias: AliasStage;
+}>;
 export type ForkInput = Readonly<{
     path: WorldRoot;
     akuma: string;
@@ -89,5 +98,7 @@ export type ForkResult = Readonly<{
 }>> & Readonly<{
     parent: AkuId;
 }>);
+export declare function beginCall(input: CallInput): Promise<BornCall>;
+export declare function finishCall(born: BornCall): Promise<CallResult>;
 export declare function callKeiyaku(input: CallInput): Promise<CallResult>;
 export declare function forkKeiyaku(input: ForkInput): Promise<ForkResult>;

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

@@ -1,6 +1,7 @@
 import { realpath, stat } from "node:fs/promises";
 import { moveAlias } from "../alias/index.js";
-import { Akuma, akumaCallExecution, callAkumaWithContext, } from "../akuma/akuma.js";
+import { Akuma } from "../akuma/akuma.js";
+import { beginAkumaCall, finishAkumaCall } from "../akuma/akuma-product.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
@@ -77,9 +78,9 @@ function callTimeout(value, mode) {
     }
     return value;
 }
-async function observeCall(handle, mode, timeoutMs, resultRoute) {
+async function observeCall(handle, mode, timeoutMs) {
     if (mode === "detach") {
-        return { kind: "detached", resultRoute: resultRoute === undefined ? "not-captured" : "captured" };
+        return { kind: "detached" };
     }
     try {
         return { kind: "observed", status: await handle.wait(undefined, { timeoutMs }) };
@@ -165,7 +166,7 @@ async function resolveCallExecution(input) {
     }
     return undefined;
 }
-export async function callKeiyaku(input) {
+export async function beginCall(input) {
     const values = requireInput(input, "Keiyaku.call input");
     onlyKeys(values, [
         "path",
@@ -180,7 +181,6 @@ export async function callKeiyaku(input) {
         "contract",
         "alias",
         "allowed",
-        "resultRoute",
     ], "Keiyaku.call input");
     const path = nonblank(values.path, "path");
     const archetype = nonblank(values.archetype, "archetype");
@@ -193,7 +193,6 @@ export async function callKeiyaku(input) {
     const settings = settingsOption(values.settings);
     const alias = values.alias === undefined ? undefined : parseAkumaAlias(nonblank(values.alias, "alias"));
     const seat = values.contract === undefined ? undefined : seatForKeiyaku(values.contract);
-    const resultRoute = values.resultRoute;
     const execution = await resolveCallExecution({
         path,
         ...(cwd === undefined ? {} : { cwd }),
@@ -206,23 +205,20 @@ export async function callKeiyaku(input) {
         ...(readonlyRequested === undefined ? {} : { readonly: readonlyRequested }),
         ...(values.allowed === undefined ? {} : { allowed: values.allowed }),
         ...(execution === undefined ? {} : { cwd: execution.cwd }),
-        ...(resultRoute === undefined ? {} : { resultRoute }),
     };
-    const handle = execution === undefined ? await world.call(call) : await callAkumaWithContext(world, call, { cwdCanonical: true });
-    const completedExecution = execution ?? akumaCallExecution(handle);
-    if (completedExecution === undefined)
-        throw new Error("Akuma call is missing its birth execution");
-    const readonly = (await handle.status()).readonly;
+    const born = await beginAkumaCall(world, call, execution === undefined ? {} : { cwdCanonical: true });
+    const akuma = born.kind === "requested" ? born.id : born.allocated.id;
+    const completedExecution = execution ?? born.execution;
     const dispatch = seat === undefined
         ? { kind: "none" }
-        : await dispatchStage({ repository: seat.scope, akuId: handle.id, contractId: seat.id });
+        : await dispatchStage({ repository: seat.scope, akuId: akuma, contractId: seat.id });
     let aliasStage = { kind: "none" };
     if (alias !== undefined) {
         if (dispatch.kind === "failed")
             aliasStage = { kind: "skipped", reason: "dispatch-failed" };
         else {
             try {
-                const moved = await moveAlias({ world: path, alias, akuId: handle.id });
+                const moved = await moveAlias({ world: path, alias, akuId: akuma });
                 aliasStage = { kind: "aliased", alias: moved.alias, previous: moved.previous };
             }
             catch (error) {
@@ -230,17 +226,34 @@ export async function callKeiyaku(input) {
             }
         }
     }
-    const observation = await observeCall(handle, mode, timeoutMs, resultRoute);
     return {
-        kind: "called",
-        akuma: handle.id,
-        ...(readonly === undefined ? {} : { readonly }),
+        path,
+        born,
         execution: completedExecution,
+        mode,
+        timeoutMs,
         dispatch,
         alias: aliasStage,
+    };
+}
+export async function finishCall(born) {
+    const world = akumaWorld(born.path);
+    const handle = await finishAkumaCall(world, born.born);
+    const readonly = (await handle.status()).readonly;
+    const observation = await observeCall(handle, born.mode, born.timeoutMs);
+    return {
+        kind: "called",
+        akuma: handle.id,
+        ...(readonly === undefined ? {} : { readonly }),
+        execution: born.execution,
+        dispatch: born.dispatch,
+        alias: born.alias,
         observation,
     };
 }
+export async function callKeiyaku(input) {
+    return await finishCall(await beginCall(input));
+}
 export async function forkKeiyaku(input) {
     const values = requireInput(input, "Keiyaku.fork input");
     onlyKeys(values, ["path", "akuma", "at", "repo"], "Keiyaku.fork input");

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

@@ -1,4 +1,4 @@
-import { type ActivityHistory, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
+import { type ActivityHistory, type OutcomeRow, type AkumaStatus, type InterruptReceipt, type KillEvidence, type TellResult } from "../akuma/index.js";
 import type { ContractId } from "../core/facts/types.js";
 import type { TaskRow } from "../task/index.js";
 import type { WorldRoot } from "../world.js";
@@ -69,6 +69,7 @@ export type AkumaInterruptResult = Readonly<{
     observation: AkumaObservationStage;
 }>;
 export type AkumaHistoryInput = AkumaAddressInput & Readonly<{
+    id?: string;
     before?: number;
     since?: number;
     limit?: number;
@@ -79,6 +80,16 @@ export type AkumaHistoryResult = Readonly<{
     id: AkumaStatus["id"];
     history: ActivityHistory;
     contract: DispatchAssociation;
+}> | Readonly<{
+    kind: "exact";
+    id: AkumaStatus["id"];
+    outcome: OutcomeRow;
+    contract: DispatchAssociation;
+}> | Readonly<{
+    kind: "unknown-history";
+    id: AkumaStatus["id"];
+    historyId: string;
+    contract: DispatchAssociation;
 }> | Readonly<{
     kind: "last";
     id: AkumaStatus["id"];

package/build/src/library/fleet.js

@@ -6,6 +6,7 @@ import { observeTaskBoard } from "../task/operations.js";
 import { addressAkuma, addressAkumaSet } from "./address.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
+import { parsePublicHistoryId } from "../akuma/identity.js";
 function source(path) {
     return Akuma.of(path);
 }
@@ -315,15 +316,24 @@ export async function interruptAkuma(input) {
     const observation = await observeAkumaStage(addressed.path, addressed.id, values.repo);
     return { id: addressed.id, receipt, observation };
 }
-export async function historyAkuma(input) {
-    const values = requireInput(input, "Keiyaku.history input");
+function validateHistoryInput(values) {
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "before", "since", "limit", "last", "repo"].includes(key)) {
+        if (!["path", "akuma", "id", "before", "since", "limit", "last", "repo"].includes(key))
             throw new TypeError(`Keiyaku.history input has unknown field: ${key}`);
-        }
     }
     if (values.last !== undefined && typeof values.last !== "boolean")
         throw new TypeError("last must be a boolean");
+    if (values.id !== undefined && (typeof values.id !== "string" || values.id.trim() === ""))
+        throw new TypeError("id must be a nonblank string");
+    if (values.id !== undefined && parsePublicHistoryId(values.id) === null)
+        throw new TypeError("id must match turn/<positive safe integer>");
+    if (values.id !== undefined &&
+        (values.last === true || values.before !== undefined || values.since !== undefined || values.limit !== undefined))
+        throw new TypeError("id cannot be combined with last, before, since, or limit");
+}
+export async function historyAkuma(input) {
+    const values = requireInput(input, "Keiyaku.history input");
+    validateHistoryInput(values);
     const addressed = await addressAkuma(directAddress(values));
     const handle = source(addressed.path).of({ id: addressed.id });
     const contract = await dispatchAssociation(values.repo, addressed.id);
@@ -334,9 +344,15 @@ export async function historyAkuma(input) {
             : { kind: "no-answer", id: addressed.id, contract };
     }
     const history = await handle.history({
+        ...(values.id === undefined ? {} : { id: values.id }),
         ...(values.before === undefined ? {} : { before: values.before }),
         ...(values.since === undefined ? {} : { since: values.since }),
         ...(values.limit === undefined ? {} : { limit: values.limit }),
     });
-    return { kind: "history", id: addressed.id, history, contract };
+    if (values.id !== undefined) {
+        if ("kind" in history && history.kind === "exact")
+            return { kind: "exact", id: addressed.id, outcome: history.outcome, contract };
+        return { kind: "unknown-history", id: addressed.id, historyId: values.id, contract };
+    }
+    return { kind: "history", id: addressed.id, history: history, contract };
 }

package/build/src/library/repo.js

@@ -1,3 +1,5 @@
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
 import { currentBranchOperation, scopeOperation } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
 import { optionalNonblank, requireInput } from "./input.js";
@@ -8,7 +10,7 @@ export { NoGitWorldError };
 const REPO_SCOPES = new WeakMap();
 async function resolvePinnedScope(path, gitPath) {
     return await scopeOperation({
-        coordinate: path === undefined ? process.cwd() : path,
+        coordinate: await realpath(resolve(path === undefined ? process.cwd() : path)),
         ...(gitPath === undefined ? {} : { gitPath }),
     });
 }

package/build/src/runtime/proc/process-exit.js

@@ -5,12 +5,17 @@ export function detachedExitStatus(code, signal) {
 export async function retainDetachedExitEvidence(log, path, from, code, signal) {
     const status = detachedExitStatus(code, signal);
     const marker = Buffer.from(`[child ${status}]\n`);
+    const before = await log.stat();
+    if (before.size < from)
+        throw new Error("run log shrank before exit evidence was retained");
     let written = 0;
+    let position = before.size;
     while (written < marker.byteLength) {
-        const write = await log.write(marker, written, marker.byteLength - written);
+        const write = await log.write(marker, written, marker.byteLength - written, position);
         if (write.bytesWritten === 0)
             throw new Error("run log exit marker write made no progress");
         written += write.bytesWritten;
+        position += write.bytesWritten;
     }
     const evidence = await log.stat();
     if (evidence.size < from)