@narumitw/pi-goal 0.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 narumiruna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# pi-goal
+
+A public [pi](https://pi.dev) extension package that adds `/goal <goal_to_complete>`.
+
+Goal mode keeps sending automatic follow-up messages until the agent calls the `goal_complete` tool, so tasks such as `/goal implement snake game` continue past planning and partial progress.
+
+## Install
+
+```bash
+pi install npm:@narumitw/pi-goal
+```
+
+Try without installing:
+
+```bash
+pi -e npm:@narumitw/pi-goal
+```
+
+Try this package locally from the repository root:
+
+```bash
+pi -e ./extensions/pi-goal
+```
+
+## Commands
+
+```bash
+/goal implement snake game
+/goal-status
+/goal-stop
+```
+
+- `/goal <goal_to_complete>` starts goal mode and asks the agent to keep working until complete.
+- `/goal-status` shows the active goal.
+- `/goal-stop` cancels the active goal loop.
+
+## How completion works
+
+The extension registers a `goal_complete` tool. While a goal is active, the system prompt tells the agent to keep working, verify the result, and call `goal_complete` only when the goal is fully done.
+
+If an agent turn ends before `goal_complete` is called, the extension automatically sends a follow-up prompt to continue the same goal.
+
+## Package layout
+
+```txt
+extensions/pi-goal/
+├── src/
+│   └── goal.ts
+├── README.md
+├── LICENSE
+├── tsconfig.json
+└── package.json
+```
+
+The package exposes its extension through `package.json`:
+
+```json
+{
+  "pi": {
+    "extensions": ["./src/goal.ts"]
+  }
+}
+```

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@narumitw/pi-goal",
+	"version": "0.1.3",
+	"description": "Pi extension that keeps working on a /goal until the agent marks it complete.",
+	"type": "module",
+	"license": "MIT",
+	"private": false,
+	"keywords": [
+		"pi-package",
+		"pi-extension",
+		"pi",
+		"goal",
+		"automation"
+	],
+	"files": [
+		"src",
+		"README.md",
+		"LICENSE"
+	],
+	"pi": {
+		"extensions": [
+			"./src/goal.ts"
+		]
+	},
+	"scripts": {
+		"check": "biome check . && npm run typecheck",
+		"format": "biome check --write .",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"typebox": "^1.1.37"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.4.14",
+		"@mariozechner/pi-coding-agent": "0.73.0",
+		"typescript": "6.0.3"
+	}
+}

package/src/goal.ts

