@vitos-pizza/vitos-pizza 0.2.0 → 0.3.1

package/packages/subagents/agents/worker.md

@@ -6,28 +6,16 @@ thinking: high
 systemPromptMode: replace
 ---
 
-You are `worker`: the implementation subagent.
+You are worker: the single writer thread. Execute the assigned task or approved plan with narrow, coherent edits. The main agent and user remain the decision authority.
 
-You are the single writer thread. Your job is to execute the assigned task or approved direction with narrow, coherent edits. The main agent and user remain the decision authority.
-
-Use the provided tools directly. First understand the inherited context, supplied files, plan, and explicit task. Then implement carefully and minimally.
-
-Default responsibilities:
-- validate the task or approved direction against the actual code
-- implement the smallest correct change
-- follow existing patterns in the codebase
-- verify the result with appropriate checks when possible
-- report back clearly with changes, validation, risks, and next steps
-
-Working rules:
-- Prefer narrow, correct changes over broad rewrites.
-- Do not add speculative scaffolding or future-proofing unless explicitly required.
-- Do not leave placeholder code, TODOs, or silent scope changes.
+Rules:
+- Read inherited context/plan first; validate against the actual code.
+- Prefer the smallest correct change; follow existing patterns.
+- No speculative scaffolding, placeholders, TODOs, or silent scope changes.
 - Use `bash` for inspection, validation, and relevant tests.
-- If there is supplied context or a plan, read it first.
-- If your delegated task expects code or file edits and you have not made those edits, do not return a success summary.
+- If the task expects file edits and you made none, do not claim success.
 
-Your final response should follow this shape:
+Final response shape:
 
 Implemented X.
 Changed files: Y.

package/packages/subagents/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/subagents",
-	"version": "0.2.0",
+	"version": "0.3.1",
 	"description": "Subagent delegation for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",

package/packages/subagents/skills/subagents/SKILL.md

@@ -7,56 +7,41 @@ description: Delegate exploration, planning, and implementation to Vito's Pizzer
 
 Use the `subagent` tool to delegate work to focused child agents with isolated context.
 
-## Agent modes
+## Modes
 
-Vito's Pizzeria uses three modes via `/mode` or `F6`:
-
-| Mode | When to use |
-|------|-------------|
-| **agent** | Default balanced work |
-| **plan** | Read-only planning — planner (+ optional scout), `question` for clarification; optional short **Next** footer |
-| **execute** | Full implementation after plan is approved |
-
-In **plan** mode the main agent cannot write/edit/bash. Delegate with subagents. Scout is optional — use it only when codebase recon is needed; otherwise call planner directly. When recon spans independent areas, run multiple scouts in parallel (`tasks: [...]`) then planner:
-
-```
-[optional scout(s) →] planner → (user confirms) → switch to execute → worker
-```
+| Mode | Constraint |
+|------|------------|
+| **plan** | Read-only. Scout (optional) → planner. Never call worker. |
+| **agent** / **execute** | May call worker after a plan is approved (or for focused implementation). |
 
 ## Built-in agents
 
 | Agent | Use when |
 |-------|----------|
-| `scout` | Fast codebase recon; returns compressed context |
+| `scout` | Fast codebase recon; compressed context for handoff |
 | `planner` | Turn context + requirements into an implementation plan |
 | `worker` | Execute an approved plan with narrow, correct edits |
-| `title` | Generate short session titles (used by `@vitos-pizza/session-title`) |
-
-## Typical workflow
 
-```
-[optional scout →] planner → worker
-```
+## Plan-mode examples
 
-### Planner only (enough context)
+### Planner only
 
 ```json
 { "agent": "planner", "task": "Create an implementation plan for ..." }
 ```
 
-### Chain with scout (when recon is needed)
+### Scout → planner
 
 ```json
 {
   "chain": [
     { "agent": "scout", "task": "Map the auth module and key entry points" },
-    { "agent": "planner", "task": "Create a plan based on {previous}" },
-    { "agent": "worker", "task": "Implement the plan from {previous}" }
+    { "agent": "planner", "task": "Create a plan based on {previous}" }
   ]
 }
 ```
 
-### Parallel
+### Parallel scouts
 
 ```json
 {
@@ -67,9 +52,23 @@ In **plan** mode the main agent cannot write/edit/bash. Delegate with subagents.
 }
 ```
 
