@astrosheep/keiyaku 1.0.1 → 1.0.2

package/build/core/queue_v2.js

@@ -0,0 +1,342 @@
+import { createHash } from "node:crypto";
+import { FlowError } from "../flow-error.js";
+import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
+import { listContractIds, readLedger } from "./ledger.js";
+import { commissionTarget, deriveContractState } from "./status.js";
+const EMPTY_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+const MISSING_REF_SENTINEL = "0".repeat(40);
+const ISO_UTC_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+function isPositiveSafeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+function isCurrentPetitionData(data) {
+    return "target" in data && "seat" in data;
+}
+function latestPetition(entries) {
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (entry.kind === "petition")
+            return entry;
+    }
+    return undefined;
+}
+export function deriveQueueReadModel(ledgers) {
+    const seatsByContract = new Map();
+    const diagnosticsByContract = new Map();
+    const orderedByTarget = new Map();
+    for (const ledger of ledgers) {
+        if (deriveContractState(ledger.entries).state !== "petitioned")
+            continue;
+        const petition = latestPetition(ledger.entries);
+        if (!petition)
+            continue;
+        const derived = commissionTarget(ledger.entries);
+        if (!derived)
+            continue;
+        const diagnostics = [];
+        let seat;
+        if (isCurrentPetitionData(petition.data)) {
+            seat = {
+                contract: ledger.contractId,
+                target: petition.data.target,
+                seat: petition.data.seat,
+                legacy: false,
+            };
+            if (petition.data.target !== derived.ref) {
+                diagnostics.push({
+                    kind: "target-mismatch",
+                    petitioned: petition.data.target,
+                    derived: derived.ref,
+                });
+            }
+            const bucket = orderedByTarget.get(petition.data.target) ?? [];
+            bucket.push(seat);
+            orderedByTarget.set(petition.data.target, bucket);
+        }
+        else {
+            seat = {
+                contract: ledger.contractId,
+                target: derived.ref,
+                seat: null,
+                legacy: true,
+            };
+            diagnostics.push({ kind: "legacy-petition" });
+        }
+        seatsByContract.set(ledger.contractId, seat);
+        diagnosticsByContract.set(ledger.contractId, diagnostics);
+    }
+    for (const [target, seats] of orderedByTarget) {
+        const bySeat = new Map();
+        for (const seat of seats) {
+            if (seat.seat === null)
+                continue;
+            const group = bySeat.get(seat.seat) ?? [];
+            group.push(seat);
+            bySeat.set(seat.seat, group);
+        }
+        for (const [seatNumber, group] of bySeat) {
+            if (group.length < 2)
+                continue;
+            const sorted = [...group].sort((a, b) => a.contract.localeCompare(b.contract));
+            for (const member of sorted) {
+                const others = sorted.filter((other) => other.contract !== member.contract);
+                const existing = diagnosticsByContract.get(member.contract) ?? [];
+                for (const other of others) {
+                    existing.push({ kind: "duplicate-seat", seat: seatNumber, with: other.contract });
+                }
+                diagnosticsByContract.set(member.contract, existing);
+            }
+        }
+        seats.sort((a, b) => {
+            const seatA = a.seat ?? Number.POSITIVE_INFINITY;
+            const seatB = b.seat ?? Number.POSITIVE_INFINITY;
+            if (seatA !== seatB)
+                return seatA - seatB;
+            return a.contract.localeCompare(b.contract);
+        });
+        orderedByTarget.set(target, seats);
+    }
+    const targetQueues = [...orderedByTarget.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([target, ordered]) => ({ target, ordered }));
+    return {
+        targetQueues,
+        seatsByContract,
+        diagnosticsByContract,
+    };
+}
+export async function readQueueReadModel(cwd) {
+    const contractIds = await listContractIds(cwd);
+    const ledgers = [];
+    for (const id of contractIds) {
+        const ledger = await readLedger(cwd, id);
+        if (ledger)
+            ledgers.push(ledger);
+    }
+    return deriveQueueReadModel(ledgers);
+}
+export function queueMembership(model, contractId) {
+    const seat = model.seatsByContract.get(contractId);
+    if (!seat)
+        return undefined;
+    const diagnostics = model.diagnosticsByContract.get(contractId) ?? [];
+    if (seat.legacy) {
+        return {
+            seat,
+            position: null,
+            queueLength: 0,
+            queueHead: null,
+            diagnostics,
+        };
+    }
+    const targetQueue = model.targetQueues.find((queue) => queue.target === seat.target);
+    if (!targetQueue) {
+        return {
+            seat,
+            position: null,
+            queueLength: 0,
+            queueHead: null,
+            diagnostics,
+        };
+    }
+    const index = targetQueue.ordered.findIndex((entry) => entry.contract === contractId);
+    const position = index < 0 ? null : index + 1;
+    return {
+        seat,
+        position,
+        queueLength: targetQueue.ordered.length,
+        queueHead: targetQueue.ordered[0]?.contract ?? null,
+        diagnostics,
+    };
+}
+export function assertClaimQueueHead(model, contractId) {
+    const membership = queueMembership(model, contractId);
+    if (!membership) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is not queue head; position=not queued`);
+    }
+    if (membership.seat.legacy) {
+        throw new FlowError("QUEUE_LEGACY_PETITION", `contract ${contractId} petitioned before seat law took effect; reject its petition and petition again`);
+    }
+    const mismatch = membership.diagnostics.find((diagnostic) => diagnostic.kind === "target-mismatch");
+    if (mismatch && mismatch.kind === "target-mismatch") {
+        throw new FlowError("QUEUE_TARGET_MISMATCH", `contract ${contractId} petition target ${mismatch.petitioned} disagrees with derived target ${mismatch.derived}; reject its petition and petition again`);
+    }
+    if (membership.position !== 1) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is not queue head; position=${membership.position ?? "not queued"}`);
+    }
+    return membership;
+}
+export function seatAllocatorRef(target) {
+    const digest = createHash("sha256").update(target, "utf8").digest("hex");
+    return `refs/keiyaku/seat/${digest}`;
+}
+async function resolveRefHeadRaw(cwd, ref) {
+    const git = createGit(cwd);
+    try {
+        // Raw observed-head read: any existing Git object id, not commit-only.
+        // Non-commit heads are returned so parseAllocatorChain can classify them as corrupt.
+        return (await git.raw(["rev-parse", "--verify", ref])).trim();
+    }
+    catch (error) {
+        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
+            return null;
+        throw wrapGitError(`rev-parse ${ref}`, error, cwd);
+    }
+}
+async function readCommitMessage(cwd, commit) {
+    const git = createGit(cwd);
+    try {
+        return await git.raw(["show", "-s", "--format=%B", commit]);
+    }
+    catch (error) {
+        throw wrapGitError(`show commit message ${commit}`, error, cwd);
+    }
+}
+function parseSeatAllocatorMessage(message, expectedTarget) {
+    const normalized = message.replace(/\r\n/g, "\n");
+    const separatorIndex = normalized.indexOf("\n\n");
+    if (separatorIndex < 0)
+        throw new Error("missing blank line");
+    const subject = normalized.slice(0, separatorIndex).trim();
+    const body = normalized.slice(separatorIndex + 2).trim();
+    const parsed = JSON.parse(body);
+    const keys = Object.keys(parsed).sort();
+    if (keys.join(",") !== "actor,at,seat,target,v")
+        throw new Error("unexpected fields");
+    if (parsed.v !== 1)
+        throw new Error("bad version");
+    if (typeof parsed.target !== "string" || parsed.target !== expectedTarget)
+        throw new Error("target mismatch");
+    if (!isPositiveSafeInteger(parsed.seat))
+        throw new Error("bad seat");
+    if (typeof parsed.at !== "string" || !ISO_UTC_RE.test(parsed.at))
+        throw new Error("bad at");
+    if (typeof parsed.actor !== "string" || parsed.actor.trim().length === 0)
+        throw new Error("bad actor");
+    if (subject !== `keiyaku seat: ${parsed.seat}`)
+        throw new Error("bad subject");
+    return {
+        v: 1,
+        target: parsed.target,
+        seat: parsed.seat,
+        at: parsed.at,
+        actor: parsed.actor,
+    };
+}
+async function parseAllocatorChain(cwd, head, expectedTarget) {
+    const git = createGit(cwd);
+    let output;
+    try {
+        output = await git.raw(["rev-list", "--reverse", head]);
+    }
+    catch {
+        return null;
+    }
+    const commits = output
+        .trim()
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (commits.length === 0)
+        return null;
+    const entries = [];
+    let previousSeat = 0;
+    for (const commit of commits) {
+        try {
+            const entry = parseSeatAllocatorMessage(await readCommitMessage(cwd, commit), expectedTarget);
+            if (entry.seat <= previousSeat)
+                return null;
+            previousSeat = entry.seat;
+            entries.push(entry);
+        }
+        catch {
+            return null;
+        }
+    }
+    return { entries, lastSeat: previousSeat };
+}
+async function ledgerSeatFloor(cwd, target) {
+    const contractIds = await listContractIds(cwd);
+    let maxSeat = 0;
+    for (const id of contractIds) {
+        const ledger = await readLedger(cwd, id);
+        if (!ledger)
+            continue;
+        for (const entry of ledger.entries) {
+            if (entry.kind !== "petition")
+                continue;
+            if (!isCurrentPetitionData(entry.data))
+                continue;
+            if (entry.data.target !== target)
+                continue;
+            if (entry.data.seat > maxSeat)
+                maxSeat = entry.data.seat;
+        }
+    }
+    return maxSeat;
+}
+async function createSeatCommit(cwd, entry, parentHead) {
+    const git = createGit(cwd);
+    const subject = `keiyaku seat: ${entry.seat}`;
+    const args = ["commit-tree", EMPTY_TREE_HASH];
+    if (parentHead)
+        args.push("-p", parentHead);
+    args.push("-m", subject, "-m", JSON.stringify(entry, null, 2));
+    try {
+        return (await git.raw(args)).trim();
+    }
+    catch (error) {
+        throw wrapGitError(`commit-tree seat ${entry.seat}`, error, cwd);
+    }
+}
+async function casUpdateRef(cwd, ref, newHead, expectedOld) {
+    const git = createGit(cwd);
+    const oldValue = expectedOld ?? MISSING_REF_SENTINEL;
+    try {
+        await git.raw(["update-ref", ref, newHead, oldValue]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function allocateSettlementSeat(cwd, input) {
+    const ref = seatAllocatorRef(input.target);
+    const maxRetries = 3;
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+        const observedHead = await resolveRefHeadRaw(cwd, ref);
+        const floor = await ledgerSeatFloor(cwd, input.target);
+        const parsed = observedHead ? await parseAllocatorChain(cwd, observedHead, input.target) : null;
+        const healthy = parsed !== null && parsed.lastSeat >= floor;
+        let seat;
+        let parent;
+        let expectedOld;
+        if (healthy && parsed) {
+            seat = parsed.lastSeat + 1;
+            parent = observedHead;
+            expectedOld = observedHead;
+        }
+        else {
+            // Missing, parse failure, target mismatch, non-monotonic, or stale-behind-ledger:
+            // mint a detached no-parent root at floor+1. Leave the bad chain for Git GC.
+            seat = floor + 1;
+            parent = null;
+            expectedOld = observedHead;
+        }
+        if (!isPositiveSafeInteger(seat)) {
+            throw new FlowError("INTERNAL_STATE", `settlement seats exhausted for ${input.target}`);
+        }
+        const entry = {
+            v: 1,
+            target: input.target,
+            seat,
+            at: input.at,
+            actor: input.actor,
+        };
+        const newHead = await createSeatCommit(cwd, entry, parent);
+        const casOk = await casUpdateRef(cwd, ref, newHead, expectedOld);
+        if (casOk)
+            return { head: newHead, seat };
+    }
+    throw new FlowError("INTERNAL_STATE", `failed to allocate settlement seat for ${input.target}`);
+}

package/build/core/registry.js

@@ -1,7 +1,7 @@
 import { FlowError } from "../flow-error.js";
 import { readLedger } from "./ledger.js";
 import { appendRefLogWithRetry } from "./ref-log.js";
-import { patternsOverlap } from "./scope.js";
+import { isNegativeScopePattern, patternsOverlap } from "./scope.js";
 import { deriveContractState, isTerminalState } from "./status.js";
 export const REGISTRY_REF = "refs/keiyaku/registry";
 function parseRegistryEntry(message) {
@@ -52,12 +52,15 @@ export async function registerScope(cwd, input) {
             if (existing.tree === input.tree) {
                 throw new FlowError("ACTIVE_KEIYAKU_EXISTS", [
                     `tree is already occupied by active contract ${existing.contract}`,
-                    "Use `keiyaku bind --worktree ...` to allocate a separate workspace.",
-                    `Or run \`keiyaku forfeit @${existing.contract}\` to free this tree.`,
+                    `Run \`keiyaku forfeit @${existing.contract}\` to free this tree.`,
                 ].join(" "));
             }
             for (const nextPattern of input.scope) {
+                if (isNegativeScopePattern(nextPattern))
+                    continue;
                 for (const existingPattern of existing.scope) {
+                    if (isNegativeScopePattern(existingPattern))
+                        continue;
                     if (patternsOverlap(nextPattern, existingPattern)) {
                         nextWarnings.push(`▲ scope overlaps registered active contract ${existing.contract}: ${nextPattern} overlaps ${existingPattern}; consider --after ${existing.contract}`);
                     }

package/build/core/render.js

@@ -69,6 +69,43 @@ function renderSealFacts(entry) {
         ]),
     ];
 }
+function bootstrapTimeoutMs(entries) {
+    const bind = entries.find((entry) => entry.kind === "bind");
+    return bind?.data.bootstrap?.timeoutMs;
+}
+function renderBootstrapFacts(entry, entries) {
+    const duration = `duration ${entry.data.durationMs}ms`;
+    let first;
+    switch (entry.data.result.kind) {
+        case "exit":
+            first = joinFactClusters([`exit ${entry.data.result.code}`, duration]);
+            break;
+        case "signal":
+            first = joinFactClusters([`signal ${entry.data.result.signal}`, duration]);
+            break;
+        case "timeout": {
+            const timeoutMs = bootstrapTimeoutMs(entries);
+            first =
+                timeoutMs === undefined
+                    ? joinFactClusters([`timeout`, duration])
+                    : joinFactClusters([`timeout ${timeoutMs}ms`, duration]);
+            break;
+        }
+        case "spawn":
+            first = joinFactClusters([
+                "spawn error",
+                compactWhitespace(entry.data.result.message),
+                duration,
+            ]);
+            break;
+    }
+    const facts = [first];
+    if (entry.data.stderrTail !== undefined) {
+        const tail = compactWhitespace(entry.data.stderrTail);
+        facts.push(entry.data.stderrTruncated ? `┆ stderr …${tail}` : `┆ stderr ${tail}`);
+    }
+    return facts;
+}
 function renderEventFacts(entry, entries) {
     switch (entry.kind) {
         case "bind":
@@ -81,6 +118,8 @@ function renderEventFacts(entry, entries) {
                     entry.data.after && entry.data.after.length > 0 ? `after ${entry.data.after.length}` : null,
                 ]),
             ];
+        case "bootstrap":
+            return renderBootstrapFacts(entry, entries);
         case "arc":
             return [renderOpenArcFact(entry)];
         case "seal":
@@ -261,6 +300,10 @@ export function projectionGlyph(state) {
             return "✕";
         case "minting":
             return "…";
+        case "startup-timeout":
+            return "!";
+        case "unknown":
+            return "?";
     }
 }
 function renderDriftMark(drift) {
@@ -273,9 +316,14 @@ function renderDriftMark(drift) {
 export function renderKanshiBoard(status) {
     const head = shortHead(status.defaultHead);
     if (status.contracts.length === 0) {
+        if (status.targetFilter !== null) {
+            return `現世 ${head} · target ${status.targetFilter}\nno commissions on target ${status.targetFilter}\n`;
+        }
         return `現世 ${head} 无在飞契约\n`;
     }
-    const header = `現世 ${head}`;
+    const header = status.targetFilter !== null
+        ? `現世 ${head} · target ${status.targetFilter}`
+        : `現世 ${head}`;
     const lines = [header, ""];
     for (const contract of status.contracts) {
         const glyph = kanshiGlyph(contract);
@@ -321,6 +369,20 @@ export function renderKanshiBoard(status) {
         const sparkCol = spark.padEnd(14);
         const factText = facts.join(" · ");
         lines.push(`${glyph} ${name.padEnd(18)} ${sparkCol} ${factText}`.trimEnd());
+        if (contract.bootstrapDiagnostics.some((diagnostic) => diagnostic.kind === "plan-without-result")) {
+            lines.push("  ! bootstrap · no result recorded · forfeit and re-bind");
+        }
+        for (const diagnostic of contract.queueDiagnostics) {
+            if (diagnostic.kind === "legacy-petition") {
+                lines.push("  ! legacy petition · no seat · reject then re-petition");
+                continue;
+            }
+            if (diagnostic.kind === "duplicate-seat") {
+                lines.push(`  ! seat ${diagnostic.seat} duplicated with ${diagnostic.with} · ordered by contract id`);
+                continue;
+            }
+            lines.push(`  ! target mismatch · petitioned ${diagnostic.petitioned} · derived ${diagnostic.derived}`);
+        }
     }
     return `${lines.join("\n")}\n`;
 }

package/build/core/renew.js

@@ -1,16 +1,16 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { FlowError } from "../flow-error.js";
-import { createGit, errorContainsAnyPattern, wrapGitError } from "../git/core.js";
+import { createGit, errorContainsAnyPattern, MISSING_HEAD_PATTERNS, wrapGitError } from "../git/core.js";
 import { KEIYAKU_FILE } from "../keiyaku.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
 import { readProjectionStatusBoard } from "./projection-status.js";
 import { renderContractView } from "./render.js";
 import { captureSeal, findOpenArc, receiptsAfterFence, sealOpenArc } from "./seal.js";
-import { deriveContractState, isTerminalState, latestBase, resolveDefaultBranch } from "./status.js";
+import { commissionTarget, deriveContractState, isTerminalState, latestBase } from "./status.js";
 import { findContractWorktreePath } from "./worktree-path.js";
 import { getCurrentBranch, isGitRepo } from "../git/branches.js";
-import { resolveCurrentContractId } from "./context.js";
+import { resolveContractAddress, withResolvedAddress } from "./addressing.js";
 import { ACTOR_IDENTITY } from "../keiyaku.js";
 import { persistResponseHistory } from "./transcripts.js";
 function assertOperable(contractId, entries) {
@@ -31,6 +31,17 @@ async function resolveCommit(cwd, rev) {
         throw wrapGitError(`rev-parse ${rev}`, error, cwd);
     }
 }
+async function resolveCommitOrNull(cwd, rev) {
+    const git = createGit(cwd);
+    try {
+        return (await git.raw(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
+    }
+    catch (error) {
+        if (errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS))
+            return null;
+        throw wrapGitError(`rev-parse ${rev}`, error, cwd);
+    }
+}
 async function renderUpdatedContract(ledgerCwd, renderCwd, contractId) {
     const ledger = await readLedger(ledgerCwd, contractId);
     if (!ledger) {
@@ -61,7 +72,8 @@ async function rewriteBranch(cwd, newBase, oldBase, branch) {
 }
 function assertNoInFlightProjection(cwd, contractId, nowMs) {
     const board = readProjectionStatusBoard(cwd, nowMs);
-    if (!board?.rows.some((row) => row.state === "out"))
+    const unsafe = new Set(["out", "minting", "startup-timeout", "unknown"]);
+    if (!board?.rows.some((row) => unsafe.has(row.state)))
         return;
     throw new FlowError("INTERNAL_STATE", `akuma still out on ${contractId}'s worktree; rewriting under it would strand its work`, { hints: ["keiyaku status — watch for the akuma to land, then renew"] });
 }
@@ -76,26 +88,31 @@ export async function renewContract(input) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
     }
     assertOperable(input.contractId, ledger.entries);
-    const target = await resolveDefaultBranch(input.cwd);
-    if (!target)
-        throw new FlowError("INTERNAL_STATE", `cannot renew ${input.contractId}: no default branch`);
+    const commission = commissionTarget(ledger.entries);
+    if (!commission) {
+        throw new FlowError("INTERNAL_STATE", `cannot renew ${input.contractId}: missing commission target`);
+    }
+    const targetHead = await resolveCommitOrNull(input.cwd, commission.ref);
+    if (!targetHead) {
+        throw new FlowError("INTERNAL_STATE", `cannot renew ${input.contractId}: commission target ${commission.ref} does not resolve`);
+    }
     const oldBase = latestBase(ledger.entries);
     if (!oldBase)
         throw new FlowError("INTERNAL_STATE", "ledger must contain bind entry");
     const branch = `keiyaku/${input.contractId}`;
     const oldHead = await resolveCommit(input.cwd, branch);
     const open = findOpenArc(ledger.entries);
-    const capture = open ? await captureSeal(input.cwd, ledger.entries, oldHead) : null;
+    const capture = open ? await captureSeal(input.cwd, ledger.entries, oldHead, input.waivePaths) : null;
     if (!open) {
         const loose = await receiptsAfterFence(input.cwd, ledger.entries, oldHead);
         if (loose.length > 0)
             throw looseCommitError(input.contractId, loose);
     }
-    if (oldBase === target.head) {
+    if (oldBase === targetHead) {
         return {
             contractId: input.contractId,
             oldBase,
-            newBase: target.head,
+            newBase: targetHead,
             oldHead,
             newHead: oldHead,
             ledgerHead: ledger.head,
@@ -106,7 +123,7 @@ export async function renewContract(input) {
     const worktreePath = await findContractWorktreePath(input.cwd, input.contractId);
     const rewriteCwd = worktreePath ?? input.cwd;
     assertNoInFlightProjection(rewriteCwd, input.contractId, input.nowMs);
-    await rewriteBranch(rewriteCwd, target.head, oldBase, worktreePath ? undefined : branch);
+    await rewriteBranch(rewriteCwd, targetHead, oldBase, worktreePath ? undefined : branch);
     const newHead = await resolveCommit(input.cwd, branch);
     const sealed = await sealOpenArc({
         cwd: input.cwd,
@@ -128,7 +145,7 @@ export async function renewContract(input) {
             contract: input.contractId,
             at,
             actor: input.actor,
-            data: { oldBase, newBase: target.head, oldHead, newHead },
+            data: { oldBase, newBase: targetHead, oldHead, newHead },
         };
     });
     if (!result.ok) {
@@ -138,7 +155,7 @@ export async function renewContract(input) {
     return {
         contractId: input.contractId,
         oldBase,
-        newBase: target.head,
+        newBase: targetHead,
         oldHead,
         newHead,
         ledgerHead: result.head,
@@ -150,46 +167,56 @@ export async function renewKeiyaku(input) {
     if (!(await isGitRepo(input.cwd))) {
         throw new FlowError("NOT_GIT_REPO", `${input.cwd} is not a git repository`);
     }
-    const resolution = input.contractId ? undefined : await resolveCurrentContractId(input.cwd);
-    if (resolution?.status === "none")
-        throw new FlowError("EMPTY_PARAM", "no active contract found");
-    const contractId = input.contractId ?? resolution.contractId;
-    const renewed = await renewContract({ cwd: input.cwd, contractId, ...{ actor: ACTOR_IDENTITY, nowMs: Date.now() } });
-    const currentBranch = await getCurrentBranch(input.cwd);
-    const target = await resolveDefaultBranch(input.cwd);
-    const diff = renewed.sealed?.incrementalDiff ?? "nothing sealed";
-    const summary = renewed.alreadyFresh
-        ? `Contract ${contractId} is already fresh; nothing touched.`
-        : `Contract ${contractId} renewed onto ${renewed.newBase}.`;
-    let responsePath;
-    try {
-        responsePath = await persistResponseHistory({
+    const address = input.address ?? await resolveContractAddress(input.cwd, input.contractId, input.contractAddressSource);
+    return await withResolvedAddress(address, async () => {
+        const contractId = address.binding.commissionId;
+        const renewed = await renewContract({
             cwd: input.cwd,
-            tool: "renew",
-            title: contractId,
-            branch: currentBranch,
-            commit: renewed.ledgerHead,
-            oldBase: renewed.oldBase,
-            newBase: renewed.newBase,
-            oldHead: renewed.oldHead,
-            newHead: renewed.newHead,
-            ledgerCommit: renewed.ledgerHead,
-            summary,
-            diff,
-            ...(renewed.sealed ? { sealed: renewed.sealed } : {}),
+            contractId,
+            actor: ACTOR_IDENTITY,
+            nowMs: Date.now(),
+            waivePaths: input.waivePaths,
         });
-    }
-    catch {
-        responsePath = undefined;
-    }
-    return {
-        status: "success",
-        ...renewed,
-        currentBranch,
-        baseBranch: target?.branch ?? currentBranch,
-        diff,
-        sealed: renewed.sealed ?? undefined,
-        summary,
-        responsePath,
-    };
+        const currentBranch = await getCurrentBranch(input.cwd);
+        const baseBranch = address.target.branch.slice("refs/heads/".length);
+        const diff = renewed.sealed?.incrementalDiff ?? "nothing sealed";
+        const summary = renewed.alreadyFresh
+            ? `Contract ${contractId} is already fresh; nothing touched.`
+            : `Contract ${contractId} renewed onto ${renewed.newBase}.`;
+        let responsePath;
+        let artifactId;
+        try {
+            const persisted = await persistResponseHistory({
+                cwd: input.cwd,
+                tool: "renew",
+                provenance: { authority: { kind: "repository" }, binding: address.binding, evidenceCwd: input.cwd },
+                title: contractId,
+                oldBase: renewed.oldBase,
+                newBase: renewed.newBase,
+                oldHead: renewed.oldHead,
+                newHead: renewed.newHead,
+                ledgerCommit: renewed.ledgerHead,
+                summary,
+                diff,
+                ...(renewed.sealed ? { sealed: renewed.sealed } : {}),
+            });
+            responsePath = persisted.responsePath;
+            artifactId = persisted.artifactId;
+        }
+        catch {
+            responsePath = undefined;
+        }
+        return {
+            status: "success",
+            ...renewed,
+            currentBranch,
+            baseBranch,
+            diff,
+            sealed: renewed.sealed ?? undefined,
+            summary,
+            responsePath,
+            artifactId,
+            address,
+        };
+    });
 }