@astrosheep/keiyaku 4.6.11 → 4.6.13

package/build/src/cli/render/{audit.js → delivery-preview.js}

@@ -1,7 +1,7 @@
 import { effectCleanup, effectExecutionStops } from "./effects.js";
-import { executionCleanupLines, executionStopLines, receiptPayload, receiptRow, stopLines, titleLines, } from "./receipt.js";
+import { executionCleanupLines, executionStopLines, receiptPayload, receiptRow, titleLines } from "./receipt.js";
 import { renderRefusalFacts } from "./refusal.js";
-import { abbreviateGitIds, displayGitId } from "./contract-observation.js";
+import { abbreviateGitIds, displayGitId, gateFact } from "./contract-observation.js";
 import { DEFAULT_CLI_COLUMNS, gitShortStat, renderTextBlock, safeText } from "./terminal.js";
 const CHILD = "  ";
 function workspaceEvidence(workspace) {
@@ -16,11 +16,16 @@ function candidateLines(report, columns, addressed, abbreviations) {
         return lines;
     }
     const identity = candidate.identity;
-    receiptRow(lines, " ", "candidate", [{ text: "ready" }, { text: displayGitId(identity.tenderSnapshot, abbreviations), opaque: true }], columns);
+    receiptRow(lines, " ", "candidate", [{ text: "prepared" }, { text: displayGitId(identity.tenderSnapshot, abbreviations), opaque: true }], columns);
     lines.push(`${CHILD}integration result  ${displayGitId(identity.integration.snapshot, abbreviations)}`);
     if (!/^0{40}$/u.test(identity.integration.changeId))
         lines.push(`${CHILD}content identity  ${displayGitId(identity.integration.changeId, abbreviations)}`);
     lines.push(...workspaceEvidence(candidate.workspace));
+    for (const report of candidate.requirements.gates)
+        lines.push(`${CHILD}${gateFact(report)}`);
+    for (const prerequisite of candidate.requirements.unmetPrerequisites) {
+        receiptRow(lines, "!", "prerequisite", [{ text: prerequisite.contractId }, { text: prerequisite.state }], columns);
+    }
     lines.push(...renderTextBlock(gitShortStat(candidate.scope), CHILD, columns));
     if (candidate.scope.paths !== undefined) {
         for (const path of candidate.scope.paths) {
@@ -31,32 +36,23 @@ function candidateLines(report, columns, addressed, abbreviations) {
         receiptPayload(lines, "diff", candidate.diff);
     return lines;
 }
-function verificationLines(verification, columns, addressed) {
+function verificationLines(verification, columns) {
     const lines = [];
-    if (verification.kind === "undeclared") {
-        receiptRow(lines, " ", "verification", [{ text: "none declared" }], columns);
-        return lines;
-    }
-    if (verification.kind === "not-run") {
-        receiptRow(lines, " ", "verification", [{ text: "not run" }], columns);
-        return lines;
-    }
-    if (verification.kind === "stopped") {
-        return stopLines(verification.stop, columns, addressed);
-    }
-    if (verification.kind === "reused") {
-        receiptRow(lines, " ", "verification", [{ text: "reused" }, { text: verification.verdict }], columns);
-        if (verification.summary !== undefined)
-            receiptPayload(lines, "summary", auditSummary(verification.summary));
+    if (verification.kind !== "recorded") {
+        const text = verification.kind === "undeclared"
+            ? "none declared"
+            : verification.kind === "required"
+                ? "required · not run"
+                : "not run";
+        receiptRow(lines, " ", "verification", [{ text }], columns);
         return lines;
     }
-    receiptRow(lines, verification.kind === "satisfied" ? "✓" : "!", "verification", [{ text: verification.kind }, { text: `${verification.passed} of ${verification.total}` }], columns);
-    if (verification.summary !== undefined) {
-        receiptPayload(lines, "summary", auditSummary(verification.summary));
-    }
+    receiptRow(lines, verification.verdict === "unsatisfied" ? "!" : " ", "verification", [{ text: "recorded" }, { text: verification.verdict }], columns);
+    if (verification.summary !== undefined)
+        receiptPayload(lines, "summary", previewSummary(verification.summary));
     return lines;
 }
-function auditSummary(summary) {
+function previewSummary(summary) {
     return summary.replace(/\[(\d+) (bash|zsh|pwsh) exit (-?\d+)( output-truncated)?\]/gu, (_, number, executor, exit, truncated) => `declaration ${number} · ${executor} exit ${exit}${truncated ?? ""}`);
 }
 function admittedCandidateLines(report, columns) {
@@ -86,6 +82,12 @@ function targetLines(report, columns, addressed, abbreviations) {
                 opaque: true,
             },
         ], columns);
+        for (const checkout of target.checkouts) {
+            if (checkout.kind === "followable")
+                continue;
+            receiptRow(lines, "!", "checkout cannot follow", [{ text: checkout.path, opaque: true }], columns);
+            receiptPayload(lines, "reason", checkout.diagnostic);
+        }
         return lines;
     }
     if (target.kind === "moved") {
@@ -114,7 +116,7 @@ function obligationLines(result, columns) {
         ...executionStopLines(effectExecutionStops(result.effects), columns),
     ];
 }
-export function renderAcceptedAudit(result, context) {
+export function renderDeliveryPreview(result, context) {
     const report = result.value;
     const columns = context?.columns ?? DEFAULT_CLI_COLUMNS;
     const ids = report.candidate.kind === "ready"
@@ -130,10 +132,10 @@ export function renderAcceptedAudit(result, context) {
         ids.push(report.target.expected, report.target.observed ?? "");
     const abbreviations = abbreviateGitIds(ids);
     return [
-        ...titleLines("✓", "audit", result.contract, columns),
+        ...titleLines("✓", "deliver --dry-run", result.contract, columns),
         ...candidateLines(report, columns, result.contract, abbreviations),
         ...admittedCandidateLines(report, columns),
-        ...verificationLines(report.verification, columns, result.contract),
+        ...verificationLines(report.verification, columns),
         ...targetLines(report, columns, result.contract, abbreviations),
         ...obligationLines(result, columns),
     ].join("\n");

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

@@ -5,7 +5,9 @@ declare function endpointFact(id: string, observed: string | undefined): string;
 /**
  * One Akuma board section. The World board omits an empty section because its other
  * sections already say what the World holds; a category board states that emptiness
- * itself, since it is the whole answer.
+ * itself, since it is the whole answer. A failed Alias observation belongs to the
+ * section, so an empty roster still states its emptiness rather than dropping that
+ * evidence.
  */
 declare function renderAkumaBoard(section: Section<AkumaKanshiWorld>, observedAt: string, context: TextRenderContext, emptyRows: readonly string[]): readonly string[];
 declare function renderAkuma(report: KanshiReport, context: TextRenderContext): readonly string[];

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

@@ -1,6 +1,6 @@
 import { snapshotActivityLines } from "./akuma-activity.js";
 import { akumaMark } from "./marks.js";
-import { ageText, elapsedMilliseconds, entityLines, identityLine, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
+import { ageText, elapsedMilliseconds, emptyCatalogue, entityLines, identityLine, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
 const NARROW_COLUMNS = 72;
 const ACTIVITY_INDENT = "  ";
 function mostRecentTimestamp(...values) {
@@ -29,9 +29,11 @@ function latestActivityLines(snapshot, context) {
     const bounded = { ...context, columns: Math.max(1, context.columns - ACTIVITY_INDENT.length) };
     return snapshotActivityLines(snapshot, bounded, { latest: true, tailAnswer: true }).map((line) => `${ACTIVITY_INDENT}${line}`);
 }
-function akumaLabel(row) {
+function akumaLabel(row, aliasesUnavailable) {
     const aliases = row.aliases ?? [];
-    return aliases.length === 0 ? "" : `(${aliases.join(" ")})`;
+    if (aliases.length > 0)
+        return `(${aliases.join(" ")})`;
+    return aliasesUnavailable ? "(aliases unavailable)" : "";
 }
 function endpointFact(id, observed) {
     // A bounded or failed Contract read leaves the disposition unknown; a parenthetical that
@@ -41,7 +43,9 @@ function endpointFact(id, observed) {
 /**
  * One Akuma board section. The World board omits an empty section because its other
  * sections already say what the World holds; a category board states that emptiness
- * itself, since it is the whole answer.
+ * itself, since it is the whole answer. A failed Alias observation belongs to the
+ * section, so an empty roster still states its emptiness rather than dropping that
+ * evidence.
  */
 function renderAkumaBoard(section, observedAt, context, emptyRows) {
     if (section.kind === "absent")
@@ -49,8 +53,15 @@ function renderAkumaBoard(section, observedAt, context, emptyRows) {
     if (section.kind === "failed")
         return ["AKUMA // unavailable", "", tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
     const rows = section.value.rows;
-    if (rows.length === 0)
-        return emptyRows;
+    const aliasesUnavailable = section.value.aliasesUnavailable === true;
+    if (rows.length === 0) {
+        if (!aliasesUnavailable)
+            return emptyRows;
+        return [
+            ...(emptyRows.length === 0 ? [emptyCatalogue("akuma")] : emptyRows),
+            tone("! aliases unavailable", "alert", context.color),
+        ];
+    }
     const rowLines = rows.map((row) => {
         const statusTone = akumaStatusTone(row, observedAt);
         const mark = statusTone === null ? akumaMark(row.life) : tone(akumaMark(row.life), statusTone, context.color);
@@ -62,10 +73,14 @@ function renderAkumaBoard(section, observedAt, context, emptyRows) {
         const key = row.life === "stranded" && "strandedReason" in row && row.strandedReason === "resume-unsupported"
             ? [life, ...activity, "resume unsupported"]
             : [life, ...activity];
-        const relation = row.contract === undefined ? [] : [endpointFact(row.contract.id, row.contract.observed)];
+        const relation = row.contract === undefined
+            ? row.contractAssociationUnavailable === true
+                ? ["contract association unavailable"]
+                : []
+            : [endpointFact(row.contract.id, row.contract.observed)];
         const snapshot = row.snapshot;
         const snapshotLines = snapshot === undefined ? [] : latestActivityLines(snapshot, context);
-        const aliases = akumaLabel(row);
+        const aliases = akumaLabel(row, aliasesUnavailable);
         if (context.columns > NARROW_COLUMNS) {
             const lines = [identityLine(mark, row.id, `${aliases} · ${[...key, ...relation].join(" · ")}`.trim())];
             return [...lines, ...snapshotLines];

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

@@ -64,6 +64,8 @@ function isTerminalAkuma(life) {
     return life === "killed" || life === "stillborn";
 }
 function linkedAkumaSummary(row, akuma) {
+    if (row.rosterUnavailable === true)
+        return "akuma  unavailable";
     if (row.roster.length === 0)
         return undefined;
     if (akuma === undefined || akuma.kind !== "present")
@@ -98,7 +100,6 @@ function payload(label, text, context) {
         columns: context.columns,
         maxLines: 3,
         quote: "“",
-        openQuote: false,
         truncated: false,
     });
 }
@@ -248,6 +249,8 @@ function renderDebts(report, context) {
         return [];
     const rowLines = rows.map((row) => {
         const relation = row.contract === undefined ? [] : [endpointFact(row.contract.id, row.contract.observed)];
+        if (row.contractAssociationUnavailable === true)
+            relation.push("contract association unavailable");
         const childFacts = row.children === undefined ? [] : [`children ${row.children.live} live · ${row.children.total} total`];
         const blockerFacts = (row.blockers ?? []).map((blocker) => `blocked ${blocker.id}`);
         const association = relation.length === 0 ? "" : ` · ${relation.join(" · ")}`;

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

@@ -1,4 +1,4 @@
-import { gateDisplayName } from "./contract-observation.js";
+import { gateDisplayName, contractOperationName } from "./contract-observation.js";
 import { renderRefusalFacts } from "./refusal.js";
 import { DEFAULT_CLI_COLUMNS, displayColumns, orderRefusalFacts, renderOpaqueBlock, safeText, quotedText, } from "./terminal.js";
 export function receiptRow(lines, mark, label, segments, columns) {
@@ -25,7 +25,7 @@ export function receiptPayload(lines, label, payload) {
     lines.push(`  ${label.trim()}`, ...renderOpaqueBlock(payload, "  ", DEFAULT_CLI_COLUMNS), "");
 }
 export function outcomeLines(mark, verb, word, contract, columns = DEFAULT_CLI_COLUMNS) {
-    const base = `${mark} ${verb} ${word}`;
+    const base = `${mark} ${contractOperationName(verb)} ${word}`;
     if (contract === undefined)
         return [base];
     const inline = `${base}  ${contract}`;
@@ -296,7 +296,7 @@ export function executionFailureLines(receipt, category, diagnostic, columns) {
             cleanup.push(effect.issue);
     }
     const lines = [];
-    receiptRow(lines, "!", "execution failed after admission", [{ text: category }, ...(contract === undefined ? [] : [{ text: contract, opaque: true }])], columns);
+    receiptRow(lines, "!", receipt.operation === "deliver-preview" ? "deliver --dry-run failed" : "execution failed after admission", [{ text: category }, ...(contract === undefined ? [] : [{ text: contract, opaque: true }])], columns);
     receiptPayload(lines, "reason", diagnostic);
     lines.push(...executionStopLines(stops, columns), ...executionCleanupLines(cleanup, columns, contract));
     return lines;

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

@@ -1,5 +1,5 @@
 import { usageAcceptanceLines } from "../usage.js";
-import { shortGitId } from "./contract-observation.js";
+import { shortGitId, contractOperationName } from "./contract-observation.js";
 import { DEFAULT_CLI_COLUMNS, checkoutNotFollowableLines, gitShortStat, orderRefusalFacts, renderOpaqueBlock, safeText, } from "./terminal.js";
 function wrap(lines, text, indent, columns) {
     lines.push(...renderOpaqueBlock(text, indent, columns));
@@ -112,7 +112,7 @@ export function renderRefusalFacts(refusal, indent, columns, addressed) {
     return orderRefusalFacts(refusalFacts(refusal, indent, columns, addressed).map((line) => line.slice(indent.length))).map((line) => `${indent}${line}`);
 }
 function refusalTitle(verb) {
-    return `× ${verb} refused`;
+    return `× ${contractOperationName(verb)} refused`;
 }
 /**
  * The one refusal receipt assembly: a denied-verdict title, a labeled reason, labeled facts, and the

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

@@ -38,7 +38,6 @@ export declare function renderBoundedPayload(input: Readonly<{
     columns: number;
     maxLines: number;
     quote: string;
-    openQuote: boolean;
     truncated: boolean;
 }>): readonly string[];
 export declare function quotedText(value: string): string;

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

@@ -186,7 +186,7 @@ export function renderBoundedPayload(input) {
         if (rest.length === 0 && !input.quote && index === 0)
             return [prefix.trimEnd()];
         const opening = input.quote && index === 0 ? input.quote : "";
-        const closing = input.quote && !input.openQuote ? (input.quote === "“" ? "”" : input.quote) : "";
+        const closing = input.quote === "“" ? "”" : input.quote;
         const budget = Math.max(0, input.columns - displayColumns(prefix + opening + closing));
         if (budget === 0)
             return lines.length === 0 ? [prefix.trimEnd()] : lines;

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

@@ -0,0 +1,15 @@
+import type { WorldRoot } from "../world.js";
+export type SquareSeatInput = Readonly<{
+    path: WorldRoot;
+    environment: NodeJS.ProcessEnv;
+}>;
+export type SquareSeatControl = Readonly<{
+    signal?: AbortSignal;
+    budgetMs?: number;
+}>;
+/**
+ * The Square participant name this submitting session should speak as, or
+ * undefined when no honest choice exists. Identity preparation is optional, so it
+ * never refuses the enclosing operation and always settles within one budget.
+ */
+export declare function squareSeat(input: SquareSeatInput, control?: SquareSeatControl): Promise<string | undefined>;

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

@@ -0,0 +1,180 @@
+import { createHash } from "node:crypto";
+import { realpath } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { inbox, Square, SquareError, squareAssignedParticipantName } from "@astrosheep/square";
+/**
+ * The Square integration's submitting-edge identity policy. Call, fork, tell, and
+ * ask share this one adapter, so no command and no generic caller decoder has to
+ * know how Square names a participant. Every Square read below is rooted in the
+ * submitted environment's own coordinates, never in this process's ambient ones.
+ */
+/** Square's own harness-session coordinates, in its resolution order. */
+const HARNESS_SESSIONS = [
+    { provider: "claude", variable: "CLAUDE_CODE_SESSION_ID" },
+    { provider: "codex", variable: "CODEX_THREAD_ID" },
+    { provider: "opencode", variable: "OPENCODE_SESSION_ID" },
+    { provider: "pi", variable: "PI_SESSION_ID" },
+    { provider: undefined, variable: "PASEO_AGENT_ID" },
+];
+const SEAT_PREFIX = "keiyaku-assigned-";
+const SEAT_DIGEST_DOMAIN = "keiyaku/square-seat/v1";
+const SEAT_DIGEST_LENGTH = 12;
+/** One bounded identity observation; a non-cooperative Square never holds a submission. */
+const IDENTITY_BUDGET_MS = 5_000;
+function declared(environment, variable) {
+    const value = environment[variable]?.trim();
+    return value === undefined || value === "" ? undefined : value;
+}
+/** A stable, collision-resistant seat for one provider session coordinate. */
+function squareSeatName(provider, session) {
+    const digest = createHash("sha256")
+        .update(`${SEAT_DIGEST_DOMAIN}\u0000${provider}\u0000${session}`, "utf8")
+        .digest("hex");
+    return `${SEAT_PREFIX}${digest.slice(0, SEAT_DIGEST_LENGTH)}`;
+}
+/** Every harness session coordinate this process declares, able to name a seat or not. */
+function sessionIds(environment) {
+    return HARNESS_SESSIONS.flatMap(({ variable }) => {
+        const session = declared(environment, variable);
+        return session === undefined ? [] : [session];
+    });
+}
+/**
+ * The deterministic candidate for this process. Only one provider-backed session
+ * may exist: a second coordinate — another provider, or the same raw token under
+ * a different one — is ambiguous and selects nothing.
+ */
+function seatCandidate(environment) {
+    const names = HARNESS_SESSIONS.flatMap(({ provider, variable }) => {
+        const session = declared(environment, variable);
+        return provider === undefined || session === undefined ? [] : [squareSeatName(provider, session)];
+    });
+    return names.length === 1 ? names[0] : undefined;
+}
+/**
+ * Square owns the name grammar, so the edge borrows one of Square's own handles
+ * instead of restating it. An in-memory square validates without touching any
+ * artifact.
+ */
+async function usableName(name) {
+    try {
+        await Square.inMemory({ markdown: "" }).participant(name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Square's own canonical coordinate for a location it already published. */
+async function canonical(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+/**
+ * Bindings this session already holds in this Square. Square's session inbox
+ * reads the same host registry as native hooks, and it is the only public read
+ * that takes the caller's own environment coordinate. Its page is bounded, so a
+ * view that hides rows proves nothing about absence here.
+ */
+async function joinedBindings(environment, ids, location, signal) {
+    const pages = await Promise.all(ids.map(async (session) => await inbox({ env: environment }, session, {}, { signal })));
+    const here = await canonical(location);
+    return {
+        here: pages.flatMap(({ rows }) => rows).filter(({ squarePath }) => squarePath === here).length,
+        complete: pages.every(({ rows, total }) => total === rows.length),
+    };
+}
+/**
+ * A session whose former participant already finished here has no replacement
+ * identity: releasing the binding leaves Square's roster as the only evidence of
+ * that standing, and a fresh seat would rename a finished caller into a new one.
+ */
+async function finishedHere(square, environment, signal) {
+    const former = squareAssignedParticipantName(environment);
+    const previous = seatCandidate(environment)?.replace(SEAT_PREFIX, "keiyaku-seat-");
+    if (former === undefined && previous === undefined)
+        return false;
+    const { participants } = await square.participants({}, { signal });
+    return participants.some(({ name, state }) => (name === former || name === previous) && state === "done");
+}
+/**
+ * A binding this edge cannot stand on is never replaced by a fresh name: Square
+ * adjudicates standing, ownership, and lifecycle. The edge only distinguishes a
+ * Square that is genuinely not there yet from evidence it cannot trust.
+ */
+async function standingAt(location, environment, ids, signal) {
+    let square;
+    try {
+        square = await Square.at({ path: location, env: environment }, { signal });
+    }
+    catch (error) {
+        // Only a Square that is genuinely not there yet may receive a new seat.
+        return error instanceof SquareError && error.code === "unavailable"
+            ? { kind: "absent" }
+            : { kind: "indeterminate" };
+    }
+    try {
+        const recognized = await square.recognize(environment);
+        if (recognized !== null)
+            return { kind: "standing", name: recognized.name };
+        const bindings = await joinedBindings(environment, ids, square.location, signal);
+        if (bindings.here > 0 || !bindings.complete)
+            return { kind: "indeterminate" };
+        return (await finishedHere(square, environment, signal)) ? { kind: "indeterminate" } : { kind: "absent" };
+    }
+    catch {
+        return { kind: "indeterminate" };
+    }
+    finally {
+        await square.close().catch(() => undefined);
+    }
+}
+/**
+ * The one bounded attempt. A late settlement keeps no authority: the adapter only
+ * reads Square, so nothing arrives after the caller has settled, and no refusal
+ * escapes as an unhandled rejection.
+ */
+async function bounded(attempt, control) {
+    const budget = new AbortController();
+    const timer = setTimeout(() => budget.abort(new Error("Square identity observation expired")), control.budgetMs ?? IDENTITY_BUDGET_MS);
+    const signal = control.signal === undefined ? budget.signal : AbortSignal.any([control.signal, budget.signal]);
+    const pending = attempt(signal);
+    pending.catch(() => undefined);
+    try {
+        return await Promise.race([pending, whenAborted(signal)]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function whenAborted(signal) {
+    return new Promise((settle) => {
+        if (signal.aborted)
+            settle(undefined);
+        else
+            signal.addEventListener("abort", () => settle(undefined), { once: true });
+    });
+}
+/**
+ * The Square participant name this submitting session should speak as, or
+ * undefined when no honest choice exists. Identity preparation is optional, so it
+ * never refuses the enclosing operation and always settles within one budget.
+ */
+export async function squareSeat(input, control = {}) {
+    const name = declared(input.environment, "SQUARE_PARTICIPANT_NAME");
+    if (name !== undefined)
+        return (await usableName(name)) ? name : undefined;
+    const ids = sessionIds(input.environment);
+    // No session coordinate: nothing to reuse, nothing to derive, nothing to read.
+    if (ids.length === 0)
+        return undefined;
+    const location = join(input.path, ".square", "KEIYAKU.square");
+    const standing = await bounded(async (signal) => await standingAt(location, input.environment, ids, signal), control);
+    if (standing?.kind === "standing")
+        return standing.name;
+    return standing?.kind === "absent" ? seatCandidate(input.environment) : undefined;
+}

package/build/src/contract-worktree.js

@@ -9,7 +9,7 @@ import { appointmentFor, placeRegisterPath } from "./workspace-place.js";
 import { repairNamespaceContext } from "./debt/context.js";
 import { contractNamespace } from "./debt/identity.js";
 const IGNORE_BYTES = ".gitignore\nKEIYAKU.md\n";
-const PRIMARY_IGNORE_BYTES = "*\n!settings.json\n!debts/\n!debts/**\n";
+const PRIMARY_IGNORE_BYTES = "*\n!settings.json\n";
 const SEAT_IGNORE_BYTES = ".gitignore\nSKILL.md\n";
 const SEAT_SKILLS = [
     ["keiyaku-onboarding", CONTRACT_ONBOARDING_SKILL],

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

@@ -1,5 +1,5 @@
 import { type GateReport } from "../facts/gate.js";
-import { type ActorId, type ContractId } from "../facts/types.js";
+import { type ActorId, type ContractId, type ContractState } from "../facts/types.js";
 import type { DecideInput, OfferDecision } from "../decide.js";
 type PlacementInput = Readonly<{
     contractId: ContractId;
@@ -24,5 +24,6 @@ export type PlacementRefusal = Readonly<{
     contractId: ContractId;
     unmet: readonly UnmetPrerequisite[];
 }>;
+export declare function unmetPrerequisites(prerequisites: readonly ContractId[], observation: ReadonlyMap<ContractId, ContractState | null>): readonly UnmetPrerequisite[];
 export declare function decidePlacement({ input, attempt, observation, }: DecideInput<PlacementInput>): OfferDecision<PlacementRefusal>;
 export {};

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

@@ -1,7 +1,7 @@
 import { gateReports } from "../facts/gate.js";
 import { activeContract, contractState } from "../facts/observation.js";
 import { journalEntry } from "../facts/types.js";
-function unmetPrerequisites(prerequisites, observation) {
+export function unmetPrerequisites(prerequisites, observation) {
     const unmet = [];
     for (const contractId of prerequisites) {
         const state = contractState(observation, contractId);

package/build/src/debt/context.d.ts

@@ -1,7 +1,3 @@
-export type NamespaceContextRead = readonly string[] | "absent" | Readonly<{
-    kind: "malformed";
-    path: string;
-}>;
 export type NamespaceContextInput = Readonly<{
     directory: string;
     boundary: string;
@@ -12,7 +8,6 @@ export type ResolvedNamespaceContext = Readonly<{
     namespace: readonly string[];
     source: NamespaceContextSource;
 }>;
-export declare function readNamespaceContext(coordinates: NamespaceContextInput): Promise<NamespaceContextRead>;
 export declare function installNamespaceContext(root: string, segments: readonly string[]): Promise<void>;
 export declare function repairNamespaceContext(root: string, segments: readonly string[]): Promise<"kept" | "installed">;
 export declare function resolveDebtNamespaceContext(input: NamespaceContextInput): Promise<ResolvedNamespaceContext | Readonly<{

package/build/src/debt/context.js

@@ -1,5 +1,5 @@
 import { lstat, mkdir, readFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { repairDerivedFile, replaceFileDurably } from "../coordination/durable-file.js";
 import { normalizeIdentityStem } from "../identity/normalize.js";
 function directory(root) {
@@ -21,9 +21,10 @@ function validNamespaceSegments(value) {
             segment !== ".."));
 }
 async function readAt(root) {
+    const path = currentPath(root);
     let bytes;
     try {
-        const path = currentPath(root), stat = await lstat(path);
+        const stat = await lstat(path);
         if (!stat.isFile() || stat.isSymbolicLink())
             return { kind: "malformed", path };
         bytes = await readFile(path, "utf8");
@@ -33,33 +34,31 @@ async function readAt(root) {
             return "absent";
         throw error;
     }
-    if (!bytes.endsWith("\n") || bytes.slice(0, -1).includes("\n")) {
-        return { kind: "malformed", path: currentPath(root) };
-    }
+    if (!bytes.endsWith("\n") || bytes.slice(0, -1).includes("\n"))
+        return { kind: "malformed", path };
     const content = bytes.slice(0, -1);
     const segments = content === "" ? [] : content.split("/");
-    return validNamespaceSegments(segments) ? segments : { kind: "malformed", path: currentPath(root) };
-}
-async function readAtWithPath(root) {
-    const selected = await readAt(root);
-    if (selected === "absent" || (typeof selected === "object" && "kind" in selected))
-        return selected;
-    return { value: selected, path: currentPath(root) };
+    return validNamespaceSegments(segments) ? segments : { kind: "malformed", path };
 }
-export async function readNamespaceContext(coordinates) {
-    let current = coordinates.directory;
+/** One ancestor walk: the nearest context at or below the boundary, and the directory that answers it. */
+async function walkNamespaceContext(coordinates) {
+    const boundary = resolve(coordinates.boundary);
+    let current = resolve(coordinates.directory);
     for (;;) {
-        const selected = await readAt(current);
-        if (selected !== "absent")
-            return selected;
-        if (current === coordinates.boundary)
-            return "absent";
-        const resolvedParent = dirname(resolve(current));
-        if (resolvedParent === current || !resolvedParent.startsWith(`${coordinates.boundary}/`))
-            return "absent";
-        current = resolvedParent;
+        const read = await readAt(current);
+        if (read !== "absent" || current === boundary)
+            return { read, root: current };
+        const parent = dirname(current);
+        if (parent === current || !descendsFrom(parent, boundary))
+            return { read, root: current };
+        current = parent;
     }
 }
+/** Whether `candidate` is the boundary or lies beneath it; a sibling or ancestor never does. */
+function descendsFrom(candidate, boundary) {
+    const step = relative(boundary, candidate);
+    return step === "" || (!isAbsolute(step) && step !== ".." && !step.startsWith(`..${sep}`));
+}
 export async function installNamespaceContext(root, segments) {
     if (!validNamespaceSegments(segments))
         throw new TypeError("namespace must contain normalized segments");
@@ -72,8 +71,7 @@ async function installIgnore(root) {
     await repairDerivedFile(ignorePath(root), "*\n");
 }
 export async function repairNamespaceContext(root, segments) {
-    const current = await readNamespaceContext({ directory: root, boundary: root });
-    if (Array.isArray(current)) {
+    if (Array.isArray(await readAt(root))) {
         await installIgnore(root);
         return "kept";
     }
@@ -81,23 +79,13 @@ export async function repairNamespaceContext(root, segments) {
     return "installed";
 }
 export async function resolveDebtNamespaceContext(input) {
-    let current = input.directory;
-    for (;;) {
-        const selected = await readAtWithPath(current);
-        if (selected !== "absent") {
-            if (typeof selected === "object" && "kind" in selected)
-                return { kind: "invalid-namespace-context", path: selected.path };
-            return {
-                namespace: "value" in selected ? selected.value : selected,
-                source: current === input.boundary && input.managed === true ? "contract-installed" : "local-override",
-            };
-        }
-        if (current === input.boundary)
-            return { namespace: [], source: "default-root" };
-        const resolvedParent = dirname(resolve(current));
-        if (resolvedParent === current || !resolvedParent.startsWith(`${input.boundary}/`)) {
-            return { namespace: [], source: "default-root" };
-        }
-        current = resolvedParent;
-    }
+    const { read, root } = await walkNamespaceContext(input);
+    if (read === "absent")
+        return { namespace: [], source: "default-root" };
+    if (typeof read === "object" && "kind" in read)
+        return { kind: "invalid-namespace-context", path: read.path };
+    return {
+        namespace: read,
+        source: root === resolve(input.boundary) && input.managed === true ? "contract-installed" : "local-override",
+    };
 }

package/build/src/git/process.d.ts

@@ -29,6 +29,7 @@ export declare class GitPlumbingError extends Error {
         pid?: number | null;
     }>);
 }
+export declare function gitChildEnvironment(environment?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export declare function executeGit(repository: GitRepository, args: readonly string[], input?: string | Uint8Array, environment?: NodeJS.ProcessEnv): Promise<Buffer>;
 /** Connect two owned Git commands without materializing the intermediate output. */
 export declare function runGitPipe(repository: GitRepository, sourceArgs: readonly string[], sinkArgs: readonly string[]): Promise<Buffer>;