@astrosheep/keiyaku 4.5.8 → 4.5.9

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

@@ -34,11 +34,11 @@ export const CONTRACT_COMMAND_SPECS = {
         usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [--json] [-]",
         purpose: "Amend one Contract's document operations or structured terms.",
         details: [
+            "  ## Context|Objective|Design|Region|Criteria|Verification|<extension>  (replace, or add new extension)",
             "  ## Replace: Context|Objective|Design|Region|Criteria|Verification|<extension>",
             "  ## Append: Context|Objective|Design|Criteria|<extension>",
             "  ## Add: Criteria|<new-extension-title>",
             "  ## Update: <existing-extension-title>",
-            "  ## Remove: Criterion <existing-title>",
             "  ## Remove: <existing-extension-title>",
         ].join("\n"),
     },
@@ -46,13 +46,12 @@ export const CONTRACT_COMMAND_SPECS = {
         positional: "optional",
         stdin: "none",
         flags: {
-            actor: "value",
             message: "value",
             "include-dirty": "boolean",
             "materialize-conflict": "boolean",
             json: "boolean",
         },
-        usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--actor <actor>] [--json]",
+        usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--json]",
         purpose: "Deliver one Contract candidate from the appointed worktree.",
         details: [
             "  --include-dirty         Capture the complete non-ignored worktree tree as the",
@@ -66,8 +65,8 @@ export const CONTRACT_COMMAND_SPECS = {
     review: {
         positional: "optional",
         stdin: "optional",
-        flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" },
-        usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>] [--json]",
+        flags: { satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" },
+        usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--json]",
         purpose: "Record one review verdict.",
     },
     arc: {
@@ -108,8 +107,8 @@ export const CONTRACT_COMMAND_SPECS = {
     audit: {
         positional: "optional",
         stdin: "none",
-        flags: { "include-dirty": "boolean", diff: "boolean", actor: "value", json: "boolean" },
-        usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>] [--json]",
+        flags: { "include-dirty": "boolean", diff: "boolean", json: "boolean" },
+        usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--json]",
         purpose: "Ask what candidate preparation, Verification, and target placement would do.",
     },
     reconcile: {
@@ -131,7 +130,7 @@ export const CONTRACT_COMMAND_SPECS = {
         stdin: "none",
         flags: { json: "boolean" },
         usage: "settings [--json]",
-        purpose: "Read user and project Settings resources.",
+        purpose: "Show effective Settings (user + project, read-only)",
     },
     region: {
         positional: "optional",
@@ -218,7 +217,6 @@ function parseDeliver(parts) {
     return {
         command: "deliver",
         ...(contract === undefined ? {} : { contract }),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
         ...(message === undefined ? {} : { message }),
         includeDirty: parts.flags["include-dirty"] === true,
         materializeConflict: parts.flags["materialize-conflict"] === true,
@@ -240,7 +238,6 @@ function parseReview(parts) {
         verdict: parts.flags.satisfied === true ? "satisfied" : "unsatisfied",
         ...(summary === undefined ? {} : { summary }),
         ...(parts.stdin ? { summaryFromStdin: true } : {}),
-        ...(parts.actor === undefined ? {} : { actor: parts.actor }),
         output: parts.output,
     };
 }
@@ -301,6 +298,28 @@ function parseLs(parts) {
 }
 export function renderContractHelp(command) {
     const spec = CONTRACT_COMMAND_SPECS[command];
+    if (command === "settings") {
+        return [
+            "Show effective Settings — the merged read-only view of:",
+            "  user      ~/.keiyaku/settings.json",
+            "  project   <WorldRoot>/.keiyaku/settings.json",
+            "A project record wholly shadows the same-name user record.",
+            "",
+            "Shape: namespace -> entry -> JSON value. There is no write",
+            "command; edit the files directly.",
+            "",
+            "Recognized settings:",
+            "  gates                            gate bundles selected by bind and amend",
+            "  worktree                         commands run when worktrees are created or destroyed",
+            "  git.requireBranchesToBeUpToDate  whether deliver and audit require up-to-date target branches",
+            "  providers                        the available Akuma and how each is run",
+            "",
+            "Each entry is validated by the feature that reads it. A rejected",
+            "value's diagnostic states the expected shape.",
+            "",
+            usageLine(spec.usage),
+        ].join("\n");
+    }
     const help = `${spec.purpose}\n\n${usageLine(spec.usage)}`;
     return spec.details === undefined ? help : `${help}\n\n${spec.details}`;
 }
@@ -352,7 +371,6 @@ export function parseContractCommand(parts) {
                 ...(contract === undefined ? {} : { contract }),
                 includeDirty: parts.flags["include-dirty"] === true,
                 showDiff: parts.flags.diff === true,
-                ...(parts.actor === undefined ? {} : { actor: parts.actor }),
                 output: parts.output,
             };
         }

package/build/src/cli/commands/install.d.ts

@@ -17,6 +17,7 @@ export type InstallInvocationResult = Readonly<{
 }>;
 export type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
 export declare const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\ninstall --all [--json]";
+export declare const INSTALL_ROOT_PURPOSE = "Install Keiyaku into coding harnesses";
 export declare function parseInstallCommand(argv: readonly string[]): ParsedInstallCommand;
 export declare function renderInstallHelp(): string;
 export declare function installAssetsRoot(): string;

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

@@ -3,6 +3,7 @@ import { fileURLToPath } from "node:url";
 import { CliUsageError, usageLine } from "../usage.js";
 export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
 export const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\ninstall --all [--json]";
+export const INSTALL_ROOT_PURPOSE = "Install Keiyaku into coding harnesses";
 function isHarness(value) {
     return value !== undefined && HARNESS_NAMES.includes(value);
 }
@@ -42,7 +43,7 @@ export function parseInstallCommand(argv) {
     };
 }
 export function renderInstallHelp() {
-    return `Install the Keiyaku skills into one or more agent harnesses.\n\n${usageLine(INSTALL_USAGE)}`;
+    return `Install Keiyaku into your coding harnesses via each harness's native plugin/package installer. --all continues past failures; any failure exits 1.\n\n${usageLine(INSTALL_USAGE)}`;
 }
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
 const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");

package/build/src/cli/parse.js

@@ -1,25 +1,39 @@
 import { isTaskAction, parseTaskCommand, renderTaskHelp, renderTaskUsage, } from "./commands/task.js";
 import { isAkumaAction, parseAkumaCommand, renderAkumaHelp, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
-import { parseInstallCommand, renderInstallHelp } from "./commands/install.js";
+import { INSTALL_ROOT_PURPOSE, parseInstallCommand, renderInstallHelp, } from "./commands/install.js";
 import { CONTRACT_COMMAND_SPECS, parseContractCommand, renderContractHelp as renderContractHelpForOwner, renderContractUsage, } from "./commands/contract.js";
 import { renderTextBlock } from "./render/terminal.js";
 import { CliUsageError, isBlankInput } from "./usage.js";
 export { CliUsageError } from "./usage.js";
 export { renderContractHelp } from "./commands/contract.js";
-const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
+const ROOT_USAGE = [
+    "usage: keiyaku <command> [options]",
+    "       keiyaku <command> --help   shows that command's complete usage",
+].join("\n");
 export function renderRootHelp(columns) {
     return renderHelpText([
+        "keiyaku — Contract, Task, and Akuma control for one repository",
+        "",
         ROOT_USAGE,
         "",
-        "global options:",
-        "  -C, --cwd <path>  Set the invocation working directory.",
-        "  --repo <path>     Select the Git repository coordinate.",
+        "Contract — standing acceptance",
+        ...Object.entries(CONTRACT_COMMAND_SPECS)
+            .filter(([command]) => command !== "settings")
+            .map(([command, spec]) => `  ${command.padEnd(10)} ${spec.purpose}`),
+        "",
+        "Task — plan memory",
+        "  task       Task coordination; see `keiyaku task --help`.",
         "",
-        "commands:",
-        ...Object.entries(CONTRACT_COMMAND_SPECS).map(([command, spec]) => `  keiyaku ${command}  ${spec.purpose}`),
-        "  keiyaku install  Install the Keiyaku skills into an agent harness.",
-        "  keiyaku task     Task coordination; see `keiyaku task --help`.",
+        "Akuma — invoke capability",
         ...renderAkumaRootRows(),
+        "",
+        "Workspace",
+        `  install   ${INSTALL_ROOT_PURPOSE}`,
+        `  settings  ${CONTRACT_COMMAND_SPECS.settings.purpose}`,
+        "",
+        "Global options:",
+        "  -C, --cwd <path>  Set the invocation working directory.",
+        "  --repo <path>     Select the Git repository coordinate.",
     ].join("\n"), columns);
 }
 function renderHelpText(help, columns) {

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

@@ -37,5 +37,5 @@ export declare function historyText(command: Extract<ParsedCommand, {
 export declare function tellText(result: Extract<AkumaInvocationResult, {
     action: "tell";
     mode: "ordinary";
-}>): string;
+}>, context: TextRenderContext): string;
 export {};

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

@@ -377,12 +377,13 @@ export function historyText(command, result, context) {
         ...groupedRows(result.history.rows, context, true),
     ].join("\n");
 }
-export function tellText(result) {
+export function tellText(result, context) {
     const wake = result.result.tell.wake;
     const target = identity(result.result.akuma, result.alias);
+    const row = groupedRows([result.result.tell.row], context).join("\n");
     if (wake.kind === "failed") {
         const child = "child" in wake ? wake.child : undefined;
-        return `${target}\n${SNAPSHOT_RULER}\n! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;
+        return `${target}\n${SNAPSHOT_RULER}\n${row}\n! tell delivery failed · ${safeText(wake.diagnostic)}${child === undefined ? "" : ` · log ${child.log.path} ${child.log.from}..${child.log.to}`}`;
     }
-    return `${target}\n${SNAPSHOT_RULER}\n✓ tell ${wake.kind}${wake.kind === "pursuing" ? ` body=${wake.bodySequence}` : ""}`;
+    return `${target}\n${SNAPSHOT_RULER}\n${row}`;
 }

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

@@ -69,7 +69,7 @@ export function renderAkumaText(command, result, context = DEFAULT_CONTEXT) {
             return waitText(result, context);
         case "tell":
             return result.mode === "ordinary"
-                ? tellText(result)
+                ? tellText(result, context)
                 : mutationObservationStageText(result.result.id, result.result.observation, context, {
                     ...(result.alias === undefined ? {} : { alias: result.alias }),
                     showLife: false,

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

@@ -140,7 +140,7 @@ export function renderCatalogText(catalog) {
         return renderContractCatalog(catalog);
     if (catalog.kind === "archetypes") {
         return [
-            `archetypes ${catalog.rows.length}`,
+            `available Akuma ${catalog.rows.length}`,
             "",
             ...catalog.rows.flatMap((row) => [
                 `${safeText(row.name)}${row.model === undefined ? "" : ` - ${safeText(row.model)}`}`,

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

@@ -11,6 +11,16 @@ function retryLines(detail, indent, columns) {
     }
     return renderOpaqueBlock(detail.kind, indent, columns);
 }
+function refMigrationConflictRows(lag, columns) {
+    const lines = [];
+    receiptRow(lines, "!", "lag", [
+        {
+            text: `ref-migration-conflict legacy=${lag.legacyRef}@${lag.legacyOid} current=${lag.currentRef}@${lag.currentOid}`,
+            opaque: true,
+        },
+    ], columns);
+    return lines;
+}
 function lagRows(lag, columns) {
     const lines = [];
     if (lag.kind === "worktree-retained") {
@@ -49,6 +59,9 @@ function lagRows(lag, columns) {
         receiptRow(lines, "!", "lag", [{ text: `contract-file-failed ${lag.worktree} ${lag.path}`, opaque: true }], columns);
         receiptPayload(lines, "diagnostic", lag.diagnostic);
     }
+    else if (lag.kind === "ref-migration-conflict") {
+        return refMigrationConflictRows(lag, columns);
+    }
     else {
         receiptRow(lines, "!", "lag", [{ text: `reconcile-failed ${lag.stage}`, opaque: true }], columns);
         receiptPayload(lines, "diagnostic", lag.diagnostic);

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

@@ -1,7 +1,28 @@
 import { visibleFleetRows } from "../../kanshi/fleet.js";
-import { boundedActivity, entityLines, identityLine, plumbFacts, renderSectionBlock, safeText, tone, } from "./terminal.js";
+import { boundedActivity, elapsedMilliseconds, entityLines, identityLine, plumbFacts, RECENT_TONE_MS, renderSectionBlock, safeText, tone, } from "./terminal.js";
 const PLUMB = "  │ ";
 const NARROW_COLUMNS = 72;
+function mostRecentTimestamp(...values) {
+    return values.reduce((latest, value) => {
+        if (value === null || value === undefined)
+            return latest;
+        return latest === null || value > latest ? value : latest;
+    }, null);
+}
+function akumaStatusTone(row, observedAt) {
+    if (row.life === "stillborn" || row.life === "hung" || row.life === "stranded")
+        return "alert";
+    if (row.life === "killed")
+        return "dim";
+    const lifeAt = "lifeAt" in row ? row.lifeAt : null;
+    const lastActivityAt = "lastActivityAt" in row ? row.lastActivityAt : null;
+    const latestAge = elapsedMilliseconds(mostRecentTimestamp(lifeAt, lastActivityAt), observedAt);
+    if (row.life === "asleep")
+        return latestAge !== null && latestAge <= RECENT_TONE_MS ? "recent" : "dim";
+    if (row.life === "running" && latestAge !== null && latestAge <= RECENT_TONE_MS)
+        return "recent";
+    return null;
+}
 function akumaMark(life) {
     return life === "running"
         ? "●"
@@ -48,6 +69,8 @@ function renderAkuma(report, context) {
         return ["AKUMA // unavailable", "", tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
     const rows = visibleFleetRows(section.value.rows);
     const rowLines = rows.map((row) => {
+        const statusTone = akumaStatusTone(row, report.observedAt);
+        const mark = statusTone === null ? akumaMark(row.life) : tone(akumaMark(row.life), statusTone, context.color);
         const lifeAt = "lifeAt" in row ? row.lifeAt : null;
         const life = `${row.life} · ${formatAge(lifeAt, report.observedAt)}`;
         const activity = "lastActivityAt" in row && row.lastActivityAt !== null
@@ -60,16 +83,14 @@ function renderAkuma(report, context) {
         const snapshot = activitySnapshotLine(row);
         const aliases = akumaLabel(row);
         if (context.columns > NARROW_COLUMNS) {
-            const lines = [
-                identityLine(akumaMark(row.life), row.id, `${aliases} · ${[...key, ...relation].join(" · ")}`.trim()),
-            ];
+            const lines = [identityLine(mark, row.id, `${aliases} · ${[...key, ...relation].join(" · ")}`.trim())];
             return snapshot === undefined
                 ? lines
                 : [...lines, ...plumbFacts([boundedActivity(snapshot, context.columns, PLUMB)], context.columns)];
         }
         const identity = aliases.length === 0 ? row.id : `${row.id} ${aliases}`;
         const lines = entityLines({
-            mark: akumaMark(row.life),
+            mark,
             identity,
             state: key[0],
             title: "",

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

@@ -1,8 +1,29 @@
 import { abbreviateGitIds, afterWording, candidateFact, dependentWording, displayGitId, gateFact, gitIdsInRow, mergeSummary, targetMovementFacts, } from "./contract-observation.js";
-import { entityLines, identityLine, plumbFacts, renderTextBlock, renderSectionBlock, safeText, tone, } from "./terminal.js";
+import { entityLines, elapsedMilliseconds, identityLine, plumbFacts, RECENT_TONE_MS, renderTextBlock, renderSectionBlock, safeText, tone, } from "./terminal.js";
 import { akumaMark, endpointFact, formatAge, NARROW_COLUMNS, renderAkuma } from "./kanshi-akuma.js";
 const PLUMB = "  │ ";
 const MAX_VISIBLE_ROWS = 10;
+const REVIEW_ATTENTION_MS = 15 * 60 * 1_000;
+const PENDING_ATTENTION_MS = 60 * 60 * 1_000;
+function contractHasError(row) {
+    return (row.title === null ||
+        row.gates.reports.some((report) => report.current.kind === "attested" && report.current.verdict === "unsatisfied") ||
+        row.targetLag.kind === "unknown" ||
+        row.workspaceObservation.kind === "failed" ||
+        row.workspaceObservation.kind === "unavailable" ||
+        row.issue !== undefined);
+}
+function contractStatusTone(row, observedAt) {
+    if (contractHasError(row))
+        return "alert";
+    const phaseAge = elapsedMilliseconds(row.phaseAt, observedAt);
+    if (row.phase === "tendered" && phaseAge !== null && phaseAge >= REVIEW_ATTENTION_MS)
+        return "attention";
+    if ((row.phase === "waiting" || row.phase === "bound") && phaseAge !== null && phaseAge >= PENDING_ATTENTION_MS)
+        return "attention";
+    const journalAge = elapsedMilliseconds(row.lastJournalAt, observedAt);
+    return journalAge !== null && journalAge <= RECENT_TONE_MS ? "recent" : null;
+}
 function contractMark(row) {
     if (row.phase === "claimed")
         return "✓";
@@ -189,9 +210,10 @@ function namespaceTaskFacts(row) {
 }
 function renderSelectedContractRow(row, report, context, abbreviations) {
     const title = row.title ?? "title unavailable";
+    const statusTone = contractStatusTone(row, report.observedAt);
     const lines = [
         ...entityLines({
-            mark: contractMark(row),
+            mark: statusTone === null ? contractMark(row) : tone(contractMark(row), statusTone, context.color),
             identity: row.id,
             state: `${row.phase} · ${formatAge(row.phaseAt, report.observedAt)}`,
             title,
@@ -255,8 +277,9 @@ function renderWorldContractRow(row, report, context) {
         ...(row.holder.kind === "unavailable" ? ["! task · unavailable"] : []),
         ...(linkedAkumaSummary(row, report) === undefined ? [] : [linkedAkumaSummary(row, report)]),
     ];
+    const statusTone = contractStatusTone(row, report.observedAt);
     return entityLines({
-        mark: contractMark(row),
+        mark: statusTone === null ? contractMark(row) : tone(contractMark(row), statusTone, context.color),
         identity: row.id,
         state: `${row.phase} · ${formatAge(row.lastJournalAt, report.observedAt)}`,
         title,

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

@@ -32,7 +32,10 @@ type CheckoutNotFollowable = Readonly<{
 export declare function checkoutNotFollowableLines(refusal: CheckoutNotFollowable): readonly string[];
 export declare function renderTextBlock(value: string, indent: string, columns: number): readonly string[];
 export declare function renderOpaqueBlock(value: string, indent: string, columns: number): readonly string[];
-export declare function tone(value: string, kind: "dim" | "alert", color: boolean): string;
+export type SemanticTone = "dim" | "recent" | "attention" | "alert";
+export declare const RECENT_TONE_MS: number;
+export declare function elapsedMilliseconds(source: string | null | undefined, observedAt: string): number | null;
+export declare function tone(value: string, kind: SemanticTone, color: boolean): string;
 export declare function boundedActivity(value: string, columns: number, prefix: string): string;
 export declare function plumbFacts(facts: readonly string[], columns: number): readonly string[];
 export declare function identityLine(mark: string, identity: string, extra?: string): string;

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

@@ -188,10 +188,21 @@ export function renderOpaqueBlock(value, indent, columns) {
     }
     return lines;
 }
+export const RECENT_TONE_MS = 5 * 60 * 1_000;
+export function elapsedMilliseconds(source, observedAt) {
+    if (source === null || source === undefined)
+        return null;
+    const sourceMs = Date.parse(source);
+    const observedMs = Date.parse(observedAt);
+    if (!Number.isFinite(sourceMs) || !Number.isFinite(observedMs))
+        return null;
+    return Math.max(0, observedMs - sourceMs);
+}
 export function tone(value, kind, color) {
     if (!color)
         return value;
-    return kind === "dim" ? `\u001b[2m${value}\u001b[0m` : `\u001b[31m${value}\u001b[0m`;
+    const code = kind === "dim" ? 2 : kind === "recent" ? 32 : kind === "attention" ? 33 : 31;
+    return `\u001b[${code}m${value}\u001b[0m`;
 }
 const KANSHI_NARROW_COLUMNS = 72;
 export function boundedActivity(value, columns, prefix) {

package/build/src/cli/runtime.js

@@ -11,7 +11,7 @@ export function invocationStart(command) {
         return "⧖ auditing";
     if (command.command === "reconcile")
         return "⧖ reconciling";
-    return command.command === "install" ? "⧖ installing skills" : undefined;
+    return command.command === "install" ? "⧖ installing harness integrations" : undefined;
 }
 function writeCliStream(stream, body) {
     stream.write(body.endsWith("\n") ? body : `${body}\n`);

package/build/src/git/nuke.js

@@ -3,7 +3,7 @@ import { isAbsolute, relative, sep } from "node:path";
 import { nukeEmptyPlaceAuthority, readPlaceRegister, releaseManagedWorktrees, withPlaceAuthorityFence, } from "../workspace-place.js";
 import { GitPlumbingError, runGit } from "./process.js";
 import { confirmPrivateStatePublication, withPrivateStatePublicationSeat } from "./private-state-seat.js";
-import { CANDIDATE_PIN_REF_NAMESPACE, DELIVERY_REF_NAMESPACE, GIT_REF, MIGRATION_CANDIDATE_PIN_REF_NAMESPACE, MIGRATION_DELIVERY_REF_NAMESPACE, NoGitWorldError, readRef, registeredWorktrees, repositoryAt, worktreeGitDirectory, } from "./repository.js";
+import { CANDIDATE_PIN_REF_NAMESPACE, DELIVERY_REF_NAMESPACE, GIT_REF, LEGACY_CANDIDATE_PIN_REF_NAMESPACE, LEGACY_DELIVERY_REF_NAMESPACE, NoGitWorldError, readRef, registeredWorktrees, repositoryAt, worktreeGitDirectory, } from "./repository.js";
 import { worktreePath } from "./workspace.js";
 async function managedCustody(repository) {
     const register = await readPlaceRegister(repository);
@@ -120,8 +120,8 @@ async function removeOwnedRefs(repository) {
     const roots = [
         DELIVERY_REF_NAMESPACE,
         CANDIDATE_PIN_REF_NAMESPACE,
-        MIGRATION_DELIVERY_REF_NAMESPACE,
-        MIGRATION_CANDIDATE_PIN_REF_NAMESPACE,
+        LEGACY_DELIVERY_REF_NAMESPACE,
+        LEGACY_CANDIDATE_PIN_REF_NAMESPACE,
     ];
     for (const root of roots) {
         const refs = (await runGit(repository, ["for-each-ref", "--format=%(refname)", root]))

package/build/src/git/process.js

@@ -58,10 +58,13 @@ async function executeGit(repository, args, input, environment) {
         inputError = error;
     });
     child.stdin.end(input);
-    const terminal = await new Promise((resolveTerminal) => {
-        child.once("error", (error) => resolveTerminal({ code: null, error }));
-        child.once("close", (code) => resolveTerminal({ code }));
-    });
+    const terminal = await Promise.race([
+        new Promise((resolveTerminal) => {
+            child.once("error", (error) => resolveTerminal({ code: null, error }));
+            child.once("close", (code) => resolveTerminal({ code }));
+        }),
+        owned.terminationFailure,
+    ]);
     await owned.waitTermination();
     const output = Buffer.concat(stdout);
     if (!owned.cancelled() && terminal.code === 0 && inputError === undefined)

package/build/src/git/read-observation.js

@@ -61,7 +61,7 @@ function batchError(child, stderr, message, status) {
 async function closeBatchProcess(process, child, closed, spawnError, stderr) {
     if (!child.stdin.destroyed)
         child.stdin.end();
-    const outcome = await closed;
+    const outcome = await Promise.race([closed, process.terminationFailure]);
     await process.waitTermination();
     if (spawnError !== null || outcome.code !== 0) {
         throw batchError(child, stderr, process.cancelled() ? "git process cancelled" : "git cat-file --batch did not close cleanly", outcome.code);

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

@@ -4,6 +4,7 @@ import type { ContractId, ContractState, SnapshotId } from "../core/facts/types.
 import type { GitDecodeChannel } from "./read-observation.js";
 import { type TargetCheckoutEffect, type TargetCheckoutLag } from "./target-placement.js";
 import { type WorktreeHookLag, type WorktreeHooks } from "./hooks.js";
+import { type RefMigrationConflict } from "./ref-migration.js";
 import type { UnsealedBytes } from "./terminal-seal.js";
 export type Effect = Readonly<{
     kind: "worktree";
@@ -53,7 +54,7 @@ export type ReconcileFailure = Readonly<{
     stage: "observation" | "effect";
     diagnostic: string;
 }>;
-export type ReconcileLag = WorktreeRetained | WorktreeFollowRetained | UnsealedBytes | TargetCheckoutLag | WorktreeHookLag | ReconcileFailure;
+export type ReconcileLag = WorktreeRetained | WorktreeFollowRetained | UnsealedBytes | TargetCheckoutLag | WorktreeHookLag | RefMigrationConflict | ReconcileFailure;
 export type ReconcileResult = Readonly<{
     effects: readonly Effect[];
     lag: readonly ReconcileLag[];

package/build/src/git/reconcile.js

@@ -10,6 +10,7 @@ import { acquireTargetPlacementFence, recoverTargetPlacement, } from "./target-p
 import { runCreateHooks } from "./hooks.js";
 import { followDependentManagedWorktree, followManagedWorktree, worktreePath } from "./workspace.js";
 import { removeCollectableScratchWorktrees } from "./scratch.js";
+import { migrateContractCustodyRefs } from "./ref-migration.js";
 import { reconcileTerminalManagedWorktree, removeRef, updateRef } from "./terminal-reconcile.js";
 const pathExists = (path) => access(path).then(() => true, () => false);
 function deliveryRefFor(contract) {
@@ -151,6 +152,11 @@ async function reconcileWithTopology(input, state, topology) {
         await removeCollectableScratch(repository, topology, effects, lag);
         if (!state)
             return complete(effects, lag);
+        const migration = await migrateContractCustodyRefs(repository, state.id);
+        effects.push(...migration.effects);
+        lag.push(...migration.lag);
+        if (migration.lag.length > 0)
+            return complete(effects, lag);
         const targetCheckouts = await reconcileTargetCheckouts(repository, state);
         effects.push(...targetCheckouts.effects);
         lag.push(...targetCheckouts.lag);

package/build/src/git/ref-migration.d.ts

@@ -0,0 +1,22 @@
+import type { ContractId } from "../core/facts/types.js";
+import { type GitRepository } from "./process.js";
+import { type GitOid } from "./repository.js";
+export type RefMigrationEffect = Readonly<{
+    kind: "ref";
+    name: string;
+    before: GitOid | null;
+    after: GitOid | null;
+    action: "created" | "removed";
+}>;
+export type RefMigrationConflict = Readonly<{
+    kind: "ref-migration-conflict";
+    legacyRef: string;
+    legacyOid: GitOid;
+    currentRef: string;
+    currentOid: GitOid;
+}>;
+export type RefMigrationResult = Readonly<{
+    effects: readonly RefMigrationEffect[];
+    lag: readonly RefMigrationConflict[];
+}>;
+export declare function migrateContractCustodyRefs(repository: GitRepository, contract: ContractId): Promise<RefMigrationResult>;

package/build/src/git/ref-migration.js

@@ -0,0 +1,55 @@
+import { contractPhysicalName } from "./identity.js";
+import { runGit } from "./process.js";
+import { CANDIDATE_PIN_REF_NAMESPACE, DELIVERY_REF_NAMESPACE, LEGACY_CANDIDATE_PIN_REF_NAMESPACE, LEGACY_DELIVERY_REF_NAMESPACE, readRef, } from "./repository.js";
+export async function migrateContractCustodyRefs(repository, contract) {
+    const leaf = contractPhysicalName(contract);
+    const pairs = [
+        {
+            legacy: `${LEGACY_DELIVERY_REF_NAMESPACE}/${leaf}`,
+            current: `${DELIVERY_REF_NAMESPACE}/${leaf}`,
+        },
+        {
+            legacy: `${LEGACY_CANDIDATE_PIN_REF_NAMESPACE}/${leaf}`,
+            current: `${CANDIDATE_PIN_REF_NAMESPACE}/${leaf}`,
+        },
+    ];
+    const observed = await Promise.all(pairs.map(async (pair) => {
+        const [legacyOid, currentOid] = await Promise.all([
+            readRef(repository, pair.legacy),
+            readRef(repository, pair.current),
+        ]);
+        return { ...pair, legacyOid, currentOid };
+    }));
+    const lag = observed.flatMap((pair) => pair.legacyOid !== null && pair.currentOid !== null && pair.currentOid !== pair.legacyOid
+        ? [
+            {
+                kind: "ref-migration-conflict",
+                legacyRef: pair.legacy,
+                legacyOid: pair.legacyOid,
+                currentRef: pair.current,
+                currentOid: pair.currentOid,
+            },
+        ]
+        : []);
+    if (lag.length > 0)
+        return { effects: [], lag };
+    const migrating = observed.filter((pair) => pair.legacyOid !== null);
+    if (migrating.length === 0)
+        return { effects: [], lag: [] };
+    const lines = ["start"];
+    const effects = [];
+    for (const pair of migrating) {
+        if (pair.currentOid === null) {
+            lines.push(`create ${pair.current} ${pair.legacyOid}`);
+            effects.push({ kind: "ref", name: pair.current, before: null, after: pair.legacyOid, action: "created" });
+        }
+        else {
+            lines.push(`verify ${pair.current} ${pair.currentOid}`);
+        }
+        lines.push(`delete ${pair.legacy} ${pair.legacyOid}`);
+        effects.push({ kind: "ref", name: pair.legacy, before: pair.legacyOid, after: null, action: "removed" });
+    }
+    lines.push("prepare", "commit", "");
+    await runGit(repository, ["update-ref", "--stdin", "--no-deref"], lines.join("\n"));
+    return { effects, lag: [] };
+}

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

@@ -2,10 +2,10 @@ import { type GitRepository } from "./process.js";
 import { type TreeChange, type TreeEntry } from "./tree.js";
 export type { TreeChange } from "./tree.js";
 export declare const GIT_REF = "refs/heads/keiyaku-state";
-export declare const DELIVERY_REF_NAMESPACE = "refs/heads/keiyaku-delivery";
-export declare const CANDIDATE_PIN_REF_NAMESPACE = "refs/heads/keiyaku-candidate";
-export declare const MIGRATION_DELIVERY_REF_NAMESPACE = "refs/keiyaku/delivery";
-export declare const MIGRATION_CANDIDATE_PIN_REF_NAMESPACE = "refs/keiyaku/candidate";
+export declare const DELIVERY_REF_NAMESPACE = "refs/keiyaku/delivery";
+export declare const CANDIDATE_PIN_REF_NAMESPACE = "refs/keiyaku/candidate";
+export declare const LEGACY_DELIVERY_REF_NAMESPACE = "refs/heads/keiyaku-delivery";
+export declare const LEGACY_CANDIDATE_PIN_REF_NAMESPACE = "refs/heads/keiyaku-candidate";
 export declare const GIT_FORMAT_PATH = "meta/format.json";
 export declare const GIT_FORMAT_BYTES = "{\"version\":4}\n";
 export declare const STATE_COMMIT_SUBJECT = "keiyaku authority - do not delete or rewrite";

package/build/src/git/repository.js

@@ -5,10 +5,10 @@ import { gitObjectId } from "./identity.js";
 import { GitPlumbingError, runGit, runGitWithEnvironment } from "./process.js";
 import { parseTreeObject, prepareTreeUpdate, treeUpdate, validPath, } from "./tree.js";
 export const GIT_REF = "refs/heads/keiyaku-state";
-export const DELIVERY_REF_NAMESPACE = "refs/heads/keiyaku-delivery";
-export const CANDIDATE_PIN_REF_NAMESPACE = "refs/heads/keiyaku-candidate";
-export const MIGRATION_DELIVERY_REF_NAMESPACE = "refs/keiyaku/delivery";
-export const MIGRATION_CANDIDATE_PIN_REF_NAMESPACE = "refs/keiyaku/candidate";
+export const DELIVERY_REF_NAMESPACE = "refs/keiyaku/delivery";
+export const CANDIDATE_PIN_REF_NAMESPACE = "refs/keiyaku/candidate";
+export const LEGACY_DELIVERY_REF_NAMESPACE = "refs/heads/keiyaku-delivery";
+export const LEGACY_CANDIDATE_PIN_REF_NAMESPACE = "refs/heads/keiyaku-candidate";
 export const GIT_FORMAT_PATH = "meta/format.json";
 const CURRENT_FORMAT_VERSION = 4;
 export const GIT_FORMAT_BYTES = `{"version":${CURRENT_FORMAT_VERSION}}\n`;
@@ -19,10 +19,10 @@ export function isKeiyakuOwnedRef(ref) {
         ref.startsWith(`${DELIVERY_REF_NAMESPACE}/`) ||
         ref === CANDIDATE_PIN_REF_NAMESPACE ||
         ref.startsWith(`${CANDIDATE_PIN_REF_NAMESPACE}/`) ||
-        ref === MIGRATION_DELIVERY_REF_NAMESPACE ||
-        ref.startsWith(`${MIGRATION_DELIVERY_REF_NAMESPACE}/`) ||
-        ref === MIGRATION_CANDIDATE_PIN_REF_NAMESPACE ||
-        ref.startsWith(`${MIGRATION_CANDIDATE_PIN_REF_NAMESPACE}/`));
+        ref === LEGACY_DELIVERY_REF_NAMESPACE ||
+        ref.startsWith(`${LEGACY_DELIVERY_REF_NAMESPACE}/`) ||
+        ref === LEGACY_CANDIDATE_PIN_REF_NAMESPACE ||
+        ref.startsWith(`${LEGACY_CANDIDATE_PIN_REF_NAMESPACE}/`));
 }
 export class NoGitWorldError extends Error {
     path;