@plannotator/pi-extension 0.27.10 → 0.27.11

package/server/ai-runtime.ts

@@ -104,14 +104,21 @@ export async function createPiAIRuntime(options: CreatePiAIRuntimeOptions = {}):
 					type: "opencode-sdk",
 					cwd,
 				});
+				const providerId = registry.register(provider);
+				// Deferred like Codex: fetchModels spawns `opencode serve`, so it
+				// must NOT run eagerly at startup — that spawned a server on every
+				// session for every user with opencode installed, and interrupted
+				// sessions orphaned it. The initializer runs on first explicit
+				// activation (?activate= from the model picker) or first opencode
+				// session.
 				if (provider && "fetchModels" in provider) {
-					modelDiscovery.push(
-						(provider as { fetchModels: () => Promise<void> })
-							.fetchModels()
-							.catch(() => {}),
+					providerInitializers.set(
+						providerId,
+						ai.createBestEffortOnce(
+							() => (provider as { fetchModels: () => Promise<void> }).fetchModels(),
+						),
 					);
 				}
-				registry.register(provider);
 			}
 		} catch {
 			// OpenCode not available.

package/server/feedback-archive.test.ts

@@ -0,0 +1,357 @@
+/**
+ * Durable feedback archive — Pi (Node) runtime parity.
+ *
+ * Node mirror of packages/server/feedback-archive.test.ts. Plannotator has two
+ * server implementations with the same API surface; a feature wired into only
+ * one of them silently drops every Pi user's feedback on the floor. These
+ * tests pin that the three Pi handlers (plan deny/approve, review
+ * /api/feedback and /api/exit, annotate submit) write the SAME record shape
+ * under the same gates.
+ *
+ * The archive is sandboxed under a temp PLANNOTATOR_DATA_DIR set inside the
+ * tests — the vendored module resolves its data dir per call. Plan version
+ * history goes through generated/storage.ts, which caches its data directory
+ * at import time, so the plan test uses a unique heading (unique slug) and
+ * removes only that slug directory afterwards.
+ */
+
+import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { startPlanReviewServer } from "./serverPlan.ts";
+import { startReviewServer } from "./serverReview.ts";
+import { startAnnotateServer } from "./serverAnnotate.ts";
+import { getPlanVersionPath } from "../generated/storage.ts";
+import { detectProjectName } from "./project.ts";
+import { parseFeedbackIndex, type FeedbackRecord } from "../generated/feedback-archive.ts";
+import { getPlannotatorDataDir } from "../generated/data-dir.ts";
+
+const MINIMAL_HTML = "<html><body>Plannotator</body></html>";
+const PATCH = "diff --git a/src/parse.ts b/src/parse.ts\n@@ -1 +1 @@\n-a\n+b\n";
+
+// Annotate version history goes through generated/storage.ts, whose data dir is
+// fixed at import time, so these sessions snapshot into the REAL data dir no
+// matter what PLANNOTATOR_DATA_DIR says here. Distinctive, test-owned project
+// names keep that out of any real project's bucket and let afterAll remove it.
+const PI_FILE_ANNOTATE_PROJECT = "_pi_feedback_archive_test_file";
+const PI_STATELESS_ANNOTATE_PROJECT = "_pi_feedback_archive_test_stateless";
+
+const ENV_KEYS = [
+	"PLANNOTATOR_DATA_DIR",
+	"PLANNOTATOR_FEEDBACK_HISTORY",
+	"PLANNOTATOR_ANNOTATE_HISTORY",
+	"PLANNOTATOR_AI",
+	"PLANNOTATOR_PORT",
+	"PLANNOTATOR_REMOTE",
+] as const;
+const saved: Record<string, string | undefined> = {};
+const tempDirs: string[] = [];
+
+function makeTempDir(prefix: string): string {
+	const dir = mkdtempSync(join(tmpdir(), prefix));
+	tempDirs.push(dir);
+	return dir;
+}
+
+function useTempDataDir(): string {
+	const dir = makeTempDir("plannotator-pi-feedback-");
+	process.env.PLANNOTATOR_DATA_DIR = dir;
+	return dir;
+}
+
+function feedbackDir(dataDir: string): string {
+	return join(dataDir, "feedback");
+}
+
+function readOnlyIndex(dataDir: string): FeedbackRecord[] {
+	const projects = readdirSync(feedbackDir(dataDir));
+	expect(projects.length).toBe(1);
+	return parseFeedbackIndex(
+		readFileSync(join(feedbackDir(dataDir), projects[0], "index.jsonl"), "utf-8"),
+	);
+}
+
+function sidecarBody(dataDir: string, record: FeedbackRecord): string {
+	const projects = readdirSync(feedbackDir(dataDir));
+	return readFileSync(join(feedbackDir(dataDir), projects[0], record.recordFile!), "utf-8");
+}
+
+beforeEach(() => {
+	for (const key of ENV_KEYS) saved[key] = process.env[key];
+	delete process.env.PLANNOTATOR_PORT;
+	process.env.PLANNOTATOR_REMOTE = "0";
+	process.env.PLANNOTATOR_AI = "disabled";
+	process.env.PLANNOTATOR_FEEDBACK_HISTORY = "1";
+	process.env.PLANNOTATOR_ANNOTATE_HISTORY = "1";
+});
+
+afterEach(() => {
+	for (const key of ENV_KEYS) {
+		if (saved[key] === undefined) delete process.env[key];
+		else process.env[key] = saved[key]!;
+	}
+	for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
+afterAll(() => {
+	// Remove the annotate history these tests deposited in the real data dir.
+	// Runs with the env already restored, so this resolves the same directory
+	// generated/storage.ts wrote to.
+	const historyDir = join(getPlannotatorDataDir(), "history");
+	for (const project of [PI_FILE_ANNOTATE_PROJECT, PI_STATELESS_ANNOTATE_PROJECT]) {
+		rmSync(join(historyDir, project), { recursive: true, force: true });
+	}
+});
+
+describe("pi feedback archive: code review", () => {
+	test("feedback submit appends one record with a sidecar, then deletes the draft", async () => {
+		const dataDir = useTempDataDir();
+		const server = await startReviewServer({
+			rawPatch: PATCH,
+			gitRef: "HEAD",
+			htmlContent: MINIMAL_HTML,
+		});
+		try {
+			await fetch(`${server.url}/api/draft`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ annotations: [{ id: "a1" }] }),
+			});
+
+			const response = await fetch(`${server.url}/api/feedback`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					approved: false,
+					feedback: "parse() still drops the null case.",
+					annotations: [
+						{ id: "a1", type: "comment", text: "null case", filePath: "src/parse.ts", lineStart: 1, lineEnd: 1, side: "new" },
+					],
+				}),
+			});
+			expect(response.status).toBe(200);
+
+			const records = readOnlyIndex(dataDir);
+			expect(records.length).toBe(1);
+			expect(records[0].v).toBe(1);
+			expect(records[0].client).toBe("plannotator");
+			expect(records[0].surface).toBe("review");
+			expect(records[0].decision).toBe("feedback");
+			expect(records[0].annotations?.[0].file).toBe("src/parse.ts");
+			expect(records[0].target?.review?.gitRef).toBe("HEAD");
+			expect(records[0].target?.review?.changedFiles).toBe(1);
+			// Identity only, never the patch bytes.
+			expect(JSON.stringify(records[0])).not.toContain("diff --git");
+			expect(sidecarBody(dataDir, records[0])).toContain("parse() still drops the null case.");
+
+			expect((await fetch(`${server.url}/api/draft`)).status).toBe(404);
+		} finally {
+			server.stop();
+		}
+	});
+
+	test("closing without feedback records a dismissal as a decision-only line", async () => {
+		const dataDir = useTempDataDir();
+		const server = await startReviewServer({ rawPatch: PATCH, gitRef: "HEAD", htmlContent: MINIMAL_HTML });
+		try {
+			expect((await fetch(`${server.url}/api/exit`, { method: "POST" })).status).toBe(200);
+			const records = readOnlyIndex(dataDir);
+			expect(records[0].decision).toBe("dismissed");
+			expect(records[0].recordFile).toBeUndefined();
+		} finally {
+			server.stop();
+		}
+	});
+
+	test("a failed archive write keeps the draft and still answers the reviewer with 200", async () => {
+		// The one invariant the Pi handler copies by hand rather than inheriting
+		// from the shared module: archive first, and only delete the draft when
+		// the record actually landed.
+		const dataDir = useTempDataDir();
+		// The review project is derived from the review cwd; block exactly that
+		// archive directory by planting a FILE where the directory must go.
+		const repoDir = join(makeTempDir("plannotator-pi-feedback-repo-"), "widgets");
+		mkdirSync(repoDir, { recursive: true });
+		mkdirSync(feedbackDir(dataDir), { recursive: true });
+		writeFileSync(join(feedbackDir(dataDir), "widgets"), "blocked", "utf-8");
+
+		const server = await startReviewServer({
+			rawPatch: PATCH,
+			gitRef: "HEAD",
+			htmlContent: MINIMAL_HTML,
+			agentCwd: repoDir,
+		});
+		try {
+			await fetch(`${server.url}/api/draft`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ annotations: [{ id: "a1" }] }),
+			});
+
+			const response = await fetch(`${server.url}/api/feedback`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ feedback: "Do not lose this.", annotations: [{ id: "a1" }] }),
+			});
+			// The submit succeeds for the user...
+			expect(response.status).toBe(200);
+			// ...and the draft survives as the recovery copy.
+			const draft = await fetch(`${server.url}/api/draft`);
+			expect(draft.status).toBe(200);
+			expect(JSON.stringify(await draft.json())).toContain("a1");
+		} finally {
+			server.stop();
+		}
+	});
+
+	test("a PR-mode session buckets under the project, not the pool checkout", async () => {
+		// PR mode never sets gitContext and `--local` points agentCwd at
+		// <sessionDir>/pool/pr-<n>; the caller's detected project must win, or
+		// every PR review files under `pr-123`.
+		const dataDir = useTempDataDir();
+		const poolCwd = join(makeTempDir("plannotator-pi-feedback-pool-"), "pool", "pr-123");
+		mkdirSync(poolCwd, { recursive: true });
+		const server = await startReviewServer({
+			rawPatch: PATCH,
+			gitRef: "HEAD",
+			htmlContent: MINIMAL_HTML,
+			project: "plannotator",
+			agentCwd: poolCwd,
+		});
+		try {
+			const response = await fetch(`${server.url}/api/feedback`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ feedback: "Rebase before merging.", annotations: [] }),
+			});
+			expect(response.status).toBe(200);
+			const projects = readdirSync(feedbackDir(dataDir));
+			expect(projects).toEqual(["plannotator"]);
+		} finally {
+			server.stop();
+		}
+	});
+
+	test("PLANNOTATOR_FEEDBACK_HISTORY=0 writes nothing and keeps the legacy draft behavior", async () => {
+		const dataDir = useTempDataDir();
+		process.env.PLANNOTATOR_FEEDBACK_HISTORY = "0";
+		const server = await startReviewServer({ rawPatch: PATCH, gitRef: "HEAD", htmlContent: MINIMAL_HTML });
+		try {
+			await fetch(`${server.url}/api/draft`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ annotations: [{ id: "a1" }] }),
+			});
+			const response = await fetch(`${server.url}/api/feedback`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ feedback: "secret", annotations: [{ id: "a1" }] }),
+			});
+			expect(response.status).toBe(200);
+			expect(existsSync(feedbackDir(dataDir))).toBe(false);
+			expect((await fetch(`${server.url}/api/draft`)).status).toBe(404);
+		} finally {
+			server.stop();
+		}
+	});
+});
+
+describe("pi feedback archive: annotate", () => {
+	test("a single local file submission is recorded with its file path", async () => {
+		const dataDir = useTempDataDir();
+		const dir = makeTempDir("plannotator-pi-feedback-doc-");
+		const docPath = join(dir, "notes.md");
+		writeFileSync(docPath, "# Notes\n\nBody\n", "utf-8");
+		const server = await startAnnotateServer({
+			markdown: "# Notes\n\nBody\n",
+			filePath: docPath,
+			htmlContent: MINIMAL_HTML,
+			project: PI_FILE_ANNOTATE_PROJECT,
+		});
+		try {
+			const response = await fetch(`${server.url}/api/feedback`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ feedback: "Rename the helper.", annotations: [] }),
+			});
+			expect(response.status).toBe(200);
+			const records = readOnlyIndex(dataDir);
+			expect(records[0].surface).toBe("annotate");
+			expect(records[0].decision).toBe("feedback");
+			expect(records[0].target?.filePath).toBe(resolve(docPath));
+		} finally {
+			server.stop();
+		}
+	});
+
+	test("PLANNOTATOR_ANNOTATE_HISTORY=0 keeps annotate sessions fully stateless", async () => {
+		const dataDir = useTempDataDir();
+		process.env.PLANNOTATOR_ANNOTATE_HISTORY = "0";
+		const dir = makeTempDir("plannotator-pi-feedback-stateless-");
+		const docPath = join(dir, "doc.md");
+		writeFileSync(docPath, "# Doc\n\nBody\n", "utf-8");
+		const server = await startAnnotateServer({
+			markdown: "# Doc\n\nBody\n",
+			filePath: docPath,
+			htmlContent: MINIMAL_HTML,
+			project: PI_STATELESS_ANNOTATE_PROJECT,
+		});
+		try {
+			const response = await fetch(`${server.url}/api/feedback`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ feedback: "Secret excerpt", annotations: [{ id: "a1" }] }),
+			});
+			expect(response.status).toBe(200);
+			expect(existsSync(feedbackDir(dataDir))).toBe(false);
+		} finally {
+			server.stop();
+		}
+	});
+});
+
+describe("pi feedback archive: plan", () => {
+	const createdSlugs: Array<{ project: string; slug: string }> = [];
+
+	afterAll(() => {
+		for (const { project, slug } of createdSlugs) {
+			const versionPath = getPlanVersionPath(project, slug, 1);
+			if (versionPath) rmSync(join(versionPath, ".."), { recursive: true, force: true });
+		}
+	});
+
+	test("a denial names the history version file the decision was made on", async () => {
+		const dataDir = useTempDataDir();
+		const heading = `Pi feedback archive plan ${Math.random().toString(36).slice(2, 10)}`;
+		const server = await startPlanReviewServer({
+			plan: `# ${heading}\n\nStep one.\n`,
+			htmlContent: MINIMAL_HTML,
+			origin: "pi",
+		});
+		try {
+			const response = await fetch(`${server.url}/api/deny`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ feedback: "Split step one in two.", planSave: { enabled: false } }),
+			});
+			expect(response.status).toBe(200);
+
+			const records = readOnlyIndex(dataDir);
+			expect(records.length).toBe(1);
+			expect(records[0].surface).toBe("plan");
+			expect(records[0].decision).toBe("denied");
+			expect(records[0].origin).toBe("pi");
+
+			const slug = records[0].target!.slug!;
+			const project = detectProjectName();
+			createdSlugs.push({ project, slug });
+
+			const versionFile = records[0].target!.planVersionFile!;
+			expect(versionFile).toBe(getPlanVersionPath(project, slug, 1));
+			expect(readFileSync(versionFile, "utf-8")).toContain(heading);
+		} finally {
+			server.stop();
+		}
+	});
+});

