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

package/dist/prompts-DnVJGtEC.mjs

@@ -0,0 +1,68 @@
+//#region src/services/prompts/index.ts
+const EVIDENCE_FIELDS = [
+	"issue",
+	"expectedBehavior",
+	"reproductionAttempt",
+	"actualBehavior",
+	"logs",
+	"correlatedTraceEvidence",
+	"processOutput",
+	"browserConsoleEvidence",
+	"correlationIds",
+	"timestamps",
+	"verifiedFacts",
+	"hypotheses",
+	"unavailableEvidence"
+];
+function evidenceLines(packet) {
+	return EVIDENCE_FIELDS.flatMap((field) => {
+		const value = packet[field];
+		if (Array.isArray(value) && value.length === 0) return [];
+		if (typeof value === "string" && value.length === 0) return [];
+		return `${field}: ${Array.isArray(value) ? value.join(" | ") : value}`;
+	}).join("\n");
+}
+/** The review protocol sentences that exist only because a host's tools support them. */
+function reviewProtocolLines(capabilities) {
+	return [
+		...capabilities.completePlanTakesDecision ? ["In an interactive text session, call complete_plan without a decision and it opens the exit-or-continue selector."] : [],
+		...capabilities.narratesReview ? ["Under autonomous voice, complete_plan displays and narrates the choices without opening a blocking dialog, then ends the turn."] : [],
+		...capabilities.completePlanTakesDecision ? ["Interpret the user's next ordinary message and call complete_plan again with decision \"exit\" or \"continue\"."] : []
+	];
+}
+/**
+* The host-independent plan mode block, pushed ahead of the flavor block.
+*
+* Both the Pi extension and the server facet append this. It lives here so the cockpit and the
+* terminal cannot drift into giving the agent different instructions for the same mode. The two
+* facets may differ only through {@link PlanHostCapabilities}, so every other sentence is shared
+* by construction.
+*/
+function buildPlanModeBasePrompt(plansDirectory, capabilities) {
+	const review = reviewProtocolLines(capabilities);
+	return `[PLAN MODE ACTIVE]\nYou are in repository read-only plan mode. The dedicated write_plan tool may write one unique Markdown plan file under ${plansDirectory}.\n\nExplore the codebase and produce a concrete implementation plan. For every plan, first call subagent with action "agents", cluster the exploration by independent domain, subsystem, or integration boundary, and create a provisional task graph with the task tool. Select specialized agents by matching their names and descriptions to each cluster. Assign every unblocked delegated task through the task tool, and use a one-shot inlineAgent with a focused systemPrompt when no discovered specialist fits. Treat the initial graph as provisional, not as a fixed contract. After findings arrive, review the entire graph at least once and perform one to three review passes in total. In each pass, use the evidence to add, rewrite, delete, cancel, reassign, or change blockedBy relationships for tasks when warranted. Do not keep following tasks that new information has made stale. Stop revising early when the graph is stable, or after the third pass.\n\nEvery plan must end with a delegated planning-draft stage blocked by all exploration and decision tasks. A single-boundary plan gets one planning draft. A complex plan spanning multiple subsystems, domains, packages, apps, or integration boundaries gets two planning drafts concurrently. Use three concurrent drafts instead when the work is cross-layer, migration-sensitive, security-sensitive, or similarly high risk. Assign each draft through the task tool to the discovered "planner" agent with context "fork" so it receives the conversation and gathered evidence. If the planner agent is unavailable, assign the same draft task through the task tool with a focused inlineAgent. All children receive read, Bash, grep, find, ls, and configured MCP tools with artifacts disabled. Bash and MCP tools are for read-only inspection and must not modify files, external systems, or repository state. Doom Team runs asynchronously, so do not poll. After launch, continue non-overlapping exploration or end your turn; completion notifications wake the parent session.\n\nAfter all planning drafts complete, the main agent must compare the candidates, pick the strongest draft, cross-check it against the gathered evidence and the other drafts, resolve conflicts and gaps, and ask the user only for product decisions. A child produces the draft, but the main agent owns and synthesizes the final plan. The edit and write tools are withheld while plan mode is active; do not modify files or repository state except through write_plan. Start the final plan with a meaningful Markdown H1 because write_plan derives the filename from it. Present the complete plan as visible Markdown in chat, then call write_plan with no arguments. After write_plan succeeds, clear the completed durable task graph and call complete_plan so the user can review the plan and choose whether to begin implementation or continue planning. Do not exit plan mode without explicit approval.${review.length === 0 ? "" : `\n\n${review.join("\n")}`}`;
+}
+/** Normal planning adds only the flavor-specific brief to the shared planning workflow. */
+function buildNormalPlanningPrompt() {
+	return `[PLAN MODE ACTIVE: NORMAL]\nStandard planning: follow the plan mode brief above using the read-only tools directly.`;
+}
+function buildDebugPlanningPrompt(plansDirectory, evidence) {
+	return `[PLAN MODE ACTIVE: DEBUG]\nYou are in repository read-only adaptive debug planning. The dedicated write_plan tool may write one unique Markdown plan file under ${plansDirectory}.\n\n${evidence ? `A bounded debug evidence packet is recorded below. Cite its verified facts when making source findings. Keep verified facts and hypotheses distinct. Do not claim a verified root cause when reproduction or supporting evidence is unavailable.\n\n[DEBUG EVIDENCE]\n${evidenceLines(evidence)}` : "No structured debug evidence packet is recorded yet. First understand the reported issue, then gather only the evidence relevant to it. Recording evidence is optional and must not block source exploration, delegation, writing a plan, or completing a plan."}\n\nUse the exact read-only tools available for the issue. Bash is available for repository inspection, but commands must not modify files or repository state. Treat unavailable evidence as unavailable, never invent its contents, and keep verified facts separate from hypotheses. ${evidence ? "The final plan must separate verified facts from hypotheses and must not present an unsupported root cause as verified." : "You may call record_debug_evidence when structured notes would help, but continue investigating without it when it is not relevant."}`;
+}
+function buildCodeReviewPlanningPrompt(plansDirectory) {
+	return `[PLAN MODE ACTIVE: CODE REVIEW]\nYou are in repository read-only code review planning. The dedicated write_plan tool may write one unique Markdown review and remediation plan under ${plansDirectory}.\n\nReview the user-specified change, commit range, or files. When no target is specified, inspect git status and the staged and unstaged diffs; ask for the review target when there are no changes to review. Trace changed behavior through callers, contracts, and relevant tests. Focus on concrete bugs, regressions, security risks, error handling, and missing regression coverage rather than unrelated cleanup or style preferences.\n\nPresent actionable findings in severity order with file and line references, the affected scenario, supporting evidence, and a minimal proposed fix. Keep verified behavior separate from source-based inferences and clearly state which checks were not run. Do not invent findings; explicitly report when no actionable issues are found and note remaining risks or test gaps. Turn supported findings into a scoped remediation plan with validation steps. Do not implement fixes or modify repository state during review. Present the final review plan, save it with write_plan, and use complete_plan for explicit approval before implementation.`;
+}
+/** @deprecated Fable is no longer an activatable planning flavor. Retained for API compatibility. */
+function buildFablePlanningPrompt(plansDirectory, stage, capabilities) {
+	if (!capabilities.fableAvailable) return `[PLAN MODE ACTIVE: FABLE]\nFable planning is unavailable in this host, so plan with the read-only tools directly.`;
+	return `[PLAN MODE ACTIVE: FABLE]\nYou are in repository read-only Fable planning. Pi owns final verification and synthesis. The dedicated write_plan tool may write one unique Markdown plan file under ${plansDirectory}.\n\nUse Pi read-only exploration first. When the bounded packet is ready, call run_fable_plan. Fable runs one fresh draft with repository inspection access and returns untrusted text. Cross-check every Fable claim against repository evidence, keep verified findings separate from explicitly inferred findings, resolve conflicts yourself, and present the final visible plan before calling write_plan. Never treat Fable output as repository evidence and never expose credentials, transcripts, commands, tools, or session data in the packet.\n\nCurrent Fable stage: ${stage}. An interrupted stage is not relaunched automatically.`;
+}
+function buildFlavorPlanningPrompt(flavor, plansDirectory, evidence, _fableStage, _capabilities) {
+	if (flavor === "debug") return buildDebugPlanningPrompt(plansDirectory, evidence);
+	if (flavor === "code-review") return buildCodeReviewPlanningPrompt(plansDirectory);
+	return buildNormalPlanningPrompt();
+}
+//#endregion
+export { buildNormalPlanningPrompt as a, buildFlavorPlanningPrompt as i, buildDebugPlanningPrompt as n, buildPlanModeBasePrompt as o, buildFablePlanningPrompt as r, buildCodeReviewPlanningPrompt as t };
+
+//# sourceMappingURL=prompts-DnVJGtEC.mjs.map

