@vitos-pizza/vitos-pizza 0.3.1 → 0.4.1

package/packages/question/src/register-tool.ts

@@ -7,8 +7,25 @@ import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { forwardQuestionPrompt } from "./forwarding/forwarder.ts";
 import { isSubagentChild, resolveParentSessionId } from "./parent-session.ts";
-import { runQuestionUi } from "./question-ui.ts";
-import type { QuestionDetails, QuestionParams } from "./types.ts";
+import { runMultiQuestionUi, runQuestionUi } from "./question-ui.ts";
+import type {
+	MultiQuestionDetails,
+	MultiQuestionParams,
+	MultiTabAnswer,
+	QuestionDetails,
+	QuestionParams,
+	QuestionUiResult,
+	QuestionsParams,
+	SelectType,
+	SingleTabAnswer,
+	TabAnswer,
+} from "./types.ts";
+
+const SelectTypeSchema = Type.Optional(
+	Type.Union([Type.Literal("single"), Type.Literal("multi")], {
+		description: '"single" (default) or "multi" — allows multiple selections',
+	}),
+);
 
 const OptionSchema = Type.Object({
 	label: Type.String({ description: "Display label for the option" }),
@@ -17,11 +34,44 @@ const OptionSchema = Type.Object({
 	),
 });
 
-const QuestionParamsSchema = Type.Object({
+const QuestionTabSchema = Type.Object({
+	id: Type.Optional(
+		Type.String({
+			description:
+				"Optional stable identifier used as result key (defaults to q0, q1, …)",
+		}),
+	),
+	title: Type.Optional(
+		Type.String({
+			description: "Optional tab bar label (defaults to Q1, Q2, …)",
+		}),
+	),
 	question: Type.String({ description: "The question to ask the user" }),
 	options: Type.Array(OptionSchema, {
 		description: "Options for the user to choose from",
 	}),
+	selectType: SelectTypeSchema,
+});
+
+const QuestionParamsSchema = Type.Object({
+	question: Type.Optional(
+		Type.String({
+			description: "The question to ask the user (single‑question mode)",
+		}),
+	),
+	options: Type.Optional(
+		Type.Array(OptionSchema, {
+			description: "Options for the user to choose from (single‑question mode)",
+		}),
+	),
+	selectType: SelectTypeSchema,
+	questions: Type.Optional(
+		Type.Array(QuestionTabSchema, {
+			description:
+				"Multiple questions displayed as tabs (multi‑question mode). Overrides question/options when present.",
+			minItems: 1,
+		}),
+	),
 });
 
 export interface QuestionToolDeps {
@@ -32,6 +82,8 @@ export interface QuestionToolDeps {
 	};
 }
 
+// ── result builders (single) ──
+
 function buildCancelledResult(
 	params: QuestionParams,
 ): AgentToolResult<QuestionDetails> {
@@ -48,34 +100,72 @@ function buildCancelledResult(
 
 function buildAnswerResult(
 	params: QuestionParams,
-	answer: string,
-	wasCustom: boolean,
-	index?: number,
+	answerData: string | SingleTabAnswer | MultiTabAnswer | QuestionUiResult,
 ): AgentToolResult<QuestionDetails> {
 	const simpleOptions = params.options.map((o) => o.label);
-	if (wasCustom) {
+
+	// Check for multi-select (from MultiTabAnswer or QuestionUiResult)
+	if (typeof answerData === "object" && ("answers" in answerData || "multiAnswers" in answerData)) {
+		const multiAnswers = "answers" in answerData
+			? (answerData as MultiTabAnswer).answers
+			: (answerData as QuestionUiResult).multiAnswers ?? [];
+		const multiIndices = "indices" in answerData
+			? (answerData as MultiTabAnswer).indices
+			: (answerData as QuestionUiResult).multiIndices ?? [];
+
+		const lines = multiAnswers.map((a: string, i: number) => {
+			const idx = multiIndices[i];
+			return idx === -1 ? `  (custom) ${a}` : `  ${idx}. ${a}`;
+		});
 		return {
-			content: [{ type: "text", text: `User wrote: ${answer}` }],
+			content: [{ type: "text", text: `User selected:\n${lines.join("\n")}` }],
 			details: {
 				question: params.question,
 				options: simpleOptions,
-				answer,
-				wasCustom: true,
+				answer: multiAnswers.join(", "),
+				multiAnswers,
+				multiIndices,
 			},
 		};
 	}
-	return {
-		content: [
-			{
-				type: "text",
-				text: `User selected: ${index ?? simpleOptions.indexOf(answer) + 1}. ${answer}`,
+
+	if (typeof answerData === "object") {
+		// Single select
+		const single = answerData as SingleTabAnswer;
+		if (single.wasCustom) {
+			return {
+				content: [{ type: "text", text: `User wrote: ${single.answer}` }],
+				details: {
+					question: params.question,
+					options: simpleOptions,
+					answer: single.answer,
+					wasCustom: true,
+				},
+			};
+		}
+		return {
+			content: [
+				{
+					type: "text",
+					text: `User selected: ${single.index ?? simpleOptions.indexOf(single.answer) + 1}. ${single.answer}`,
+				},
+			],
+			details: {
+				question: params.question,
+				options: simpleOptions,
+				answer: single.answer,
+				wasCustom: false,
 			},
-		],
+		};
+	}
+
+	// Legacy string
+	return {
+		content: [{ type: "text", text: `User selected: ${answerData}` }],
 		details: {
 			question: params.question,
 			options: simpleOptions,
-			answer,
-			wasCustom: false,
+			answer: answerData,
 		},
 	};
 }
@@ -94,7 +184,75 @@ function buildUnavailableResult(
 	};
 }
 
-async function executeQuestion(
+// ── result builders (multi) ──
+
+function buildMultiCancelledResult(
+	params: MultiQuestionParams,
+): AgentToolResult<MultiQuestionDetails> {
+	return {
+		content: [
+			{ type: "text", text: "User cancelled the multi‑question selection" },
+		],
+		details: {
+			answers: {},
+		},
+	};
+}
+
+function buildMultiAnswerResult(
+	params: MultiQuestionParams,
+	answers: Record<string, TabAnswer>,
+): AgentToolResult<MultiQuestionDetails> {
+	const lines: string[] = ["User answered:"];
+	for (const [key, ans] of Object.entries(answers)) {
+		const tab = params.questions.find(
+			(q) => (q.id ?? `q${params.questions.indexOf(q)}`) === key,
+		);
+		const label = tab?.title ?? key;
+		if ("answers" in ans) {
+			const multi = ans as MultiTabAnswer;
+			const parts = multi.answers.map((a, i) => {
+				const idx = multi.indices[i];
+				return idx === -1 ? `${a}(custom)` : `${idx}. ${a}`;
+			});
+			lines.push(`  ${label}: ${parts.join(", ")}`);
+		} else {
+			const single = ans as SingleTabAnswer;
+			if (single.wasCustom) {
+				lines.push(`  ${label}: ${single.answer} (custom)`);
+			} else {
+				lines.push(`  ${label}: ${single.index}. ${single.answer}`);
+			}
+		}
+	}
+	return {
+		content: [{ type: "text", text: lines.join("\n") }],
+		details: { answers },
+	};
+}
+
+function buildMultiUnavailableResult(
+	params: MultiQuestionParams,
+	reason: string,
+): AgentToolResult<MultiQuestionDetails> {
+	return {
+		content: [{ type: "text", text: reason }],
+		details: { answers: {} },
+	};
+}
+
+// ── execution ──
+
+function isMultiParams(
+	params: QuestionsParams,
+): params is MultiQuestionParams {
+	return (
+		"questions" in params &&
+		Array.isArray((params as MultiQuestionParams).questions)
+	);
+}
+
+async function executeSingleQuestion(
 	params: QuestionParams,
 	ctx: ExtensionContext,
 	deps: QuestionToolDeps,
@@ -110,12 +268,13 @@ async function executeQuestion(
 	if (!child && ctx.hasUI) {
 		const result = await runQuestionUi(ctx.ui, params);
 		if (!result) return buildCancelledResult(params);
-		return buildAnswerResult(
-			params,
-			result.answer,
-			result.wasCustom,
-			result.index,
-		);
+		if (result.multiAnswers && result.multiIndices) {
+			return buildAnswerResult(params, {
+				answers: result.multiAnswers,
+				indices: result.multiIndices,
+			} as MultiTabAnswer);
+		}
+		return buildAnswerResult(params, result as SingleTabAnswer);
 	}
 
 	if (!parentSessionId) {
@@ -140,17 +299,83 @@ async function executeQuestion(
 		);
 	}
 
-	if (forwarded.cancelled || forwarded.answer === null) {
+	if (forwarded.cancelled) {
 		return buildCancelledResult(params);
 	}
 
-	return buildAnswerResult(
+	// Multi-select via forwarding
+	if (forwarded.multiAnswers && forwarded.multiIndices) {
+		return buildAnswerResult(params, {
+			answers: forwarded.multiAnswers,
+			indices: forwarded.multiIndices,
+		} as MultiTabAnswer);
+	}
+
+	// Single-select via forwarding
+	if (forwarded.answer !== null && forwarded.answer !== undefined) {
+		return buildAnswerResult(params, {
+			answer: forwarded.answer,
+			wasCustom: forwarded.wasCustom ?? false,
+		} as SingleTabAnswer);
+	}
+
+	return buildCancelledResult(params);
+}
+
+async function executeMultiQuestion(
+	params: MultiQuestionParams,
+	ctx: ExtensionContext,
+	deps: QuestionToolDeps,
+): Promise<AgentToolResult<MultiQuestionDetails>> {
+	if (params.questions.length === 0) {
+		return buildMultiUnavailableResult(params, "Error: No questions provided");
+	}
+
+	const child = isSubagentChild();
+	const parentSessionId = resolveParentSessionId();
+	const currentSessionId = ctx.sessionManager.getSessionId?.() ?? null;
+
+	if (!child && ctx.hasUI) {
+		const result = await runMultiQuestionUi(ctx.ui, params);
+		if (!result) return buildMultiCancelledResult(params);
+		return buildMultiAnswerResult(params, result.answers);
+	}
+
+	if (!parentSessionId) {
+		return buildMultiUnavailableResult(
+			params,
+			"Error: UI not available (running in non-interactive mode)",
+		);
+	}
+
+	const forwarded = await forwardQuestionPrompt({
+		events: deps.events,
+		agentDir: deps.getAgentDir(),
+		targetSessionId: parentSessionId,
+		requesterSessionId: currentSessionId ?? "unknown",
 		params,
-		forwarded.answer,
-		forwarded.wasCustom ?? false,
-	);
+	});
+
+	if (!forwarded) {
+		return buildMultiUnavailableResult(
+			params,
+			"Error: Question prompt timed out or parent session unavailable",
+		);
+	}
+
+	if (forwarded.cancelled) {
+		return buildMultiCancelledResult(params);
+	}
+
+	if (forwarded.answers) {
+		return buildMultiAnswerResult(params, forwarded.answers);
+	}
+
+	return buildMultiUnavailableResult(params, "Error: No answers returned");
 }
 
+// ── tool registration ──
+
 export function registerQuestionTool(
 	pi: ExtensionAPI,
 	deps: QuestionToolDeps,
@@ -159,12 +384,26 @@ export function registerQuestionTool(
 		name: "question",
 		label: "Question",
 		description:
-			"Ask the user a question and let them pick from options. Use when you need user input to proceed.",
+			"Ask the user a question and let them pick from options. Supports single questions (question+options) or multiple tabbed questions (questions[]). Use when you need user input to proceed.",
 		parameters: QuestionParamsSchema,
 		executionMode: "sequential",
 
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-			return executeQuestion(params, ctx, deps);
+			const p = params as QuestionsParams;
+			if (isMultiParams(p)) {
+				return executeMultiQuestion(p, ctx, deps);
+			}
+			const single = p as QuestionParams;
+			if (!single.question || !single.options) {
+				return buildUnavailableResult(
+					{
+						question: single.question ?? "",
+						options: single.options ?? [],
+					},
+					"Error: Provide either question+options or questions[]",
+				);
+			}
+			return executeSingleQuestion(single, ctx, deps);
 		},
 
 		renderCall(_args, theme, _context) {
@@ -172,19 +411,56 @@ export function registerQuestionTool(
 		},
 
 		renderResult(result, _options, theme, _context) {
-			const details = result.details as QuestionDetails | undefined;
+			const details = result.details as
+				| QuestionDetails
+				| MultiQuestionDetails
+				| undefined;
 			if (!details) {
 				const text = result.content[0];
 				const fallback = text?.type === "text" ? text.text : "";
 				return new Text(fallback, 0, 0);
 			}
 
-			if (details.answer === null) {
-				return new Text(theme.fg("warning", "Cancelled"), 0, 0);
+			// Multi-question (tabbed) result
+			if ("answers" in details && details.answers) {
+				const ans = details.answers;
+				const keys = Object.keys(ans);
+				if (keys.length === 0) {
+					return new Text(theme.fg("warning", "Cancelled"), 0, 0);
+				}
+				const first = ans[keys[0]!];
+				if (keys.length === 1 && first) {
+					const display = "answers" in first
+						? (first as MultiTabAnswer).answers.join(", ")
+						: (first as SingleTabAnswer).answer;
+					return new Text(
+						theme.fg("success", "✓ ") + theme.fg("accent", display),
+						0,
+						0,
+					);
+				}
+				return new Text(
+					theme.fg("success", `✓ ${keys.length} answered`),
+					0,
+					0,
+				);
 			}
 
+			// Single-question result
+			const sq = details as QuestionDetails;
+			if (sq.multiAnswers && sq.multiAnswers.length > 0) {
+				return new Text(
+					theme.fg("success", "✓ ") +
+						theme.fg("accent", sq.multiAnswers.join(", ")),
+					0,
+					0,
+				);
+			}
+			if (sq.answer === null || sq.answer === undefined) {
+				return new Text(theme.fg("warning", "Cancelled"), 0, 0);
+			}
 			return new Text(
-				theme.fg("success", "✓ ") + theme.fg("accent", details.answer),
+				theme.fg("success", "✓ ") + theme.fg("accent", sq.answer),
 				0,
 				0,
 			);
@@ -192,26 +468,61 @@ export function registerQuestionTool(
 	});
 }
 
+// ── local prompt helper ──
+
 export async function promptQuestionLocally(
 	ui: ExtensionContext["ui"],
-	params: QuestionParams,
+	params: QuestionParams | MultiQuestionParams,
 	responderSessionId: string,
 ) {
-	const simpleOptions = params.options.map((o) => o.label);
+	if (isMultiParams(params)) {
+		const result = await runMultiQuestionUi(ui, params);
+		if (!result) {
+			return {
+				answers: {},
+				cancelled: true,
+				responderSessionId,
+				respondedAt: Date.now(),
+			};
+		}
+		return {
+			answers: result.answers,
+			cancelled: false,
+			responderSessionId,
+			respondedAt: Date.now(),
+		};
+	}
+
 	const result = await runQuestionUi(ui, params);
 	if (!result) {
 		return {
 			question: params.question,
-			options: simpleOptions,
+			options: params.options.map((o) => o.label),
 			answer: null,
 			cancelled: true,
 			responderSessionId,
 			respondedAt: Date.now(),
 		};
 	}
+
+	// Multi-select result
+	if (result.multiAnswers && result.multiIndices) {
+		return {
+			question: params.question,
+			options: params.options.map((o) => o.label),
+			answer: result.multiAnswers.join(", "),
+			multiAnswers: result.multiAnswers,
+			multiIndices: result.multiIndices,
+			cancelled: false,
+			responderSessionId,
+			respondedAt: Date.now(),
+		};
+	}
+
+	// Single-select result
 	return {
 		question: params.question,
-		options: simpleOptions,
+		options: params.options.map((o) => o.label),
 		answer: result.answer,
 		wasCustom: result.wasCustom,
 		cancelled: false,

package/packages/question/src/types.ts

@@ -1,3 +1,5 @@
+export type SelectType = "single" | "multi";
+
 export interface QuestionOption {
 	label: string;
 	description?: string;
@@ -6,35 +8,105 @@ export interface QuestionOption {
 export interface QuestionParams {
 	question: string;
 	options: QuestionOption[];
+	selectType?: SelectType;
 }
 
-export interface QuestionDetails {
+// --- Multi-question (tabs) types ---
+
+export interface QuestionTab {
+	/** Optional stable identifier used as result key; defaults to "q0", "q1", … */
+	id?: string;
+	/** Tab bar label; defaults to "Q1", "Q2", … */
+	title?: string;
+	/** The question text shown inside the tab */
 	question: string;
-	options: string[];
+	options: QuestionOption[];
+	/** "single" (default) or "multi" */
+	selectType?: SelectType;
+}
+
+export interface MultiQuestionParams {
+	questions: QuestionTab[];
+}
+
+// --- Answer types ---
+
+/** Single-select answer (one pick) */
+export interface SingleTabAnswer {
+	answer: string;
+	wasCustom: boolean;
+	index?: number;
+}
+
+/** Multi-select answer (multiple picks) */
+export interface MultiTabAnswer {
+	answers: string[];
+	indices: number[];
+}
+
+export type TabAnswer = SingleTabAnswer | MultiTabAnswer;
+
+export type QuestionsParams = QuestionParams | MultiQuestionParams;
+
+/** Returns true if the answer is a multi-select answer */
+export function isMultiAnswer(ans: TabAnswer): ans is MultiTabAnswer {
+	return "answers" in ans;
+}
+
+// --- Result types ---
+
+export interface QuestionDetails {
+	question?: string;
+	options?: string[];
 	answer: string | null;
 	wasCustom?: boolean;
+	/** Multi-select answers (present when selectType="multi") */
+	multiAnswers?: string[];
+	multiIndices?: number[];
+}
+
+export interface MultiQuestionDetails {
+	answers: Record<string, TabAnswer>;
 }
 
 export interface QuestionUiResult {
 	answer: string;
 	wasCustom: boolean;
 	index?: number;
+	/** Multi-select answers (present when selectType="multi") */
+	multiAnswers?: string[];
+	multiIndices?: number[];
 }
 
+export interface MultiQuestionUiResult {
+	answers: Record<string, TabAnswer>;
+}
+
+// --- Forwarding types ---
+
 export interface ForwardedQuestionRequest {
 	id: string;
 	createdAt: number;
 	requesterSessionId: string;
 	targetSessionId: string;
-	question: string;
-	options: QuestionOption[];
+	/** Single question (legacy) */
+	question?: string;
+	options?: QuestionOption[];
+	selectType?: SelectType;
+	/** Multi-question (new) */
+	questions?: QuestionTab[];
 }
 
 export interface ForwardedQuestionResponse {
-	question: string;
-	options: string[];
-	answer: string | null;
+	question?: string;
+	options?: string[];
+	answer?: string | null;
 	wasCustom?: boolean;
+	/** Multi-select answers */
+	multiAnswers?: string[];
+	multiIndices?: number[];
+	/** Multi-question answers (each value can be single or multi answer) */
+	answers?: Record<string, TabAnswer>;
 	cancelled?: boolean;
 	responderSessionId: string;
 	respondedAt: number;

package/packages/session-title/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/session-title",
-	"version": "0.3.1",
+	"version": "0.4.1",
 	"description": "Async session auto-naming for Vito's Pizzeria Pi distribution",
 	"type": "module",
 	"license": "MIT",
@@ -11,7 +11,7 @@
 		]
 	},
 	"dependencies": {
-		"@vitos-pizza/subagents": "0.3.1"
+		"@vitos-pizza/subagents": "0.4.1"
 	},
 	"scripts": {
 		"test": "vitest run",
@@ -30,7 +30,7 @@
 	"devDependencies": {
 		"@earendil-works/pi-ai": "*",
 		"@earendil-works/pi-coding-agent": "*",
-		"@vitos-pizza/subagents": "0.3.1",
+		"@vitos-pizza/subagents": "0.4.1",
 		"typebox": "*",
 		"vitest": "^3.2.4"
 	}

package/packages/settings-preset/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vitos-pizza/settings-preset",
-	"version": "0.3.1",
+	"version": "0.4.1",
 	"description": "Default Pi settings for Vito's Pizzeria distribution — written on first session start",
 	"type": "module",
 	"license": "MIT",

package/packages/subagents/agents/planner.md

@@ -1,7 +1,7 @@
 ---
 name: planner
 description: Creates implementation plans from context and requirements
-tools: read, grep, find, ls, write, question, web_search, web_read
+tools: hypa_read, hypa_grep, hypa_find, hypa_ls, write, question, web_search, web_read
 thinking: high
 systemPromptMode: replace
 ---
@@ -10,6 +10,7 @@ You are planner: turn requirements and code context into a concrete implementati
 
 Rules:
 - Read provided context (and more code as needed) before planning.
+- Use `hypa_read` / `hypa_grep` / `hypa_find` / `hypa_ls` for codebase exploration.
 - Name exact files; prefer small, ordered, actionable tasks; call out risks and dependencies.
 - Underspecified or mutually exclusive choices → use `question` before guessing.
 - Web tools only for current external facts outside the repo.
@@ -39,4 +40,4 @@ Anything likely to go wrong or need careful verification.
 ## 功能验收
 3–6 checkboxes of observable outcomes (yes/no verifiable).
 
-Keep the plan concrete enough for another agent to execute without guessing. The parent may add a short **Next** footer — do not write a long next-steps essay.
+Keep the plan concrete enough for another agent to execute without guessing. The parent may add a short **Worth considering** footer for gaps or adjacent capabilities — do not write a long next-steps essay.

package/packages/subagents/agents/scout.md

@@ -1,7 +1,7 @@
 ---
 name: scout
 description: Fast codebase recon that returns compressed context for handoff
-tools: read, grep, find, ls, question, web_search, web_read
+tools: hypa_read, hypa_grep, hypa_find, hypa_ls, question, web_search, web_read
 thinking: low
 systemPromptMode: replace
 ---
@@ -11,6 +11,7 @@ You are scout: fast codebase recon for handoff. Do not guess. Prefer targeted se
 Return the minimum context another agent needs: entry points, key types/APIs, data flow, files likely to change, risks and open questions.
 
 Rules:
+- Use `hypa_read` / `hypa_grep` / `hypa_find` / `hypa_ls` for codebase exploration.
 - Cite exact file paths and line ranges.
 - Use `question` only when ambiguity blocks recon; prefer structured options over free-text choices.
 - Web tools only for current external facts outside the repo.