@heart-of-gold/toolkit 0.1.8 → 0.1.9

package/README.md

@@ -36,12 +36,13 @@ pi install npm:@heart-of-gold/toolkit
 Pi also discovers skills from the shared `~/.agents/skills/` location, so installs done with the OpenCode target are usable from Pi too.
 
 When installed as a Pi package, Heart of Gold exposes Pi-native extension commands for the flagship workflows:
-- `/deep-thought-brainstorm` — guided brainstorm intake for the shared `brainstorm` skill
-- `/deep-thought-plan` — planning mode entrypoint with pi-friendly tool defaults
-- `/marvin-work` — execution mode entrypoint with stronger work guardrails
-- `/marvin-execute` — leave planning mode and begin execution
+- `/deep-thought-brainstorm` — start a brainstorm (collaborative discovery)
+- `/deep-thought-plan` — start planning (research and produce a plan document)
+- `/marvin-work` — start executing a plan (with always-on safety guardrails)
 
-For Pi, these extension commands replace the direct shared-skill entries for `brainstorm`, `plan`, and `work` so the command palette stays clean and there is only one obvious command per flagship workflow.
+The skills themselves enforce their own boundaries (read-only for brainstorm/plan, safe commands for work) via `allowed-tools` and prompt constraints — no manual mode switching needed.
+
+The work extension also provides always-on guardrails that protect `.env`, `.git/`, and `node_modules/` from edits, block `git add .` and destructive `rm`, and require confirmation for `git push` / `npm publish`.
 
 ### List available skills
 ```bash

package/extensions/pi/brainstorm.ts

@@ -1,67 +1,23 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
-function sendPrompt(pi: ExtensionAPI, prompt: string, ctx: Parameters<NonNullable<Parameters<ExtensionAPI["registerCommand"]>[1]["handler"]>>[1]) {
-	if (ctx.isIdle()) {
-		pi.sendUserMessage(prompt);
-	} else {
-		pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-		ctx.ui.notify("Brainstorm prompt queued as follow-up", "info");
-	}
-}
-
 export default function brainstormExtension(pi: ExtensionAPI) {
 	pi.registerCommand("deep-thought-brainstorm", {
-		description: "Interactive pi-first intake for the shared brainstorm skill",
+		description: "Start a brainstorm — collaborative discovery before planning",
 		handler: async (args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/deep-thought-brainstorm requires interactive mode", "warning");
-				return;
-			}
-
-			const topic = args.trim() || (await ctx.ui.editor("Brainstorm topic", ""))?.trim();
+			const topic = args.trim() || (ctx.hasUI ? (await ctx.ui.editor("Brainstorm topic", ""))?.trim() : undefined);
 			if (!topic) {
-				ctx.ui.notify("Cancelled", "info");
+				ctx.ui.notify("Usage: /deep-thought-brainstorm <topic>", "info");
 				return;
 			}
 
-			const clarity = await ctx.ui.select("How clear are the requirements right now?", [
-				"Unclear — need discovery",
-				"Partly clear — explore tradeoffs",
-				"Quite clear — validate before planning",
-			]);
-			if (!clarity) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
-			}
+			const prompt = `/skill:brainstorm ${topic}`;
 
-			const goal = await ctx.ui.select("What should the brainstorm optimize for first?", [
-				"Find the right problem framing",
-				"Compare 2-3 viable approaches",
-				"Pressure-test the chosen direction",
-			]);
-			if (!goal) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				ctx.ui.notify("Brainstorm queued as follow-up", "info");
 			}
-
-			const prompt = [
-				`/skill:brainstorm ${topic}`,
-				"",
-				"Use a pi-friendly interactive flow:",
-				"- Ask one question at a time.",
-				"- Use explicit option lists whenever there are natural choices.",
-				"- Keep momentum high and avoid dumping questionnaires.",
-				"",
-				`Current clarity: ${clarity}`,
-				`Primary goal: ${goal}`,
-			].join("\n");
-
-			const theme = ctx.ui.theme;
-			ctx.ui.setStatus(
-				"deep-thought-brainstorm",
-				theme.fg("accent", "◉") + theme.fg("dim", " Brainstorm flow active"),
-			);
-			sendPrompt(pi, prompt, ctx);
 		},
 	});
 }

package/extensions/pi/plan.ts

@@ -1,93 +1,22 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 
-const PLAN_SAFE_TOOLS = ["read", "bash", "grep", "find", "ls"];
-
 export default function planExtension(pi: ExtensionAPI) {
-	let previousTools: string[] | null = null;
-
-	const applyPlanTools = () => {
-		const available = new Set(pi.getAllTools().map((tool) => tool.name));
-		const nextTools = PLAN_SAFE_TOOLS.filter((tool) => available.has(tool));
-		if (nextTools.length > 0) {
-			pi.setActiveTools(nextTools);
-		}
-	};
-
 	pi.registerCommand("deep-thought-plan", {
-		description: "Interactive pi-first entrypoint for planning mode and the shared plan skill",
+		description: "Start planning — research and produce a plan document",
 		handler: async (args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/deep-thought-plan requires interactive mode", "warning");
-				return;
-			}
-
-			const source = args.trim() || (await ctx.ui.editor("Plan topic or brainstorm path", ""))?.trim();
+			const source = args.trim() || (ctx.hasUI ? (await ctx.ui.editor("Plan topic or brainstorm path", ""))?.trim() : undefined);
 			if (!source) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
-			}
-
-			const mode = await ctx.ui.select("How should planning mode behave?", [
-				"Read-only planning (recommended)",
-				"Allow normal tools, but stay in planning mode",
-			]);
-			if (!mode) {
-				ctx.ui.notify("Cancelled", "info");
+				ctx.ui.notify("Usage: /deep-thought-plan <topic or brainstorm path>", "info");
 				return;
 			}
 
-			if (previousTools === null) {
-				previousTools = pi.getActiveTools();
-			}
-			if (mode.startsWith("Read-only")) {
-				applyPlanTools();
-			}
-
-			const prompt = [
-				`/skill:plan ${source}`,
-				"",
-				"Use a pi-friendly planning flow:",
-				"- Keep planning read-only unless the user explicitly exits planning mode.",
-				"- Ask one question at a time when clarification is needed.",
-				"- Use concise option lists when choosing between paths or handoffs.",
-			].join("\n");
-
-			const theme = ctx.ui.theme;
-			ctx.ui.setStatus(
-				"deep-thought-plan",
-				theme.fg("accent", "◉") + theme.fg("dim", " Plan mode active"),
-			);
-
-			if (ctx.isIdle()) {
-				pi.sendUserMessage(prompt);
-			} else {
-				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-				ctx.ui.notify("Plan prompt queued as follow-up", "info");
-			}
-		},
-	});
-
-	pi.registerCommand("marvin-execute", {
-		description: "Exit planning mode, restore tools, and optionally start work",
-		handler: async (args, ctx) => {
-			if (previousTools) {
-				pi.setActiveTools(previousTools);
-				previousTools = null;
-			}
-			ctx.ui.setStatus("deep-thought-plan", "");
-
-			const target = args.trim();
-			if (!target) {
-				ctx.ui.notify("Planning mode cleared. Run /marvin-work <plan-path> when ready.", "info");
-				return;
-			}
+			const prompt = `/skill:plan ${source}`;
 
-			const prompt = `/skill:work ${target}`;
 			if (ctx.isIdle()) {
 				pi.sendUserMessage(prompt);
 			} else {
 				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-				ctx.ui.notify("Work prompt queued as follow-up", "info");
+				ctx.ui.notify("Plan queued as follow-up", "info");
 			}
 		},
 	});

package/extensions/pi/work.ts

@@ -5,76 +5,15 @@ const CONFIRM_COMMANDS = [/\bgit\s+push\b/i, /\bnpm\s+publish\b/i, /\bbun\s+publ
 const BLOCKED_COMMANDS = [/\bgit\s+add\s+\.\b/i, /\brm\s+(-rf?|--recursive)/i];
 
 export default function workExtension(pi: ExtensionAPI) {
-	let workMode = false;
-
-	pi.registerCommand("marvin-work", {
-		description: "Interactive pi-first entrypoint for the shared work skill",
-		handler: async (args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("/marvin-work requires interactive mode", "warning");
-				return;
-			}
-
-			const planPath = args.trim() || (await ctx.ui.editor("Plan path", ""))?.trim();
-			if (!planPath) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
-			}
-
-			const runMode = await ctx.ui.select("How strict should work mode be?", [
-				"Normal guardrails (recommended)",
-				"Strict guardrails for shipping work",
-			]);
-			if (!runMode) {
-				ctx.ui.notify("Cancelled", "info");
-				return;
-			}
-
-			workMode = true;
-			const theme = ctx.ui.theme;
-			ctx.ui.setStatus(
-				"marvin-work",
-				theme.fg("accent", "◉") + theme.fg("dim", ` Work mode active — ${runMode}`),
-			);
-
-			const prompt = [
-				`/skill:work ${planPath}`,
-				"",
-				"Use pi guardrails while executing:",
-				"- keep progress visible as tasks move from in-progress to complete",
-				"- do not use `git add .`",
-				"- confirm push/publish actions deliberately",
-				"- protect .env, .git/, and node_modules/ from accidental edits",
-			].join("\n");
-
-			if (ctx.isIdle()) {
-				pi.sendUserMessage(prompt);
-			} else {
-				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
-				ctx.ui.notify("Work prompt queued as follow-up", "info");
-			}
-		},
-	});
-
-	pi.registerCommand("marvin-work-off", {
-		description: "Disable Heart of Gold work-mode guardrails",
-		handler: async (_args, ctx) => {
-			workMode = false;
-			ctx.ui.setStatus("marvin-work", "");
-			ctx.ui.notify("Work mode disabled", "info");
-		},
-	});
-
+	// Always-on guardrails — no mode toggle needed
 	pi.on("tool_call", async (event, ctx) => {
-		if (!workMode) return undefined;
-
 		if (event.toolName === "write" || event.toolName === "edit") {
 			const path = String(event.input.path ?? "");
 			if (PROTECTED_PATHS.some((segment) => path.includes(segment))) {
 				if (ctx.hasUI) {
-					ctx.ui.notify(`Blocked protected path in work mode: ${path}`, "warning");
+					ctx.ui.notify(`⛔ Protected path: ${path}`, "warning");
 				}
-				return { block: true, reason: `Protected path in work mode: ${path}` };
+				return { block: true, reason: `Protected path: ${path}` };
 			}
 		}
 
@@ -82,7 +21,7 @@ export default function workExtension(pi: ExtensionAPI) {
 		const command = String(event.input.command ?? "");
 
 		if (BLOCKED_COMMANDS.some((pattern) => pattern.test(command))) {
-			return { block: true, reason: `Blocked unsafe command in work mode: ${command}` };
+			return { block: true, reason: `Blocked unsafe command: ${command}` };
 		}
 
 		if (!CONFIRM_COMMANDS.some((pattern) => pattern.test(command))) {
@@ -93,11 +32,31 @@ export default function workExtension(pi: ExtensionAPI) {
 			return { block: true, reason: `Interactive confirmation required for: ${command}` };
 		}
 
-		const choice = await ctx.ui.select(`Confirm work-mode command:\n\n${command}`, ["Allow", "Block"]);
+		const choice = await ctx.ui.select(`Confirm: ${command}`, ["Allow", "Block"]);
 		if (choice !== "Allow") {
 			return { block: true, reason: `Blocked by user: ${command}` };
 		}
 
 		return undefined;
 	});
+
+	pi.registerCommand("marvin-work", {
+		description: "Start executing a plan — implement with guardrails",
+		handler: async (args, ctx) => {
+			const planPath = args.trim() || (ctx.hasUI ? (await ctx.ui.editor("Plan path", ""))?.trim() : undefined);
+			if (!planPath) {
+				ctx.ui.notify("Usage: /marvin-work <plan path>", "info");
+				return;
+			}
+
+			const prompt = `/skill:work ${planPath}`;
+
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+				ctx.ui.notify("Work queued as follow-up", "info");
+			}
+		},
+	});
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heart-of-gold/toolkit",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "type": "module",
   "description": "Cross-platform installer for Heart of Gold skills — works with Codex, OpenCode, Pi, Claude Code, and more",
   "bin": {