@astrosheep/keiyaku 4.6.3 → 4.6.6

package/build/src/cli/scan.js

@@ -0,0 +1,82 @@
+import { isBlankInput } from "./usage.js";
+/** The one `-` reader for this invocation; a second `-` is the duplicate refusal. */
+function selectStdin(spec, stdin, fail) {
+    if (spec.stdin === undefined)
+        fail(spec.stdinRefusal);
+    if (stdin !== undefined)
+        fail("stdin marker '-' may appear only once");
+    return spec.stdin;
+}
+/** A value token this surface refuses: `-`, or one of its own refused tokens. */
+function refusedValue(kind, value, spec) {
+    if (kind === "raw-value")
+        return false;
+    return value === "-" || spec.refused?.[value] !== undefined;
+}
+/** The admitted value after `--name`: absent, dash-like, and blank values carry their own refusals. */
+function optionValue(token, value, kind, spec, fail) {
+    if (value === undefined || value.startsWith("--") || refusedValue(kind, value, spec))
+        fail(`${token} requires a value`);
+    if (kind !== "raw-value" && isBlankInput(value))
+        fail(`${token} requires a nonblank value`);
+    return value;
+}
+/** One `--name` option: a boolean, a repeated value, or a single value. Returns its consumed tokens. */
+function assignOption(option, spec, flags, fail) {
+    const { token, name, kind, value } = option;
+    if (flags[name] !== undefined && kind !== "repeat")
+        fail(`duplicate option: ${token}`);
+    if (kind === "boolean") {
+        flags[name] = true;
+        return 0;
+    }
+    const admitted = optionValue(token, value, kind, spec, fail);
+    flags[name] = kind === "repeat" ? [...(Array.isArray(flags[name]) ? flags[name] : []), admitted] : admitted;
+    return 1;
+}
+/**
+ * One argument scan for every CLI grammar: `--name value` options, `--` positional-only mode,
+ * `-` stdin, and the surface's own refusal text. A refused token is refused in option position with
+ * its own text, and in value position as the missing-value refusal.
+ */
+export function scanArgs(argv, spec, fail) {
+    const flags = {};
+    const positionals = [];
+    let stdin;
+    let positionalOnly = false;
+    for (let index = 1; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!positionalOnly && token === "--") {
+            positionalOnly = true;
+            continue;
+        }
+        if (!positionalOnly && spec.refused?.[token] !== undefined)
+            fail(spec.refused[token]);
+        if (!positionalOnly && token === "-") {
+            stdin = selectStdin(spec, stdin, fail);
+            continue;
+        }
+        if (positionalOnly || !token.startsWith("--")) {
+            if (isBlankInput(token))
+                fail(`${spec.subject} requires a nonblank value`);
+            positionals.push(token);
+            continue;
+        }
+        const name = token.slice(2);
+        const kind = spec.flags[name];
+        if (kind === undefined)
+            fail(`option ${token} is not valid for ${spec.subject}`);
+        const reader = spec.stdinValue;
+        const value = kind === "boolean" ? undefined : argv[index + 1];
+        if (reader !== undefined && reader === name && value === "-") {
+            if (stdin !== undefined)
+                fail("stdin marker '-' may appear only once");
+            flags[name] = "";
+            stdin = reader;
+            index += 1;
+            continue;
+        }
+        index += assignOption({ token, name, kind, value }, spec, flags, fail);
+    }
+    return { flags, positionals, ...(stdin === undefined ? {} : { stdin }) };
+}

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

@@ -9,3 +9,8 @@ export declare function displayContext(): TextRenderContext;
 export declare function resultContext(): TextRenderContext;
 /** One JSON product answer, verbatim from the native value. */
 export declare function writeJson(value: unknown): void;
+/**
+ * One product result: JSON writes the untouched native value, text writes the rendered projection,
+ * and the native exit classifier's verdict follows.
+ */
+export declare function emit<Result>(output: "text" | "json", result: Result, text: () => string, code: number): number;

package/build/src/cli/streams.js

