@zihanw/pi-forge 0.2.0 → 0.3.0

package/src/index.ts

@@ -1,47 +1,71 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
 import { buildSessionContext, type BuildSystemPromptOptions, type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
 import {
 	compileMessages,
 	compileSystemPrompt,
 	createPromptVariableStore,
+	agentMessageToPreviewText,
 	getLatestUserMessage,
 	markSessionVariablesClean,
-	renderPreviewMessages,
 	resetTurnVariables,
 } from "./compiler.ts";
-import { chooseDefaultStack, isDisabledPromptStackId, loadPromptStacks, promptStacksDir, validatePromptStack } from "./loader.ts";
+import { chooseDefaultStack, isDisabledPromptStackId, loadPromptStacks, promptStackPath, promptStackReadDirs } from "./loader.ts";
+import { createProviderPayloadCapture, estimatePayloadTokens } from "./payload-capture.ts";
+import { applyResourcePolicy, hasResourcePolicy } from "./policy.ts";
+import { applyFinalizeRegexRulesToMessage } from "./regex.ts";
 import { importSillyTavernPreset } from "./sillytavern-importer.ts";
-import type { LoadedPromptStack, PromptStack, PromptStackDiagnostic, PromptStateValue, PromptVariableStore } from "./types.ts";
-import { DEFAULT_WEB_EDITOR_PORT, startWebEditorServer, type WebEditorCreateStackOptions, type WebEditorHost, type WebEditorServer, type WebEditorStackSummary } from "./web-editor.ts";
+import { migrateLegacyPromptStacks, renderMigrationReport } from "./stack-migration.ts";
+import type { CompileMessageSource, LoadedPromptStack, PromptStackDiagnostic, PromptVariableValue, PromptVariableStore } from "./types.ts";
+import { createWebEditorHost, loadWebEditorSettings, type WebHostRuntime } from "./web-host.ts";
+import { startWebEditorServer, type WebEditorPayloadCapture, type WebEditorPayloadSnapshot, type WebEditorPreview, type WebEditorPreviewSection, type WebEditorServer } from "./web-editor/index.ts";
 
 const STATE_ENTRY_TYPE = "pi-forge-prompt-stack-state";
 const VARIABLE_ENTRY_TYPE = "pi-forge-variable-state";
-const AGENT_VAR_PREFIX = "agent.";
+const WEB_EDITOR_GLOBAL_KEY = "__piForgeWebEditor";
 
-type StateActor = "agent" | "user";
+type PayloadDisplayTarget = "editor" | "web";
 
-interface StateUpdateInput {
-	name: string;
-	value: PromptStateValue;
-	reason?: string;
+interface SharedWebEditorState {
+	server?: WebEditorServer;
+	cwd?: string;
+	preferredPort?: number;
+}
+
+interface SharedWebEditorRegistry {
+	byCwd: Record<string, SharedWebEditorState | undefined>;
+}
+
+type PiForgeGlobal = typeof globalThis & {
+	__piForgeWebEditor?: SharedWebEditorRegistry;
+};
+
+function getSharedWebEditorRegistry(): SharedWebEditorRegistry {
+	const globalScope = globalThis as PiForgeGlobal;
+	globalScope[WEB_EDITOR_GLOBAL_KEY] ??= { byCwd: {} };
+	return globalScope[WEB_EDITOR_GLOBAL_KEY];
 }
 
 export default function piForge(pi: ExtensionAPI) {
+	const sharedWebEditors = getSharedWebEditorRegistry();
 	let stacks: LoadedPromptStack[] = [];
 	let active: LoadedPromptStack | undefined;
 	let currentSystemPromptOptions: BuildSystemPromptOptions | undefined;
 	let currentLatestUserMessage: string | undefined;
 	let currentVariableStore: PromptVariableStore | undefined;
 	let contextRewritePending = false;
-	let sessionVariables: Record<string, PromptStateValue> = {};
+	let sessionVariables: Record<string, PromptVariableValue> = {};
 	let lastPersistedActiveId: string | undefined;
 	let interceptNextProviderPayload = false;
 	let interceptPayloadSavePath: string | undefined;
+	let interceptPayloadDisplayTarget: PayloadDisplayTarget = "editor";
+	let payloadCaptureArmedAt: string | undefined;
+	let latestProviderPayloadCapture: WebEditorPayloadCapture | undefined;
 	let latestCompileDiagnostics: PromptStackDiagnostic[] = [];
 	let webEditor: WebEditorServer | undefined;
 	let webEditorCwd: string | undefined;
+	let webEditorPreferredPort: number | undefined;
+	let toolPolicyBaseline: string[] | undefined;
 
 	function activeId(): string | undefined {
 		return active?.stack.id;
@@ -63,6 +87,7 @@ export default function piForge(pi: ExtensionAPI) {
 			active = undefined;
 			if (id) persistActiveSelection("none");
 			if (ctx) updateStatus(ctx);
+			syncActiveToolPolicy(ctx);
 			return true;
 		}
 
@@ -71,6 +96,7 @@ export default function piForge(pi: ExtensionAPI) {
 		active = found;
 		persistActiveSelection(found.stack.id);
 		if (ctx) updateStatus(ctx);
+		syncActiveToolPolicy(ctx);
 		return true;
 	}
 
@@ -78,6 +104,7 @@ export default function piForge(pi: ExtensionAPI) {
 		if (!ctx.isProjectTrusted()) {
 			stacks = [];
 			active = undefined;
+			syncActiveToolPolicy(ctx);
 			ctx.ui.notify("pi-forge: project is not trusted; prompt stacks are disabled.", "warning");
 			updateStatus(ctx);
 			return;
@@ -86,6 +113,7 @@ export default function piForge(pi: ExtensionAPI) {
 		stacks = loadPromptStacks(ctx.cwd);
 		active = chooseDefaultStack(stacks, preferredId);
 		updateStatus(ctx);
+		syncActiveToolPolicy(ctx);
 	}
 
 	function updateStatus(ctx: ExtensionContext): void {
@@ -98,6 +126,37 @@ export default function piForge(pi: ExtensionAPI) {
 		}
 	}
 
+	function syncActiveToolPolicy(ctx?: ExtensionContext): void {
+		const policy = active?.stack.tools;
+		if (!hasResourcePolicy(policy)) {
+			restoreToolPolicy(ctx);
+			return;
+		}
+
+		const baseline = toolPolicyBaseline ?? pi.getActiveTools();
+		toolPolicyBaseline ??= [...baseline];
+		const nextTools = applyResourcePolicy(filterKnownTools(baseline), policy);
+		pi.setActiveTools(nextTools);
+		if (ctx) {
+			const label = nextTools.length > 0 ? `tools:${nextTools.length}` : "tools:none";
+			ctx.ui.setStatus("pi-forge-tools", ctx.ui.theme.fg(nextTools.length > 0 ? "accent" : "warning", label));
+		}
+	}
+
+	function restoreToolPolicy(ctx?: ExtensionContext): void {
+		if (toolPolicyBaseline) {
+			pi.setActiveTools(filterKnownTools(toolPolicyBaseline));
+			toolPolicyBaseline = undefined;
+		}
+		if (ctx) ctx.ui.setStatus("pi-forge-tools", undefined);
+	}
+
+	function filterKnownTools(names: string[]): string[] {
+		const known = new Set(pi.getAllTools().map((tool) => tool.name));
+		if (known.size === 0) return names;
+		return names.filter((name) => known.has(name));
+	}
+
 	function notifyActivePreset(ctx: ExtensionContext, detail: string): void {
 		if (!active) return;
 		const errorCount = active.diagnostics.filter((d) => d.level === "error").length;
@@ -117,241 +176,129 @@ export default function piForge(pi: ExtensionAPI) {
 		ctx.ui.setStatus("pi-forge-diagnostics", undefined);
 	}
 
-	function stackSummary(loaded: LoadedPromptStack): WebEditorStackSummary {
-		const errors = loaded.diagnostics.filter((d) => d.level === "error").length;
-		const warnings = loaded.diagnostics.filter((d) => d.level === "warning").length;
+	function webHostRuntime(ctx: ExtensionCommandContext): WebHostRuntime {
 		return {
-			id: loaded.stack.id,
-			name: loaded.stack.name,
-			filePath: loaded.filePath,
-			active: loaded === active,
-			autoActivate: loaded.stack.autoActivate,
-			mode: loaded.stack.mode ?? "replace",
-			itemCount: loaded.stack.items.length,
-			errors,
-			warnings,
-			diagnostics: loaded.diagnostics,
-		};
-	}
-
-	function stackSummaries(): WebEditorStackSummary[] {
-		return stacks.map(stackSummary);
-	}
-
-	function createWebEditorHost(ctx: ExtensionCommandContext): WebEditorHost {
-		return {
-			cwd: ctx.cwd,
-			listStacks: () => stackSummaries(),
-			getStack: (id) => {
-				const loaded = stacks.find((candidate) => candidate.stack.id === id);
-				return loaded ? { stack: loaded.stack, filePath: loaded.filePath, diagnostics: loaded.diagnostics } : undefined;
+			getStacks: () => stacks,
+			getActive: () => active,
+			getActiveId: activeId,
+			getSelectedActiveId: selectedActiveId,
+			setActive: (id) => setActive(id, ctx),
+			reloadStacks: (preferredId) => reloadStacks(ctx, preferredId),
+			buildPreview: (target) => buildPreview(ctx, target),
+			getPayload: () => ({ ok: true, ...webPayloadSnapshot() }),
+			armPayload: (savePath) => {
+				armPayloadIntercept(ctx, savePath, "web");
+				return { ok: true, ...webPayloadSnapshot() };
 			},
-			createStack: (stack, options) => createStackFile(ctx, stack, options),
-			saveStack: (id, stack) => {
-				if (!ctx.isProjectTrusted()) {
-					return { ok: false, status: 403, error: "Project is not trusted; refusing to save prompt stacks." };
-				}
-
-				const target = stacks.find((candidate) => candidate.stack.id === id);
-				if (!target) return { ok: false, status: 404, error: `Unknown prompt stack: ${id}` };
-				if (!isInsidePromptStacksDir(ctx.cwd, target.filePath)) {
-					return { ok: false, status: 403, error: "Refusing to save outside .pi/prompt-stacks." };
-				}
-
-				writeFileSync(target.filePath, `${JSON.stringify(stack, null, 2)}\n`, "utf8");
-				const preferredId = active?.stack.id === id ? stack.id : selectedActiveId();
-				reloadStacks(ctx, preferredId);
-				const saved = stacks.find((candidate) => candidate.stack.id === stack.id) ?? stacks.find((candidate) => candidate.filePath === target.filePath);
-				if (!saved) return { ok: false, status: 500, error: "Saved stack could not be reloaded." };
-				return { ok: true, stack: stackSummary(saved), stacks: stackSummaries() };
-			},
-			deleteStack: (id) => deleteStackFile(ctx, id),
-			validateStack: (stack) => validatePromptStack(stack),
-			previewStack: (id, stack) => {
-				const target = stacks.find((candidate) => candidate.stack.id === id);
-				if (!target) return { ok: false, status: 404, error: `Unknown prompt stack: ${id}` };
-				const diagnostics = validatePromptStack(stack);
-				const text = renderPreview(ctx, { stack, filePath: target.filePath, diagnostics });
-				return { ok: true, text, diagnostics };
-			},
-			activateStack: (id) => {
-				if (!setActive(id, ctx)) return { ok: false, status: 404, error: `Unknown prompt stack: ${id}` };
-				return { ok: true, activeId: activeId(), stacks: stackSummaries() };
-			},
-			disableStacks: () => {
-				setActive("none", ctx);
-				return { ok: true, activeId: activeId(), stacks: stackSummaries() };
-			},
-			reloadStacks: () => {
-				reloadStacks(ctx, selectedActiveId());
-				return { ok: true, activeId: activeId(), stacks: stackSummaries() };
+			clearPayload: () => {
+				clearPayloadCapture(ctx);
+				return { ok: true, ...webPayloadSnapshot() };
 			},
 		};
 	}
 
-	function createStackFile(
-		ctx: ExtensionCommandContext,
-		stack: PromptStack,
-		options: WebEditorCreateStackOptions,
-	): { ok: true; stack: WebEditorStackSummary; stacks: WebEditorStackSummary[] } | { ok: false; status?: number; error: string } {
-		if (!ctx.isProjectTrusted()) {
-			return { ok: false, status: 403, error: "Project is not trusted; refusing to create prompt stacks." };
-		}
-
-		const idError = validateWebStackId(stack.id);
-		if (idError) return { ok: false, status: 400, error: idError };
-
-		const stacksDir = promptStacksDir(ctx.cwd);
-		const targetPath = join(stacksDir, `${stack.id}.json`);
-		if (!isInsidePromptStacksDir(ctx.cwd, targetPath)) {
-			return { ok: false, status: 403, error: "Refusing to create outside .pi/prompt-stacks." };
-		}
-
-		const existingById = stacks.find((candidate) => candidate.stack.id === stack.id);
-		if (existingById && resolve(existingById.filePath) !== resolve(targetPath)) {
-			return { ok: false, status: 409, error: `Stack id already exists in ${existingById.filePath}.` };
-		}
-		if ((existsSync(targetPath) || existingById) && !options.overwrite) {
-			return { ok: false, status: 409, error: `Prompt stack already exists: ${stack.id}` };
-		}
-
-		const previousSelection = selectedActiveId();
-		mkdirSync(stacksDir, { recursive: true });
-		writeFileSync(targetPath, `${JSON.stringify(stack, null, 2)}\n`, "utf8");
-		reloadStacks(ctx, options.activate ? stack.id : (previousSelection ?? "none"));
-		if (options.activate) setActive(stack.id, ctx);
+	function sharedWebEditorForCwd(cwd: string): SharedWebEditorState {
+		sharedWebEditors.byCwd[cwd] ??= {};
+		return sharedWebEditors.byCwd[cwd];
+	}
 
-		const created = stacks.find((candidate) => candidate.stack.id === stack.id);
-		if (!created) return { ok: false, status: 500, error: "Created stack could not be reloaded." };
-		return { ok: true, stack: stackSummary(created), stacks: stackSummaries() };
+	function syncWebEditorFromShared(cwd: string): void {
+		const shared = sharedWebEditorForCwd(cwd);
+		webEditor = shared.server;
+		webEditorCwd = shared.cwd;
+		webEditorPreferredPort = shared.preferredPort;
 	}
 
-	function deleteStackFile(
-		ctx: ExtensionCommandContext,
-		id: string,
-	): { ok: true; activeId?: string; stacks: WebEditorStackSummary[] } | { ok: false; status?: number; error: string } {
-		if (!ctx.isProjectTrusted()) {
-			return { ok: false, status: 403, error: "Project is not trusted; refusing to delete prompt stacks." };
-		}
+	function rememberWebEditor(server: WebEditorServer, cwd: string, preferredPort: number | undefined): void {
+		const shared = sharedWebEditorForCwd(cwd);
+		webEditor = server;
+		webEditorCwd = cwd;
+		webEditorPreferredPort = preferredPort;
+		shared.server = server;
+		shared.cwd = cwd;
+		shared.preferredPort = preferredPort;
+	}
 
-		const target = stacks.find((candidate) => candidate.stack.id === id);
-		if (!target) return { ok: false, status: 404, error: `Unknown prompt stack: ${id}` };
-		if (!isInsidePromptStacksDir(ctx.cwd, target.filePath)) {
-			return { ok: false, status: 403, error: "Refusing to delete outside .pi/prompt-stacks." };
+	function clearWebEditor(server: WebEditorServer): void {
+		if (webEditor === server) {
+			webEditor = undefined;
+			webEditorCwd = undefined;
+			webEditorPreferredPort = undefined;
 		}
-
-		const wasActive = active?.stack.id === id;
-		unlinkSync(target.filePath);
-		if (wasActive) {
-			setActive("none", ctx);
-			reloadStacks(ctx, "none");
-		} else {
-			reloadStacks(ctx, selectedActiveId());
+		for (const [cwd, shared] of Object.entries(sharedWebEditors.byCwd)) {
+			if (shared?.server === server) delete sharedWebEditors.byCwd[cwd];
 		}
-		return { ok: true, activeId: activeId(), stacks: stackSummaries() };
 	}
 
-	function validateWebStackId(id: string): string | undefined {
-		if (!id.trim()) return "Stack id must not be empty.";
-		if (!/^[A-Za-z0-9_-]+$/.test(id)) {
-			return "Stack id may only contain letters, numbers, underscore, and dash.";
-		}
-		return undefined;
+	function refreshWebEditorHost(ctx: ExtensionContext): void {
+		syncWebEditorFromShared(ctx.cwd);
+		if (!webEditor) return;
+		const commandCtx = ctx as ExtensionCommandContext;
+		webEditor.updateHost(createWebEditorHost(commandCtx, webHostRuntime(commandCtx)));
+		rememberWebEditor(webEditor, ctx.cwd, webEditorPreferredPort);
+		ctx.ui.setStatus("pi-forge-editor", ctx.ui.theme.fg("accent", `editor:${webEditor.port}`));
 	}
 
 	async function openWebEditor(ctx: ExtensionCommandContext, mode: "open" | "restart" = "open"): Promise<void> {
+		syncWebEditorFromShared(ctx.cwd);
 		const settings = loadWebEditorSettings(ctx);
 		for (const warning of settings.warnings) ctx.ui.notify(warning, "warning");
 
-		if (webEditor && (mode === "restart" || webEditorCwd !== ctx.cwd || webEditor.port !== settings.port)) {
-			await webEditor.close();
-			webEditor = undefined;
-			webEditorCwd = undefined;
+		if (webEditor && (mode === "restart" || webEditorPreferredPort !== settings.preferredPort)) {
+			const server = webEditor;
+			await server.close();
+			clearWebEditor(server);
 			ctx.ui.setStatus("pi-forge-editor", undefined);
 		}
 
 		if (!webEditor) {
 			try {
-				webEditor = await startWebEditorServer(createWebEditorHost(ctx), { port: settings.port });
+				webEditor = await startWebEditorServer(createWebEditorHost(ctx, webHostRuntime(ctx)), { port: settings.preferredPort });
 			} catch (error) {
-				const detail = error instanceof Error ? error.message : String(error);
-				ctx.ui.setStatus("pi-forge-editor", undefined);
-				ctx.ui.notify(`pi-forge: failed to start stack editor on 127.0.0.1:${settings.port}: ${detail}. Change ${settings.configPath} or stop the process using that port.`, "error");
-				return;
+				if (settings.preferredPort !== undefined) {
+					const detail = error instanceof Error ? error.message : String(error);
+					ctx.ui.notify(`pi-forge: preferred editor port 127.0.0.1:${settings.preferredPort} was unavailable (${detail}); using an available port instead.`, "warning");
+					try {
+						webEditor = await startWebEditorServer(createWebEditorHost(ctx, webHostRuntime(ctx)));
+					} catch (fallbackError) {
+						const fallbackDetail = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+						ctx.ui.setStatus("pi-forge-editor", undefined);
+						ctx.ui.notify(`pi-forge: failed to start stack editor on an available localhost port: ${fallbackDetail}.`, "error");
+						return;
+					}
+				} else {
+					const detail = error instanceof Error ? error.message : String(error);
+					ctx.ui.setStatus("pi-forge-editor", undefined);
+					ctx.ui.notify(`pi-forge: failed to start stack editor on an available localhost port: ${detail}.`, "error");
+					return;
+				}
 			}
-			webEditorCwd = ctx.cwd;
+			rememberWebEditor(webEditor, ctx.cwd, settings.preferredPort);
 			ctx.ui.setStatus("pi-forge-editor", ctx.ui.theme.fg("accent", `editor:${webEditor.port}`));
 			ctx.ui.notify(`pi-forge: stack editor running at ${webEditor.url}`, "info");
 		} else {
+			webEditor.updateHost(createWebEditorHost(ctx, webHostRuntime(ctx)));
+			rememberWebEditor(webEditor, ctx.cwd, settings.preferredPort);
+			ctx.ui.setStatus("pi-forge-editor", ctx.ui.theme.fg("accent", `editor:${webEditor.port}`));
 			ctx.ui.notify(`pi-forge: stack editor already running at ${webEditor.url}`, "info");
 		}
 
 		await showText(ctx, "pi-forge stack editor", `Open the local stack editor:\n\n${webEditor.url}\n\nServer bound to 127.0.0.1:${webEditor.port}\nOptional config: ${settings.configPath}\nProject: ${webEditorCwd}`);
 	}
 
-	function loadWebEditorSettings(ctx: ExtensionCommandContext): { port: number; configPath: string; warnings: string[] } {
-		const configPath = join(ctx.cwd, ".pi", "forge", "config.json");
-		if (!ctx.isProjectTrusted() || !existsSync(configPath)) {
-			return { port: DEFAULT_WEB_EDITOR_PORT, configPath, warnings: [] };
-		}
-
-		let raw: unknown;
-		try {
-			raw = JSON.parse(readFileSync(configPath, "utf8"));
-		} catch (error) {
-			return {
-				port: DEFAULT_WEB_EDITOR_PORT,
-				configPath,
-				warnings: [`pi-forge: failed to read ${configPath}; using editor port ${DEFAULT_WEB_EDITOR_PORT}. ${error instanceof Error ? error.message : String(error)}`],
-			};
-		}
-
-		if (!isPlainObject(raw)) {
-			return {
-				port: DEFAULT_WEB_EDITOR_PORT,
-				configPath,
-				warnings: [`pi-forge: ${configPath} must be a JSON object; using editor port ${DEFAULT_WEB_EDITOR_PORT}.`],
-			};
-		}
-
-		const webEditorConfig = isPlainObject(raw.webEditor) ? raw.webEditor : undefined;
-		const rawPort = webEditorConfig?.port ?? raw.webEditorPort;
-		if (rawPort === undefined) return { port: DEFAULT_WEB_EDITOR_PORT, configPath, warnings: [] };
-
-		if (typeof rawPort === "number" && Number.isInteger(rawPort) && rawPort >= 1 && rawPort <= 65535) {
-			return { port: rawPort, configPath, warnings: [] };
-		}
-
-		return {
-			port: DEFAULT_WEB_EDITOR_PORT,
-			configPath,
-			warnings: [`pi-forge: ${configPath} webEditor.port must be an integer from 1 to 65535; using editor port ${DEFAULT_WEB_EDITOR_PORT}.`],
-		};
-	}
-
-	function isPlainObject(value: unknown): value is Record<string, unknown> {
-		return !!value && typeof value === "object" && !Array.isArray(value);
-	}
-
 	async function stopWebEditor(ctx: ExtensionCommandContext): Promise<void> {
+		syncWebEditorFromShared(ctx.cwd);
 		if (!webEditor) {
 			ctx.ui.notify("pi-forge: stack editor is not running.", "info");
 			return;
 		}
-		await webEditor.close();
-		webEditor = undefined;
-		webEditorCwd = undefined;
+		const server = webEditor;
+		await server.close();
+		clearWebEditor(server);
 		ctx.ui.setStatus("pi-forge-editor", undefined);
 		ctx.ui.notify("pi-forge: stack editor stopped.", "info");
 	}
 
-	function isInsidePromptStacksDir(cwd: string, filePath: string): boolean {
-		const root = resolve(promptStacksDir(cwd));
-		const target = resolve(filePath);
-		const rel = relative(root, target);
-		return !!rel && !rel.startsWith("..") && !isAbsolute(rel);
-	}
-
 	function getCurrentBranchEntries(ctx: ExtensionContext): unknown[] {
 		const leafId = ctx.sessionManager.getLeafId();
 		if (leafId === null) return [];
@@ -373,13 +320,13 @@ export default function piForge(pi: ExtensionAPI) {
 		return undefined;
 	}
 
-	function getRestoredVariables(ctx: ExtensionContext): Record<string, PromptStateValue> {
+	function getRestoredVariables(ctx: ExtensionContext): Record<string, PromptVariableValue> {
 		const entries = getCurrentBranchEntries(ctx);
 		for (let i = entries.length - 1; i >= 0; i--) {
 			const entry = entries[i] as { type?: string; customType?: string; data?: { variables?: unknown } };
 			if (entry.type !== "custom" || entry.customType !== VARIABLE_ENTRY_TYPE) continue;
 			if (!entry.data || typeof entry.data.variables !== "object" || Array.isArray(entry.data.variables)) return {};
-			return normalizeStateRecord(entry.data.variables as Record<string, unknown>);
+			return normalizeVariableRecord(entry.data.variables as Record<string, unknown>);
 		}
 		return {};
 	}
@@ -391,135 +338,25 @@ export default function piForge(pi: ExtensionAPI) {
 		markSessionVariablesClean(store);
 	}
 
-	function normalizeStateRecord(value: Record<string, unknown>): Record<string, PromptStateValue> {
-		const result: Record<string, PromptStateValue> = {};
+	function normalizeVariableRecord(value: Record<string, unknown>): Record<string, PromptVariableValue> {
+		const result: Record<string, PromptVariableValue> = {};
 		for (const [key, raw] of Object.entries(value)) {
-			if (isPromptStateValue(raw)) result[key] = raw;
+			if (isPromptVariableValue(raw)) result[key] = raw;
 		}
 		return result;
 	}
 
-	function isPromptStateValue(value: unknown): value is PromptStateValue {
+	function isPromptVariableValue(value: unknown): value is PromptVariableValue {
 		if (value === null) return true;
 		const type = typeof value;
 		if (type === "string" || type === "boolean") return true;
 		if (type === "number") return Number.isFinite(value);
-		if (Array.isArray(value)) return value.every(isPromptStateValue);
+		if (Array.isArray(value)) return value.every(isPromptVariableValue);
 		if (!value || typeof value !== "object") return false;
-		return Object.values(value as Record<string, unknown>).every(isPromptStateValue);
-	}
-
-	function validateStateName(name: string): string | undefined {
-		if (!name.trim()) return "state name must not be empty";
-		if (!/^[A-Za-z0-9_.:-]+$/.test(name)) {
-			return "state name may only contain letters, numbers, underscore, dash, dot, and colon";
-		}
-		return undefined;
-	}
-
-	function validateStateUpdate(update: StateUpdateInput, actor: StateActor): string | undefined {
-		const permissionError = validateStateWritePermission(update.name, actor, actor === "agent" ? "write" : "set");
-		if (permissionError) return permissionError;
-
-		const definition = active?.stack.state?.definitions?.[update.name];
-		if (definition?.type) {
-			const typeError = validateStateValueType(update.value, definition.type);
-			if (typeError) return `${update.name}: expected ${definition.type}, got ${typeError}`;
-		}
-		return undefined;
-	}
-
-	function validateStateClear(name: string, actor: StateActor): string | undefined {
-		return validateStateWritePermission(name, actor, "clear");
-	}
-
-	function validateStateWritePermission(name: string, actor: StateActor, action: "set" | "write" | "clear"): string | undefined {
-		const nameError = validateStateName(name);
-		if (nameError) return `${name || "(empty)"}: ${nameError}`;
-
-		if (actor === "agent" && !name.startsWith(AGENT_VAR_PREFIX)) {
-			return `${name}: agents may only ${action} ${AGENT_VAR_PREFIX}* state`;
-		}
-
-		const definition = active?.stack.state?.definitions?.[name];
-		if (actor === "agent" && definition?.agentWritable === false) {
-			return `${name}: stack schema marks this state as not agent-writable`;
-		}
-		if (actor === "user" && definition?.userWritable === false) {
-			return `${name}: stack schema marks this state as not user-writable`;
-		}
-		return undefined;
-	}
-
-	function applyStatePatch(updates: StateUpdateInput[], clears: string[], actor: StateActor): { ok: true; updated: number; cleared: number } | { ok: false; error: string } {
-		for (const update of updates) {
-			const error = validateStateUpdate(update, actor);
-			if (error) return { ok: false, error };
-		}
-		for (const name of clears) {
-			const error = validateStateClear(name, actor);
-			if (error) return { ok: false, error };
-		}
-
-		for (const update of updates) {
-			sessionVariables[update.name] = update.value;
-			if (currentVariableStore) currentVariableStore.session[update.name] = update.value;
-		}
-		for (const name of clears) {
-			delete sessionVariables[name];
-			if (currentVariableStore) delete currentVariableStore.session[name];
-		}
-
-		pi.appendEntry(VARIABLE_ENTRY_TYPE, { variables: { ...sessionVariables } });
-		if (currentVariableStore) markSessionVariablesClean(currentVariableStore);
-		return { ok: true, updated: updates.length, cleared: clears.length };
-	}
-
-	function validateStateValueType(value: PromptStateValue, typeExpression: string): string | undefined {
-		const types = typeExpression.split("|").map((part) => part.trim()).filter(Boolean);
-		if (types.length === 0 || types.some((type) => stateValueMatchesType(value, type))) return undefined;
-		return inferRuntimeType(value);
-	}
-
-	function stateValueMatchesType(value: PromptStateValue, type: string): boolean {
-		if (type === "any" || type === "unknown" || type === "json" || type === "Json") return true;
-		if (type === "null") return value === null;
-		if (type === "array" || type === "unknown[]") return Array.isArray(value);
-		if (type === "object" || type === "Record<string, unknown>" || type === "Record<string, any>") {
-			return !!value && typeof value === "object" && !Array.isArray(value);
-		}
-		if (type.endsWith("[]")) {
-			if (!Array.isArray(value)) return false;
-			const itemType = type.slice(0, -2).trim();
-			return value.every((item) => stateValueMatchesType(item, itemType));
-		}
-		return typeof value === type;
-	}
-
-	function inferRuntimeType(value: PromptStateValue): string {
-		if (value === null) return "null";
-		if (Array.isArray(value)) return "array";
-		return typeof value;
-	}
-
-	function parseStateCommandValue(raw: string): PromptStateValue {
-		const trimmed = raw.trim();
-		if (/^(true|false|null|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|["[{])/.test(trimmed)) {
-			try {
-				const parsed = JSON.parse(trimmed);
-				if (isPromptStateValue(parsed)) return parsed;
-			} catch {
-				// Fall back to string for friendly command input.
-			}
-		}
-		return raw;
+		return Object.values(value as Record<string, unknown>).every(isPromptVariableValue);
 	}
 
-	function formatStateValue(value: PromptStateValue): string {
-		return typeof value === "string" ? value : JSON.stringify(value, null, 2);
-	}
-
-	function restoreBranchScopedState(ctx: ExtensionContext): void {
+	function restoreBranchScopedRuntime(ctx: ExtensionContext): void {
 		sessionVariables = getRestoredVariables(ctx);
 		currentVariableStore = undefined;
 		const restoredActiveId = getRestoredActiveId(ctx);
@@ -528,21 +365,25 @@ export default function piForge(pi: ExtensionAPI) {
 	}
 
 	pi.on("session_start", async (event, ctx) => {
-		restoreBranchScopedState(ctx);
+		restoreBranchScopedRuntime(ctx);
+		refreshWebEditorHost(ctx);
 		notifyActivePreset(ctx, "after session " + event.reason);
 	});
 
 	pi.on("session_tree", async (_event, ctx) => {
-		restoreBranchScopedState(ctx);
+		restoreBranchScopedRuntime(ctx);
+		refreshWebEditorHost(ctx);
 		notifyActivePreset(ctx, "after tree navigation");
 	});
 
 	pi.on("session_compact", async (_event, ctx) => {
-		restoreBranchScopedState(ctx);
+		restoreBranchScopedRuntime(ctx);
+		refreshWebEditorHost(ctx);
 		notifyActivePreset(ctx, "after compaction");
 	});
 
 	pi.on("turn_start", async () => {
+		syncActiveToolPolicy();
 		const id = activeId();
 		if (id) persistActiveSelection(id);
 	});
@@ -588,6 +429,15 @@ export default function piForge(pi: ExtensionAPI) {
 		return { messages: result.messages };
 	});
 
+	pi.on("message_end", async (event, ctx) => {
+		if (!active) return;
+		const diagnostics: PromptStackDiagnostic[] = [];
+		const message = applyFinalizeRegexRulesToMessage(active.stack, event.message, diagnostics);
+		if (diagnostics.length > 0) recordCompileDiagnostics(ctx, [...latestCompileDiagnostics, ...diagnostics]);
+		if (!message) return;
+		return { message };
+	});
+
 	pi.on("agent_end", async () => {
 		persistVariablesIfDirty(currentVariableStore);
 		currentSystemPromptOptions = undefined;
@@ -599,139 +449,61 @@ export default function piForge(pi: ExtensionAPI) {
 	pi.on("before_provider_request", async (event, ctx) => {
 		if (!interceptNextProviderPayload) return;
 		const savePath = interceptPayloadSavePath;
+		const displayTarget = interceptPayloadDisplayTarget;
 		interceptNextProviderPayload = false;
 		interceptPayloadSavePath = undefined;
+		interceptPayloadDisplayTarget = "editor";
+		payloadCaptureArmedAt = undefined;
 		ctx.ui.setStatus("pi-forge-intercept", undefined);
 
-		const payload = safeStringify(event.payload);
-		const approxTokens = estimatePayloadTokens(payload);
+		const capture = captureProviderPayload(event.payload, savePath);
 		if (savePath) {
 			if (!ctx.isProjectTrusted()) {
 				ctx.ui.notify("pi-forge: project is not trusted; refusing to save provider payload.", "warning");
 			} else {
 				const resolvedPath = savePath.startsWith("/") ? savePath : join(ctx.cwd, savePath);
 				mkdirSync(dirname(resolvedPath), { recursive: true });
-				writeFileSync(resolvedPath, payload, "utf8");
-				ctx.ui.notify(`pi-forge: provider payload saved to ${resolvedPath} (${payload.length} chars, ~${approxTokens} tokens)`, "info");
+				writeFileSync(resolvedPath, capture.text, "utf8");
+				ctx.ui.notify(`pi-forge: provider payload saved to ${resolvedPath} (${capture.chars} chars, ~${capture.approxTokens} tokens)`, "info");
 			}
 		}
 
-		if (ctx.hasUI) {
-			await ctx.ui.editor(`pi-forge: provider payload (${payload.length} chars, ~${approxTokens} tokens)`, payload);
+		if (displayTarget === "web") {
+			ctx.ui.notify(`pi-forge: provider payload captured for web editor (${capture.chars} chars, ~${capture.approxTokens} tokens).`, "info");
 			return;
 		}
 
-		console.log(payload);
-	});
-
-	pi.registerTool({
-		name: "forge_state_set",
-		label: "Set Prompt State",
-		description: "Batch update persistent prompt state for future turns. Only names starting with 'agent.' can be written by the agent.",
-		promptSnippet: "Batch update agent-scoped prompt state for cross-turn continuity. Use this when durable state should be visible in the prompt_state slot on future turns.",
-		promptGuidelines: [
-			"Use forge_state_set to persist concise cross-turn state such as task progress, story state, open questions, or durable facts the user asked you to remember.",
-			`Only state names starting with '${AGENT_VAR_PREFIX}' are writable by the agent. User and stack configuration state are read-only to the agent.`,
-			"Prefer one batch update at natural checkpoints instead of many small updates. Do not store secrets or large transcripts.",
-			"State written by this tool is primarily for future turns; the current prompt has already been built.",
-		],
-		parameters: Type.Object({
-			updates: Type.Optional(Type.Array(Type.Object({
-				name: Type.String({ description: `State name (must start with '${AGENT_VAR_PREFIX}')` }),
-				value: Type.Unknown({ description: "JSON-compatible value: string, number, boolean, null, array, or object" }),
-				reason: Type.Optional(Type.String({ description: "Brief reason for the update" })),
-			}))),
-			clears: Type.Optional(Type.Array(Type.String({ description: `State names to clear (must start with '${AGENT_VAR_PREFIX}')` }))),
-		}),
-		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-			const updatesRaw = Array.isArray(params.updates) ? params.updates : [];
-			const clears = Array.isArray(params.clears) ? params.clears.filter((name): name is string => typeof name === "string") : [];
-			const updates: StateUpdateInput[] = [];
-
-			for (const raw of updatesRaw) {
-				if (!raw || typeof raw !== "object") {
-					return {
-						content: [{ type: "text", text: "Error: every update must be an object." }],
-						details: { error: "invalid update" },
-					};
-				}
-				const update = raw as { name?: unknown; value?: unknown; reason?: unknown };
-				if (typeof update.name !== "string") {
-					return {
-						content: [{ type: "text", text: "Error: every update needs a string name." }],
-						details: { error: "invalid update name" },
-					};
-				}
-				if (!isPromptStateValue(update.value)) {
-					return {
-						content: [{ type: "text", text: `Error: ${update.name} value is not JSON-compatible.` }],
-						details: { error: "invalid value", name: update.name },
-					};
-				}
-				updates.push({
-					name: update.name,
-					value: update.value,
-					reason: typeof update.reason === "string" ? update.reason : undefined,
-				});
-			}
-
-			if (updates.length === 0 && clears.length === 0) {
-				return {
-					content: [{ type: "text", text: "No state updates or clears provided." }],
-					details: { updated: 0, cleared: 0 },
-				};
-			}
-
-			const result = applyStatePatch(updates, clears, "agent");
-			if (!result.ok) {
-				return {
-					content: [{ type: "text", text: `Error: ${result.error}` }],
-					details: { error: result.error },
-				};
-			}
+		if (ctx.hasUI) {
+			await ctx.ui.editor(`pi-forge: provider payload (${capture.chars} chars, ~${capture.approxTokens} tokens)`, capture.text);
+			return;
+		}
 
-			return {
-				content: [{ type: "text", text: `State updated: ${result.updated} set, ${result.cleared} cleared.` }],
-				details: { updated: updates.map(({ name, value, reason }) => ({ name, value, reason })), cleared: clears },
-			};
-		},
+		console.log(capture.text);
 	});
 
-	pi.registerTool({
-		name: "forge_set_var",
-		label: "Set Prompt Variable",
-		description: "Compatibility alias for forge_state_set. Set one persistent agent-scoped state value. Only variables starting with 'agent.' can be written by the agent.",
-		promptSnippet: "Compatibility alias for forge_state_set. Prefer forge_state_set for batch prompt state updates.",
-		promptGuidelines: [
-			"Prefer forge_state_set when updating prompt state. forge_set_var only exists for compatibility with older prompt stacks.",
-			`Only variable names starting with '${AGENT_VAR_PREFIX}' are writable.`,
-		],
-		parameters: Type.Object({
-			name: Type.String({ description: `Variable name (must start with '${AGENT_VAR_PREFIX}')` }),
-			value: Type.String({ description: "Variable value" }),
-		}),
-		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-			const result = applyStatePatch([{ name: params.name, value: params.value }], [], "agent");
-			if (!result.ok) {
-				return {
-					content: [{ type: "text", text: `Error: ${result.error}` }],
-					details: { error: result.error, name: params.name },
-				};
-			}
-			return {
-				content: [{ type: "text", text: `Variable ${params.name} set.` }],
-				details: { name: params.name, value: params.value },
-			};
-		},
-	});
-
-	function armPayloadIntercept(ctx: ExtensionCommandContext, savePath?: string): void {
+	function armPayloadIntercept(ctx: ExtensionCommandContext, savePath?: string, displayTarget: PayloadDisplayTarget = "editor"): void {
 		interceptNextProviderPayload = true;
 		interceptPayloadSavePath = savePath;
+		interceptPayloadDisplayTarget = displayTarget;
+		payloadCaptureArmedAt = new Date().toISOString();
+		latestProviderPayloadCapture = undefined;
 		ctx.ui.setStatus("pi-forge-intercept", ctx.ui.theme.fg("warning", savePath ? "payload:armed+save" : "payload:armed"));
+		if (displayTarget === "web") {
+			ctx.ui.notify(savePath ? `pi-forge: next provider payload will be captured in the web editor and saved to ${savePath}.` : "pi-forge: next provider payload will be captured in the web editor.", "info");
+			return;
+		}
 		ctx.ui.notify(savePath ? `pi-forge: next provider payload will be displayed and saved to ${savePath}.` : "pi-forge: next provider payload will be displayed before sending.", "info");
 	}
 
+	function clearPayloadCapture(ctx: ExtensionCommandContext): void {
+		interceptNextProviderPayload = false;
+		interceptPayloadSavePath = undefined;
+		interceptPayloadDisplayTarget = "editor";
+		payloadCaptureArmedAt = undefined;
+		latestProviderPayloadCapture = undefined;
+		ctx.ui.setStatus("pi-forge-intercept", undefined);
+	}
+
 	pi.registerCommand("intercept", {
 		description: "Display the next provider payload before it is sent",
 		handler: async (_args, ctx) => {
@@ -765,11 +537,11 @@ export default function piForge(pi: ExtensionAPI) {
 	});
 
 	pi.registerCommand("preset", {
-		description: "Manage pi-forge prompt stacks: list, use, preview, validate, reload, vars, ui",
+		description: "Manage pi-forge prompt stacks: list, use, preview, validate, reload, ui",
 		getArgumentCompletions: (prefix) => {
 			const parts = prefix.trimStart().split(/\s+/);
 			if (parts.length <= 1 && !prefix.endsWith(" ")) {
-				const commands = ["list", "use", "preview", "validate", "diagnostics", "reload", "status", "vars", "import-silly", "ui"];
+				const commands = ["list", "use", "preview", "validate", "diagnostics", "reload", "status", "import-silly", "migrate-stacks", "ui"];
 				return commands.filter((cmd) => cmd.startsWith(parts[0] ?? "")).map((cmd) => ({ value: cmd, label: cmd }));
 			}
 			const first = parts[0];
@@ -778,49 +550,20 @@ export default function piForge(pi: ExtensionAPI) {
 				const ids = ["none", ...stacks.map((loaded) => loaded.stack.id)];
 				return ids.filter((id) => id.startsWith(fragment)).map((id) => ({ value: `${first} ${id}`, label: id }));
 			}
-			if (first === "vars") {
-				const sub = parts[1] ?? "";
-				if (parts.length <= 2 && !prefix.endsWith(" ")) {
-					const subs = ["set", "get", "clear", "list"];
-					return subs.filter((s) => s.startsWith(sub)).map((s) => ({ value: `vars ${s}`, label: s }));
-				}
-				if (["set", "get", "clear"].includes(sub) && parts.length <= 3) {
-					const fragment = parts[2] ?? "";
-					const names = Object.keys(sessionVariables);
-					return names.filter((n) => n.startsWith(fragment)).map((n) => ({ value: `vars ${sub} ${n}`, label: n }));
-				}
-			}
 			if (first === "ui" && parts.length <= 2) {
 				const fragment = parts[1] ?? "";
 				const subs = ["stop", "restart"];
 				return subs.filter((s) => s.startsWith(fragment)).map((s) => ({ value: `ui ${s}`, label: s }));
 			}
-			return null;
-		},
-		handler: async (args, ctx) => {
-			await handlePresetCommand(args, ctx);
-		},
-	});
-
-	pi.registerCommand("state", {
-		description: "Manage pi-forge prompt state",
-		getArgumentCompletions: (prefix) => {
-			const parts = prefix.trimStart().split(/\s+/);
-			if (parts.length <= 1 && !prefix.endsWith(" ")) {
-				const commands = ["list", "set", "get", "clear"];
-				return commands.filter((cmd) => cmd.startsWith(parts[0] ?? "")).map((cmd) => ({ value: cmd, label: cmd }));
-			}
-			const first = parts[0];
-			if (["get", "clear"].includes(first) && parts.length <= 2) {
-				const fragment = parts[1] ?? "";
-				return Object.keys(sessionVariables)
-					.filter((name) => name.startsWith(fragment))
-					.map((name) => ({ value: `${first} ${name}`, label: name }));
+			if (first === "migrate-stacks") {
+				const fragment = parts[parts.length - 1] ?? "";
+				const flags = ["--dry-run", "--overwrite", "--delete-legacy"];
+				return flags.filter((flag) => flag.startsWith(fragment)).map((flag) => ({ value: `${parts.slice(0, -1).join(" ")} ${flag}`.trim(), label: flag }));
 			}
 			return null;
 		},
 		handler: async (args, ctx) => {
-			await handleStateCommand(args, ctx);
+			await handlePresetCommand(args, ctx);
 		},
 	});
 
@@ -849,57 +592,6 @@ export default function piForge(pi: ExtensionAPI) {
 				return;
 			}
 
-			case "vars": {
-				const sub = rest[0];
-
-				if (sub === "set") {
-					const name = rest[1];
-					const value = rest.slice(2).join(" ");
-					if (!name || value === "") {
-						ctx.ui.notify("Usage: /preset vars set <name> <value>", "warning");
-						return;
-					}
-					const result = applyStatePatch([{ name, value }], [], "user");
-					if (!result.ok) {
-						ctx.ui.notify(`pi-forge variable error: ${result.error}`, "error");
-						return;
-					}
-					ctx.ui.notify(`pi-forge: set session variable ${name} = ${JSON.stringify(value)}`, "info");
-					return;
-				}
-
-				if (sub === "get") {
-					const name = rest[1];
-					if (!name) {
-						ctx.ui.notify("Usage: /preset vars get <name>", "warning");
-						return;
-					}
-					const value = sessionVariables[name];
-					if (value === undefined) {
-						await showText(ctx, `pi-forge variable: ${name}`, `# ${name}\n\n(not set)`);
-					} else {
-						await showText(ctx, `pi-forge variable: ${name}`, `# ${name}\n\n${formatStateValue(value)}`);
-					}
-					return;
-				}
-
-				if (sub === "clear") {
-					const name = rest[1];
-					const clears = name ? [name] : Object.keys(sessionVariables);
-					const result = applyStatePatch([], clears, "user");
-					if (!result.ok) {
-						ctx.ui.notify(`pi-forge variable error: ${result.error}`, "error");
-						return;
-					}
-					ctx.ui.notify(name ? `pi-forge: cleared session variable ${name}` : "pi-forge: cleared all session variables", "info");
-					return;
-				}
-
-				// No subcommand or "list" — show all variables
-				await showText(ctx, "pi-forge variables", renderVariablesList());
-				return;
-			}
-
 			case "use": {
 				const id = rest[0];
 				if (!id) {
@@ -939,6 +631,28 @@ export default function piForge(pi: ExtensionAPI) {
 				return;
 			}
 
+			case "migrate-stacks": {
+				const flags = new Set(rest);
+				const dryRun = flags.has("--dry-run");
+				if (!ctx.isProjectTrusted() && !dryRun) {
+					ctx.ui.notify("pi-forge: project is not trusted; refusing to migrate prompt stacks.", "warning");
+					return;
+				}
+				const report = migrateLegacyPromptStacks(ctx.cwd, {
+					dryRun,
+					overwrite: flags.has("--overwrite"),
+					deleteLegacy: flags.has("--delete-legacy"),
+				});
+				if (!dryRun) reloadStacks(ctx, selectedActiveId());
+				const changed = report.copied + report.overwritten;
+				const summary = dryRun
+					? `pi-forge: migration dry run found ${report.files.length} legacy stack file(s).`
+					: `pi-forge: migrated ${changed} legacy stack file(s), skipped ${report.skipped}, errors ${report.errors}.`;
+				ctx.ui.notify(summary, report.errors ? "warning" : "info");
+				await showText(ctx, "pi-forge prompt-stack migration", renderMigrationReport(report));
+				return;
+			}
+
 			case "import-silly": {
 				if (!ctx.isProjectTrusted()) {
 					ctx.ui.notify("pi-forge: project is not trusted; refusing to write imported prompt stacks.", "warning");
@@ -974,8 +688,9 @@ export default function piForge(pi: ExtensionAPI) {
 					return;
 				}
 
-				const stacksDir = promptStacksDir(ctx.cwd);
-				const stackPath = join(stacksDir, `${result.stack.id}.json`);
+				const existingStack = stacks.find((candidate) => candidate.stack.id === result.stack.id);
+				const stackPath = existingStack?.filePath ?? promptStackPath(ctx.cwd, result.stack.id);
+				const stacksDir = dirname(stackPath);
 				const reportDir = join(ctx.cwd, ".pi", "forge", "import-reports");
 				const reportPath = join(reportDir, `${result.stack.id}.md`);
 
@@ -1017,71 +732,16 @@ export default function piForge(pi: ExtensionAPI) {
 		}
 	}
 
-	async function handleStateCommand(args: string, ctx: ExtensionCommandContext): Promise<void> {
-		const trimmed = args.trim();
-		const [command = "list", ...rest] = trimmed ? trimmed.split(/\s+/) : ["list"];
-
-		switch (command) {
-			case "list":
-			case "status":
-				await showText(ctx, "pi-forge state", renderVariablesList());
-				return;
-
-			case "set": {
-				const name = rest[0];
-				const rawValue = rest.slice(1).join(" ");
-				if (!name || rawValue === "") {
-					ctx.ui.notify("Usage: /state set <name> <json-or-text-value>", "warning");
-					return;
-				}
-				const value = parseStateCommandValue(rawValue);
-				const result = applyStatePatch([{ name, value }], [], "user");
-				if (!result.ok) {
-					ctx.ui.notify(`pi-forge state error: ${result.error}`, "error");
-					return;
-				}
-				ctx.ui.notify(`pi-forge: set state ${name} = ${JSON.stringify(value)}`, "info");
-				return;
-			}
-
-			case "get": {
-				const name = rest[0];
-				if (!name) {
-					ctx.ui.notify("Usage: /state get <name>", "warning");
-					return;
-				}
-				const value = sessionVariables[name];
-				await showText(ctx, `pi-forge state: ${name}`, value === undefined ? `# ${name}\n\n(not set)` : `# ${name}\n\n${formatStateValue(value)}`);
-				return;
-			}
-
-			case "clear": {
-				const name = rest[0];
-				const clears = name ? [name] : Object.keys(sessionVariables);
-				const result = applyStatePatch([], clears, "user");
-				if (!result.ok) {
-					ctx.ui.notify(`pi-forge state error: ${result.error}`, "error");
-					return;
-				}
-				ctx.ui.notify(name ? `pi-forge: cleared state ${name}` : "pi-forge: cleared all session state", "info");
-				return;
-			}
-
-			default:
-				ctx.ui.notify(`Unknown /state subcommand: ${command}`, "warning");
-				return;
-		}
-	}
-
 	function renderStackList(ctx: ExtensionCommandContext): string {
 		const lines = [
-			`Prompt stack directory: ${promptStacksDir(ctx.cwd)}`,
+			"Prompt stack directories:",
+			...promptStackReadDirs(ctx.cwd).map((dir, index) => `  ${index === 0 ? "primary" : "legacy"}: ${dir}`),
 			`Active stack: ${active?.stack.id ?? "(none)"}`,
 			"",
 		];
 
 		if (stacks.length === 0) {
-			lines.push("No prompt stacks found.", "Create .pi/prompt-stacks/default.json to auto-activate a stack.");
+			lines.push("No prompt stacks found.", "Create .pi/forge/prompt-stacks/default.json to auto-activate a stack.");
 			return lines.join("\n");
 		}
 
@@ -1094,7 +754,7 @@ export default function piForge(pi: ExtensionAPI) {
 			lines.push(`  ${loaded.filePath}`);
 		}
 
-		lines.push("", "Commands:", "  /preset use <id|none>", "  /preset preview [id]", "  /preset validate [id]", "  /preset diagnostics", "  /preset reload", "  /preset ui [stop|restart]", "  /state [list|set <name> <value>|get <name>|clear [name]]", "  /preset vars [set <name> <value>|get <name>|clear [name]]");
+		lines.push("", "Commands:", "  /preset use <id|none>", "  /preset preview [id]", "  /preset validate [id]", "  /preset diagnostics", "  /preset reload", "  /preset migrate-stacks [--dry-run] [--overwrite] [--delete-legacy]", "  /preset ui [stop|restart]");
 		return lines.join("\n");
 	}
 
@@ -1107,36 +767,28 @@ export default function piForge(pi: ExtensionAPI) {
 		return lines.join("\n");
 	}
 
-	function renderVariablesList(): string {
-		const lines = ["# pi-forge state", "", "## Session state", ""];
-		const sessionEntries = Object.entries(sessionVariables).sort(([a], [b]) => a.localeCompare(b));
-		if (sessionEntries.length === 0) lines.push("(none)");
-		else for (const [key, value] of sessionEntries) lines.push(`${key} = ${JSON.stringify(value)}`);
-
-		lines.push("", "## Active stack static variables", "");
-		const staticEntries = Object.entries(active?.stack.variables ?? {}).sort(([a], [b]) => a.localeCompare(b));
-		if (staticEntries.length === 0) lines.push("(none)");
-		else for (const [key, value] of staticEntries) lines.push(`${key} = ${JSON.stringify(value)}`);
-
-		const definitions = Object.entries(active?.stack.state?.definitions ?? {}).sort(([a], [b]) => a.localeCompare(b));
-		if (definitions.length > 0) {
-			lines.push("", "## Active stack state definitions", "");
-			for (const [name, definition] of definitions) {
-				const details = [
-					definition.type ? `type=${definition.type}` : undefined,
-					definition.scope ? `scope=${definition.scope}` : undefined,
-					definition.agentWritable !== undefined ? `agentWritable=${definition.agentWritable}` : undefined,
-					definition.userWritable !== undefined ? `userWritable=${definition.userWritable}` : undefined,
-				].filter(Boolean).join(", ");
-				lines.push(`${name}${details ? ` (${details})` : ""}${definition.description ? ` — ${definition.description}` : ""}`);
-			}
+	function webPayloadSnapshot(): WebEditorPayloadSnapshot {
+		if (interceptNextProviderPayload) {
+			return {
+				status: "armed",
+				armedAt: payloadCaptureArmedAt,
+				savePath: interceptPayloadSavePath,
+			};
 		}
-
-		lines.push("", "Turn variables are cleared for each user message and are only visible during prompt compilation.");
-		return lines.join("\n");
+		if (latestProviderPayloadCapture) {
+			return {
+				status: "captured",
+				capture: latestProviderPayloadCapture,
+			};
+		}
+		return { status: "idle" };
 	}
 
 	function renderPreview(ctx: ExtensionCommandContext, target: LoadedPromptStack): string {
+		return buildPreview(ctx, target).text;
+	}
+
+	function buildPreview(ctx: ExtensionCommandContext, target: LoadedPromptStack): { text: string; preview: WebEditorPreview; diagnostics: PromptStackDiagnostic[] } {
 		const options = ctx.getSystemPromptOptions();
 		const sessionContext = buildSessionContext(ctx.sessionManager.getEntries(), ctx.sessionManager.getLeafId());
 		const latestUserMessage = getLatestUserMessage(sessionContext.messages);
@@ -1145,8 +797,23 @@ export default function piForge(pi: ExtensionAPI) {
 		const system = compileSystemPrompt(target.stack, runtime, ctx.getSystemPrompt());
 		const messages = compileMessages(target.stack, runtime, sessionContext.messages);
 		const diagnostics = [...target.diagnostics, ...system.diagnostics, ...messages.diagnostics];
+		const messageSections = messages.messages.map((message, index) => {
+			const content = agentMessageToPreviewText(message);
+			const source = messages.messageSources[index];
+			return previewSection(`message-${index}`, previewMessageTitle(source, index), content, message.role);
+		});
+		const systemSection = previewSection("system", "System prompt", system.systemPrompt || "(empty)");
+		const totalChars = systemSection.chars + messageSections.reduce((sum, section) => sum + section.chars, 0);
+		const preview: WebEditorPreview = {
+			stackId: target.stack.id,
+			generatedAt: new Date().toISOString(),
+			system: systemSection,
+			messages: messageSections,
+			totalChars,
+			approxTokens: estimatePayloadTokens(`${system.systemPrompt}\n${messageSections.map((section) => section.content).join("\n")}`),
+		};
 
-		return [
+		const text = [
 			`# Prompt stack preview: ${target.stack.id}`,
 			"",
 			"## System prompt",
@@ -1155,76 +822,69 @@ export default function piForge(pi: ExtensionAPI) {
 			"",
 			"## Message layout",
 			"",
-			renderPreviewMessages(messages.messages),
+			renderPreviewSectionText(messageSections),
 			"",
 			"## Diagnostics",
 			"",
 			renderDiagnostics(diagnostics),
 		].join("\n");
-	}
 
-	function renderDiagnostics(diagnostics: PromptStackDiagnostic[]): string {
-		if (diagnostics.length === 0) return "No diagnostics.";
-		return diagnostics.map((d) => `${d.level.toUpperCase()}${d.itemId ? ` [${d.itemId}]` : ""}: ${d.message}`).join("\n");
+		return { text, preview, diagnostics };
 	}
 
-	async function showText(ctx: ExtensionCommandContext, title: string, text: string): Promise<void> {
-		if (ctx.hasUI) {
-			await ctx.ui.editor(title, text);
-			return;
+	function previewMessageTitle(source: CompileMessageSource | undefined, index: number): string {
+		if (source?.kind === "stack-item") {
+			return source.itemName?.trim() || source.itemId || `Stack item ${index + 1}`;
 		}
-		console.log(text);
+		if (source?.kind === "chat-history") {
+			const label = source.itemName?.trim() || "Chat history";
+			return `${label} #${source.historyIndex ?? index + 1}`;
+		}
+		if (source?.kind === "implicit-history") {
+			return `Conversation history #${source.historyIndex ?? index + 1}`;
+		}
+		return `Message ${index + 1}`;
 	}
 
-	function safeStringify(value: unknown): string {
-		try {
-			const text = JSON.stringify(redactPayload(value), null, 2);
-			const maxChars = 200_000;
-			return text.length > maxChars ? `${text.slice(0, maxChars)}\n\n[pi-forge: payload truncated after ${maxChars} chars]` : text;
-		} catch (error) {
-			return `Failed to stringify provider payload: ${error instanceof Error ? error.message : String(error)}`;
+	function renderPreviewSectionText(sections: WebEditorPreviewSection[], maxChars = 8000): string {
+		let text = "";
+		for (const section of sections) {
+			const role = section.role ? ` (${section.role})` : "";
+			text += `\n--- ${section.title}${role} ---\n`;
+			text += section.content;
+			text += "\n";
+			if (text.length > maxChars) return `${text.slice(0, maxChars)}\n\n[preview truncated]`;
 		}
+		return text.trimStart();
 	}
 
-	function estimatePayloadTokens(payload: string): number {
-		return Math.max(1, Math.ceil(payload.length / 4));
+	function previewSection(id: string, title: string, content: string, role?: string): WebEditorPreviewSection {
+		return {
+			id,
+			title,
+			role,
+			content,
+			chars: content.length,
+			approxTokens: estimatePayloadTokens(content),
+		};
 	}
 
-	function redactPayload(value: unknown, depth = 0): unknown {
-		if (depth > 8) return "[pi-forge: max depth reached]";
-		if (typeof value === "string") return redactLongString(value);
-		if (value === null || typeof value !== "object") return value;
-		if (Array.isArray(value)) {
-			const maxItems = 80;
-			const items = value.slice(0, maxItems).map((item) => redactPayload(item, depth + 1));
-			if (value.length > maxItems) items.push(`[pi-forge: ${value.length - maxItems} more items omitted]`);
-			return items;
-		}
-
-		const result: Record<string, unknown> = {};
-		let count = 0;
-		for (const [key, raw] of Object.entries(value as Record<string, unknown>)) {
-			if (++count > 120) {
-				result["[pi-forge: omitted]"] = "object has more than 120 keys";
-				break;
-			}
-			if (isSecretKey(key)) {
-				result[key] = "[redacted]";
-				continue;
-			}
-			result[key] = redactPayload(raw, depth + 1);
-		}
-		return result;
+	function renderDiagnostics(diagnostics: PromptStackDiagnostic[]): string {
+		if (diagnostics.length === 0) return "No diagnostics.";
+		return diagnostics.map((d) => `${d.level.toUpperCase()}${d.itemId ? ` [${d.itemId}]` : ""}: ${d.message}`).join("\n");
 	}
 
-	function isSecretKey(key: string): boolean {
-		return /(api[-_]?key|authorization|bearer|token|secret|password|cookie|credential)/i.test(key);
+	async function showText(ctx: ExtensionCommandContext, title: string, text: string): Promise<void> {
+		if (ctx.hasUI) {
+			await ctx.ui.editor(title, text);
+			return;
+		}
+		console.log(text);
 	}
 
-	function redactLongString(value: string): string {
-		if (/^data:image\//.test(value)) return "[image data omitted]";
-		if (value.length > 8_000 && /^[A-Za-z0-9+/=\r\n]+$/.test(value)) return `[base64-like data omitted: ${value.length} chars]`;
-		if (value.length > 12_000) return `${value.slice(0, 12_000)}\n[pi-forge: string truncated from ${value.length} chars]`;
-		return value;
+	function captureProviderPayload(value: unknown, savePath?: string): WebEditorPayloadCapture {
+		const capture = createProviderPayloadCapture(value, { stackId: active?.stack.id, savePath });
+		latestProviderPayloadCapture = capture;
+		return capture;
 	}
 }