@astrosheep/keiyaku 0.1.76 → 0.1.78

package/build/tools/ask/persist.js

@@ -7,8 +7,10 @@ import { runAsk } from "./run.js";
 import { assertKeiyakuProtocolFiles } from "../../protocol/file-guards.js";
 import { persistResponseHistory } from "../../protocol/response-history.js";
 import { getCurrentBranch } from "../../git/branches.js";
+import { MISSING_HEAD_PATTERNS, NOT_GIT_REPOSITORY_PATTERNS, errorContainsAnyPattern } from "../../git/core.js";
 import { getActiveKeiyakuGitState } from "../../git/keiyaku-state.js";
 import { addFiles, commit, getLatestCommitHash } from "../../git/staging.js";
+import { isErrnoException } from "../../errno.js";
 const ASK_TRACE_COMMIT_PREFIX = "ask: ";
 const ASK_TRACE_COMMIT_SUMMARY_MAX_CHARS = 50;
 const ASK_TRACE_IGNORE_FLOW_ERRORS = new Set([
@@ -17,6 +19,24 @@ const ASK_TRACE_IGNORE_FLOW_ERRORS = new Set([
     "MISSING_PROTOCOL_FILES",
     "NOT_ACTIVE_KEIYAKU_BRANCH",
 ]);
+function isMissingPathError(error) {
+    return isErrnoException(error) && error.code === "ENOENT";
+}
+function isBenignHistoryBranchLookupError(error) {
+    return ((isFlowError(error) && error.code === "DETACHED_HEAD") ||
+        isMissingPathError(error) ||
+        errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS));
+}
+function isBenignHistoryCommitLookupError(error) {
+    return (isMissingPathError(error) ||
+        errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS) ||
+        errorContainsAnyPattern(error, MISSING_HEAD_PATTERNS));
+}
+function isBenignAskTracePersistenceError(error) {
+    return ((isFlowError(error) && ASK_TRACE_IGNORE_FLOW_ERRORS.has(error.code)) ||
+        isMissingPathError(error) ||
+        errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS));
+}
 function buildAskTraceCommitMessage(request) {
     const summary = request.replaceAll(/\s+/g, " ").trim().slice(0, ASK_TRACE_COMMIT_SUMMARY_MAX_CHARS);
     return `${ASK_TRACE_COMMIT_PREFIX}${summary}`;
@@ -24,22 +44,28 @@ function buildAskTraceCommitMessage(request) {
 export async function runAskAndPersist(input) {
     const result = await runAsk(input);
     let responsePath;
+    let historyBranch;
     try {
-        let historyBranch;
-        try {
-            historyBranch = await getCurrentBranch(input.cwd);
-        }
-        catch {
-            historyBranch = undefined;
-        }
-        let commit;
-        try {
-            commit = await getLatestCommitHash(input.cwd);
+        historyBranch = await getCurrentBranch(input.cwd);
+    }
+    catch (error) {
+        if (!isBenignHistoryBranchLookupError(error)) {
+            throw error;
         }
-        catch {
-            // Ask can run outside git repos; history should still be persisted.
-            commit = undefined;
+        historyBranch = undefined;
+    }
+    let commitHash;
+    try {
+        commitHash = await getLatestCommitHash(input.cwd);
+    }
+    catch (error) {
+        if (!isBenignHistoryCommitLookupError(error)) {
+            throw error;
         }
+        // Ask can run outside git repos; history should still be persisted.
+        commitHash = undefined;
+    }
+    try {
         responsePath = await persistResponseHistory({
             cwd: input.cwd,
             tool: "ask",
@@ -51,7 +77,7 @@ export async function runAskAndPersist(input) {
             sessionId: result.sessionId,
             subagentName: result.identity,
             branch: historyBranch,
-            commit,
+            commit: commitHash,
         });
     }
     catch (historyError) {
@@ -69,29 +95,6 @@ export async function runAskAndPersist(input) {
             summary: result.summary,
             historyPath: responsePath,
         });
-        try {
-            const activeState = await getActiveKeiyakuGitState(input.cwd);
-            if (activeState) {
-                await assertKeiyakuProtocolFiles(input.cwd);
-                try {
-                    await addFiles(input.cwd, TRACE_FILE);
-                    await commit(input.cwd, buildAskTraceCommitMessage(input.request));
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    logWarn(`Failed to commit ask trace update: ${message}`, { cwd: input.cwd, section: "script" });
-                }
-            }
-        }
-        catch (error) {
-            if (isFlowError(error) && ASK_TRACE_IGNORE_FLOW_ERRORS.has(error.code)) {
-                // Non-active keiyaku or missing protocol files should not block ask.
-            }
-            else {
-                const message = error instanceof Error ? error.message : String(error);
-                logWarn(`Unexpected ask trace path error: ${message}`, { cwd: input.cwd, section: "script" });
-            }
-        }
     }
     catch (askTraceError) {
         const askTraceErrorMessage = askTraceError instanceof Error ? askTraceError.message : String(askTraceError);
@@ -99,6 +102,26 @@ export async function runAskAndPersist(input) {
             cwd: input.cwd,
             section: "script",
         });
+        if (!isBenignAskTracePersistenceError(askTraceError)) {
+            logWarn(`Failed to append ask trace entry: ${askTraceErrorMessage}`, {
+                cwd: input.cwd,
+                section: "script",
+            });
+            throw askTraceError;
+        }
+    }
+    try {
+        const activeState = await getActiveKeiyakuGitState(input.cwd);
+        if (activeState) {
+            await assertKeiyakuProtocolFiles(input.cwd);
+            await addFiles(input.cwd, TRACE_FILE);
+            await commit(input.cwd, buildAskTraceCommitMessage(input.request));
+        }
+    }
+    catch (error) {
+        if (!isBenignAskTracePersistenceError(error)) {
+            throw error;
+        }
     }
     return { result, responsePath };
 }

package/build/tools/ask/run.js

@@ -1,9 +1,11 @@
 import * as fs from "fs/promises";
 import * as path from "path";
 import { KEIYAKU_FILE, TRACE_FILE } from "../../keiyaku.js";
+import { isErrnoException } from "../../errno.js";
 import { requireText } from "../../flow-error.js";
 import { selectSubagent } from "../../agents/selector.js";
 import { runSubagentWithResult } from "../../agents/round-runner.js";
+import { NOT_GIT_REPOSITORY_PATTERNS, errorContainsAnyPattern } from "../../git/core.js";
 import { getActiveKeiyakuGitState } from "../../git/keiyaku-state.js";
 import { createWorkspaceSnapshot, getChangedFilesBetweenSnapshots } from "../../git/snapshot.js";
 import { MAX_DIFF_LINES_PER_FILE } from "../../git/diff/constants.js";
@@ -14,13 +16,16 @@ import { readBaseRules } from "../../config/base-rules.js";
 import { resolveIncrementalDiffMode } from "../../config/incremental-diff-mode.js";
 import { resolveAskResponsePath } from "../../protocol/response-history.js";
 import { INCREMENTAL_DIFF_MAX_CHARS } from "../../keiyaku.js";
-async function renderSnapshotDiff(cwd, beforeSha, afterSha, mode) {
-    const range = `${beforeSha}..${afterSha}`;
-    if (mode === "stat" || mode === "targeted") {
-        const statDiff = await readDiff(cwd, range, "stat", { maxChars: INCREMENTAL_DIFF_MAX_CHARS.stat });
+function isBenignAskGitStateError(error) {
+    return (isErrnoException(error) && error.code === "ENOENT") || errorContainsAnyPattern(error, NOT_GIT_REPOSITORY_PATTERNS);
+}
+export async function renderSnapshotDiff(cwd, beforeSha, afterSha, mode) {
+    const snapshotTarget = [beforeSha, afterSha];
+    if (mode === "stat") {
+        const statDiff = await readDiff(cwd, snapshotTarget, "stat", { maxChars: INCREMENTAL_DIFF_MAX_CHARS.stat });
         return statDiff ?? "No incremental diff available.";
     }
-    const patchDiff = await readDiff(cwd, range, "patch", {
+    const patchDiff = await readDiff(cwd, snapshotTarget, "patch", {
         maxChars: INCREMENTAL_DIFF_MAX_CHARS.targeted,
         maxLinesPerFile: MAX_DIFF_LINES_PER_FILE,
     });
@@ -35,7 +40,7 @@ async function readAskProtocolReferences(cwd) {
         return { keiyaku, trace };
     }
     catch (error) {
-        if (error?.code === "ENOENT") {
+        if (isErrnoException(error) && error.code === "ENOENT") {
             return undefined;
         }
         throw error;
@@ -46,7 +51,12 @@ export async function runAsk(input) {
     requireText("title", input.title);
     const request = requireText("request", input.request);
     const referenceRules = await readBaseRules(cwd);
-    const activeState = await getActiveKeiyakuGitState(cwd).catch(() => null);
+    const activeState = await getActiveKeiyakuGitState(cwd).catch((error) => {
+        if (isBenignAskGitStateError(error)) {
+            return null;
+        }
+        throw error;
+    });
     const protocolReferences = activeState ? await readAskProtocolReferences(cwd) : undefined;
     const prompt = buildAskPrompt(request, input.context, referenceRules, protocolReferences);
     const beforeSnapshot = await createWorkspaceSnapshot(cwd);

package/build/tools/create-handler.js

@@ -0,0 +1,31 @@
+import { appendDebugLog } from "../telemetry/debug-log.js";
+import { handleToolError } from "../mcp/tool-errors.js";
+const TOOL_LOG_SECTION = "script";
+function resolveWorkingDirectory(cwd) {
+    return typeof cwd === "string" && cwd.length > 0 ? cwd : process.cwd();
+}
+export function createToolHandler(config) {
+    return async (input, extra) => {
+        const normalizedInput = { ...input, cwd: resolveWorkingDirectory(input.cwd) };
+        try {
+            appendDebugLog(`${config.logLabel} cwd=${normalizedInput.cwd}`, {
+                cwd: normalizedInput.cwd,
+                section: TOOL_LOG_SECTION,
+            });
+            const result = await config.run(normalizedInput, extra);
+            const doneLog = typeof config.doneLog === "function" ? config.doneLog(result) : config.doneLog;
+            appendDebugLog(doneLog, {
+                cwd: normalizedInput.cwd,
+                section: TOOL_LOG_SECTION,
+            });
+            return config.buildResponse(result, normalizedInput);
+        }
+        catch (error) {
+            return handleToolError({
+                error,
+                cwd: normalizedInput.cwd,
+                logLabel: config.logLabel,
+            });
+        }
+    };
+}

package/build/tools/drive/index.js

@@ -1,35 +1,22 @@
-import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { driveServant } from "./run.js";
 import { buildDriveResponse, } from "../../mcp/responses.js";
-import { handleToolError } from "../../mcp/tool-errors.js";
+import { createToolHandler } from "../create-handler.js";
 export function createDriveHandler() {
-    return async ({ title, directive, context, tier, cwd }, extra) => {
-        const workingDir = cwd || process.cwd();
-        try {
-            appendDebugLog(`tool drive start cwd=${workingDir}`, {
-                cwd: workingDir,
-                section: "script",
-            });
-            const outcome = await driveServant({
-                cwd: workingDir,
+    return createToolHandler({
+        logLabel: "tool drive",
+        doneLog: (outcome) => `tool drive success round=${outcome.round}`,
+        async run({ title, directive, context, tier, cwd }, extra) {
+            return driveServant({
+                cwd,
                 title,
                 directive,
                 context,
                 tier,
                 signal: extra.signal,
             });
-            appendDebugLog(`tool drive success round=${outcome.round}`, {
-                cwd: workingDir,
-                section: "script",
-            });
+        },
+        buildResponse(outcome, { tier }) {
             return buildDriveResponse(outcome, { tier });
-        }
-        catch (err) {
-            return handleToolError({
-                error: err,
-                cwd: workingDir,
-                logLabel: "tool drive",
-            });
-        }
-    };
+        },
+    });
 }

package/build/tools/drive/run.js

@@ -23,6 +23,7 @@ import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { isDraftArtifactPath } from "../../protocol/draft-artifacts.js";
 import { getUntrackedFiles } from "../../git/worktree.js";
 import { renderIncrementalDiff } from "../round/incremental-diff.js";
+import { assertHeadUnchanged } from "../round/head-guard.js";
 const DRIVE_CANCELLATION_NOTE = "Round execution canceled.";
 const DRIVE_CANCELLATION_REASON = "canceled";
 function normalizeSectionTitle(title) {
@@ -67,9 +68,10 @@ function buildCancelledRevertCommitMessage(titleToken, round, attemptCommit) {
 function buildCancelledTraceCommitMessage(titleToken, round) {
     return buildRoundCommitMessage(titleToken, round, DRIVE_CANCELLATION_REASON);
 }
-async function stageAbortAttemptFiles(cwd) {
+async function stageAbortAttemptFiles(cwd, preRunUntracked) {
     await addUpdatedFiles(cwd);
-    const untracked = (await getUntrackedFiles(cwd)).filter((filePath) => !isDraftArtifactPath(filePath));
+    const before = new Set(preRunUntracked);
+    const untracked = (await getUntrackedFiles(cwd)).filter((filePath) => !isDraftArtifactPath(filePath) && !before.has(filePath));
     if (untracked.length > 0) {
         await addFiles(cwd, untracked);
     }
@@ -80,11 +82,11 @@ async function commitCancellationTraceOnly(cwd, title, round) {
     await commitChanges(cwd, buildCancelledTraceCommitMessage(title, round));
     await getLatestCommitHash(cwd);
 }
-async function commitAndRevertCancelledRoundAttempt(cwd, title, round) {
+export async function commitAndRevertCancelledRoundAttempt(cwd, title, round, preRunUntracked) {
     await appendRoundSystemNote(cwd, round, DRIVE_CANCELLATION_NOTE);
     let attemptCommit;
     try {
-        await stageAbortAttemptFiles(cwd);
+        await stageAbortAttemptFiles(cwd, preRunUntracked);
         await commitChanges(cwd, buildCancelledAttemptCommitMessage(title, round));
         attemptCommit = await getLatestCommitHash(cwd);
     }
@@ -142,15 +144,17 @@ export async function driveServant(input) {
             traceState = computeTraceState(traceContent);
         }
         const plan = buildIteratePlan(title, traceState, traceContent, keiyakuContent, goal, normalizedDirective, context, baseRules);
+        const headBeforeRound = await getLatestCommitHash(cwd);
         const preRunUntracked = await getUntrackedFiles(cwd);
         const { roundSummary, rawSummary, commit, identity, sessionId } = await runAndRecordRound(cwd, title, plan.targetRound, plan.prompt, {
             signal,
             tier,
             failureMode: "round_specific",
             preRunUntracked,
+            beforePersist: () => assertHeadUnchanged(cwd, headBeforeRound, "drive"),
             beforeRoundWrite: () => appendDirective(cwd, plan.targetRound, plan.directiveReason),
             onAbort: async () => {
-                await commitAndRevertCancelledRoundAttempt(cwd, title, plan.targetRound);
+                await commitAndRevertCancelledRoundAttempt(cwd, title, plan.targetRound, preRunUntracked);
             },
         });
         const summary = renderToolRoundSummary(roundSummary);

package/build/tools/petition/claim-gates.js

@@ -33,16 +33,33 @@ const REVIEW_REJECTION_MESSAGE = "CLAIM rejected by independent reviewer.";
 const REVIEW_REJECTION_AUDIT_PREFIX = "Independent reviewer rejected CLAIM.";
 const REVIEW_RESPONSE_FALLBACK = "(no output)";
 const REVIEW_SKIPPED_RESULT = { pass: true };
+const REVIEW_ATTEMPT_SECTION_TITLE = "## Review Attempt";
 const REVIEW_PROMPT_LINES = [
     "You are an independent reviewer.",
-    "Evaluate whether the submitted work satisfies the keiyaku criteria.",
-    "You have full access to the repository. Read any file you need.",
+    "Evaluate whether the submitted work fulfills the keiyaku.",
+    "You have full access to the repository. Read source files as needed to verify the changes in context.",
+    "Do not run tests or commands - a separate verification step handles that.",
+    "",
+    "## Workflow Context",
+    "- KEIYAKU.md and KEIYAKU_TRACE.md are workflow protocol files that will be removed before merge. Ignore them.",
+    "- Commit messages in this branch are intermediate; the branch will be squash-merged. Do not evaluate commit hygiene.",
     "",
     "## Output Rules",
-    "- If the work meets all criteria: output exactly `PASS` and nothing else.",
-    "- If not: output your findings. Be specific. Reference files and lines.",
-    "  Do not suggest fixes. State what is wrong and why it fails the criteria.",
+    "- If the work fulfills the keiyaku: begin with `PASS`, optionally followed by observations.",
+    "- If not: begin with `REJECTED`, then state what is wrong and why.",
+    "  Be specific. Reference files and lines. Do not suggest fixes.",
 ];
+function buildReviewAttemptBlock(reviewNumber) {
+    if (reviewNumber === 1) {
+        return [REVIEW_ATTEMPT_SECTION_TITLE, "This is review attempt 1."];
+    }
+    return [
+        REVIEW_ATTEMPT_SECTION_TITLE,
+        `This is review attempt ${reviewNumber}.`,
+        "The prior review was rejected.",
+        "Focus on whether the previous concerns have been addressed.",
+    ];
+}
 function buildCommandmentFailureMessage(violationTitle, score, threshold, definition, driveCommandName) {
     return `${violationTitle} score too low (${score} < ${threshold})\n${definition}\nIdentify what needs to change to meet this standard. Then use \`${driveCommandName}\` to implement those improvements in the code. Score edits without new implementation evidence are treated as oath violation.`;
 }
@@ -83,6 +100,8 @@ function buildReviewerPrompt(input) {
     const lines = [
         ...REVIEW_PROMPT_LINES,
         "",
+        ...buildReviewAttemptBlock(input.reviewNumber),
+        "",
         "## Keiyaku",
         input.keiyakuContent,
         "",
@@ -223,18 +242,26 @@ export function createAgentReviewGate() {
                 claimPlea: input.plea,
                 baseRef: baseBranch,
                 headRef,
+                reviewNumber,
                 diffStat: diffStat ?? "No diff.",
                 fullDiff: fullDiff ?? "No diff.",
                 priorFindings: priorReview?.result === "rejected" ? priorReview.findings : undefined,
             });
             const responsePathResolution = getConfig().review.resumeSession && priorReview?.historyPath
-                ? await resolveAskResponsePath({ cwd, responsePath: priorReview.historyPath })
+                ? await resolveAskResponsePath({
+                    cwd,
+                    responsePath: priorReview.historyPath,
+                    allowedTools: ["review"],
+                    onArtifactTypeMismatch: "return-null",
+                })
                 : undefined;
             const subagentResult = await runSubagentExec(REVIEWER_ROLE, prompt, cwd, {
                 signal: input.signal,
                 responsePath: responsePathResolution?.sessionId,
             });
-            const findings = subagentResult.finalMessage.trim();
+            const raw = subagentResult.finalMessage.trim();
+            const passed = raw.startsWith(REVIEW_PASS_TOKEN);
+            const observations = passed ? raw.slice(REVIEW_PASS_TOKEN.length).trim() || undefined : undefined;
             const responsePath = await persistResponseHistory({
                 cwd,
                 tool: "review",
@@ -248,14 +275,15 @@ export function createAgentReviewGate() {
             });
             const review = {
                 review: reviewNumber,
-                result: findings === REVIEW_PASS_TOKEN ? "passed" : "rejected",
+                result: passed ? "passed" : "rejected",
                 historyPath: responsePath,
-                findings: findings === REVIEW_PASS_TOKEN ? undefined : findings || REVIEW_RESPONSE_FALLBACK,
+                findings: passed ? observations : raw || REVIEW_RESPONSE_FALLBACK,
             };
             if (review.result === "passed") {
                 return {
                     pass: true,
                     review,
+                    reviewHeadBeforeWrite: headRef,
                 };
             }
             return {
@@ -264,6 +292,7 @@ export function createAgentReviewGate() {
                 message: REVIEW_REJECTION_MESSAGE,
                 auditFailures: [`${REVIEW_REJECTION_AUDIT_PREFIX} See Review ${review.review}.`],
                 review,
+                reviewHeadBeforeWrite: headRef,
             };
         },
     };

package/build/tools/petition/claim.js

@@ -13,6 +13,7 @@ import { appendReview, computeTraceState, readTraceContent, renderReviewSection,
 import { assertKeiyakuProtocolFiles } from "../../protocol/file-guards.js";
 import { assertCleanWorkingTree } from "../round/worktree.js";
 import { buildClaimGatePipeline, collectClaimScores, } from "./claim-gates.js";
+import { assertHeadUnchanged } from "../round/head-guard.js";
 function buildMergeMessage(title, plea, keiyakuContent, reportContent) {
     return `keiyaku(${title}): done\n\nPlea: ${plea}\n\n---\n${keiyakuContent}\n---\n${reportContent}\n---\n`;
 }
@@ -23,6 +24,9 @@ async function throwClaimGateFailure(failure, input, context, dependencies) {
     const { cwd, titleToken } = context;
     const scores = "dangerouslyBypassGates" in input && input.dangerouslyBypassGates ? undefined : collectClaimScores(input);
     if (failure.review) {
+        if (failure.reviewHeadBeforeWrite) {
+            await assertHeadUnchanged(cwd, failure.reviewHeadBeforeWrite, "petition claim review");
+        }
         await appendReview(cwd, failure.review);
     }
     if (failure.auditFailures && scores) {
@@ -38,6 +42,7 @@ async function runClaimGatePipelineOrThrow(input, context, dependencies) {
     const driveCommandName = resolveTermPreset().tools.drive.name;
     const { verdict, verificationCommands } = await dependencies.resolveClaimGateConfig(context.cwd);
     let review;
+    let reviewHeadBeforeWrite;
     for (const gate of buildClaimGatePipeline()) {
         const result = await gate.evaluate({
             cwd: context.cwd,
@@ -51,12 +56,13 @@ async function runClaimGatePipelineOrThrow(input, context, dependencies) {
         });
         if (result.review) {
             review = result.review;
+            reviewHeadBeforeWrite = result.reviewHeadBeforeWrite;
         }
         if (!result.pass) {
             await throwClaimGateFailure(result, input, context, dependencies);
         }
     }
-    return { scores, review };
+    return { scores, review, reviewHeadBeforeWrite };
 }
 export async function claimKeiyaku(input, context, dependencies) {
     const { cwd, baseBranch, keiyakuBranch, titleToken } = context;
@@ -66,7 +72,7 @@ export async function claimKeiyaku(input, context, dependencies) {
     const claimTitle = input.title;
     const claimPlea = input.plea;
     const claimResult = "dangerouslyBypassGates" in input && input.dangerouslyBypassGates
-        ? { review: undefined, scores: undefined, bypassedByArchitect: true }
+        ? { review: undefined, reviewHeadBeforeWrite: undefined, scores: undefined, bypassedByArchitect: true }
         : {
             ...(await runClaimGatePipelineOrThrow(input, { cwd, titleToken }, {
                 ...dependencies,
@@ -80,6 +86,17 @@ export async function claimKeiyaku(input, context, dependencies) {
         logInfo(`[CLAIM] Collecting diff preview against base '${baseBranch}'`, { cwd, section: "script", progressOnly: true });
         logInfo("[CLAIM] Reading keiyaku protocol files", { cwd, section: "script", progressOnly: true });
         const keiyakuContent = await fs.readFile(path.join(cwd, KEIYAKU_FILE), "utf-8");
+        if (claimResult.review && claimResult.reviewHeadBeforeWrite) {
+            await assertHeadUnchanged(cwd, claimResult.reviewHeadBeforeWrite, "petition claim review");
+            await appendReview(cwd, claimResult.review);
+            try {
+                await dependencies.commitPassedReviewAuditTrail(cwd);
+            }
+            catch (error) {
+                const warning = `[CLAIM] Failed to persist passed review audit trail: ${error instanceof Error ? error.message : String(error)}`;
+                logWarn(warning, { cwd, section: "script" });
+            }
+        }
         const reportTraceContent = claimResult.review ? `${traceContent}${renderReviewSection(claimResult.review)}` : traceContent;
         const reportContent = `${reportTraceContent}${renderVerdictSection("ACCEPTED", {
             scores: claimResult.scores,
@@ -114,6 +131,7 @@ export async function claimKeiyaku(input, context, dependencies) {
         return {
             status: "success",
             result: "merged",
+            review: claimResult.review,
             round,
             currentBranch: baseBranch,
             baseBranch,

package/build/tools/petition/forfeit.js

@@ -16,6 +16,9 @@ function buildForfeitSafetyStashMessage(titleToken) {
 function buildForfeitRecoveryHint(stashRef) {
     return `${FORFEIT_SAFETY_STASH_HINT_PREFIX}: ${stashRef}`;
 }
+function buildArchiveTag(titleToken, now = Date.now()) {
+    return `${KEIYAKU_ARCHIVE_TAG_PREFIX}${titleToken}-${now}`;
+}
 async function restoreForfeitSafetySnapshot(cwd, keiyakuBranch, stashRef) {
     const hints = [];
     try {
@@ -38,7 +41,7 @@ async function restoreForfeitSafetySnapshot(cwd, keiyakuBranch, stashRef) {
 }
 export async function forfeitKeiyaku(context) {
     const { cwd, baseBranch, keiyakuBranch, titleToken, draftSnapshot } = context;
-    const archiveTag = `${KEIYAKU_ARCHIVE_TAG_PREFIX}${titleToken}`;
+    const archiveTag = buildArchiveTag(titleToken);
     let round = 0;
     try {
         const trace = await fs.readFile(path.join(cwd, TRACE_FILE), "utf-8");