@@ -30,3 +30,14 @@ export function resultContext() {
 export function writeJson(value) {
     writeStdout(JSON.stringify(value));
 }
+/**
+ * One product result: JSON writes the untouched native value, text writes the rendered projection,
+ * and the native exit classifier's verdict follows.
+ */
+export function emit(output, result, text, code) {
+    if (output === "json")
+        writeJson(result);
+    else
+        writeStdout(text());
+    return code;
+}

package/build/src/contract-worktree.js

@@ -3,7 +3,7 @@ import { chmod, lstat, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { repairDerivedFile } from "./coordination/durable-file.js";
 import { CONTRACT_DELIVERER_SKILL, CONTRACT_REVIEWER_SKILL, CONTRACT_ONBOARDING_SKILL, renderContractGuidance, } from "./contract-guidance.js";
-import { GitPlumbingError, runGit } from "./git/process.js";
+import { executeGit } from "./git/process.js";
 import { worktreePath } from "./git/workspace.js";
 import { appointmentFor, placeRegisterPath } from "./workspace-place.js";
 import { repairNamespaceContext } from "./task/context.js";
@@ -16,6 +16,12 @@ const SEAT_SKILLS = [
     ["keiyaku-deliver", CONTRACT_DELIVERER_SKILL],
     ["keiyaku-review", CONTRACT_REVIEWER_SKILL],
 ];
+const PRIMARY_GENERATED_PATHS = [".keiyaku/.gitignore"];
+const GENERATED_PATHS = [
+    ...PRIMARY_GENERATED_PATHS,
+    ".keiyaku/KEIYAKU.md",
+    ...SEAT_SKILLS.flatMap(([seat]) => [`.agents/skills/${seat}/.gitignore`, `.agents/skills/${seat}/SKILL.md`]),
+];
 export const contractFileEffectSchema = z
     .object({
     kind: z.literal("contract-file"),
@@ -31,23 +37,24 @@ export const contractFileLagSchema = z
     diagnostic: z.string().refine((value) => value.trim() !== ""),
 })
     .strict();
-async function isTracked(repository, relativePath) {
-    try {
-        await runGit(repository, ["ls-files", "--error-unmatch", "--", relativePath]);
-        return true;
-    }
-    catch (error) {
-        if (error instanceof GitPlumbingError && error.status === 1)
-            return false;
-        throw error;
-    }
+async function readTrackedPaths(repository, worktree, paths) {
+    const output = await executeGit({ ...repository, effectiveCwd: worktree }, [
+        "ls-files",
+        "-z",
+        "--",
+        ...paths.map((path) => `:(literal)${path}`),
+    ]);
+    return new Set(output
+        .toString("utf8")
+        .split("\0")
+        .filter((path) => path !== ""));
 }
 function generatedPath(worktree, name) {
     return join(worktree, ".keiyaku", name);
 }
-async function repair(repository, worktree, relativePath, bytes) {
+async function repair(worktree, relativePath, bytes, tracked) {
     const path = join(worktree, relativePath);
-    if (await isTracked(repository, relativePath))
+    if (tracked.has(relativePath))
         throw new Error(`generated path is tracked by Git: ${path}`);
     const action = await repairDerivedFile(path, bytes);
     if (relativePath === ".keiyaku/KEIYAKU.md") {
@@ -65,7 +72,7 @@ async function isKeiyakuSeatLeaf(worktree, seat) {
     const stat = await lstat(sentinel).catch((error) => error.code === "ENOENT" ? undefined : Promise.reject(error));
     return stat?.isFile() === true && !stat.isSymbolicLink() && (await readFile(sentinel, "utf8")) === SEAT_IGNORE_BYTES;
 }
-async function materializeSeatSkill(repository, worktree, seat, bytes) {
+async function materializeSeatSkill(worktree, seat, bytes, tracked) {
     const leaf = `.agents/skills/${seat}`;
     const skill = `${leaf}/SKILL.md`;
     const skillPath = join(worktree, skill);
@@ -73,8 +80,8 @@ async function materializeSeatSkill(repository, worktree, seat, bytes) {
     if (!(await isKeiyakuSeatLeaf(worktree, seat)) && skillExists)
         return [];
     return [
-        await repair(repository, worktree, `${leaf}/.gitignore`, SEAT_IGNORE_BYTES),
-        await repair(repository, worktree, skill, bytes),
+        await repair(worktree, `${leaf}/.gitignore`, SEAT_IGNORE_BYTES, tracked),
+        await repair(worktree, skill, bytes, tracked),
     ];
 }
 async function materialize(repository, worktree, guidance, namespace) {
@@ -90,11 +97,14 @@ async function materialize(repository, worktree, guidance, namespace) {
             },
         ],
     });
+    const primaryWorktree = repository.primaryWorktree;
+    let tracked;
     try {
-        effects.push(await repair({ ...repository, effectiveCwd: repository.primaryWorktree }, repository.primaryWorktree, ".keiyaku/.gitignore", PRIMARY_IGNORE_BYTES));
+        tracked = await readTrackedPaths(repository, primaryWorktree, worktree === primaryWorktree ? GENERATED_PATHS : PRIMARY_GENERATED_PATHS);
+        effects.push(await repair(primaryWorktree, ".keiyaku/.gitignore", PRIMARY_IGNORE_BYTES, tracked));
     }
     catch (error) {
-        return failed(repository.primaryWorktree, join(repository.primaryWorktree, ".keiyaku", ".gitignore"), error);
+        return failed(primaryWorktree, join(primaryWorktree, ".keiyaku", ".gitignore"), error);
     }
     const stat = await lstat(worktree).catch((error) => {
         if (error.code === "ENOENT")
@@ -114,19 +124,26 @@ async function materialize(repository, worktree, guidance, namespace) {
             ],
         };
     }
-    const scoped = { ...repository, effectiveCwd: worktree };
     try {
         await repairNamespaceContext(worktree, namespace);
     }
     catch (error) {
         return failed(worktree, join(worktree, ".keiyaku", "namespace", "current"), error);
     }
+    if (worktree !== primaryWorktree) {
+        try {
+            tracked = await readTrackedPaths(repository, worktree, GENERATED_PATHS);
+        }
+        catch (error) {
+            return failed(worktree, join(worktree, ".keiyaku", ".gitignore"), error);
+        }
+    }
     for (const [relativePath, bytes] of [
         [".keiyaku/.gitignore", IGNORE_BYTES],
         [".keiyaku/KEIYAKU.md", guidance],
     ]) {
         try {
-            effects.push(await repair(scoped, worktree, relativePath, bytes));
+            effects.push(await repair(worktree, relativePath, bytes, tracked));
         }
         catch (error) {
             return failed(worktree, join(worktree, relativePath), error);
@@ -134,7 +151,7 @@ async function materialize(repository, worktree, guidance, namespace) {
     }
     for (const [seat, bytes] of SEAT_SKILLS) {
         try {
-            effects.push(...(await materializeSeatSkill(scoped, worktree, seat, bytes)));
+            effects.push(...(await materializeSeatSkill(worktree, seat, bytes, tracked)));
         }
         catch (error) {
             return failed(worktree, join(worktree, ".agents", "skills", seat), error);

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

@@ -1,5 +1,4 @@
 import type { JournalEntry } from "./types.js";
-/** Validate one in-memory journal value with the persisted-fact authority. */
-export declare function decodeJournalEntry(value: unknown): JournalEntry;
+export declare function validateEntry(value: unknown): JournalEntry;
 export declare function encodeEntry(entry: JournalEntry): string;
 export declare function decodeJournal(journal: string): JournalEntry[];

package/build/src/core/facts/codec.js

@@ -159,7 +159,7 @@ function validateData(kind, value) {
             return termsValue(value, path);
         case "deliver": {
             const object = requireRecord(value, path);
-            requireKeys(object, ["tenderSnapshot", "integration", "method", "policy"], path);
+            requireKeys(object, ["tenderSnapshot", "integration", "method", "policy"], path, ["note"]);
             const integration = requireRecord(object.integration, `${path}.integration`);
             requireKeys(integration, ["predecessor", "snapshot", "changeId"], `${path}.integration`);
             const method = stringValue(object.method, `${path}.method`);
@@ -168,6 +168,7 @@ function validateData(kind, value) {
             const policy = requireRecord(object.policy, `${path}.policy`);
             requireKeys(policy, ["requireBranchesToBeUpToDate"], `${path}.policy`);
             return {
+                ...(object.note === undefined ? {} : { note: stringValue(object.note, `${path}.note`) }),
                 tenderSnapshot: brandedValue(object.tenderSnapshot, `${path}.tenderSnapshot`, snapshotId),
                 integration: {
                     predecessor: brandedValue(integration.predecessor, `${path}.integration.predecessor`, snapshotId),
@@ -206,7 +207,7 @@ function validateData(kind, value) {
         }
     }
 }
-function validateEntry(value) {
+export function validateEntry(value) {
     const object = requireRecord(value, "entry");
     requireKeys(object, ["v", "kind", "contract", "entry", "at", "data"], "entry", ["actor"]);
     const kind = object.kind;
@@ -231,10 +232,6 @@ function validateEntry(value) {
     }
     return entry;
 }
-/** Validate one in-memory journal value with the persisted-fact authority. */
-export function decodeJournalEntry(value) {
-    return validateEntry(value);
-}
 function canonicalValue(value) {
     if (value === null)
         return "null";
@@ -253,12 +250,9 @@ function canonicalValue(value) {
     }
     throw new AuthorityCorruptionError("canonical JSON accepts only JSON values");
 }
-function canonicalJson(value) {
-    return canonicalValue(value);
-}
 export function encodeEntry(entry) {
     const validated = validateEntry(entry);
-    return `${canonicalJson(validated)}\n`;
+    return `${canonicalValue(validated)}\n`;
 }
 function decodeEntry(line) {
     if (line.includes("\r") || line.includes("\n\n"))
@@ -274,7 +268,7 @@ function decodeEntry(line) {
         throw new AuthorityCorruptionError("journal entry is not valid JSON", { cause: error });
     }
     const entry = validateEntry(value);
-    if (canonicalJson(value) !== body)
+    if (canonicalValue(value) !== body)
         throw new AuthorityCorruptionError("journal entry is not canonical");
     return entry;
 }

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

@@ -73,6 +73,7 @@ export type BindData = Readonly<{
 }>;
 export type AmendData = ContractTerms;
 export type DeliverData = Readonly<{
+    note?: string;
     tenderSnapshot: SnapshotId;
     integration: Readonly<{
         predecessor: SnapshotId;
@@ -84,7 +85,7 @@ export type DeliverData = Readonly<{
         requireBranchesToBeUpToDate: boolean;
     }>;
 }>;
-export type CurrentIntegration = DeliverData["integration"];
+type CurrentIntegration = DeliverData["integration"];
 export type ReintegratedData = Readonly<{
     predecessor: SnapshotId;
     snapshot: SnapshotId;
@@ -118,13 +119,26 @@ type JournalEnvelope<Kind extends string, Data> = Readonly<{
 export type BindEntry = JournalEnvelope<"bind", BindData>;
 type AmendEntry = JournalEnvelope<"amend", AmendData>;
 type DeliverEntry = JournalEnvelope<"deliver", DeliverData>;
-export type ReintegratedEntry = JournalEnvelope<"reintegrated", ReintegratedData>;
+type ReintegratedEntry = JournalEnvelope<"reintegrated", ReintegratedData>;
 export type AttestationEntry = JournalEnvelope<"attestation", AttestationData>;
 type ClaimedEntry = JournalEnvelope<"claimed", ClaimedData>;
 export type ArcEntry = JournalEnvelope<"arc", ArcData>;
 type AbandonedEntry = JournalEnvelope<"abandoned", AbandonedData>;
 export type JournalEntry = BindEntry | AmendEntry | DeliverEntry | ReintegratedEntry | AttestationEntry | ClaimedEntry | ArcEntry | AbandonedEntry;
 export type FactKind = JournalEntry["kind"];
+/**
+ * The one journal-envelope constructor for every verb offering a single fact: entry identity, the
+ * invoking decision input's Contract, timestamp, and optional actor, and the verb's own payload.
+ */
+export declare function journalEntry<Kind extends FactKind, Input extends Readonly<{
+    contractId: ContractId;
+    at: string;
+    actor?: ActorId;
+}>>(kind: Kind, input: Input, entry: EntryUlid, data: Extract<JournalEntry, {
+    kind: Kind;
+}>["data"]): Extract<JournalEntry, {
+    kind: Kind;
+}>;
 type ContractTerminal = ClaimedEntry | AbandonedEntry;
 export type ContractState = Readonly<{
     id: ContractId;

package/build/src/core/facts/types.js

@@ -64,3 +64,18 @@ export function gate(value) {
     }
     return value;
 }
+/**
+ * The one journal-envelope constructor for every verb offering a single fact: entry identity, the
+ * invoking decision input's Contract, timestamp, and optional actor, and the verb's own payload.
+ */
+export function journalEntry(kind, input, entry, data) {
+    return {
+        v: 1,
+        kind,
+        contract: input.contractId,
+        entry,
+        at: input.at,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        data,
+    };
+}

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

@@ -1,17 +1,11 @@
 import { activeContract } from "../facts/observation.js";
+import { journalEntry } from "../facts/types.js";
 export function decideAbandon({ input, attempt, observation, }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
     if ("kind" in current)
         return { kind: "refused", refusal: current };
-    const abandoned = {
-        v: 1,
-        kind: "abandoned",
-        contract: id,
-        entry: attempt.entryUlids[0],
-        at: input.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        data: input.note === undefined ? {} : { note: input.note },
-    };
+    const data = input.note === undefined ? {} : { note: input.note };
+    const abandoned = journalEntry("abandoned", input, attempt.entryUlids[0], data);
     return { kind: "offer", offer: { facts: [{ contractId: id, entries: [abandoned] }] } };
 }

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

@@ -1,5 +1,6 @@
 import { prerequisitesReach, samePrerequisites } from "../facts/eligibility.js";
 import { activeContract, prerequisiteStatus } from "../facts/observation.js";
+import { journalEntry } from "../facts/types.js";
 export function decideAmend({ input, attempt, observation, }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
@@ -28,14 +29,6 @@ export function decideAmend({ input, attempt, observation, }) {
     if (prerequisitesReach(id, data.after, observation)) {
         return { kind: "refused", refusal: { kind: "cyclic-prerequisite", contractId: id } };
     }
-    const entry = {
-        v: 1,
-        kind: "amend",
-        contract: id,
-        entry: attempt.entryUlids[0],
-        at: input.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        data,
-    };
+    const entry = journalEntry("amend", input, attempt.entryUlids[0], data);
     return { kind: "offer", offer: { facts: [{ contractId: id, entries: [entry] }] } };
 }

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

@@ -1,22 +1,15 @@
 import { activeContract } from "../facts/observation.js";
+import { journalEntry } from "../facts/types.js";
 export function decideArc({ input, attempt, observation, }) {
     const id = input.contractId;
     const current = activeContract(observation, id);
     if ("kind" in current)
         return { kind: "refused", refusal: current };
-    const arc = {
-        v: 1,
-        kind: "arc",
-        contract: id,
-        entry: attempt.entryUlids[0],
-        at: input.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        data: {
-            seq: (current.currentArc?.data.seq ?? 0) + 1,
-            title: input.data.title,
-            body: input.data.body,
-        },
-    };
+    const arc = journalEntry("arc", input, attempt.entryUlids[0], {
+        seq: (current.currentArc?.data.seq ?? 0) + 1,
+        title: input.data.title,
+        body: input.data.body,
+    });
     return {
         kind: "offer",
         offer: { facts: [{ contractId: id, entries: [arc] }] },

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

@@ -1,4 +1,5 @@
 import { activeContract } from "../facts/observation.js";
+import { journalEntry } from "../facts/types.js";
 export function decideAttestation({ input, attempt, observation, }) {
     const state = activeContract(observation, input.contractId);
     if ("kind" in state)
@@ -8,15 +9,7 @@ export function decideAttestation({ input, attempt, observation, }) {
     }
     if (input.preparation.kind === "refused")
         return { kind: "refused", refusal: input.preparation.refusal };
-    const attestation = {
-        v: 1,
-        kind: "attestation",
-        contract: input.contractId,
-        entry: attempt.entryUlids[0],
-        at: input.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        data: input.preparation.data,
-    };
+    const attestation = journalEntry("attestation", input, attempt.entryUlids[0], input.preparation.data);
     return {
         kind: "offer",
         offer: { facts: [{ contractId: input.contractId, entries: [attestation] }] },

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

@@ -1,4 +1,5 @@
 import { contractState, prerequisiteStatus } from "../facts/observation.js";
+import { journalEntry } from "../facts/types.js";
 export function decideBind({ input, attempt, observation, }) {
     const id = input.contractId;
     const current = contractState(observation, id);
@@ -13,14 +14,6 @@ export function decideBind({ input, attempt, observation, }) {
     if (prerequisites === "unknown") {
         return { kind: "refused", refusal: { kind: "unknown-prerequisite", contractId: id } };
     }
-    const bind = {
-        v: 1,
-        kind: "bind",
-        contract: id,
-        entry: attempt.entryUlids[0],
-        at: input.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        data,
-    };
+    const bind = journalEntry("bind", input, attempt.entryUlids[0], data);
     return { kind: "offer", offer: { facts: [{ contractId: id, entries: [bind] }] } };
 }

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

@@ -1,4 +1,5 @@
 import { activeContract, documentIsCurrent } from "../facts/observation.js";
+import { journalEntry } from "../facts/types.js";
 export function decideDeliver({ input, attempt, observation, }) {
     const state = activeContract(observation, input.contractId);
     if ("kind" in state)
@@ -11,14 +12,6 @@ export function decideDeliver({ input, attempt, observation, }) {
     }
     if (input.preparation.kind === "refused")
         return { kind: "refused", refusal: input.preparation.refusal };
-    const deliver = {
-        v: 1,
-        kind: "deliver",
-        contract: input.contractId,
-        entry: attempt.entryUlids[0],
-        at: input.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        data: input.preparation.data,
-    };
+    const deliver = journalEntry("deliver", input, attempt.entryUlids[0], input.preparation.data);
     return { kind: "offer", offer: { facts: [{ contractId: input.contractId, entries: [deliver] }] } };
 }

package/build/src/core/verbs/placement.d.ts

@@ -6,7 +6,7 @@ type PlacementInput = Readonly<{
     actor?: ActorId;
     at: string;
 }>;
-export type UnmetPrerequisite = Readonly<{
+type UnmetPrerequisite = Readonly<{
     contractId: ContractId;
     state: "missing" | "active" | "abandoned";
 }>;

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

@@ -1,5 +1,6 @@
 import { gateReports } from "../facts/gate.js";
 import { activeContract, contractState } from "../facts/observation.js";
+import { journalEntry } from "../facts/types.js";
 function unmetPrerequisites(prerequisites, observation) {
     const unmet = [];
     for (const contractId of prerequisites) {
@@ -43,15 +44,7 @@ export function decidePlacement({ input, attempt, observation, }) {
             },
         };
     }
-    const claimed = {
-        v: 1,
-        kind: "claimed",
-        contract: id,
-        entry: attempt.entryUlids[0],
-        at: input.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        data: { delivery: delivery.entry },
-    };
+    const claimed = journalEntry("claimed", input, attempt.entryUlids[0], { delivery: delivery.entry });
     return {
         kind: "offer",
         offer: {

package/build/src/core/verbs/reintegrate.d.ts

@@ -1,5 +1,5 @@
 import type { DecideInput, OfferDecision, Preparation } from "../decide.js";
-import type { ActorId, ContractId, ReintegratedData } from "../facts/types.js";
+import { type ActorId, type ContractId, type ReintegratedData } from "../facts/types.js";
 export type ReintegrateInput<Failure = never> = Readonly<{
     contractId: ContractId;
     actor?: ActorId;

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

@@ -1,4 +1,5 @@
 import { activeContract } from "../facts/observation.js";
+import { journalEntry } from "../facts/types.js";
 export function decideReintegrate({ input, attempt, observation, }) {
     const state = activeContract(observation, input.contractId);
     if ("kind" in state)
@@ -8,15 +9,7 @@ export function decideReintegrate({ input, attempt, observation, }) {
     }
     if (input.preparation.kind === "refused")
         return { kind: "refused", refusal: input.preparation.refusal };
-    const reintegrated = {
-        v: 1,
-        kind: "reintegrated",
-        contract: input.contractId,
-        entry: attempt.entryUlids[0],
-        at: input.at,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        data: input.preparation.data,
-    };
+    const reintegrated = journalEntry("reintegrated", input, attempt.entryUlids[0], input.preparation.data);
     return {
         kind: "offer",
         offer: { facts: [{ contractId: input.contractId, entries: [reintegrated] }] },

package/build/src/dispatch/index.d.ts

@@ -33,5 +33,5 @@ export declare function publishDispatch(input: Readonly<{
     contractId: ContractId;
 }>): Promise<DispatchPublication>;
 export { dispatchAssociationSchema, NO_DISPATCH_ASSOCIATION, parseDispatchAssociation, type DispatchAssociation, } from "./association.js";
-/** Read-only Dispatch association projection for one Akuma identity. */
-export declare function observeDispatchAssociation(repository: GitRepository | undefined, akuId: AkuId): Promise<DispatchAssociation>;
+/** Read selected associations in one targeted observation, isolating per-identity decoding failures. */
+export declare function observeDispatchAssociations(repository: GitRepository | undefined, akuIds: readonly AkuId[]): Promise<ReadonlyMap<AkuId, DispatchAssociation>>;

package/build/src/dispatch/index.js

@@ -4,7 +4,7 @@ import { contractId } from "../core/facts/types.js";
 import { parseAkuId } from "../akuma/identity.js";
 import { appendPrivateStateSeatClose, confirmPrivateStatePublication, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
 import { GIT_FORMAT_BYTES, GIT_FORMAT_PATH, GIT_REF, readBlob, readGitPaths, updateGitTree, updateRefsAtomically, writeBlob, writeStateCommit, } from "../git/repository.js";
-import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
+import { withGitDecodeChannel, withGitReadObservation, withGitTargetedReadObservation, } from "../git/read-observation.js";
 import { NO_DISPATCH_ASSOCIATION } from "./association.js";
 const DISPATCH_ROOT = "dispatch";
 const DISPATCH_PREFIX = `${DISPATCH_ROOT}/`;
@@ -187,18 +187,40 @@ export async function publishDispatch(input) {
     }));
 }
 export { dispatchAssociationSchema, NO_DISPATCH_ASSOCIATION, parseDispatchAssociation, } from "./association.js";
-function associationDiagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-/** Read-only Dispatch association projection for one Akuma identity. */
-export async function observeDispatchAssociation(repository, akuId) {
-    if (repository === undefined)
-        return NO_DISPATCH_ASSOCIATION;
+/** Read selected associations in one targeted observation, isolating per-identity decoding failures. */
+export async function observeDispatchAssociations(repository, akuIds) {
+    const requested = [...new Set(akuIds.map((akuId) => parseAkuId(akuId).id))];
+    const associations = new Map(requested.map((akuId) => [akuId, NO_DISPATCH_ASSOCIATION]));
+    if (repository === undefined || requested.length === 0)
+        return associations;
     try {
-        const dispatch = await readDispatch(repository, akuId);
-        return dispatch === null ? NO_DISPATCH_ASSOCIATION : { kind: "associated", contractId: dispatch.contractId };
+        await withGitDecodeChannel(repository, (channel) => withGitTargetedReadObservation(repository, channel, { paths: requested.map(pathFor) }, async (observation) => {
+            const entries = requested.map((akuId) => {
+                const path = pathFor(akuId);
+                return [akuId, path, observation.snapshot.paths.get(path)];
+            });
+            const blobs = await observation.readBlobs(entries.flatMap(([, , entry]) => (entry?.type === "blob" ? [entry.oid] : [])));
+            for (const [akuId, path, entry] of entries) {
+                if (entry === undefined)
+                    continue;
+                try {
+                    if (entry.type !== "blob")
+                        corruption(`Dispatch path is not a blob: ${path}`);
+                    const result = blobs.get(entry.oid);
+                    if (result?.kind !== "present")
+                        corruption(`missing Dispatch Git object: ${path}`);
+                    associations.set(akuId, { kind: "associated", contractId: decode(path, result.bytes).contractId });
+                }
+                catch (error) {
+                    associations.set(akuId, { kind: "failed", diagnostic: diagnostic(error) });
+                }
+            }
+        }));
     }
     catch (error) {
-        return { kind: "failed", diagnostic: associationDiagnostic(error) };
+        const message = diagnostic(error);
+        for (const akuId of requested)
+            associations.set(akuId, { kind: "failed", diagnostic: message });
     }
+    return associations;
 }