@@ -0,0 +1,143 @@
+import { defineTool, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+
+interface ActiveGoal {
+	text: string;
+	startedAt: number;
+	iteration: number;
+}
+
+interface GoalCompleteDetails {
+	goal: string;
+	summary: string;
+}
+
+let activeGoal: ActiveGoal | undefined;
+
+const goalCompleteTool = defineTool({
+	name: "goal_complete",
+	label: "Goal Complete",
+	description:
+		"Mark the active /goal as complete. Only call this after the requested goal is fully done and verified.",
+	promptSnippet: "Mark the active /goal as complete after fully finishing and verifying it",
+	promptGuidelines: [
+		"When a /goal is active, keep working until the goal is complete; do not stop with only a plan or partial progress.",
+		"Call goal_complete only after the requested goal is fully implemented, verified, and no known required work remains.",
+	],
+	parameters: Type.Object({
+		summary: Type.String({
+			description: "Concise summary of what was completed and how it was verified.",
+		}),
+	}),
+	async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+		const completedGoal = activeGoal;
+		activeGoal = undefined;
+		ctx.ui.setStatus("goal", undefined);
+
+		const goal = completedGoal?.text ?? "unknown goal";
+		const summary = params.summary.trim();
+
+		ctx.ui.notify(`Goal complete: ${goal}`, "info");
+
+		return {
+			content: [{ type: "text", text: `Goal complete: ${summary}` }],
+			details: { goal, summary } satisfies GoalCompleteDetails,
+			terminate: true,
+		};
+	},
+});
+
+export default function goal(pi: ExtensionAPI) {
+	pi.registerTool(goalCompleteTool);
+
+	pi.registerCommand("goal", {
+		description: "Run a goal to completion: /goal <goal_to_complete>",
+		handler: async (args, ctx) => {
+			const goalText = args.trim();
+			if (!goalText) {
+				ctx.ui.notify("Usage: /goal <goal_to_complete>", "warning");
+				return;
+			}
+
+			activeGoal = {
+				text: goalText,
+				startedAt: Date.now(),
+				iteration: 0,
+			};
+
+			ctx.ui.setStatus("goal", `goal: ${goalText}`);
+			ctx.ui.notify(`Goal started: ${goalText}`, "info");
+
+			const prompt = buildGoalPrompt(goalText);
+			if (ctx.isIdle()) {
+				pi.sendUserMessage(prompt);
+			} else {
+				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+			}
+		},
+	});
+
+	pi.registerCommand("goal-stop", {
+		description: "Stop the active /goal loop",
+		handler: async (_args, ctx) => {
+			if (!activeGoal) {
+				ctx.ui.notify("No active goal.", "info");
+				return;
+			}
+
+			const stoppedGoal = activeGoal.text;
+			activeGoal = undefined;
+			ctx.ui.setStatus("goal", undefined);
+			ctx.ui.notify(`Goal stopped: ${stoppedGoal}`, "warning");
+		},
+	});
+
+	pi.registerCommand("goal-status", {
+		description: "Show the active /goal status",
+		handler: async (_args, ctx) => {
+			if (!activeGoal) {
+				ctx.ui.notify("No active goal.", "info");
+				return;
+			}
+
+			ctx.ui.notify(`Active goal: ${activeGoal.text} (iteration ${activeGoal.iteration})`, "info");
+		},
+	});
+
+	pi.on("session_start", (_event, ctx) => {
+		if (activeGoal) ctx.ui.setStatus("goal", `goal: ${activeGoal.text}`);
+	});
+
+	pi.on("session_shutdown", (_event, ctx) => {
+		ctx.ui.setStatus("goal", undefined);
+	});
+
+	pi.on("before_agent_start", (event) => {
+		if (!activeGoal) return;
+
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n${buildGoalSystemPrompt(activeGoal.text)}`,
+		};
+	});
+
+	pi.on("agent_end", (_event, ctx) => {
+		if (!activeGoal) return;
+
+		activeGoal.iteration += 1;
+		ctx.ui.setStatus("goal", `goal: ${activeGoal.text} (${activeGoal.iteration})`);
+
+		pi.sendUserMessage(buildContinuePrompt(activeGoal), { deliverAs: "followUp" });
+	});
+}
+
+function buildGoalPrompt(goalText: string) {
+	return `Goal mode is active. Complete this goal fully:\n\n${goalText}\n\nKeep working until the goal is done. Do not stop after planning or partial progress. When the goal is fully complete and verified, call the goal_complete tool with a concise completion summary.`;
+}
+
+function buildGoalSystemPrompt(goalText: string) {
+	return `Active /goal: ${goalText}\n\nGoal-mode rules:\n- Continue making concrete progress until the active goal is fully complete.\n- Do not end your response with only a plan, TODO list, or partial progress.\n- Verify the result when possible using appropriate checks.\n- If the goal is not complete at the end of a turn, expect an automatic follow-up and continue from where you left off.\n- Only call the goal_complete tool after the goal is fully complete and verified.`;
+}
+
+function buildContinuePrompt(goal: ActiveGoal) {
+	return `Continue the active /goal until it is complete:\n\n${goal.text}\n\nThis is automatic continuation #${goal.iteration}. If the goal is not complete yet, keep working and verify progress. If it is fully complete and verified, call the goal_complete tool.`;
+}