-### Async + wait
+Then call planner with the combined findings.
+
+## After plan approval (agent / execute)
 
-Start work in the background, then block until it finishes:
+### Chain through worker
+
+```json
+{
+  "chain": [
+    { "agent": "scout", "task": "Map relevant code" },
+    { "agent": "planner", "task": "Create a plan based on {previous}" },
+    { "agent": "worker", "task": "Implement the plan from {previous}" }
+  ]
+}
+```
+
+### Async + wait
 
 ```json
 { "agent": "worker", "task": "...", "async": true }

package/packages/subagents/src/agents.ts

@@ -36,6 +36,23 @@ const THINKING_LEVELS = new Set([
 	"max",
 ]);
 
+/** Internal agents (e.g. session naming) — callable by name, not listed to the main agent. */
+const INTERNAL_AGENT_NAMES = new Set(["title"]);
+
+export function isPublicAgent(name: string): boolean {
+	return !INTERNAL_AGENT_NAMES.has(name);
+}
+
+export function formatAvailableAgents(
+	agents: Array<{ name: string; source: string }>,
+): string {
+	const visible = agents.filter((agent) => isPublicAgent(agent.name));
+	return (
+		visible.map((agent) => `${agent.name} (${agent.source})`).join(", ") ||
+		"none"
+	);
+}
+
 export function getBuiltinAgentsDir(): string {
 	return path.join(
 		path.dirname(fileURLToPath(import.meta.url)),

package/packages/subagents/src/execute-subagent.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import { discoverAgents } from "./agents.ts";
+import { discoverAgents, formatAvailableAgents } from "./agents.ts";
 import { runSingleAgent } from "./run-agent.ts";
 import type {
 	AgentScope,
@@ -67,9 +67,7 @@ export async function executeSubagent(
 	const mode = resolveMode(input);
 
 	if (countModes(input) !== 1 || !mode) {
-		const available =
-			agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") ||
-			"none";
+		const available = formatAvailableAgents(agents);
 		return {
 			content: [
 				{
@@ -267,8 +265,7 @@ export async function executeSubagent(
 		};
 	}
 
-	const available =
-		agents.map((agent) => `${agent.name} (${agent.source})`).join(", ") || "none";
+	const available = formatAvailableAgents(agents);
 	return {
 		content: [
 			{

package/packages/subagents/src/run-agent.ts

@@ -7,6 +7,7 @@ import type { Message } from "@earendil-works/pi-ai";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import {
 	applyThinkingSuffix,
+	formatAvailableAgents,
 	type AgentConfig,
 } from "./agents.ts";
 import {
@@ -77,7 +78,7 @@ export async function runSingleAgent(
 
 	const agent = agents.find((entry) => entry.name === agentName);
 	if (!agent) {
-		const available = agents.map((entry) => `"${entry.name}"`).join(", ") || "none";
+		const available = formatAvailableAgents(agents);
 		return {
 			agent: agentName,
 			agentSource: "unknown",

package/packages/todoist/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/todoist",
-	"version": "0.2.0",
+	"version": "0.3.1",
 	"description": "In-memory task management with TUI widget and optional Todoist MCP sync for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",

package/packages/ui-enhancements/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/ui-enhancements",
-	"version": "0.2.0",
+	"version": "0.3.1",
 	"description": "TUI and UI enhancements for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",

package/packages/ui-enhancements/src/chrome/border-status.ts

@@ -13,6 +13,14 @@ import {
 	getAgentModeBadge,
 	registerAgentModeBadge,
 } from "./agent-mode-badge.ts";
+import {
+	EXECUTE_START_MESSAGE,
+	type ExecutePromptFocus,
+	formatExecuteActionLine,
+	formatExecuteSeparatorLine,
+	handleExecutePromptKey,
+	injectExecutePromptRows,
+} from "./execute-prompt.ts";
 import { fitBorder } from "./format-border.ts";
 import { attachResizeRecovery } from "./resize-recovery.ts";
 
@@ -31,6 +39,10 @@ function formatThinking(level: string): string {
 	return level === "off" ? "off" : level;
 }
 
+function isExecuteMode(): boolean {
+	return getAgentModeBadge()?.mode === "execute";
+}
+
 class EmptyFooter implements Component {
 	render(): string[] {
 		return [];
@@ -127,6 +139,8 @@ export function registerBorderStatusBar(
 		void refreshGit();
 
 		class BorderStatusEditor extends CustomEditor {
+			private executeFocus: ExecutePromptFocus = "action";
+
 			constructor(
 				tui: TUI,
 				theme: EditorTheme,
@@ -136,9 +150,8 @@ export function registerBorderStatusBar(
 				activeTui = tui;
 			}
 
-			render(width: number): string[] {
-				const lines = super.render(width);
-				if (lines.length < 2) return lines;
+			private applyStatusBorders(lines: string[], width: number): void {
+				if (lines.length < 2) return;
 
 				const thm = ctx.ui.theme;
 				const model = ctx.model
@@ -171,8 +184,68 @@ export function registerBorderStatusBar(
 					width,
 					borderColor,
 				);
+			}
+
+			render(width: number): string[] {
+				const execute = isExecuteMode();
+				if (!execute) {
+					this.executeFocus = "action";
+				}
+
+				const wasFocused = this.focused;
+				if (execute && this.executeFocus === "action") {
+					this.focused = false;
+				}
+
+				let lines = super.render(width);
+				this.focused = wasFocused;
+
+				if (lines.length < 2) return lines;
+
+				if (execute) {
+					const thm = ctx.ui.theme;
+					const onAction = this.executeFocus === "action";
+					lines = injectExecutePromptRows(
+						lines,
+						formatExecuteActionLine(onAction, thm, width),
+						formatExecuteSeparatorLine(thm, width),
+					);
+				}
+
+				this.applyStatusBorders(lines, width);
 				return lines;
 			}
+
+			handleInput(data: string): void {
+				if (!isExecuteMode()) {
+					this.executeFocus = "action";
+					super.handleInput(data);
+					return;
+				}
+
+				const result = handleExecutePromptKey(this.executeFocus, data, {
+					editorEmpty: this.isEditorEmpty(),
+					onFirstVisualLine: this.isOnFirstVisualLine(),
+				});
+
+				if (result.type === "setFocus") {
+					this.executeFocus = result.focus;
+					this.focused = result.focus === "editor";
+					this.tui.requestRender();
+					return;
+				}
+
+				if (result.type === "submitStart") {
+					this.setText(EXECUTE_START_MESSAGE);
+					this.submitValue();
+					this.executeFocus = "action";
+					this.focused = false;
+					this.tui.requestRender();
+					return;
+				}
+
+				super.handleInput(data);
+			}
 		}
 
 		ctx.ui.setEditorComponent(

package/packages/ui-enhancements/src/chrome/execute-prompt.ts

@@ -0,0 +1,83 @@
+import { Key, matchesKey, visibleWidth } from "@earendil-works/pi-tui";
+
+export const EXECUTE_START_MESSAGE = "开始实现";
+export const EXECUTE_ACTION_LABEL = "开始实现";
+
+export type ExecutePromptFocus = "action" | "editor";
+
+export type ExecutePromptTheme = {
+	fg(color: string, text: string): string;
+};
+
+export type ExecutePromptKeyResult =
+	| { type: "setFocus"; focus: ExecutePromptFocus }
+	| { type: "submitStart" }
+	| { type: "delegate" };
+
+export function formatExecuteActionLine(
+	selected: boolean,
+	theme: ExecutePromptTheme,
+	_width: number,
+): string {
+	const label = theme.fg(selected ? "accent" : "dim", EXECUTE_ACTION_LABEL);
+	if (selected) {
+		return `${theme.fg("accent", "▶ ")}${label}`;
+	}
+	return label;
+}
+
+/** Light dotted rule — avoids competing with the full-width border chrome. */
+export function formatExecuteSeparatorLine(
+	theme: ExecutePromptTheme,
+	width: number,
+): string {
+	const unit = "· ";
+	const count = Math.max(0, Math.floor(width / visibleWidth(unit)));
+	const dots = unit.repeat(count).trimEnd();
+	return theme.fg("dim", dots);
+}
+
+/**
+ * Decide how execute-mode prompt UI should handle a key when it owns focus logic.
+ * Returns `delegate` for keys the underlying CustomEditor should handle
+ * (shortcuts, free-text editing, etc.).
+ */
+export function handleExecutePromptKey(
+	focus: ExecutePromptFocus,
+	data: string,
+	options: { editorEmpty: boolean; onFirstVisualLine: boolean },
+): ExecutePromptKeyResult {
+	if (focus === "action") {
+		if (matchesKey(data, Key.down)) {
+			return { type: "setFocus", focus: "editor" };
+		}
+		if (matchesKey(data, Key.up)) {
+			return { type: "setFocus", focus: "action" };
+		}
+		if (matchesKey(data, Key.enter)) {
+			return { type: "submitStart" };
+		}
+		return { type: "delegate" };
+	}
+
+	if (
+		matchesKey(data, Key.up) &&
+		options.editorEmpty &&
+		options.onFirstVisualLine
+	) {
+		return { type: "setFocus", focus: "action" };
+	}
+	return { type: "delegate" };
+}
+
+/** Insert action + separator after the top border, before the editor body. */
+export function injectExecutePromptRows(
+	lines: string[],
+	actionLine: string,
+	separatorLine: string,
+): string[] {
+	if (lines.length < 2) return lines;
+	const next = [...lines];
+	next.splice(1, 0, actionLine, separatorLine);
+	return next;
+}

package/packages/websearch/extensions/index.ts

@@ -25,9 +25,11 @@ export default function (pi: ExtensionAPI) {
 		label: "Web Search",
 		description:
 			"Search the web using configured backends. Auto mode tries Exa MCP, Firecrawl, and optional keyed providers.",
-		promptSnippet: "Search the web for up-to-date information",
+		promptSnippet:
+			"Search the web only when local context is insufficient for current external facts",
 		promptGuidelines: [
-			"Use web_search when you need current facts, documentation, or news from the web",
+			"Do not use web_search when the answer is already in the repo, conversation, or local tools (read/grep/find/ls)",
+			"Use web_search only when you need current external facts, docs, or news that local context cannot provide",
 			"Auto mode tries enabled backends in order; Exa MCP works without API keys",
 			"Configure Tavily or Brave in .pi/search.json for higher-quality results",
 		],

package/packages/websearch/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/websearch",
-	"version": "0.2.0",
+	"version": "0.3.1",
 	"description": "Web search and URL reading for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",

package/scripts/sync-pi-manifest.mjs

@@ -10,7 +10,7 @@ const RESOURCE_TYPES = ["extensions", "skills", "prompts", "themes"];
 
 const BUNDLED_FIRST = [];
 const BUNDLED_LAST = [];
-const LOCAL_ORDER = ["permission-system", "question", "ui-enhancements", "agent-mode", "subagents", "websearch", "session-title", "todoist", "keybindings"];
+const LOCAL_ORDER = ["permission-system", "settings-preset", "question", "ui-enhancements", "agent-mode", "subagents", "websearch", "session-title", "todoist", "keybindings"];
 
 function loadJson(path) {
 	return JSON.parse(readFileSync(path, "utf8"));

package/node_modules/@vitos-pizza/agent-mode/extensions/index.ts

@@ -1,138 +0,0 @@
-/**
- * @vitos-pizza/agent-mode — centralized agent / plan / execute mode switching.
- */
-
-import type {
-	ExtensionAPI,
-	ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import { emitShortcutAction } from "@vitos-pizza/keybindings/types";
-import {
-	applyAgentMode,
-	createReloadEmitter,
-	ensureAgentModePersisted,
-} from "../src/apply-mode.ts";
-import {
-	clearAgentModeStatus,
-	emitAgentModeChanged,
-	updateAgentModeStatusFallback,
-} from "../src/mode-events.ts";
-import {
-	AGENT_MODES,
-	cycleAgentMode,
-	isAgentMode,
-	MODE_LABELS,
-	type AgentMode,
-} from "../src/modes.ts";
-import {
-	PLAN_INSTRUCTIONS,
-	PLAN_MODE_ENDED_MESSAGE,
-	PLAN_MODE_MESSAGE,
-	PLAN_MODE_TOOLS,
-} from "../src/plan-instructions.ts";
-
-export default function (pi: ExtensionAPI): void {
-	let currentMode: AgentMode = "agent";
-
-	const emitReload = createReloadEmitter(pi.events);
-
-	const allToolNames = () => pi.getAllTools().map((tool) => tool.name);
-
-	const publishMode = (ctx: ExtensionContext, mode: AgentMode) => {
-		currentMode = mode;
-		emitAgentModeChanged(pi.events, mode);
-		updateAgentModeStatusFallback(ctx, mode);
-	};
-
-	const switchMode = async (ctx: ExtensionContext, mode: AgentMode) => {
-		const leavingPlan = currentMode === "plan" && mode !== "plan";
-		applyAgentMode(ctx.cwd, mode, { emitReload: emitReload });
-		publishMode(ctx, mode);
-		if (leavingPlan) {
-			const tools = allToolNames();
-			if (tools.length > 0) {
-				pi.setActiveTools(tools);
-			}
-			pi.sendMessage({
-				customType: "agent-plan-mode-ended",
-				content: PLAN_MODE_ENDED_MESSAGE,
-				display: false,
-			});
-		}
-		ctx.ui.notify(`Mode: ${mode}`, "info");
-	};
-
-	emitShortcutAction(pi.events, {
-		id: "agent-mode.cycle",
-		description: "Cycle agent mode (agent → plan → execute)",
-		handler: async (shortcutCtx) => {
-			const next = cycleAgentMode(currentMode);
-			await switchMode(shortcutCtx, next);
-		},
-	});
-
-	pi.on("session_start", async (_event, ctx) => {
-		const mode = ensureAgentModePersisted(ctx.cwd, { emitReload });
-		publishMode(ctx, mode);
-	});
-
-	pi.on("session_shutdown", (_event, ctx) => {
-		clearAgentModeStatus(ctx);
-	});
-
-	pi.on("before_agent_start", async (event, _ctx) => {
-		if (currentMode !== "plan") {
-			const tools = allToolNames();
-			if (tools.length > 0) {
-				pi.setActiveTools(tools);
-			}
-			return {};
-		}
-
-		const registered = new Set(allToolNames());
-		const activeTools = PLAN_MODE_TOOLS.filter((name) => registered.has(name));
-		if (activeTools.length > 0) {
-			pi.setActiveTools([...activeTools]);
-		}
-
-		return {
-			message: {
-				customType: "agent-plan-mode",
-				content: PLAN_MODE_MESSAGE,
-				display: false,
-			},
-			systemPrompt: `${event.systemPrompt}\n\n${PLAN_INSTRUCTIONS}`,
-		};
-	});
-
-	pi.registerCommand("mode", {
-		description: "Switch agent mode (agent|plan|execute)",
-		handler: async (args, ctx) => {
-			const requested = args?.trim().toLowerCase();
-			let mode: AgentMode | undefined;
-
-			if (requested) {
-				if (!isAgentMode(requested)) {
-					ctx.ui.notify(
-						`Unknown mode "${requested}". Use: ${AGENT_MODES.join(", ")}`,
-						"error",
-					);
-					return;
-				}
-				mode = requested;
-			} else if (ctx.hasUI) {
-				const options = AGENT_MODES.map((m) => MODE_LABELS[m]);
-				const selected = await ctx.ui.select("Agent mode", options);
-				if (!selected) return;
-				const index = options.indexOf(selected);
-				if (index < 0) return;
-				mode = AGENT_MODES[index];
-			} else {
-				ctx.ui.notify(`Usage: /mode <${AGENT_MODES.join("|")}>`, "info");
-				return;
-			}
-
-			await switchMode(ctx, mode);
-		},
-	});
-}

package/node_modules/@vitos-pizza/agent-mode/package.json

@@ -1,31 +0,0 @@
-{
-	"name": "@vitos-pizza/agent-mode",
-	"version": "0.2.0",
-	"description": "Centralized agent / plan / execute mode switching for Vito's Pizzeria",
-	"type": "module",
-	"license": "MIT",
-	"private": true,
-	"scripts": {
-		"test": "vitest run",
-		"test:watch": "vitest",
-		"typecheck": "tsc --noEmit",
-		"lint": "biome check .",
-		"lint:fix": "biome check --write ."
-	},
-	"dependencies": {
-		"@vitos-pizza/keybindings": "0.2.0",
-		"@vitos-pizza/permission-system": "0.2.0"
-	},
-	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": "*"
-	},
-	"pi": {
-		"requires": [
-			"@vitos-pizza/permission-system"
-		]
-	},
-	"devDependencies": {
-		"@earendil-works/pi-coding-agent": "*",
-		"vitest": "^3.2.4"
-	}
-}