package/server/serverAnnotate.ts

@@ -17,7 +17,8 @@ import { contentHash, deleteDraft } from "../generated/draft.ts";
 import { getPlanVersion, getVersionCount, listVersions } from "../generated/storage.ts";
 import { computeAnnotateHistory, deriveAnnotateHistorySlug, persistAnnotateSubmission, type AnnotateHistoryResult } from "../generated/annotate-history.ts";
 import { htmlDiff } from "../generated/html-diff.ts";
-import { saveConfig, detectGitUser, getServerConfig, isAgentTerminalSide, loadConfig, resolveAIEnabled, resolveSharingEnabled, resolveAnnotateHistory, type PromptRuntime } from "../generated/config.ts";
+import { saveConfig, detectGitUser, getServerConfig, isAgentTerminalSide, loadConfig, resolveAIEnabled, resolveSharingEnabled, resolveAnnotateHistory, resolveFeedbackHistory, type PromptRuntime } from "../generated/config.ts";
+import { appendFeedbackRecord, type FeedbackDecision, type FeedbackSurface } from "../generated/feedback-archive.ts";
 import { isFaviconStyle, type FaviconStyle } from "../generated/favicon.ts";
 import { getAnnotateFileFeedbackTemplate, getAnnotateMessageFeedbackTemplate } from "../generated/prompts.ts";
 import { disabledSourceSave, type SourceSaveRequest } from "../generated/source-save.ts";
