@agimon-ai/po-plan 0.0.0-alpha.0

package/dist/extensions/server.mjs

@@ -0,0 +1,993 @@
+import { l as resolvePlanningPlansDirectory, r as loadDoomConfig } from "../config-BC-Tou05.mjs";
+import { i as buildFlavorPlanningPrompt, o as buildPlanModeBasePrompt } from "../prompts-DnVJGtEC.mjs";
+import { Buffer } from "node:buffer";
+import { composeServerProviderOverrides, defineServerPlugin, readPackageResource } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineRoot, defineRoute, defineRoutedContribution, defineToolRestriction } from "@agimon-ai/po-core/extensionFile";
+import { Type } from "typebox";
+import { createHash } from "node:crypto";
+import fs, { mkdir, readFile, writeFile } from "node:fs/promises";
+import { Hono } from "hono";
+import fs$1 from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { piAgentDirectory } from "@agimon-ai/po-core/piSettings";
+import { apiResponse, defineApiRoutes } from "@agimon-ai/po-core/web";
+import { DOOM_VOICE_AUTO_MODE_ID } from "@agimon-ai/po-core/voiceTools";
+import { defineMinorMode, serverMinorModes } from "@agimon-ai/po-minor-mode";
+//#region src/schemas/mcpTools.ts
+const markdown = Type.String({ minLength: 1 });
+Type.Object({ markdown }, { additionalProperties: false });
+const writePlanParameters = Type.Object({ markdown: Type.Optional(markdown) }, { additionalProperties: false });
+//#endregion
+//#region src/services/mcpTools/index.ts
+const PLAN_MCP_TOOLS_SERVICE = "doom/plan-mcp-tools";
+function mountMcpTools(tools) {
+	return (context) => {
+		context.plugin((providerContext) => {
+			providerContext.provide(PLAN_MCP_TOOLS_SERVICE, {
+				get: (name) => tools.find((tool) => tool.name === name),
+				names: () => tools.map((tool) => tool.name)
+			});
+		});
+	};
+}
+//#endregion
+//#region src/services/planPointer/index.ts
+/**
+* Record and read where write_plan left this session's plan file.
+*
+* Pi already gives every session an agent directory, so the records live under
+* it rather than in a second place a reader would have to know about. The
+* posture matches the plan file itself, 0700 on the directory and 0600 on the
+* record: a plan is a private working document, not something to leave
+* world-readable in a shared home.
+*/
+const POINTER_DIRECTORY = "doom-plan";
+const PRIVATE_DIRECTORY_MODE = 448;
+const PRIVATE_FILE_MODE = 384;
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var PlanPointerService = class {
+	env;
+	homeDirectory;
+	constructor(options = {}) {
+		this.env = options.env ?? {};
+		this.homeDirectory = options.homeDirectory ?? os.homedir();
+	}
+	/** Where the records live; exposed so a test can look without guessing. */
+	directory() {
+		return path.join(piAgentDirectory(this.env, this.homeDirectory), POINTER_DIRECTORY);
+	}
+	/**
+	* The record for one session. The id is hashed rather than used as written:
+	* it reaches here from a host that may word it however it likes, and a
+	* filename is not the place to find that out.
+	*/
+	pathFor(sessionId) {
+		return path.join(this.directory(), `${this.hash(sessionId)}.json`);
+	}
+	read(sessionId) {
+		let raw;
+		try {
+			raw = fs$1.readFileSync(this.pathFor(sessionId), "utf8");
+		} catch {
+			return;
+		}
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		if (!isRecord$1(parsed)) return void 0;
+		const { path: planPath, title, writtenAt, planId } = parsed;
+		if (typeof planPath !== "string" || !path.isAbsolute(planPath)) return void 0;
+		if (typeof title !== "string" || typeof writtenAt !== "string") return void 0;
+		return {
+			path: planPath,
+			title,
+			writtenAt,
+			...typeof planId === "string" ? { planId } : {}
+		};
+	}
+	write(sessionId, record) {
+		fs$1.mkdirSync(this.directory(), {
+			recursive: true,
+			mode: PRIVATE_DIRECTORY_MODE
+		});
+		fs$1.writeFileSync(this.pathFor(sessionId), JSON.stringify(record), { mode: PRIVATE_FILE_MODE });
+	}
+	clear(sessionId) {
+		fs$1.rmSync(this.pathFor(sessionId), { force: true });
+	}
+	hash(value) {
+		return createHash("sha256").update(value).digest("hex").slice(0, 16);
+	}
+};
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path. The build reads both off
+* `src/extensions/workspaces/sessions/(backend)/api/plans/`, so the mount is
+* stated once, by the folder that creates it. The paths used to be written
+* here as helpers, again in the contract, and again inside every URL the page
+* built, and the copies were free to disagree.
+*
+* This is the one file the routes, the Hono app and the browser all read, so a
+* path cannot move on one side alone.
+*
+* Neither route takes a query or a path parameter: a session has one current
+* plan, so `current` answers it and `save` takes the manual write back.
+*/
+var apiRoutes_default = defineApiRoutes({
+	current: {
+		method: "GET",
+		path: "/current",
+		response: apiResponse()
+	},
+	save: {
+		method: "PUT",
+		path: "/content",
+		response: apiResponse()
+	}
+});
+//#endregion
+//#region src/types/planApi.ts
+/**
+* The wire vocabulary this package's API shares with whatever calls it.
+*
+* It lives under src/types because that is the one server root a browser
+* bundle may read: the routes answer with these shapes and the cockpit plugin
+* reads them, so neither half can drift from the other. The paths themselves
+* are not here; they are declared once in `./apiRoutes`, which the Hono app
+* and the generated client both read.
+*
+* Two routes, and neither takes a path. A session has one current plan, so
+* `current` answers it and `content` takes the manual save back; the file they
+* act on is the one write_plan recorded, never one the page named. That is
+* also why there is nothing to escape here: a reader cannot address a second
+* file through these URLs.
+*/
+/** Where a host mounts this package's API; the segment after /api/plugins/. */
+const API_BASE_PATH = "plans";
+/**
+* Footer status key the session publishes once a plan exists, which is what
+* makes the cockpit's activity group appear at all. It outlives plan mode: the
+* plan is most worth reading while the agent implements it.
+*/
+const PLAN_STATUS_KEY = "doom-plan-document";
+/** The selector contract shared by complete_plan and its cockpit composer prompt. */
+const PLAN_REVIEW_TITLE = "Plan complete. What would you like to do?";
+const EXIT_PLAN_MODE_CHOICE = "Exit plan mode and start implementation";
+const CONTINUE_PLANNING_CHOICE = "Continue planning";
+const EXIT_PLAN_DECISION = "exit";
+const CONTINUE_PLAN_DECISION = "continue";
+/**
+* The label the reader sees paired with the decision the tool acts on. A headless
+* client answers with `value`, so a facet never has to recognise the wording; Pi's
+* own `ui.select` carries labels only, so its half maps the label back itself.
+*/
+const PLAN_REVIEW_CHOICES = [{
+	label: EXIT_PLAN_MODE_CHOICE,
+	value: EXIT_PLAN_DECISION
+}, {
+	label: CONTINUE_PLANNING_CHOICE,
+	value: CONTINUE_PLAN_DECISION
+}];
+PLAN_REVIEW_CHOICES.map((choice) => choice.label);
+/** Between the plan's title and the stamp that marks a rewrite. */
+const STATUS_SEPARATOR = " · ";
+/** The status line the session publishes; the stamp changes on every write. */
+function formatPlanStatus(title, stamp) {
+	return `${title}${STATUS_SEPARATOR}${stamp}`;
+}
+//#endregion
+//#region src/services/planApi/index.ts
+/**
+* This package's HTTP surface: the session's current plan, and the manual save.
+*
+* Each path comes from the route table the browser reads, so a route the page
+* calls and the route this serves cannot be spelled apart. Both are relative
+* to the mount its host gives it, so nothing here repeats where it was mounted. The host is one session's own server, which is what
+* makes the session id available without the page supplying it.
+*
+* Neither route takes a path. A session has exactly one current plan, and the
+* file both routes act on is the one the pointer names, so a page can address
+* the plan and nothing else; there is no traversal question to answer because
+* there is no path to traverse.
+*
+* The save refuses unless the reader proves they were looking at the content
+* that is still on disk. The agent may rewrite the plan while a tab is open,
+* and silently discarding whichever side finished second is the one outcome
+* worth ruling out.
+*/
+/** Past this, the plan is reported rather than carried. */
+const MAX_PLAN_BYTES = 1048576;
+const NO_PLAN = "This session has not written a plan yet.";
+const STALE_SAVE = "The plan changed since it was opened.";
+const NOT_A_FILE = "The plan file is no longer a regular file, so it was not written.";
+function hashOf(content) {
+	return createHash("sha256").update(content, "utf8").digest("hex");
+}
+/** Reads the plan as the source view will show it, or says why it cannot. */
+async function readPlan(planPath) {
+	let raw;
+	try {
+		raw = await fs.readFile(planPath);
+	} catch {
+		return {
+			content: "",
+			hash: "",
+			unavailable: true,
+			reason: "the plan file no longer exists"
+		};
+	}
+	if (raw.byteLength > 1048576) return {
+		content: "",
+		hash: "",
+		unavailable: true,
+		reason: `the plan is larger than ${MAX_PLAN_BYTES} bytes`
+	};
+	const content = raw.toString("utf8");
+	return {
+		content,
+		hash: hashOf(content),
+		unavailable: false
+	};
+}
+function createPlanApi(options = {}) {
+	const app = new Hono();
+	const pointers = options.pointers ?? new PlanPointerService({ env: process.env });
+	const pointerFor = () => options.sessionId === void 0 ? void 0 : pointers.read(options.sessionId);
+	app.get(apiRoutes_default.current.path, async (context) => {
+		const pointer = pointerFor();
+		if (pointer === void 0) return context.json({ error: NO_PLAN }, 404);
+		const view = {
+			path: pointer.path,
+			title: pointer.title,
+			writtenAt: pointer.writtenAt,
+			...pointer.planId === void 0 ? {} : { planId: pointer.planId },
+			...await readPlan(pointer.path)
+		};
+		return context.json(view);
+	});
+	app.put(apiRoutes_default.save.path, async (context) => {
+		let request;
+		try {
+			request = await context.req.json();
+		} catch {
+			return context.json({ error: "The save body is not JSON." }, 400);
+		}
+		if (typeof request.content !== "string" || typeof request.expectedHash !== "string") return context.json({ error: "A save carries the content to write and the hash it was read at." }, 400);
+		const pointer = pointerFor();
+		if (pointer === void 0) return context.json({ error: NO_PLAN }, 404);
+		const current = await readPlan(pointer.path);
+		if (current.unavailable) return context.json({ error: current.reason ?? NO_PLAN }, 409);
+		if (current.hash !== request.expectedHash) return context.json({
+			error: STALE_SAVE,
+			hash: current.hash
+		}, 409);
+		const stats = await fs.lstat(pointer.path);
+		if (!stats.isFile() || stats.nlink !== 1) return context.json({ error: NOT_A_FILE }, 409);
+		await fs.writeFile(pointer.path, request.content, {
+			encoding: "utf8",
+			mode: 384
+		});
+		return context.json({ hash: hashOf(request.content) });
+	});
+	return app;
+}
+/** The named export a host imports from this package's built entry. */
+const api = {
+	basePath: API_BASE_PATH,
+	start(context) {
+		const app = createPlanApi(context.sessionId === void 0 ? {} : { sessionId: context.sessionId });
+		return {
+			fetch: (request) => app.fetch(request),
+			close: () => void 0
+		};
+	}
+};
+//#endregion
+//#region src/services/optionalTeamServices/index.ts
+const DOOM_SUBAGENT_POLICY_SERVICE = "doom/subagent-policy";
+function readDoomSubagentPolicyService(ctx) {
+	return ctx.get(DOOM_SUBAGENT_POLICY_SERVICE);
+}
+//#endregion
+//#region src/services/planServerSession/index.ts
+const RECORD_DEBUG_EVIDENCE_TOOL = "record_debug_evidence";
+const WRITE_PLAN_TOOL = "write_plan";
+const COMPLETE_PLAN_TOOL = "complete_plan";
+const PLAN_MODE_ID = "plan";
+const PLAN_MODEL_SNAPSHOT = "plan-server-model-snapshot";
+const PLAN_FLAVOR_SNAPSHOT = "plan-server-flavor";
+const PLAN_DEBUG_EVIDENCE = "plan-debug-evidence";
+const PLAN_DOCUMENT = "plan-document";
+/** This host supports UI review without narrated decisions. */
+const PLAN_SERVER_CAPABILITIES = {
+	completePlanTakesDecision: false,
+	narratesReview: false,
+	fableAvailable: false
+};
+const PLAN_SUBAGENT_POLICY = {
+	owner: "@agimon-ai/po-plan",
+	allowedTools: [
+		"read",
+		"bash",
+		"grep",
+		"find",
+		"ls",
+		"mcp"
+	],
+	requiredTools: ["bash"],
+	allowMcpTools: true,
+	allowedExternalProfiles: [],
+	denyExtensions: false
+};
+function serverPlanSubagentPolicy(host) {
+	return (context) => {
+		context.inject([DOOM_SUBAGENT_POLICY_SERVICE], (child) => {
+			const service = readDoomSubagentPolicyService(child);
+			if (!service) return void 0;
+			let handle;
+			const sync = () => {
+				if (modeSelected(host)) {
+					if (handle) handle.update(PLAN_SUBAGENT_POLICY);
+					else handle = service.register(PLAN_SUBAGENT_POLICY);
+				} else {
+					handle?.dispose();
+					handle = void 0;
+				}
+			};
+			sync();
+			child.effect(() => host.subscribeSelection(sync));
+			return () => handle?.dispose();
+		});
+	};
+}
+function modeSelected(host) {
+	return (host.context.selection.state?.["minor-mode"] ?? []).includes(PLAN_MODE_ID);
+}
+function output(value, isError = false) {
+	return {
+		content: [{
+			type: "text",
+			text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+		}],
+		details: value,
+		...isError ? { isError: true } : {}
+	};
+}
+function createPlanServerSession(host) {
+	let flavor = "normal";
+	let debugEvidence;
+	let modeOwner;
+	const selected = () => modeSelected(host);
+	const homeDirectory = () => host.context.environment.HOME ?? os.homedir();
+	const plansDirectory = () => resolvePlanningPlansDirectory(loadDoomConfig(host.context.repoRoot, homeDirectory()).modes?.planning?.plansDirectory, host.context.repoRoot, homeDirectory());
+	const pointers = new PlanPointerService({ env: host.context.environment });
+	/**
+	* The activity group's line, and the pointer its panel reads.
+	*
+	* A cockpit drives this facet and never the Pi runtime, so both were written
+	* only on the Pi side: the group never appeared, and when it did its panel
+	* had no pointer to answer from.
+	*/
+	const announcePlanDocument = (filePath, title, writtenAt) => {
+		try {
+			pointers.write(host.context.sessionId, {
+				path: filePath,
+				title,
+				writtenAt
+			});
+		} catch {}
+		host.context.client.setStatus(PLAN_STATUS_KEY, formatPlanStatus(title, planStampOf(writtenAt)));
+	};
+	const modeState = () => {
+		const active = selected();
+		return {
+			activation: active ? "active" : "inactive",
+			condition: "ready",
+			...active ? {
+				detail: `${flavor} - read only`,
+				modelContextVariant: flavor
+			} : {},
+			actions: [{
+				id: "activate",
+				enabled: true
+			}, {
+				id: "deactivate",
+				enabled: active,
+				...active ? {} : { disabledReason: "Plan mode is inactive." }
+			}]
+		};
+	};
+	const publishMode = () => modeOwner?.publish();
+	const restoreModel = async () => {
+		const session = host.context.session;
+		const data = (await session.entries({
+			type: "custom",
+			customType: PLAN_MODEL_SNAPSHOT,
+			limit: 1
+		}))[0]?.data;
+		if (data === void 0 || data === null) return;
+		if (typeof data !== "object" || !("thinkingLevel" in data) || ![
+			"off",
+			"minimal",
+			"low",
+			"medium",
+			"high",
+			"xhigh",
+			"max"
+		].includes(String(data.thinkingLevel))) throw new Error("The saved planning model settings are invalid.");
+		if (!session.setModelSettings) throw new Error("This session cannot restore its model settings.");
+		await session.setModelSettings(data);
+		await session.appendCustomEntry(PLAN_MODEL_SNAPSHOT, null);
+	};
+	const selectPlan = async (enabled, nextFlavor = flavor) => {
+		const wasEnabled = selected();
+		const session = host.context.session;
+		if (enabled && !wasEnabled) {
+			const config = loadDoomConfig(host.context.repoRoot, homeDirectory()).modes?.planning?.main;
+			if (config?.model || config?.thinking) {
+				if (!session.readModelSettings || !session.setModelSettings) throw new Error("This session cannot apply planning model settings.");
+				const previous = await session.readModelSettings();
+				const settings = {};
+				if (config.model) {
+					const separator = config.model.indexOf("/");
+					const provider = separator > 0 ? config.model.slice(0, separator) : previous.model?.provider;
+					if (!provider) throw new Error("The planning model needs a provider.");
+					settings.model = {
+						provider,
+						id: separator > 0 ? config.model.slice(separator + 1) : config.model
+					};
+				}
+				if (config.thinking) settings.thinkingLevel = config.thinking;
+				await session.appendCustomEntry(PLAN_MODEL_SNAPSHOT, previous);
+				try {
+					await session.setModelSettings(settings);
+				} catch (error) {
+					await session.setModelSettings(previous);
+					await session.appendCustomEntry(PLAN_MODEL_SNAPSHOT, null);
+					throw error;
+				}
+			}
+		} else if (!enabled && wasEnabled) await restoreModel();
+		const modes = (host.context.selection.state?.["minor-mode"] ?? []).filter((mode) => mode !== PLAN_MODE_ID);
+		await host.changeSelection({
+			axis: "state",
+			key: "minor-mode",
+			values: enabled ? [...modes, PLAN_MODE_ID] : modes
+		});
+		flavor = nextFlavor;
+		await session.appendCustomEntry(PLAN_FLAVOR_SNAPSHOT, enabled ? { flavor } : null);
+		publishMode();
+	};
+	/** Newest value for a custom entry type, or undefined when none was recorded. */
+	const latestEntry = async (customType) => {
+		return (await host.context.session.entries({
+			type: "custom",
+			customType,
+			limit: 1
+		}))[0]?.data ?? void 0;
+	};
+	const restorePlanState = async () => {
+		const saved = await latestEntry(PLAN_FLAVOR_SNAPSHOT);
+		if (saved !== void 0 && saved !== null && typeof saved === "object" && "flavor" in saved) {
+			const candidate = String(saved.flavor);
+			if (candidate === "fable") flavor = "normal";
+			else if (candidate === "normal" || candidate === "debug" || candidate === "code-review") flavor = candidate;
+		}
+		const evidence = await latestEntry(PLAN_DEBUG_EVIDENCE);
+		if (evidence === void 0 || evidence === null) return;
+		try {
+			debugEvidence = parseDebugEvidencePacket(evidence);
+		} catch {
+			debugEvidence = void 0;
+		}
+	};
+	modeOwner = defineMinorMode({
+		descriptor: {
+			source: "@agimon-ai/po-plan",
+			id: PLAN_MODE_ID,
+			label: "Plan",
+			description: "Read-only planning with normal, debug, and code review flavors.",
+			order: 40,
+			actions: [{
+				id: "activate",
+				label: "Activate",
+				description: "Activate plan mode or switch its planning flavor.",
+				contexts: ["headless"],
+				parameters: [{
+					name: "flavor",
+					label: "Flavor",
+					kind: "enum",
+					required: true,
+					choices: [
+						{
+							value: "normal",
+							label: "Normal"
+						},
+						{
+							value: "debug",
+							label: "Debug"
+						},
+						{
+							value: "code-review",
+							label: "Code Review"
+						}
+					]
+				}]
+			}, {
+				id: "deactivate",
+				label: "Deactivate",
+				description: "Exit plan mode and restore the previous agent configuration.",
+				contexts: ["headless"],
+				parameters: []
+			}]
+		},
+		state: () => modeState(),
+		async handleAction(_runtime, actionId, argumentsValue, { signal }) {
+			signal.throwIfAborted();
+			if (actionId === "activate") {
+				const nextFlavor = argumentsValue.flavor;
+				if (nextFlavor !== "normal" && nextFlavor !== "debug" && nextFlavor !== "code-review") throw new Error("A valid plan flavor is required.");
+				await selectPlan(true, nextFlavor);
+				return { message: `Plan mode is active with the ${nextFlavor} flavor.` };
+			}
+			if (actionId === "deactivate") {
+				await selectPlan(false);
+				return { message: "Plan mode deactivated." };
+			}
+			throw new Error(`Unknown plan mode action: ${actionId}`);
+		}
+	}).createOwner(void 0);
+	return {
+		services: [serverMinorModes([modeOwner]), serverPlanSubagentPolicy(host)],
+		resources: [{
+			when: {
+				state: { "minor-mode": PLAN_MODE_ID },
+				attribution: {
+					kind: "minor",
+					mode: PLAN_MODE_ID
+				}
+			},
+			name: "po-use-plan",
+			kind: "skill",
+			read: () => readPackageResource(import.meta.url, "src/prompts/po-use-plan/SKILL.md")
+		}],
+		tools: [
+			{
+				when: {
+					state: { "minor-mode": PLAN_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: PLAN_MODE_ID
+					}
+				},
+				name: RECORD_DEBUG_EVIDENCE_TOOL,
+				label: "Record Debug Evidence",
+				description: "Record bounded debug evidence as optional planning context.",
+				parameters: {
+					type: "object",
+					properties: {
+						issue: { type: "string" },
+						expectedBehavior: { type: "string" },
+						reproductionAttempt: { type: "string" },
+						actualBehavior: { type: "string" },
+						logs: {
+							type: "array",
+							items: { type: "string" }
+						},
+						correlatedTraceEvidence: {
+							type: "array",
+							items: { type: "string" }
+						},
+						processOutput: {
+							type: "array",
+							items: { type: "string" }
+						},
+						browserConsoleEvidence: {
+							type: "array",
+							items: { type: "string" }
+						},
+						correlationIds: {
+							type: "array",
+							items: { type: "string" }
+						},
+						timestamps: {
+							type: "array",
+							items: { type: "string" }
+						},
+						verifiedFacts: {
+							type: "array",
+							items: { type: "string" }
+						},
+						hypotheses: {
+							type: "array",
+							items: { type: "string" }
+						},
+						unavailableEvidence: {
+							type: "array",
+							items: { type: "string" }
+						}
+					},
+					required: ["issue"],
+					additionalProperties: false
+				},
+				executionMode: "serial",
+				async execute(_toolCallId, parameters) {
+					try {
+						const parsedEvidence = parseDebugEvidencePacket(parameters);
+						await host.context.session.appendCustomEntry(PLAN_DEBUG_EVIDENCE, parsedEvidence);
+						debugEvidence = parsedEvidence;
+						return output({ recorded: true });
+					} catch (error) {
+						return output(error instanceof Error ? error.message : String(error), true);
+					}
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": PLAN_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: PLAN_MODE_ID
+					}
+				},
+				name: WRITE_PLAN_TOOL,
+				label: "Write Plan",
+				description: "Save the supplied Markdown plan, or the plan already presented in the local session.",
+				parameters: writePlanParameters,
+				executionMode: "serial",
+				async execute(toolCallId, parameters, signal) {
+					try {
+						signal?.throwIfAborted();
+						let content = typeof parameters === "object" && parameters !== null && "markdown" in parameters ? parameters.markdown : void 0;
+						if (content !== void 0 && typeof content !== "string") throw new Error("Plan Markdown must be a string.");
+						if (content === void 0) content = visiblePlanForToolCall(await host.context.session.entries(), toolCallId);
+						if (content === void 0) {
+							if (host.context.selection.state?.["minor-mode"]?.includes(DOOM_VOICE_AUTO_MODE_ID)) throw new Error("Supply Markdown to write_plan during autonomous Voice; UI input is unavailable.");
+							const requested = await host.context.client.request({
+								kind: "input",
+								title: "Implementation plan",
+								multiline: true
+							}, signal);
+							content = typeof requested === "string" ? requested : "";
+						}
+						if (typeof content !== "string" || !content.trim()) throw new Error("No implementation plan content was supplied.");
+						const directory = plansDirectory();
+						await mkdir(directory, {
+							recursive: true,
+							mode: 448
+						});
+						const title = planTitleOf(content);
+						const writtenAt = (/* @__PURE__ */ new Date()).toISOString();
+						const filename = `${planTitleSlug(content)}-${Date.now()}.md`;
+						const filePath = path.join(directory, filename);
+						await writeFile(filePath, `${content.trim()}\n`, {
+							encoding: "utf8",
+							mode: 384,
+							flag: "wx"
+						});
+						await host.context.session.appendCustomEntry(PLAN_DOCUMENT, {
+							path: filePath,
+							content: content.trim(),
+							title,
+							writtenAt
+						});
+						announcePlanDocument(filePath, title, writtenAt);
+						await selectPlan(true);
+						const saved = {
+							path: filePath,
+							written: true
+						};
+						return {
+							...output(saved),
+							structuredContent: saved
+						};
+					} catch (error) {
+						return output(error instanceof Error ? error.message : String(error), true);
+					}
+				}
+			},
+			{
+				when: {
+					state: { "minor-mode": PLAN_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: PLAN_MODE_ID
+					}
+				},
+				name: COMPLETE_PLAN_TOOL,
+				label: "Complete Plan",
+				description: "Request exit-or-continue approval in the local Po UI. Requires the user to interact there; this is not a ChatGPT approval dialog.",
+				parameters: {
+					type: "object",
+					properties: {},
+					additionalProperties: false
+				},
+				executionMode: "serial",
+				async execute(_toolCallId, _parameters, signal) {
+					try {
+						if (host.context.selection.state?.["minor-mode"]?.includes(DOOM_VOICE_AUTO_MODE_ID)) throw new Error("UI plan review is unavailable during autonomous Voice. Wait for explicit user direction.");
+						const exited = await host.context.client.request({
+							kind: "select",
+							title: PLAN_REVIEW_TITLE,
+							options: PLAN_REVIEW_CHOICES.map((choice) => ({ ...choice }))
+						}, signal) === EXIT_PLAN_DECISION;
+						await host.context.session.appendCustomEntry("plan-review", { decision: exited ? EXIT_PLAN_DECISION : CONTINUE_PLAN_DECISION });
+						await selectPlan(!exited);
+						return {
+							content: [{
+								type: "text",
+								text: exited ? PLAN_EXIT_APPROVED_TEXT : PLAN_CONTINUE_TEXT
+							}],
+							details: { exited }
+						};
+					} catch (error) {
+						return output(error instanceof Error ? error.message : String(error), true);
+					}
+				}
+			}
+		],
+		hooks: [
+			{
+				when: {
+					state: { "minor-mode": PLAN_MODE_ID },
+					attribution: {
+						kind: "minor",
+						mode: PLAN_MODE_ID
+					}
+				},
+				event: "before_agent_start",
+				async handle(event) {
+					const prompt = typeof event.systemPrompt === "string" ? event.systemPrompt : "";
+					const directory = plansDirectory();
+					const sections = [buildPlanModeBasePrompt(directory, PLAN_SERVER_CAPABILITIES), buildFlavorPlanningPrompt(flavor, directory, debugEvidence)];
+					const saved = await latestEntry(PLAN_DOCUMENT);
+					if (saved !== void 0 && saved !== null && typeof saved === "object" && "path" in saved) {
+						const document = saved;
+						let content = document.content ?? "";
+						try {
+							content = await readFile(document.path, "utf8");
+						} catch {
+							content = document.content ?? "";
+						}
+						if (content.trim()) sections.push(`[CURRENT PLAN]\nSource: ${document.path}\n\n${content}`);
+					}
+					return { systemPrompt: `${prompt}\n\n${sections.join("\n\n")}`.trim() };
+				}
+			},
+			{
+				event: "session_start",
+				async handle() {
+					await restorePlanState();
+					const pointer = pointers.read(host.context.sessionId);
+					if (pointer) host.context.client.setStatus(PLAN_STATUS_KEY, formatPlanStatus(pointer.title, planStampOf(pointer.writtenAt)));
+					if (!selected()) await restoreModel();
+				}
+			},
+			{
+				event: "context",
+				async handle(event) {
+					if (!Array.isArray(event.messages)) return;
+					return { messages: event.messages.filter((message) => message.customType !== PLAN_MODE_CONTEXT) };
+				}
+			}
+		]
+	};
+}
+const DEFAULT_PLAN_TITLE = "implementation-plan";
+const PLAN_TITLE_MAX_LENGTH = 64;
+const DEBUG_EVIDENCE_MAX_BYTES = 32768;
+const DEBUG_EVIDENCE_MAX_TEXT_BYTES = 4096;
+const DEBUG_EVIDENCE_MAX_ITEMS = 32;
+const PLAN_MODE_CONTEXT = "agent-harness-plan-mode-context";
+const PLAN_EXIT_APPROVED_TEXT = "The user approved exiting plan mode. Full tool access is restored. Begin implementing the approved plan.";
+const PLAN_CONTINUE_TEXT = "The user chose to continue planning. Remain read-only and refine the plan.";
+/** The plan's own heading, as the status line and the pointer record word it. */
+function planTitleOf(markdown) {
+	return markdown.match(/^#\s+(.+?)\s*$/m)?.[1] ?? DEFAULT_PLAN_TITLE;
+}
+function planTitleSlug(markdown) {
+	return planTitleOf(markdown).normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, PLAN_TITLE_MAX_LENGTH) || DEFAULT_PLAN_TITLE;
+}
+/**
+* How the status line words when a plan was written. A malformed timestamp is
+* shown as it came rather than as an invalid date: the stamp's other job is to
+* change on a rewrite, and it can still do that.
+*/
+function planStampOf(writtenAt) {
+	const at = new Date(writtenAt);
+	return Number.isNaN(at.getTime()) ? writtenAt : at.toLocaleTimeString();
+}
+function visiblePlanForToolCall(entries, toolCallId) {
+	for (let index = entries.length - 1; index >= 0; index -= 1) {
+		const entry = entries[index];
+		if (!entry || typeof entry !== "object") continue;
+		const candidate = entry;
+		if (candidate.type !== "message" || candidate.message?.role !== "assistant") continue;
+		if (!Array.isArray(candidate.message.content)) continue;
+		const toolIndex = candidate.message.content.findIndex((block) => {
+			if (!block || typeof block !== "object") return false;
+			const content = block;
+			return content.type === "toolCall" && content.id === toolCallId && content.name === WRITE_PLAN_TOOL;
+		});
+		if (toolIndex < 0) continue;
+		return candidate.message.content.slice(0, toolIndex).flatMap((block) => {
+			if (!block || typeof block !== "object") return [];
+			const content = block;
+			return content.type === "text" && typeof content.text === "string" ? [content.text] : [];
+		}).join("\n\n").trim() || void 0;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function boundedDebugText(value, field, required) {
+	if (!isString(value)) throw new Error(`${field} must be a string.`);
+	const text = value.trim();
+	if (required && !text) throw new Error(`${field} must not be empty.`);
+	if (Buffer.byteLength(text, "utf8") > DEBUG_EVIDENCE_MAX_TEXT_BYTES) throw new Error(`${field} exceeds the bounded debug evidence limit.`);
+	return text;
+}
+function boundedDebugList(value, field) {
+	if (!Array.isArray(value) || value.length > DEBUG_EVIDENCE_MAX_ITEMS) throw new Error(`${field} must be a bounded string array.`);
+	return value.map((item, index) => boundedDebugText(item, `${field}[${index}]`, false));
+}
+function optionalDebugText(value, field) {
+	return value === void 0 ? "" : boundedDebugText(value, field, false);
+}
+function optionalDebugList(value, field) {
+	return value === void 0 ? [] : boundedDebugList(value, field);
+}
+function assertExactObjectKeys(value, keys, field) {
+	const allowed = new Set(keys);
+	const unexpected = Object.keys(value).find((key) => !allowed.has(key));
+	if (unexpected) throw new Error(`${field} contains unsupported field '${unexpected}'.`);
+}
+function parseDebugEvidencePacket(value) {
+	if (!isRecord(value)) throw new Error("Debug evidence must be an object.");
+	assertExactObjectKeys(value, [
+		"issue",
+		"expectedBehavior",
+		"reproductionAttempt",
+		"actualBehavior",
+		"logs",
+		"correlatedTraceEvidence",
+		"processOutput",
+		"browserConsoleEvidence",
+		"correlationIds",
+		"timestamps",
+		"verifiedFacts",
+		"hypotheses",
+		"unavailableEvidence"
+	], "Debug evidence");
+	const packet = {
+		issue: boundedDebugText(value.issue, "issue", true),
+		expectedBehavior: optionalDebugText(value.expectedBehavior, "expectedBehavior"),
+		reproductionAttempt: optionalDebugText(value.reproductionAttempt, "reproductionAttempt"),
+		actualBehavior: optionalDebugText(value.actualBehavior, "actualBehavior"),
+		logs: optionalDebugList(value.logs, "logs"),
+		correlatedTraceEvidence: optionalDebugList(value.correlatedTraceEvidence, "correlatedTraceEvidence"),
+		processOutput: optionalDebugList(value.processOutput, "processOutput"),
+		browserConsoleEvidence: optionalDebugList(value.browserConsoleEvidence, "browserConsoleEvidence"),
+		correlationIds: optionalDebugList(value.correlationIds, "correlationIds"),
+		timestamps: optionalDebugList(value.timestamps, "timestamps"),
+		verifiedFacts: optionalDebugList(value.verifiedFacts, "verifiedFacts"),
+		hypotheses: optionalDebugList(value.hypotheses, "hypotheses"),
+		unavailableEvidence: optionalDebugList(value.unavailableEvidence, "unavailableEvidence")
+	};
+	if (Buffer.byteLength(JSON.stringify(packet), "utf8") > DEBUG_EVIDENCE_MAX_BYTES) throw new Error("Debug evidence exceeds the bounded packet size.");
+	return packet;
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot(({ agent }) => {
+	const value = {
+		api: [api],
+		...agent ? createPlanServerSession(agent) : {}
+	};
+	return {
+		value,
+		services: [...value.services ?? [], ...value.tools?.length ? [mountMcpTools(value.tools)] : []]
+	};
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/api/plans/route.server.ts
+var route_server_default = defineRoute((context) => context.root.api[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/beforeAgentStart.server.ts
+var beforeAgentStart_server_default = defineRoutedContribution((context) => context.root.hooks?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/context.server.ts
+var context_server_default = defineRoutedContribution((context) => context.root.hooks?.[2], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/sessionStart.server.ts
+var sessionStart_server_default = defineRoutedContribution((context) => context.root.hooks?.[1], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/poUsePlan.server.ts
+var poUsePlan_server_default = defineRoutedContribution((context) => context.root.resources?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool-restriction/plan.server.ts
+var plan_server_default = defineToolRestriction({
+	when: { state: { "minor-mode": DOOM_VOICE_AUTO_MODE_ID } },
+	excludedTools: ["complete_plan"]
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool-restriction/planReadOnly.server.ts
+var planReadOnly_server_default = defineToolRestriction({
+	when: { state: { "minor-mode": "plan" } },
+	excludedTools: ["edit", "write"]
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/completePlan.server.ts
+var completePlan_server_default = defineRoutedContribution((context) => context.root.tools?.[2], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/recordDebugEvidence.server.ts
+var recordDebugEvidence_server_default = defineRoutedContribution((context) => context.root.tools?.[0], { cardinality: "optional" });
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/writePlan.server.ts
+var writePlan_server_default = defineRoutedContribution((context) => context.root.tools?.[1], { cardinality: "optional" });
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+/* v8 ignore next -- generated normalization branch */
+const defined = (values) => values.filter((value) => value !== void 0);
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-plan",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get api() {
+				return [at(route_server_default, contextSession)];
+			},
+			get hooks() {
+				return defined([
+					via({ event: "before_agent_start" }, at(beforeAgentStart_server_default, contextSession)),
+					via({ event: "context" }, at(context_server_default, contextSession)),
+					via({ event: "session_start" }, at(sessionStart_server_default, contextSession))
+				]);
+			},
+			get resources() {
+				return defined([at(poUsePlan_server_default, contextSession)]);
+			},
+			get toolRestrictions() {
+				return [at(plan_server_default, contextSession), at(planReadOnly_server_default, contextSession)];
+			},
+			get tools() {
+				return defined([
+					via({ name: "complete_plan" }, at(completePlan_server_default, contextSession)),
+					via({ name: "record_debug_evidence" }, at(recordDebugEvidence_server_default, contextSession)),
+					via({ name: "write_plan" }, at(writePlan_server_default, contextSession))
+				]);
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map