package/dist/prompts-DnVJGtEC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts-DnVJGtEC.mjs","names":[],"sources":["../src/services/prompts/index.ts"],"sourcesContent":["export type PlanningFlavor = 'normal' | 'debug' | 'code-review';\n\nexport interface DebugEvidencePacket {\n  issue: string;\n  expectedBehavior: string;\n  reproductionAttempt: string;\n  actualBehavior: string;\n  logs: string[];\n  correlatedTraceEvidence: string[];\n  processOutput: string[];\n  browserConsoleEvidence: string[];\n  correlationIds: string[];\n  timestamps: string[];\n  verifiedFacts: string[];\n  hypotheses: string[];\n  unavailableEvidence: string[];\n}\n\nconst EVIDENCE_FIELDS: readonly (keyof DebugEvidencePacket)[] = [\n  'issue',\n  'expectedBehavior',\n  'reproductionAttempt',\n  'actualBehavior',\n  'logs',\n  'correlatedTraceEvidence',\n  'processOutput',\n  'browserConsoleEvidence',\n  'correlationIds',\n  'timestamps',\n  'verifiedFacts',\n  'hypotheses',\n  'unavailableEvidence',\n];\n\nfunction evidenceLines(packet: DebugEvidencePacket): string {\n  return EVIDENCE_FIELDS.flatMap((field) => {\n    const value = packet[field];\n    if (Array.isArray(value) && value.length === 0) return [];\n    if (typeof value === 'string' && value.length === 0) return [];\n    return `${field}: ${Array.isArray(value) ? value.join(' | ') : value}`;\n  }).join('\\n');\n}\n\n/**\n * What a host's plan tooling can actually do, declared as capabilities rather than as a host\n * name. The prompt must instruct only what the host's tool surface accepts: the server's\n * complete_plan takes no parameters, so telling that model to pass a decision asks for an\n * argument its provider schema rejects. A `cli | server` flag would encode identity and invite\n * the next divergence to hide behind it.\n */\nexport interface PlanHostCapabilities {\n  /** The host's complete_plan accepts a `decision` argument. */\n  readonly completePlanTakesDecision: boolean;\n  /** The host can narrate the plan review under autonomous voice. */\n  readonly narratesReview: boolean;\n  /** The host has a Fable broker. */\n  readonly fableAvailable: boolean;\n}\n\n/** The review protocol sentences that exist only because a host's tools support them. */\nfunction reviewProtocolLines(capabilities: PlanHostCapabilities): string[] {\n  return [\n    ...(capabilities.completePlanTakesDecision\n      ? [\n          'In an interactive text session, call complete_plan without a decision and it opens the exit-or-continue selector.',\n        ]\n      : []),\n    ...(capabilities.narratesReview\n      ? [\n          'Under autonomous voice, complete_plan displays and narrates the choices without opening a blocking dialog, then ends the turn.',\n        ]\n      : []),\n    ...(capabilities.completePlanTakesDecision\n      ? ['Interpret the user\\'s next ordinary message and call complete_plan again with decision \"exit\" or \"continue\".']\n      : []),\n  ];\n}\n\n/**\n * The host-independent plan mode block, pushed ahead of the flavor block.\n *\n * Both the Pi extension and the server facet append this. It lives here so the cockpit and the\n * terminal cannot drift into giving the agent different instructions for the same mode. The two\n * facets may differ only through {@link PlanHostCapabilities}, so every other sentence is shared\n * by construction.\n */\nexport function buildPlanModeBasePrompt(plansDirectory: string, capabilities: PlanHostCapabilities): string {\n  const review = reviewProtocolLines(capabilities);\n  return `[PLAN MODE ACTIVE]\\nYou are in repository read-only plan mode. The dedicated write_plan tool may write one unique Markdown plan file under ${plansDirectory}.\\n\\nExplore the codebase and produce a concrete implementation plan. For every plan, first call subagent with action \"agents\", cluster the exploration by independent domain, subsystem, or integration boundary, and create a provisional task graph with the task tool. Select specialized agents by matching their names and descriptions to each cluster. Assign every unblocked delegated task through the task tool, and use a one-shot inlineAgent with a focused systemPrompt when no discovered specialist fits. Treat the initial graph as provisional, not as a fixed contract. After findings arrive, review the entire graph at least once and perform one to three review passes in total. In each pass, use the evidence to add, rewrite, delete, cancel, reassign, or change blockedBy relationships for tasks when warranted. Do not keep following tasks that new information has made stale. Stop revising early when the graph is stable, or after the third pass.\\n\\nEvery plan must end with a delegated planning-draft stage blocked by all exploration and decision tasks. A single-boundary plan gets one planning draft. A complex plan spanning multiple subsystems, domains, packages, apps, or integration boundaries gets two planning drafts concurrently. Use three concurrent drafts instead when the work is cross-layer, migration-sensitive, security-sensitive, or similarly high risk. Assign each draft through the task tool to the discovered \"planner\" agent with context \"fork\" so it receives the conversation and gathered evidence. If the planner agent is unavailable, assign the same draft task through the task tool with a focused inlineAgent. All children receive read, Bash, grep, find, ls, and configured MCP tools with artifacts disabled. Bash and MCP tools are for read-only inspection and must not modify files, external systems, or repository state. Doom Team runs asynchronously, so do not poll. After launch, continue non-overlapping exploration or end your turn; completion notifications wake the parent session.\\n\\nAfter all planning drafts complete, the main agent must compare the candidates, pick the strongest draft, cross-check it against the gathered evidence and the other drafts, resolve conflicts and gaps, and ask the user only for product decisions. A child produces the draft, but the main agent owns and synthesizes the final plan. The edit and write tools are withheld while plan mode is active; do not modify files or repository state except through write_plan. Start the final plan with a meaningful Markdown H1 because write_plan derives the filename from it. Present the complete plan as visible Markdown in chat, then call write_plan with no arguments. After write_plan succeeds, clear the completed durable task graph and call complete_plan so the user can review the plan and choose whether to begin implementation or continue planning. Do not exit plan mode without explicit approval.${review.length === 0 ? '' : `\\n\\n${review.join('\\n')}`}`;\n}\n\n/** Normal planning adds only the flavor-specific brief to the shared planning workflow. */\nexport function buildNormalPlanningPrompt(): string {\n  return `[PLAN MODE ACTIVE: NORMAL]\\nStandard planning: follow the plan mode brief above using the read-only tools directly.`;\n}\n\nexport function buildDebugPlanningPrompt(plansDirectory: string, evidence: DebugEvidencePacket | undefined): string {\n  const guidance = evidence\n    ? `A bounded debug evidence packet is recorded below. Cite its verified facts when making source findings. Keep verified facts and hypotheses distinct. Do not claim a verified root cause when reproduction or supporting evidence is unavailable.\\n\\n[DEBUG EVIDENCE]\\n${evidenceLines(evidence)}`\n    : 'No structured debug evidence packet is recorded yet. First understand the reported issue, then gather only the evidence relevant to it. Recording evidence is optional and must not block source exploration, delegation, writing a plan, or completing a plan.';\n  return `[PLAN MODE ACTIVE: DEBUG]\\nYou are in repository read-only adaptive debug planning. The dedicated write_plan tool may write one unique Markdown plan file under ${plansDirectory}.\\n\\n${guidance}\\n\\nUse the exact read-only tools available for the issue. Bash is available for repository inspection, but commands must not modify files or repository state. Treat unavailable evidence as unavailable, never invent its contents, and keep verified facts separate from hypotheses. ${evidence ? 'The final plan must separate verified facts from hypotheses and must not present an unsupported root cause as verified.' : 'You may call record_debug_evidence when structured notes would help, but continue investigating without it when it is not relevant.'}`;\n}\n\nexport function buildCodeReviewPlanningPrompt(plansDirectory: string): string {\n  return `[PLAN MODE ACTIVE: CODE REVIEW]\\nYou are in repository read-only code review planning. The dedicated write_plan tool may write one unique Markdown review and remediation plan under ${plansDirectory}.\\n\\nReview the user-specified change, commit range, or files. When no target is specified, inspect git status and the staged and unstaged diffs; ask for the review target when there are no changes to review. Trace changed behavior through callers, contracts, and relevant tests. Focus on concrete bugs, regressions, security risks, error handling, and missing regression coverage rather than unrelated cleanup or style preferences.\\n\\nPresent actionable findings in severity order with file and line references, the affected scenario, supporting evidence, and a minimal proposed fix. Keep verified behavior separate from source-based inferences and clearly state which checks were not run. Do not invent findings; explicitly report when no actionable issues are found and note remaining risks or test gaps. Turn supported findings into a scoped remediation plan with validation steps. Do not implement fixes or modify repository state during review. Present the final review plan, save it with write_plan, and use complete_plan for explicit approval before implementation.`;\n}\n\n/** @deprecated Fable is no longer an activatable planning flavor. Retained for API compatibility. */\nexport function buildFablePlanningPrompt(\n  plansDirectory: string,\n  stage: string,\n  capabilities: PlanHostCapabilities,\n): string {\n  if (!capabilities.fableAvailable) {\n    return `[PLAN MODE ACTIVE: FABLE]\\nFable planning is unavailable in this host, so plan with the read-only tools directly.`;\n  }\n  return `[PLAN MODE ACTIVE: FABLE]\\nYou are in repository read-only Fable planning. Pi owns final verification and synthesis. The dedicated write_plan tool may write one unique Markdown plan file under ${plansDirectory}.\\n\\nUse Pi read-only exploration first. When the bounded packet is ready, call run_fable_plan. Fable runs one fresh draft with repository inspection access and returns untrusted text. Cross-check every Fable claim against repository evidence, keep verified findings separate from explicitly inferred findings, resolve conflicts yourself, and present the final visible plan before calling write_plan. Never treat Fable output as repository evidence and never expose credentials, transcripts, commands, tools, or session data in the packet.\\n\\nCurrent Fable stage: ${stage}. An interrupted stage is not relaunched automatically.`;\n}\n\nexport function buildFlavorPlanningPrompt(\n  flavor: PlanningFlavor,\n  plansDirectory: string,\n  evidence: DebugEvidencePacket | undefined,\n  _fableStage?: string,\n  _capabilities?: PlanHostCapabilities,\n): string {\n  if (flavor === 'debug') return buildDebugPlanningPrompt(plansDirectory, evidence);\n  if (flavor === 'code-review') return buildCodeReviewPlanningPrompt(plansDirectory);\n  return buildNormalPlanningPrompt();\n}\n"],"mappings":";AAkBA,MAAM,kBAA0D;CAC9D;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,SAAS,cAAc,QAAqC;CAC1D,OAAO,gBAAgB,SAAS,UAAU;EACxC,MAAM,QAAQ,OAAO;EACrB,IAAI,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG,OAAO,CAAC;EACxD,IAAI,OAAO,UAAU,YAAY,MAAM,WAAW,GAAG,OAAO,CAAC;EAC7D,OAAO,GAAG,MAAM,IAAI,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,KAAK,IAAI;CACjE,CAAC,CAAC,CAAC,KAAK,IAAI;AACd;;AAmBA,SAAS,oBAAoB,cAA8C;CACzE,OAAO;EACL,GAAI,aAAa,4BACb,CACE,mHACF,IACA,CAAC;EACL,GAAI,aAAa,iBACb,CACE,gIACF,IACA,CAAC;EACL,GAAI,aAAa,4BACb,CAAC,iHAA8G,IAC/G,CAAC;CACP;AACF;;;;;;;;;AAUA,SAAgB,wBAAwB,gBAAwB,cAA4C;CAC1G,MAAM,SAAS,oBAAoB,YAAY;CAC/C,OAAO,8IAA8I,eAAe,g2FAAg2F,OAAO,WAAW,IAAI,KAAK,OAAO,OAAO,KAAK,IAAI;AACxjG;;AAGA,SAAgB,4BAAoC;CAClD,OAAO;AACT;AAEA,SAAgB,yBAAyB,gBAAwB,UAAmD;CAIlH,OAAO,mKAAmK,eAAe,OAHxK,WACb,yQAAyQ,cAAc,QAAQ,MAC/R,kQACqM,0RAA0R,WAAW,4HAA4H;AAC5mB;AAEA,SAAgB,8BAA8B,gBAAgC;CAC5E,OAAO,wLAAwL,eAAe;AAChN;;AAGA,SAAgB,yBACd,gBACA,OACA,cACQ;CACR,IAAI,CAAC,aAAa,gBAChB,OAAO;CAET,OAAO,oMAAoM,eAAe,sjBAAsjB,MAAM;AACxxB;AAEA,SAAgB,0BACd,QACA,gBACA,UACA,aACA,eACQ;CACR,IAAI,WAAW,SAAS,OAAO,yBAAyB,gBAAgB,QAAQ;CAChF,IAAI,WAAW,eAAe,OAAO,8BAA8B,cAAc;CACjF,OAAO,0BAA0B;AACnC"}

package/dist/prompts.cjs

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_prompts = require("./prompts-DUVUPNZd.cjs");
+exports.buildCodeReviewPlanningPrompt = require_prompts.buildCodeReviewPlanningPrompt;
+exports.buildDebugPlanningPrompt = require_prompts.buildDebugPlanningPrompt;
+exports.buildFablePlanningPrompt = require_prompts.buildFablePlanningPrompt;
+exports.buildFlavorPlanningPrompt = require_prompts.buildFlavorPlanningPrompt;
+exports.buildNormalPlanningPrompt = require_prompts.buildNormalPlanningPrompt;
+exports.buildPlanModeBasePrompt = require_prompts.buildPlanModeBasePrompt;

package/dist/prompts.d.mts

@@ -0,0 +1,2 @@
+import { a as buildDebugPlanningPrompt, c as buildNormalPlanningPrompt, i as buildCodeReviewPlanningPrompt, l as buildPlanModeBasePrompt, n as PlanHostCapabilities, o as buildFablePlanningPrompt, r as PlanningFlavor, s as buildFlavorPlanningPrompt, t as DebugEvidencePacket } from "./index-C9QBG9cw.mjs";
+export { DebugEvidencePacket, PlanHostCapabilities, PlanningFlavor, buildCodeReviewPlanningPrompt, buildDebugPlanningPrompt, buildFablePlanningPrompt, buildFlavorPlanningPrompt, buildNormalPlanningPrompt, buildPlanModeBasePrompt };

package/dist/prompts.mjs

@@ -0,0 +1,2 @@
+import { a as buildNormalPlanningPrompt, i as buildFlavorPlanningPrompt, n as buildDebugPlanningPrompt, o as buildPlanModeBasePrompt, r as buildFablePlanningPrompt, t as buildCodeReviewPlanningPrompt } from "./prompts-DnVJGtEC.mjs";
+export { buildCodeReviewPlanningPrompt, buildDebugPlanningPrompt, buildFablePlanningPrompt, buildFlavorPlanningPrompt, buildNormalPlanningPrompt, buildPlanModeBasePrompt };

package/llms.txt

@@ -0,0 +1,9 @@
+# Doom Pi Plan
+
+## Resources
+
+- [Package README](./README.md): Planning flavors, review flow, model configuration, storage, and safety boundaries.
+
+## How to use
+
+- [po-use-plan](./src/prompts/po-use-plan/SKILL.md): Draft reviewable normal, debug, or code review plans, persist them, and exit safely.

package/package.json

@@ -0,0 +1,164 @@
+{
+  "name": "@agimon-ai/po-plan",
+  "version": "0.0.0-alpha.0",
+  "description": "Reviewable Pi planning mode that removes file-editing tools and persists implementation plans.",
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "developer-tools",
+    "implementation-planning",
+    "pi-coding-agent",
+    "pi-extension",
+    "pi-package",
+    "planMode",
+    "po",
+    "tool-restrictions"
+  ],
+  "homepage": "https://agimon.ai",
+  "bugs": {
+    "url": "https://github.com/AgiFlow/po/issues"
+  },
+  "license": "MIT",
+  "author": "Vuong Ngo",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AgiFlow/po.git",
+    "directory": "packages/minor/po-plan"
+  },
+  "files": [
+    "dist",
+    "llms.txt",
+    "src/prompts",
+    "src/types/planApi.ts",
+    "src/types/planSettings.ts",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "jsnext:main": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./config": {
+      "types": "./dist/config.d.mts",
+      "import": "./dist/config.mjs",
+      "require": "./dist/config.cjs"
+    },
+    "./extensions/server": {
+      "types": "./dist/extensions/server.d.mts",
+      "import": "./dist/extensions/server.mjs",
+      "require": "./dist/extensions/server.cjs"
+    },
+    "./extensions/web": {
+      "import": "./dist/extensions/web.mjs"
+    },
+    "./fableFlow": {
+      "types": "./dist/fableFlow.d.mts",
+      "import": "./dist/fableFlow.mjs",
+      "require": "./dist/fableFlow.cjs"
+    },
+    "./logSinkTelemetry": {
+      "types": "./dist/logSinkTelemetry.d.mts",
+      "import": "./dist/logSinkTelemetry.mjs",
+      "require": "./dist/logSinkTelemetry.cjs"
+    },
+    "./planConfig": {
+      "types": "./dist/planConfig.d.mts",
+      "import": "./dist/planConfig.mjs",
+      "require": "./dist/planConfig.cjs"
+    },
+    "./prompts": {
+      "types": "./dist/prompts.d.mts",
+      "import": "./dist/prompts.mjs",
+      "require": "./dist/prompts.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@agimon-ai/po-config": "0.0.0-alpha.0",
+    "@agimon-ai/po-core": "0.0.0-alpha.0",
+    "@agimon-ai/po-minor-mode": "0.0.0-alpha.0",
+    "@agimon-ai/po-telemetry": "0.0.0-alpha.0",
+    "@agimon-ai/po-web-components": "0.0.0-alpha.0",
+    "@agimon-ai/po-web-security": "0.0.0-alpha.0",
+    "@deepseek-ai/cordis": "4.0.4",
+    "hono": "4.13.12",
+    "typebox": "1.3.34"
+  },
+  "devDependencies": {
+    "@agimon-ai/po-build": "0.0.0-alpha.0",
+    "@earendil-works/pi-coding-agent": "1.0.2",
+    "@tanstack/react-store": "0.11.2",
+    "@tanstack/store": "0.11.2",
+    "@types/node": "26.6.4",
+    "@types/react": "19.3.0",
+    "@types/react-dom": "19.3.0",
+    "@vitest/coverage-v8": "5.0.3",
+    "react": "19.3.0",
+    "react-dom": "19.3.0",
+    "typescript": "7.0.2",
+    "vitest": "5.0.3"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "1.0.2"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "poMcp": {
+    "entry": "./generated/mcp.ts",
+    "dist": "./dist/extensions/mcp.mjs",
+    "scopes": [
+      "session"
+    ],
+    "ui": {
+      "entry": "./generated/mcp-ui.ts",
+      "dist": "./dist/extensions/mcp-ui.mjs",
+      "widgets": [
+        "@agimon-ai/po-plan/complete_plan",
+        "@agimon-ai/po-plan/record_debug_evidence",
+        "@agimon-ai/po-plan/write_plan"
+      ]
+    }
+  },
+  "poServer": {
+    "entry": "./generated/server.ts",
+    "dist": "./dist/extensions/server.mjs",
+    "scopes": [
+      "session"
+    ],
+    "contracts": {
+      "entry": "./src/exports/apiContracts.ts",
+      "dist": "./dist/apiContracts.mjs"
+    }
+  },
+  "poWeb": {
+    "pluginId": "plan",
+    "channels": [],
+    "client": "./dist/extensions/web.mjs",
+    "scopes": [
+      "global",
+      "workspace",
+      "session"
+    ]
+  },
+  "scripts": {
+    "build": "tsdown && tsdown --config tsdown.mcp.config.ts",
+    "build:mcp": "tsdown --config tsdown.mcp.config.ts",
+    "test": "vitest --run",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.web.json && tsc --noEmit -p tsconfig.mcp.json",
+    "lint": "oxlint . && oxfmt . --check",
+    "fixcode": "oxlint . --fix && oxfmt ."
+  }
+}

package/src/prompts/po-use-plan/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: po-use-plan
+description: Use Doom Pi Plan to draft reviewable normal, debug, or code review plans, persist them, and exit safely.
+---
+
+# Use Doom Pi Plan
+
+Use Plan when the user wants investigation and a reviewable implementation plan before repository changes.
+
+## Remote MCP workflow
+
+Call `load_context` to inspect the bound session and its active minor modes.
+Use the available inspection tools to investigate and present the complete plan
+as visible Markdown. Separate verified facts from hypotheses.
+
+When Plan mode is already active, call `write_plan` with that exact text in the
+`markdown` argument. Use the returned path with `read` to verify the saved text.
+The host file is not a downloadable ChatGPT attachment. Do not substitute local
+transcript content or claim that saving authorizes implementation.
+
+When Plan mode is inactive, present the plan in chat and explain that persistence
+requires the user to activate Plan mode in Po. Do not change modes through
+Bash or a hidden interface to bypass that gate.
+
+`complete_plan` requests approval in the local Po UI, not in ChatGPT. Only use
+it when the user intends to review there. An explicit instruction in chat does
+not itself exit server Plan mode. Do not simulate approval or bypass mode gates.
+During autonomous Voice, the headless UI-only `complete_plan` tool is unavailable.
+Supply Markdown to `write_plan`; it will not open a UI input dialog in that mode.
+Present the plan and wait for explicit user direction, never approve it yourself.
+Use repository inspection directly and do not launch background subagents through this remote workflow.
+
+## Local Po workflow
+
+The local TUI uses `SPC p e` for normal planning, `SPC p d` for debugging, and
+`SPC p r` for Code Review. These are local shortcuts, not
+remote tools. The local no-argument `write_plan` reads the visible plan from its
+own session. `complete_plan` requires the user's explicit exit-or-continue choice.
+
+Plan withholds `edit` and `write` while it is active, and adds its own tools without removing anything else. `bash` is not sandboxed: do not mutate the repository while planning, except to save the plan through `write_plan`. If exit restoration fails, report the failure and continue planning without starting implementation.
+
+## Code Review planning
+
+Select Code Review to inspect the requested diff, commit range, or files without editing them. Start with staged and unstaged changes when no target is specified. Report concrete findings in severity order with file and line references, distinguish verified behavior from source-based inferences, and propose the smallest fixes with validation steps. State when no actionable findings exist. Save the review and remediation plan with `write_plan`; implementation still requires explicit approval.

package/src/types/planApi.ts

@@ -0,0 +1,125 @@
+/**
+ * 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/. */
+export 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.
+ */
+export const PLAN_STATUS_KEY = 'doom-plan-document';
+
+/** The selector contract shared by complete_plan and its cockpit composer prompt. */
+export const PLAN_REVIEW_TITLE = 'Plan complete. What would you like to do?';
+export const EXIT_PLAN_MODE_CHOICE = 'Exit plan mode and start implementation';
+export const CONTINUE_PLANNING_CHOICE = 'Continue planning';
+export const EXIT_PLAN_DECISION = 'exit';
+export 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.
+ */
+export const PLAN_REVIEW_CHOICES = [
+  { label: EXIT_PLAN_MODE_CHOICE, value: EXIT_PLAN_DECISION },
+  { label: CONTINUE_PLANNING_CHOICE, value: CONTINUE_PLAN_DECISION },
+] as const;
+
+/** The same options as bare labels, which is all Pi's select and the composer prompt need. */
+export const PLAN_REVIEW_OPTIONS = PLAN_REVIEW_CHOICES.map((choice) => choice.label);
+
+/** Between the plan's title and the stamp that marks a rewrite. */
+const STATUS_SEPARATOR = ' · ';
+
+/** Strips the colour a session may have themed a status with. */
+const ANSI = /\[[0-9;]*m/gu;
+
+/** The status line the session publishes; the stamp changes on every write. */
+export function formatPlanStatus(title: string, stamp: string): string {
+  return `${title}${STATUS_SEPARATOR}${stamp}`;
+}
+
+/** What a reader gets out of the status line. */
+export interface PlanStatusView {
+  title: string;
+  /** When the plan was last written, as the session worded it; empty when it said nothing. */
+  stamp: string;
+}
+
+/**
+ * Reading the status line back. Statuses reach a plugin raw, so the colour a
+ * session may have added comes off here. A title can itself contain the
+ * separator, so the stamp is taken from the last one rather than the first.
+ */
+export function parsePlanStatus(raw: string | undefined): PlanStatusView | undefined {
+  if (raw === undefined) return undefined;
+  const text = raw.replace(ANSI, '').trim();
+  if (text === '') return undefined;
+  const cut = text.lastIndexOf(STATUS_SEPARATOR);
+  if (cut === -1) return { title: text, stamp: '' };
+  return { title: text.slice(0, cut).trim(), stamp: text.slice(cut + STATUS_SEPARATOR.length).trim() };
+}
+
+/**
+ * What write_plan recorded about this session's plan.
+ *
+ * The absolute path is the point of it: the extension resolves the plans
+ * directory against the harness root, which no other process knows, so it
+ * writes down where the plan landed rather than leaving the API to derive a
+ * location it would sometimes get wrong.
+ */
+export interface PlanPointerRecord {
+  path: string;
+  title: string;
+  writtenAt: string;
+  planId?: string;
+}
+
+/** The plan as it stands on disk right now, which is what the source view edits. */
+export interface PlanDetailView {
+  path: string;
+  title: string;
+  writtenAt: string;
+  planId?: string;
+  content: string;
+  /** sha256 of the content; the token a save hands back to prove it is not stale. */
+  hash: string;
+  /** True when the plan is missing or past the size cap, so `content` is empty. */
+  unavailable: boolean;
+  reason?: string;
+}
+
+/** What the save route takes. */
+export interface PlanSaveRequest {
+  /** The hash the reader loaded; a mismatch means the plan moved underneath them. */
+  expectedHash: string;
+  content: string;
+}
+
+/** What the save route answers with. */
+export interface PlanSaveView {
+  hash: string;
+}
+
+/** What a route reports when it refuses; the page shows `error` verbatim. */
+export interface PlanErrorView {
+  error: string;
+  /** On a stale save, the hash the plan actually has now. */
+  hash?: string;
+}

package/src/types/planSettings.ts

@@ -0,0 +1,78 @@
+/**
+ * The planning settings, described once for both surfaces.
+ *
+ * The terminal panel and the cockpit settings page render the same five fields,
+ * and the one thing they must agree on is which config key each one writes. So
+ * the ids, labels and key paths live here rather than in either renderer.
+ *
+ * It lives under src/types because that is the one server root a browser bundle
+ * may read, which also means it may import nothing: pulling the config package
+ * in for the thinking levels would drag a node module into the page. They are
+ * spelled out instead, and a test asserts they still match the parser's.
+ */
+
+export const PLAN_CONFIG_SECTION_ID = 'planning';
+const PLANNING_PATH = ['modes', PLAN_CONFIG_SECTION_ID] as const;
+const MAIN_KEY = 'main';
+const SUBAGENTS_KEY = 'subagents';
+
+/** Both agents fall back to the session's own settings when left unset. */
+const INHERIT_MODEL = 'inherit the session model';
+const INHERIT_THINKING = 'inherit';
+
+/** Mirrors DOOM_PLANNING_THINKING_LEVELS; pinned by planConfig's test. */
+export const PLAN_THINKING_LEVELS: readonly string[] = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'];
+
+export interface PlanSettingShape {
+  readonly id: string;
+  readonly label: string;
+  readonly keyPath: readonly string[];
+  readonly placeholder: string;
+  readonly detail: string;
+  /** Present for a closed set; a renderer offers these rather than free text. */
+  readonly options?: readonly string[];
+  /** Offers the machine's authenticated models rather than free text. */
+  readonly models?: boolean;
+}
+
+export const PLAN_SETTING_SHAPES: readonly PlanSettingShape[] = [
+  {
+    id: 'main.model',
+    label: 'main model',
+    keyPath: [...PLANNING_PATH, MAIN_KEY, 'model'],
+    placeholder: INHERIT_MODEL,
+    detail: 'model the main agent switches to while plan mode is on.',
+    models: true,
+  },
+  {
+    id: 'main.thinking',
+    label: 'main thinking',
+    keyPath: [...PLANNING_PATH, MAIN_KEY, 'thinking'],
+    placeholder: INHERIT_THINKING,
+    detail: 'thinking level appended to the main model while planning.',
+    options: PLAN_THINKING_LEVELS,
+  },
+  {
+    id: 'subagents.model',
+    label: 'subagent model',
+    keyPath: [...PLANNING_PATH, SUBAGENTS_KEY, 'model'],
+    placeholder: INHERIT_MODEL,
+    detail: 'model forced onto delegated planning subagents.',
+    models: true,
+  },
+  {
+    id: 'subagents.thinking',
+    label: 'subagent thinking',
+    keyPath: [...PLANNING_PATH, SUBAGENTS_KEY, 'thinking'],
+    placeholder: INHERIT_THINKING,
+    detail: 'thinking level appended to the subagent model.',
+    options: PLAN_THINKING_LEVELS,
+  },
+  {
+    id: 'plansdirectory',
+    label: 'plans directory',
+    keyPath: [...PLANNING_PATH, 'plansDirectory'],
+    placeholder: '~/.po/plans',
+    detail: 'absolute, repo-relative, or under ~. written plans land here.',
+  },
+];