@astrosheep/keiyaku 0.1.87 → 1.0.0

package/build/core/registry.js

@@ -0,0 +1,96 @@
+import { FlowError } from "../flow-error.js";
+import { readLedger } from "./ledger.js";
+import { appendRefLogWithRetry } from "./ref-log.js";
+import { patternsOverlap } from "./scope.js";
+import { deriveContractState, isTerminalState } from "./status.js";
+export const REGISTRY_REF = "refs/keiyaku/registry";
+function parseRegistryEntry(message) {
+    const body = message.slice(message.indexOf("\n\n") + 2).trim();
+    const parsed = JSON.parse(body);
+    if (parsed.v !== 1 || !parsed.contract || !["register", "release", "repair"].includes(parsed.kind)) {
+        throw new FlowError("INTERNAL_STATE", `invalid registry entry for ${REGISTRY_REF}`);
+    }
+    return parsed;
+}
+function registrySubject(entry) {
+    return `keiyaku registry: ${entry.kind} ${entry.contract}`;
+}
+async function isActiveNonTerminal(cwd, contractId) {
+    const ledger = await readLedger(cwd, contractId);
+    if (!ledger)
+        return false;
+    const state = deriveContractState(ledger.entries);
+    return state.state !== "corrupt" && !isTerminalState(state);
+}
+async function activeRegistrations(cwd, entries) {
+    const released = new Set(entries.filter((entry) => entry.kind === "release").map((entry) => entry.contract));
+    const registrations = new Map();
+    for (const entry of entries) {
+        if (entry.kind === "register" && !released.has(entry.contract)) {
+            registrations.set(entry.contract, { scope: entry.scope, tree: entry.tree });
+        }
+    }
+    const active = [];
+    for (const [contract, registration] of registrations) {
+        if (await isActiveNonTerminal(cwd, contract))
+            active.push({ contract, scope: registration.scope, tree: registration.tree });
+    }
+    return active;
+}
+export async function registerScope(cwd, input) {
+    let warnings = [];
+    const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, async (entries) => {
+        const nextWarnings = [];
+        const active = await activeRegistrations(cwd, entries);
+        if (input.exclusive && active.length > 0) {
+            const blocking = active.find((existing) => existing.contract !== input.contractId) ?? active[0];
+            throw new FlowError("ACTIVE_KEIYAKU_EXISTS", `exclusive bind rejected: active contract ${blocking.contract} already exists`);
+        }
+        for (const existing of active) {
+            if (existing.contract === input.contractId)
+                continue;
+            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.`,
+                ].join(" "));
+            }
+            for (const nextPattern of input.scope) {
+                for (const existingPattern of existing.scope) {
+                    if (patternsOverlap(nextPattern, existingPattern)) {
+                        nextWarnings.push(`▲ scope overlaps registered active contract ${existing.contract}: ${nextPattern} overlaps ${existingPattern}; consider --after ${existing.contract}`);
+                    }
+                }
+            }
+        }
+        warnings = nextWarnings;
+        return {
+            v: 1,
+            kind: "register",
+            contract: input.contractId,
+            at: input.at,
+            actor: input.actor,
+            scope: input.scope,
+            tree: input.tree,
+        };
+    });
+    if (!result.ok)
+        throw new FlowError("INTERNAL_STATE", `failed to register scope for ${input.contractId}: ${result.reason}`);
+    return { head: result.head, warnings };
+}
+export async function releaseScope(cwd, input) {
+    const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, (entries) => {
+        const hasActiveRegistration = entries.some((entry) => entry.kind === "register" && entry.contract === input.contractId);
+        const alreadyReleased = entries.some((entry) => entry.kind === "release" && entry.contract === input.contractId);
+        if (!hasActiveRegistration || alreadyReleased)
+            return null;
+        return { v: 1, kind: "release", contract: input.contractId, at: input.at, actor: input.actor };
+    });
+    if (!result.ok && result.reason !== "aborted") {
+        throw new FlowError("INTERNAL_STATE", `failed to release scope for ${input.contractId}: ${result.reason}`);
+    }
+}
+export function bindScope(entry) {
+    return entry.data.scope;
+}

package/build/core/render.js

@@ -0,0 +1,326 @@
+import { deriveContractState, } from "./status.js";
+const VERB_COLUMN_WIDTH = 11;
+const TIME_COLUMN_WIDTH = 6;
+const ACTOR_COLUMN_WIDTH = 11;
+export function shortCommitHash(hash) {
+    return hash.slice(0, 12);
+}
+function compactWhitespace(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function elapsedLabel(anchorAt, at) {
+    const anchorMs = Date.parse(anchorAt);
+    const currentMs = Date.parse(at);
+    if (!Number.isFinite(anchorMs) || !Number.isFinite(currentMs) || currentMs >= anchorMs) {
+        return "now";
+    }
+    const seconds = Math.max(0, Math.floor((anchorMs - currentMs) / 1_000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
+}
+function sealAggregate(entries) {
+    return entries.reduce((total, entry) => {
+        if (entry.kind !== "seal")
+            return total;
+        return {
+            insertions: total.insertions + entry.data.diffstat.insertions,
+            deletions: total.deletions + entry.data.diffstat.deletions,
+        };
+    }, { insertions: 0, deletions: 0 });
+}
+function scopeStatusFact(entry) {
+    if (entry.data.scopeAudit.violations.length === 0)
+        return "scope ✓ clean";
+    if (entry.data.scopeAudit.waived)
+        return `scope ▲ waived ${entry.data.scopeAudit.violations.length}`;
+    return `scope ✕ ${entry.data.scopeAudit.violations.length}`;
+}
+function formatDiffstat(insertions, deletions) {
+    return `+${insertions} −${deletions}`;
+}
+function joinFactClusters(clusters) {
+    return clusters.filter((cluster) => Boolean(cluster)).join(" · ");
+}
+function sealsByArc(entries) {
+    const seals = new Map();
+    for (const entry of entries) {
+        if (entry.kind === "seal") {
+            seals.set(entry.data.arc, entry);
+        }
+    }
+    return seals;
+}
+function renderOpenArcFact(entry) {
+    return joinFactClusters([`open ${compactWhitespace(entry.data.title)}`, compactWhitespace(entry.data.brief)]);
+}
+function renderSealFacts(entry) {
+    return [
+        joinFactClusters([
+            `${entry.data.receipts.length} receipts`,
+            formatDiffstat(entry.data.diffstat.insertions, entry.data.diffstat.deletions),
+            scopeStatusFact(entry),
+        ]),
+    ];
+}
+function renderEventFacts(entry, entries) {
+    switch (entry.kind) {
+        case "bind":
+            return [
+                joinFactClusters([
+                    `workspace ${entry.data.workspace}`,
+                    entry.data.place ? `place ${entry.data.place}` : null,
+                    `base ${shortCommitHash(entry.data.base)}`,
+                    `scope ${entry.data.scope.length}`,
+                    entry.data.after && entry.data.after.length > 0 ? `after ${entry.data.after.length}` : null,
+                ]),
+            ];
+        case "arc":
+            return [renderOpenArcFact(entry)];
+        case "seal":
+            return renderSealFacts(entry);
+        case "amend":
+            return [compactWhitespace(entry.data.amendment)];
+        case "renew":
+            return [
+                `${shortCommitHash(entry.data.oldBase)}..${shortCommitHash(entry.data.oldHead)} → ${shortCommitHash(entry.data.newBase)}..${shortCommitHash(entry.data.newHead)}`,
+            ];
+        case "petition":
+            return [joinFactClusters([`intent ${entry.data.intent}`]), "┆ 誓言"];
+        case "verdict": {
+            const seal = entry.data.result === "approved" ? "準" : "却";
+            return [`${seal} ${compactWhitespace(entry.data.summary)}`];
+        }
+        case "claim": {
+            const aggregate = sealAggregate(entries);
+            return [joinFactClusters([formatDiffstat(aggregate.insertions, aggregate.deletions), `ledger ${entries.length}`])];
+        }
+        case "forfeit":
+            return [
+                joinFactClusters([
+                    entry.data.reason === "manual" ? "裁决人" : entry.data.reason,
+                    entry.data.note ? `「${compactWhitespace(entry.data.note)}」` : null,
+                    entry.data.by ? `by ${entry.data.by}` : null,
+                ]),
+            ];
+    }
+}
+function headGlyph(entry) {
+    if (entry.kind === "forfeit")
+        return "×";
+    return "·";
+}
+function renderDisplayRow(row) {
+    const [firstFact = "", ...restFacts] = row.facts;
+    return [
+        `${row.glyph}  ${row.verb.padEnd(VERB_COLUMN_WIDTH)}${row.time.padEnd(TIME_COLUMN_WIDTH)}${row.actor.padEnd(ACTOR_COLUMN_WIDTH)}${firstFact}`.trimEnd(),
+        ...restFacts,
+    ];
+}
+function displayRowForEntry(entry, anchorAt, entries) {
+    const actor = entry.kind === "claim" ? "engine" : entry.kind === "petition" ? "holder" : entry.actor;
+    const verb = entry.kind === "arc" ? `arc ${entry.data.arc}` : entry.kind;
+    return {
+        glyph: headGlyph(entry),
+        time: elapsedLabel(anchorAt, entry.at),
+        actor,
+        verb,
+        facts: renderEventFacts(entry, entries),
+    };
+}
+function displayRowForSeal(entry, anchorAt) {
+    return {
+        glyph: headGlyph(entry),
+        time: elapsedLabel(anchorAt, entry.at),
+        actor: entry.actor,
+        verb: `arc ${entry.data.arc}`,
+        facts: renderSealFacts(entry),
+    };
+}
+function renderLedgerRows(entries) {
+    const anchorAt = entries.at(-1)?.at ?? entries[0].at;
+    const body = [...terminalHeader(entries)];
+    const sealedArcs = sealsByArc(entries);
+    const newestFirst = [...entries].reverse();
+    for (const entry of newestFirst) {
+        if (entry.kind === "arc" && sealedArcs.has(entry.data.arc)) {
+            continue;
+        }
+        const row = entry.kind === "seal"
+            ? displayRowForSeal(entry, anchorAt)
+            : displayRowForEntry(entry, anchorAt, entries);
+        body.push(...renderDisplayRow(row));
+    }
+    return body;
+}
+export function terminalHeader(entries) {
+    const terminal = entries.at(-1);
+    if (!terminal || terminal.kind !== "claim")
+        return [];
+    return [`◆  現世 ${shortCommitHash(terminal.data.mergeCommit)}`, "├─╯"];
+}
+export function renderVerticalLog(input) {
+    if (input.entries.length === 0) {
+        return "(empty ledger)";
+    }
+    return renderLedgerRows(input.entries).join("\n");
+}
+export function renderContractView(input) {
+    const bind = input.entries.find((entry) => entry.kind === "bind");
+    const state = deriveContractState(input.entries);
+    if (!bind) {
+        return [
+            "# Keiyaku Contract",
+            "",
+            "generated by keiyaku - edits are not read back",
+            "",
+            `id: ${input.id}`,
+            `state: ${state.state}`,
+            "",
+            "log:",
+            renderVerticalLog(input),
+            "",
+        ].join("\n");
+    }
+    return [
+        `# ${bind.data.name}`,
+        "",
+        "generated by keiyaku - edits are not read back",
+        "",
+        `id: ${input.id}`,
+        `state: ${state.state}`,
+        `base: ${bind.data.base}`,
+        `workspace: ${bind.data.workspace}`,
+        `place: ${bind.data.place ?? "(none)"}`,
+        `after: ${(bind.data.after ?? []).join(", ") || "(none)"}`,
+        "",
+        "objective:",
+        bind.data.objective,
+        "",
+        "scope:",
+        ...bind.data.scope.map((pattern) => `- ${pattern}`),
+        "",
+        "log:",
+        renderVerticalLog(input),
+        "",
+    ].join("\n");
+}
+function shortHead(hash) {
+    if (!hash)
+        return "????????";
+    return hash.slice(0, 7);
+}
+export function formatAgeMs(ms) {
+    if (ms === undefined)
+        return undefined;
+    const seconds = Math.max(0, Math.floor(ms / 1_000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    return `${Math.floor(hours / 24)}d`;
+}
+function arcSparkline(arcs) {
+    if (arcs <= 0)
+        return "";
+    return Array.from({ length: arcs }, () => "·").join("──");
+}
+function pendingAfterIds(contract) {
+    return contract.after.filter((item) => !item.terminal).map((item) => item.id);
+}
+function kanshiGlyph(contract) {
+    if (contract.state.state === "corrupt")
+        return "×";
+    if (pendingAfterIds(contract).length > 0)
+        return "○";
+    if (contract.state.state === "petitioned")
+        return "◎";
+    return "●";
+}
+export function projectionGlyph(state) {
+    switch (state) {
+        case "out":
+            return "●";
+        case "lost":
+            return "○";
+        case "done":
+            return "◎";
+        case "dismissed":
+            return "×";
+        case "dead":
+            return "✕";
+        case "minting":
+            return "…";
+    }
+}
+function renderDriftMark(drift) {
+    if (drift.state === "drift")
+        return `▲${drift.behindBy}`;
+    if (drift.state === "orphaned")
+        return "▲orphaned";
+    return undefined;
+}
+export function renderKanshiBoard(status) {
+    const head = shortHead(status.defaultHead);
+    if (status.contracts.length === 0) {
+        return `現世 ${head} 无在飞契约\n`;
+    }
+    const header = `現世 ${head}`;
+    const lines = [header, ""];
+    for (const contract of status.contracts) {
+        const glyph = kanshiGlyph(contract);
+        const name = contract.slug;
+        const spark = arcSparkline(contract.arcs);
+        const facts = [];
+        const lifecycle = contract.state.state;
+        if (lifecycle === "bound" || lifecycle === "active" || lifecycle === "petitioned") {
+            facts.push(lifecycle);
+        }
+        if (contract.place) {
+            facts.push(`@${contract.place}`);
+        }
+        const arcObjective = compactWhitespace(contract.currentArc.objective || "(no arc objective)");
+        const arcMark = contract.currentArc.state === "open"
+            ? `a${contract.currentArc.number}+`
+            : `a${contract.currentArc.number}`;
+        facts.push(`${arcMark} ${arcObjective}`);
+        facts.push(`next ${contract.nextStep.detail}`);
+        const age = formatAgeMs(contract.lastActiveMs);
+        if (age)
+            facts.push(age);
+        if (contract.queuePosition)
+            facts.push(`Q${contract.queuePosition}`);
+        const drift = renderDriftMark(contract.baseDrift);
+        if (drift)
+            facts.push(drift);
+        if (contract.nextStep.hint)
+            facts.push(contract.nextStep.hint);
+        const pending = pendingAfterIds(contract);
+        if (pending.length > 0) {
+            facts.push(`⧗ ${pending.map((id) => {
+                const dot = id.indexOf(".");
+                return dot > 0 ? id.slice(0, dot) : id;
+            }).join(",")}`);
+        }
+        if (contract.state.state === "corrupt") {
+            facts.push(`corrupt (${contract.state.reason ?? contract.corruptReason ?? "unknown"})`);
+        }
+        if (contract.queueHeadStalled) {
+            facts.push("朱 stall 去广场");
+        }
+        const sparkCol = spark.padEnd(14);
+        const factText = facts.join(" · ");
+        lines.push(`${glyph} ${name.padEnd(18)} ${sparkCol} ${factText}`.trimEnd());
+    }
+    return `${lines.join("\n")}\n`;
+}

package/build/core/renew.js

@@ -0,0 +1,195 @@
+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 { 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 { findContractWorktreePath } from "./worktree-path.js";
+import { getCurrentBranch, isGitRepo } from "../git/branches.js";
+import { resolveCurrentContractId } from "./context.js";
+import { ACTOR_IDENTITY } from "../keiyaku.js";
+import { persistResponseHistory } from "./transcripts.js";
+function assertOperable(contractId, entries) {
+    const state = deriveContractState(entries);
+    if (state.state === "corrupt") {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is corrupt at entry ${state.at}: ${state.reason}`);
+    }
+    if (isTerminalState(state) || state.state === "petitioned") {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} cannot renew from state ${state.state}`);
+    }
+}
+async function resolveCommit(cwd, rev) {
+    const git = createGit(cwd);
+    try {
+        return (await git.raw(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
+    }
+    catch (error) {
+        throw wrapGitError(`rev-parse ${rev}`, error, cwd);
+    }
+}
+async function renderUpdatedContract(ledgerCwd, renderCwd, contractId) {
+    const ledger = await readLedger(ledgerCwd, contractId);
+    if (!ledger) {
+        throw new FlowError("INTERNAL_STATE", `contract ${contractId} active ledger disappeared before render`);
+    }
+    await fs.writeFile(path.join(renderCwd, KEIYAKU_FILE), renderContractView({ id: contractId, entries: ledger.entries }), "utf8");
+}
+async function rewriteBranch(cwd, newBase, oldBase, branch) {
+    const git = createGit(cwd);
+    const args = branch
+        ? ["rebase", "--onto", newBase, oldBase, branch]
+        : ["rebase", "--onto", newBase, oldBase];
+    try {
+        await git.raw(args);
+    }
+    catch (error) {
+        try {
+            await git.raw(["rebase", "--abort"]);
+        }
+        catch {
+            // Preserve the rewrite failure after best-effort restoration.
+        }
+        if (errorContainsAnyPattern(error, ["CONFLICT", "could not apply", "Resolve all conflicts manually"])) {
+            throw new FlowError("CLOSE_MERGE_CONFLICT", "renew conflict; working tree restored", { cause: error });
+        }
+        throw wrapGitError(`renew ${branch ?? "current branch"}`, error, cwd);
+    }
+}
+function assertNoInFlightProjection(cwd, contractId, nowMs) {
+    const board = readProjectionStatusBoard(cwd, nowMs);
+    if (!board?.rows.some((row) => row.state === "out"))
+        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"] });
+}
+function looseCommitError(contractId, receipts) {
+    return new FlowError("NO_OPEN_ARC", `${receipts.length} commits after fence have no arc to receipt them`, {
+        hints: [`keiyaku @${contractId} arc — opens a new arc to receipt them, then renew`],
+    });
+}
+export async function renewContract(input) {
+    const ledger = await readLedger(input.cwd, input.contractId);
+    if (!ledger) {
+        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 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;
+    if (!open) {
+        const loose = await receiptsAfterFence(input.cwd, ledger.entries, oldHead);
+        if (loose.length > 0)
+            throw looseCommitError(input.contractId, loose);
+    }
+    if (oldBase === target.head) {
+        return {
+            contractId: input.contractId,
+            oldBase,
+            newBase: target.head,
+            oldHead,
+            newHead: oldHead,
+            ledgerHead: ledger.head,
+            alreadyFresh: true,
+            sealed: null,
+        };
+    }
+    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);
+    const newHead = await resolveCommit(input.cwd, branch);
+    const sealed = await sealOpenArc({
+        cwd: input.cwd,
+        renderCwd: rewriteCwd,
+        contractId: input.contractId,
+        sealedBy: "renew",
+        nowMs: input.nowMs,
+        capture: capture ? { ...capture, newFence: newHead } : null,
+    });
+    const at = new Date(input.nowMs).toISOString();
+    const result = await appendWithRetry(input.cwd, activeLedgerRef(input.contractId), (_head, entries) => {
+        assertOperable(input.contractId, entries);
+        if (latestBase(entries) !== oldBase) {
+            throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} changed while renewing`);
+        }
+        return {
+            v: 1,
+            kind: "renew",
+            contract: input.contractId,
+            at,
+            actor: input.actor,
+            data: { oldBase, newBase: target.head, oldHead, newHead },
+        };
+    });
+    if (!result.ok) {
+        throw new FlowError("INTERNAL_STATE", `failed to append renew for ${input.contractId}: ${result.reason}`);
+    }
+    await renderUpdatedContract(input.cwd, rewriteCwd, input.contractId);
+    return {
+        contractId: input.contractId,
+        oldBase,
+        newBase: target.head,
+        oldHead,
+        newHead,
+        ledgerHead: result.head,
+        alreadyFresh: false,
+        sealed,
+    };
+}
+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({
+            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 } : {}),
+        });
+    }
+    catch {
+        responsePath = undefined;
+    }
+    return {
+        status: "success",
+        ...renewed,
+        currentBranch,
+        baseBranch: target?.branch ?? currentBranch,
+        diff,
+        sealed: renewed.sealed ?? undefined,
+        summary,
+        responsePath,
+    };
+}