@@ -397,6 +398,53 @@ export async function startAnnotateServer(options: {
 	// written, when there was no user content to lose, or when the session
 	// does not persist; false only when a durable write was expected and
 	// failed — the draft then stays behind as the recovery copy.
+	// --- Durable feedback archive (Node mirror of packages/server/annotate.ts) ---
+	//
+	// Unlike the legacy #678 record above, the archive covers EVERY annotate
+	// session type: it stores what the reviewer submitted, not a copy of the
+	// annotated document. Both gates apply — PLANNOTATOR_ANNOTATE_HISTORY=0
+	// still means "no annotate content in the data dir at all", and submitted
+	// feedback quotes that content, so the fully-stateless annotate promise
+	// stays verbatim true.
+	const annotateFeedbackSurface: FeedbackSurface =
+		options.mode === "annotate-app"
+			? "annotate-app"
+			: options.mode === "annotate-last"
+				? "annotate-last"
+				: options.mode === "annotate-folder"
+					? "annotate-folder"
+					: singleFileLocalAnnotate
+						? "annotate"
+						: "annotate-url";
+
+	const archiveAnnotateDecision = (
+		feedbackText: string,
+		annotationList: unknown[],
+		decision: FeedbackDecision,
+	): boolean => {
+		if (!resolveFeedbackHistory(loadConfig())) return true;
+		if (!annotateHistoryEnabled) return true;
+		const isUrlTarget = /^https?:\/\//i.test(options.filePath);
+		return (
+			appendFeedbackRecord({
+				project: annotateProjectName,
+				origin: options.origin,
+				surface: annotateFeedbackSurface,
+				decision,
+				target:
+					options.mode === "annotate-app" && options.liveApp
+						? { url: options.liveApp.targetUrl }
+						: isUrlTarget
+							? { url: options.filePath }
+							: options.mode === "annotate-last"
+								? { filePath: options.filePath }
+								: { filePath: resolvePath(options.filePath) },
+				feedback: feedbackText,
+				annotations: annotationList,
+			}) !== null
+		);
+	};
+
 	const persistSubmittedDecision = (
 		feedback: unknown,
 		annotations: unknown,
@@ -407,18 +455,26 @@ export async function startAnnotateServer(options: {
 		// behavior (settle + delete draft + 200), never throw into a 500.
 		const feedbackText = typeof feedback === "string" ? feedback : "";
 		const annotationList = Array.isArray(annotations) ? annotations : [];
-		if (!feedbackText.trim() && annotationList.length === 0) return true; // contentless (e.g. bare approve)
-		if (!annotateHistoryEnabled) return true; // opt-out: stateless annotate sessions
-		if (!singleFileLocalAnnotate) return true; // stateless modes stay stateless
-		return (
-			persistAnnotateSubmission({
-				project: annotateProjectName,
-				sessionPath: resolvePath(options.filePath),
-				feedback: feedbackText,
-				annotations: annotationList,
-				approved,
-			}) !== null
+		const hasContent = feedbackText.trim().length > 0 || annotationList.length > 0;
+		const archived = archiveAnnotateDecision(
+			feedbackText,
+			annotationList,
+			approved ? (hasContent ? "approved-with-notes" : "approved") : "feedback",
 		);
+		// Legacy #678 record: unchanged scope (single local files with content).
+		let legacyDurable = true;
+		if (hasContent && annotateHistoryEnabled && singleFileLocalAnnotate) {
+			legacyDurable =
+				persistAnnotateSubmission({
+					project: annotateProjectName,
+					sessionPath: resolvePath(options.filePath),
+					feedback: feedbackText,
+					annotations: annotationList,
+					approved,
+				}) !== null;
+		}
+		// A failed write only holds the draft back when there was content to lose.
+		return legacyDurable && (archived || !hasContent);
 	};
 
 	// Detect repo info (cached for this session)
@@ -1005,6 +1061,9 @@ export async function startAnnotateServer(options: {
 				sendAlreadyDecided(res);
 				return;
 			}
+			// Decision-only line — a dismissal has no content, so a failed
+			// write must not change the legacy draft behavior.
+			archiveAnnotateDecision("", [], "dismissed");
 			deleteDraft(draftKey, readDraftGenerationFromUrl(req));
 			clientLease.cancel();
 			json(res, { ok: true });

package/server/serverPlan.ts

@@ -41,7 +41,8 @@ import {
 } from "./integrations.ts";
 import { buildAdvertisedUrl, listenOnPort } from "./network.ts";
 
-import { loadConfig, saveConfig, detectGitUser, getServerConfig, resolveAIEnabled, resolveSharingEnabled } from "../generated/config.ts";
+import { loadConfig, saveConfig, detectGitUser, getServerConfig, resolveAIEnabled, resolveFeedbackHistory, resolveSharingEnabled } from "../generated/config.ts";
+import { appendFeedbackRecord, type FeedbackDecision } from "../generated/feedback-archive.ts";
 import { isFaviconStyle, type FaviconStyle } from "../generated/favicon.ts";
 import { readImprovementHook, getImprovementHookExpectedPath } from "../generated/improvement-hooks.ts";
 import { composeImproveContext } from "../generated/pfm-reminder.ts";
@@ -137,6 +138,39 @@ export async function startPlanReviewServer(options: {
 				}
 			: null;
 
+	// Durable feedback archive (Node mirror of packages/server/index.ts).
+	// Appends the decision to feedback/{project}/index.jsonl at settlement
+	// time, independent of the client-side planSave setting, and names the
+	// history version file rather than copying the plan text. Plan policy on
+	// failure: log and proceed — an approval is never blocked on the archive.
+	//
+	// Data-dir asymmetry worth knowing: getPlanVersionPath resolves against the
+	// data directory generated/storage.ts captured at import time, while the
+	// archive resolves it per call. They agree in every real run and can only
+	// disagree if PLANNOTATOR_DATA_DIR changes mid-process, in which case
+	// planVersionFile names where the version file was actually written.
+	const archivePlanDecision = (decision: FeedbackDecision, feedback?: string): void => {
+		if (options.mode === "archive") return;
+		if (!resolveFeedbackHistory(loadConfig())) return;
+		const version = versionInfo?.version ?? 0;
+		appendFeedbackRecord({
+			project,
+			origin: options.origin ?? "pi",
+			surface: "plan",
+			decision,
+			target: {
+				slug,
+				...(version > 0
+					? {
+							planVersion: version,
+							planVersionFile: getPlanVersionPath(project, slug, version) ?? undefined,
+						}
+					: {}),
+			},
+			feedback,
+		});
+	};
+
 	const reviewId = randomUUID();
 	let resolveDecision!: (result: PlanReviewDecision) => void;
 	const decisionListeners = new Set<(result: PlanReviewDecision) => void | Promise<void>>();
@@ -414,6 +448,11 @@ export async function startPlanReviewServer(options: {
 					planSaveCustomPath,
 				);
 			}
+			// Archive before the draft delete (#678 ordering, generalized).
+			archivePlanDecision(
+				typeof feedback === "string" && feedback.trim() ? "approved-with-notes" : "approved",
+				feedback,
+			);
 			deleteDraft(draftKey, draftGeneration);
 			const effectivePermissionMode = requestedPermissionMode || options.permissionMode;
 			publishDecision({
@@ -456,6 +495,7 @@ export async function startPlanReviewServer(options: {
 					planSaveCustomPath,
 				);
 			}
+			archivePlanDecision("denied", feedback);
 			deleteDraft(draftKey, draftGeneration);
 			publishDecision({ approved: false, feedback, savedPath });
 			json(res, { ok: true, savedPath });