headlesscode 1.0.2

package/src/vendor/zoo-code/types/message.ts

@@ -0,0 +1,375 @@
+import { z } from "zod"
+
+/**
+ * ClineAsk
+ */
+
+/**
+ * Array of possible ask types that the LLM can use to request user interaction or approval.
+ * These represent different scenarios where the assistant needs user input to proceed.
+ *
+ * @constant
+ * @readonly
+ *
+ * Ask type descriptions:
+ * - `followup`: LLM asks a clarifying question to gather more information needed to complete the task
+ * - `command`: Permission to execute a terminal/shell command
+ * - `command_output`: Permission to read the output from a previously executed command
+ * - `completion_result`: Task has been completed, awaiting user feedback or a new task
+ * - `tool`: Permission to use a tool for file operations (read, write, search, etc.)
+ * - `api_req_failed`: API request failed, asking user whether to retry
+ * - `resume_task`: Confirmation needed to resume a previously paused task
+ * - `resume_completed_task`: Confirmation needed to resume a task that was already marked as completed
+ * - `mistake_limit_reached`: Too many errors encountered, needs user guidance on how to proceed
+ * - `use_mcp_server`: Permission to use Model Context Protocol (MCP) server functionality
+ * - `auto_approval_max_req_reached`: Auto-approval limit has been reached, manual approval required
+ */
+export const clineAsks = [
+	"followup",
+	"command",
+	"command_output",
+	"completion_result",
+	"tool",
+	"api_req_failed",
+	"resume_task",
+	"resume_completed_task",
+	"mistake_limit_reached",
+	"use_mcp_server",
+	"auto_approval_max_req_reached",
+] as const
+
+export const clineAskSchema = z.enum(clineAsks)
+
+export type ClineAsk = z.infer<typeof clineAskSchema>
+/**
+ * IdleAsk
+ *
+ * Asks that put the task into an "idle" state.
+ */
+
+export const idleAsks = [
+	"completion_result",
+	"api_req_failed",
+	"resume_completed_task",
+	"mistake_limit_reached",
+	"auto_approval_max_req_reached",
+] as const satisfies readonly ClineAsk[]
+
+export type IdleAsk = (typeof idleAsks)[number]
+
+export function isIdleAsk(ask: ClineAsk): ask is IdleAsk {
+	return (idleAsks as readonly ClineAsk[]).includes(ask)
+}
+
+/**
+ * ResumableAsk
+ *
+ * Asks that put the task into an "resumable" state.
+ */
+
+export const resumableAsks = ["resume_task"] as const satisfies readonly ClineAsk[]
+
+export type ResumableAsk = (typeof resumableAsks)[number]
+
+export function isResumableAsk(ask: ClineAsk): ask is ResumableAsk {
+	return (resumableAsks as readonly ClineAsk[]).includes(ask)
+}
+
+/**
+ * InteractiveAsk
+ *
+ * Asks that put the task into an "user interaction required" state.
+ */
+
+export const interactiveAsks = ["followup", "command", "tool", "use_mcp_server"] as const satisfies readonly ClineAsk[]
+
+export type InteractiveAsk = (typeof interactiveAsks)[number]
+
+export function isInteractiveAsk(ask: ClineAsk): ask is InteractiveAsk {
+	return (interactiveAsks as readonly ClineAsk[]).includes(ask)
+}
+
+/**
+ * NonBlockingAsk
+ *
+ * Asks that are not associated with an actual approval, and are only used
+ * to update chat messages.
+ */
+
+export const nonBlockingAsks = ["command_output"] as const satisfies readonly ClineAsk[]
+
+export type NonBlockingAsk = (typeof nonBlockingAsks)[number]
+
+export function isNonBlockingAsk(ask: ClineAsk): ask is NonBlockingAsk {
+	return (nonBlockingAsks as readonly ClineAsk[]).includes(ask)
+}
+
+/**
+ * ClineSay
+ */
+
+/**
+ * Array of possible say types that represent different kinds of messages the assistant can send.
+ * These are used to categorize and handle various types of communication from the LLM to the user.
+ *
+ * @constant
+ * @readonly
+ *
+ * Say type descriptions:
+ * - `error`: General error message
+ * - `api_req_started`: Indicates an API request has been initiated
+ * - `api_req_finished`: Indicates an API request has completed successfully
+ * - `api_req_retried`: Indicates an API request is being retried after a failure
+ * - `api_req_retry_delayed`: Indicates an API request retry has been delayed
+ * - `api_req_rate_limit_wait`: Indicates a configured rate-limit wait (not an error)
+ * - `api_req_deleted`: Indicates an API request has been deleted/cancelled
+ * - `text`: General text message or assistant response
+ * - `reasoning`: Assistant's reasoning or thought process (often hidden from user)
+ * - `completion_result`: Final result of task completion
+ * - `user_feedback`: Message containing user feedback
+ * - `user_feedback_diff`: Diff-formatted feedback from user showing requested changes
+ * - `command_output`: Output from an executed command
+ * - `shell_integration_warning`: Warning about shell integration issues or limitations
+ * - `mcp_server_request_started`: MCP server request has been initiated
+ * - `mcp_server_response`: Response received from MCP server
+ * - `subtask_result`: Result of a completed subtask
+ * - `checkpoint_saved`: Indicates a checkpoint has been saved
+ * - `rooignore_error`: Error related to .rooignore file processing
+ * - `diff_error`: Error occurred while applying a diff/patch
+ * - `condense_context`: Context condensation/summarization has started
+ * - `condense_context_error`: Error occurred during context condensation
+ * - `codebase_search_result`: Results from searching the codebase
+ * - `too_many_tools_warning`: Warning that too many MCP tools are enabled, which may confuse the LLM
+ */
+export const clineSays = [
+	"error",
+	"api_req_started",
+	"api_req_finished",
+	"api_req_retried",
+	"api_req_retry_delayed",
+	"api_req_rate_limit_wait",
+	"api_req_deleted",
+	"text",
+	"task",
+	"image",
+	"reasoning",
+	"completion_result",
+	"user_feedback",
+	"user_feedback_diff",
+	"command_output",
+	"shell_integration_warning",
+	"mcp_server_request_started",
+	"mcp_server_response",
+	"subtask_result",
+	"checkpoint_saved",
+	"rooignore_error",
+	"diff_error",
+	"condense_context",
+	"condense_context_error",
+	"sliding_window_truncation",
+	"codebase_search_result",
+	"user_edit_todos",
+	"too_many_tools_warning",
+	"tool",
+] as const
+
+export const clineSaySchema = z.enum(clineSays)
+
+export type ClineSay = z.infer<typeof clineSaySchema>
+
+/**
+ * ToolProgressStatus
+ */
+
+export const toolProgressStatusSchema = z.object({
+	icon: z.string().optional(),
+	text: z.string().optional(),
+})
+
+export type ToolProgressStatus = z.infer<typeof toolProgressStatusSchema>
+
+/**
+ * ContextCondense
+ *
+ * Data associated with a successful context condensation event.
+ * This is attached to messages with `say: "condense_context"` when
+ * the condensation operation completes successfully.
+ *
+ * @property cost - The API cost incurred for the condensation operation
+ * @property prevContextTokens - Token count before condensation
+ * @property newContextTokens - Token count after condensation
+ * @property summary - The condensed summary that replaced the original context
+ * @property condenseId - Optional unique identifier for this condensation operation
+ */
+export const contextCondenseSchema = z.object({
+	cost: z.number(),
+	prevContextTokens: z.number(),
+	newContextTokens: z.number(),
+	summary: z.string(),
+	condenseId: z.string().optional(),
+})
+
+export type ContextCondense = z.infer<typeof contextCondenseSchema>
+
+/**
+ * ContextTruncation
+ *
+ * Data associated with a sliding window truncation event.
+ * This is attached to messages with `say: "sliding_window_truncation"` when
+ * messages are removed from the conversation history to stay within token limits.
+ *
+ * Unlike condensation, truncation simply removes older messages without
+ * summarizing them. This is a faster but less context-preserving approach.
+ *
+ * @property truncationId - Unique identifier for this truncation operation
+ * @property messagesRemoved - Number of conversation messages that were removed
+ * @property prevContextTokens - Token count before truncation occurred
+ * @property newContextTokens - Token count after truncation occurred
+ */
+export const contextTruncationSchema = z.object({
+	truncationId: z.string(),
+	messagesRemoved: z.number(),
+	prevContextTokens: z.number(),
+	newContextTokens: z.number(),
+})
+
+export type ContextTruncation = z.infer<typeof contextTruncationSchema>
+
+/**
+ * ClineMessage
+ *
+ * The main message type used for communication between the extension and webview.
+ * Messages can either be "ask" (requiring user response) or "say" (informational).
+ *
+ * Context Management Fields:
+ * - `contextCondense`: Present when `say: "condense_context"` and condensation succeeded
+ * - `contextTruncation`: Present when `say: "sliding_window_truncation"` and truncation occurred
+ *
+ * Note: These fields are mutually exclusive - a message will have at most one of them.
+ */
+export const clineMessageSchema = z.object({
+	ts: z.number(),
+	type: z.union([z.literal("ask"), z.literal("say")]),
+	ask: clineAskSchema.optional(),
+	say: clineSaySchema.optional(),
+	text: z.string().optional(),
+	images: z.array(z.string()).optional(),
+	partial: z.boolean().optional(),
+	reasoning: z.string().optional(),
+	conversationHistoryIndex: z.number().optional(),
+	checkpoint: z.record(z.string(), z.unknown()).optional(),
+	progressStatus: toolProgressStatusSchema.optional(),
+	/**
+	 * Data for successful context condensation.
+	 * Present when `say: "condense_context"` and `partial: false`.
+	 */
+	contextCondense: contextCondenseSchema.optional(),
+	/**
+	 * Data for sliding window truncation.
+	 * Present when `say: "sliding_window_truncation"`.
+	 */
+	contextTruncation: contextTruncationSchema.optional(),
+	isProtected: z.boolean().optional(),
+	apiProtocol: z.union([z.literal("openai"), z.literal("anthropic")]).optional(),
+	isAnswered: z.boolean().optional(),
+})
+
+export type ClineMessage = z.infer<typeof clineMessageSchema>
+
+export interface CompletionCheckpoint {
+	ts: number
+	commitHash: string
+}
+
+const isInitialTaskMessage = (message: ClineMessage | undefined): boolean => {
+	return message?.type === "say" && (message.say === "text" || message.say === "task")
+}
+
+const isUserFeedbackMessage = (message: ClineMessage): boolean => {
+	return message.type === "say" && message.say === "user_feedback"
+}
+
+const isCompletionMessage = (message: ClineMessage): boolean => {
+	return (
+		(message.type === "ask" && message.ask === "completion_result") ||
+		(message.type === "say" && message.say === "completion_result")
+	)
+}
+
+const isCheckpointMessage = (message: ClineMessage): boolean => {
+	return message.type === "say" && message.say === "checkpoint_saved" && typeof message.text === "string"
+}
+
+function findLastIndexBefore(
+	messages: ClineMessage[],
+	beforeIndex: number,
+	predicate: (message: ClineMessage) => boolean,
+): number {
+	for (let i = beforeIndex - 1; i >= 0; i--) {
+		const message = messages[i]
+
+		if (message && predicate(message)) {
+			return i
+		}
+	}
+
+	return -1
+}
+
+/**
+ * Finds the checkpoint that should anchor completion-result actions.
+ *
+ * The baseline is the first checkpoint created after the latest user prompt in
+ * the turn that produced the completion. Restoring to that checkpoint reverts
+ * changes made for the latest prompt, and diffing from it shows the same scoped
+ * changes.
+ */
+export function getCompletionCheckpoint(messages: ClineMessage[]): CompletionCheckpoint | undefined {
+	const completionIndex = findLastIndexBefore(messages, messages.length, isCompletionMessage)
+	const searchEnd = completionIndex === -1 ? messages.length : completionIndex
+	const latestUserFeedbackIndex = findLastIndexBefore(messages, searchEnd, isUserFeedbackMessage)
+	const latestUserPromptIndex =
+		latestUserFeedbackIndex !== -1 ? latestUserFeedbackIndex : isInitialTaskMessage(messages[0]) ? 0 : -1
+
+	if (latestUserPromptIndex === -1) {
+		return undefined
+	}
+
+	for (let i = latestUserPromptIndex + 1; i < searchEnd; i++) {
+		const message = messages[i]
+
+		if (message && isCheckpointMessage(message)) {
+			return { ts: message.ts, commitHash: message.text! }
+		}
+	}
+
+	return undefined
+}
+
+/**
+ * TokenUsage
+ */
+
+export const tokenUsageSchema = z.object({
+	totalTokensIn: z.number(),
+	totalTokensOut: z.number(),
+	totalCacheWrites: z.number().optional(),
+	totalCacheReads: z.number().optional(),
+	totalCost: z.number(),
+	contextTokens: z.number(),
+})
+
+export type TokenUsage = z.infer<typeof tokenUsageSchema>
+
+/**
+ * QueuedMessage
+ */
+
+export const queuedMessageSchema = z.object({
+	timestamp: z.number(),
+	id: z.string(),
+	text: z.string(),
+	images: z.array(z.string()).optional(),
+})
+
+export type QueuedMessage = z.infer<typeof queuedMessageSchema>

package/src/vendor/zoo-code/types/mode.ts

@@ -0,0 +1,241 @@
+import { z } from "zod"
+
+import { deprecatedToolGroups, toolGroupsSchema } from "./tool.js"
+
+/**
+ * GroupOptions
+ */
+
+export const groupOptionsSchema = z.object({
+	fileRegex: z
+		.string()
+		.optional()
+		.refine(
+			(pattern) => {
+				if (!pattern) {
+					return true // Optional, so empty is valid.
+				}
+
+				try {
+					new RegExp(pattern)
+					return true
+				} catch {
+					return false
+				}
+			},
+			{ message: "Invalid regular expression pattern" },
+		),
+	description: z.string().optional(),
+})
+
+export type GroupOptions = z.infer<typeof groupOptionsSchema>
+
+/**
+ * GroupEntry
+ */
+
+export const groupEntrySchema = z.union([toolGroupsSchema, z.tuple([toolGroupsSchema, groupOptionsSchema])])
+
+export type GroupEntry = z.infer<typeof groupEntrySchema>
+
+/**
+ * ModeConfig
+ */
+
+/**
+ * Checks if a group entry references a deprecated tool group.
+ * Handles both string entries ("browser") and tuple entries (["browser", { ... }]).
+ */
+function isDeprecatedGroupEntry(entry: unknown): boolean {
+	if (typeof entry === "string") {
+		return deprecatedToolGroups.includes(entry)
+	}
+	if (Array.isArray(entry) && entry.length >= 1 && typeof entry[0] === "string") {
+		return deprecatedToolGroups.includes(entry[0])
+	}
+	return false
+}
+
+/**
+ * Raw schema for validating group entries after deprecated groups are stripped.
+ */
+const rawGroupEntryArraySchema = z.array(groupEntrySchema).refine(
+	(groups) => {
+		const seen = new Set()
+
+		return groups.every((group) => {
+			// For tuples, check the group name (first element).
+			const groupName = Array.isArray(group) ? group[0] : group
+
+			if (seen.has(groupName)) {
+				return false
+			}
+
+			seen.add(groupName)
+			return true
+		})
+	},
+	{ message: "Duplicate groups are not allowed" },
+)
+
+/**
+ * Schema for mode group entries. Preprocesses the input to strip deprecated
+ * tool groups (e.g., "browser") before validation, ensuring backward compatibility
+ * with older user configs.
+ *
+ * The type assertion to `z.ZodType<GroupEntry[], z.ZodTypeDef, GroupEntry[]>` is
+ * required because `z.preprocess` erases the input type to `unknown`, which
+ * propagates through `modeConfigSchema → rooCodeSettingsSchema → createRunSchema`
+ * and breaks `zodResolver` generic inference in downstream consumers.
+ */
+export const groupEntryArraySchema = z.preprocess((val) => {
+	if (!Array.isArray(val)) return val
+	return val.filter((entry) => !isDeprecatedGroupEntry(entry))
+}, rawGroupEntryArraySchema) as z.ZodType<GroupEntry[], z.ZodTypeDef, GroupEntry[]>
+
+export const modeConfigSchema = z.object({
+	slug: z.string().regex(/^[a-zA-Z0-9-]+$/, "Slug must contain only letters numbers and dashes"),
+	name: z.string().min(1, "Name is required"),
+	roleDefinition: z.string().min(1, "Role definition is required"),
+	whenToUse: z.string().optional(),
+	description: z.string().optional(),
+	customInstructions: z.string().optional(),
+	groups: groupEntryArraySchema,
+	source: z.enum(["global", "project"]).optional(),
+	allowedMcpServers: z
+		.array(z.string())
+		.describe(
+			"Optional list of MCP server names to include. When omitted, all servers are available. When set, only the listed servers are injected.",
+		)
+		.optional(),
+})
+
+export type ModeConfig = z.infer<typeof modeConfigSchema>
+
+/**
+ * CustomModesSettings
+ */
+
+export const customModesSettingsSchema = z.object({
+	customModes: z.array(modeConfigSchema).refine(
+		(modes) => {
+			const slugs = new Set()
+
+			return modes.every((mode) => {
+				if (slugs.has(mode.slug)) {
+					return false
+				}
+
+				slugs.add(mode.slug)
+				return true
+			})
+		},
+		{
+			message: "Duplicate mode slugs are not allowed",
+		},
+	),
+})
+
+export type CustomModesSettings = z.infer<typeof customModesSettingsSchema>
+
+/**
+ * PromptComponent
+ */
+
+export const promptComponentSchema = z.object({
+	roleDefinition: z.string().optional(),
+	whenToUse: z.string().optional(),
+	description: z.string().optional(),
+	customInstructions: z.string().optional(),
+})
+
+export type PromptComponent = z.infer<typeof promptComponentSchema>
+
+/**
+ * CustomModePrompts
+ */
+
+export const customModePromptsSchema = z.record(z.string(), promptComponentSchema.optional())
+
+export type CustomModePrompts = z.infer<typeof customModePromptsSchema>
+
+/**
+ * CustomSupportPrompts
+ */
+
+export const customSupportPromptsSchema = z.record(z.string(), z.string().optional())
+
+export type CustomSupportPrompts = z.infer<typeof customSupportPromptsSchema>
+
+/**
+ * DEFAULT_MODES
+ */
+
+export const DEFAULT_MODES: readonly ModeConfig[] = [
+	{
+		slug: "architect",
+		name: "🏗️ Architect",
+		roleDefinition:
+			"You are Zoo, an experienced technical leader who is inquisitive and an excellent planner. Your goal is to gather information and get context to create a detailed plan for accomplishing the user's task, which the user will review and approve before they switch into another mode to implement the solution.",
+		whenToUse:
+			"Use this mode when you need to plan, design, or strategize before implementation. Perfect for breaking down complex problems, creating technical specifications, designing system architecture, or brainstorming solutions before coding.",
+		description: "Plan and design before implementation",
+		// Deviates from upstream Zoo/Roo Code (which gives architect no
+		// "command" group at all, so it can't run anything — not even
+		// read-only exploration commands like `grep`/`find`/test runners).
+		// Headless architect sessions need real exploration, so this adds
+		// "command" and drops the upstream .md-only "edit" group entirely:
+		// architect gets every read/search tool plus a shell, but zero
+		// write capability (see TOOL_GROUPS in shared/tools.ts — "edit" is
+		// the only group backed by write_to_file/apply_diff).
+		groups: ["read", "command", "mcp"],
+		customInstructions:
+			'1. Do some information gathering (using provided tools) to get more context about the task.\n\n2. You should also ask the user clarifying questions to get a better understanding of the task.\n\n3. Once you\'ve gained more context about the user\'s request, break down the task into clear, actionable steps and create a todo list using the `update_todo_list` tool. Each todo item should be:\n   - Specific and actionable\n   - Listed in logical execution order\n   - Focused on a single, well-defined outcome\n   - Clear enough that another mode could execute it independently\n\n   **Note:** If the `update_todo_list` tool is not available, write the plan to a markdown file (e.g., `plan.md` or `todo.md`) instead.\n\n4. As you gather more information or discover new requirements, update the todo list to reflect the current understanding of what needs to be accomplished.\n\n5. Ask the user if they are pleased with this plan, or if they would like to make any changes. Think of this as a brainstorming session where you can discuss the task and refine the todo list.\n\n6. Include Mermaid diagrams if they help clarify complex workflows or system architecture. Please avoid using double quotes ("") and parentheses () inside square brackets ([]) in Mermaid diagrams, as this can cause parsing errors.\n\n7. Use the switch_mode tool to request that the user switch to another mode to implement the solution.\n\n**IMPORTANT: Focus on creating clear, actionable todo lists rather than lengthy markdown documents. Use the todo list as your primary planning tool to track and organize the work that needs to be done.**\n\n**CRITICAL: Never provide level of effort time estimates (e.g., hours, days, weeks) for tasks. Focus solely on breaking down the work into clear, actionable steps without estimating how long they will take.**\n\nUnless told otherwise, if you want to save a plan file, put it in the ./plans directory (a directory named "plans" relative to the workspace root, not the absolute filesystem path /plans)',
+	},
+	{
+		slug: "code",
+		name: "💻 Code",
+		roleDefinition:
+			"You are Zoo, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.",
+		whenToUse:
+			"Use this mode when you need to write, modify, or refactor code. Ideal for implementing features, fixing bugs, creating new files, or making code improvements across any programming language or framework.",
+		description: "Write, modify, and refactor code",
+		groups: ["read", "edit", "command", "mcp"],
+	},
+	{
+		slug: "ask",
+		name: "❓ Ask",
+		roleDefinition:
+			"You are Zoo, a knowledgeable technical assistant focused on answering questions and providing information about software development, technology, and related topics.",
+		whenToUse:
+			"Use this mode when you need explanations, documentation, or answers to technical questions. Best for understanding concepts, analyzing existing code, getting recommendations, or learning about technologies without making changes.",
+		description: "Get answers and explanations",
+		groups: ["read", "mcp"],
+		customInstructions:
+			"You can analyze code, explain concepts, and access external resources. Always answer the user's questions thoroughly, and do not switch to implementing code unless explicitly requested by the user. Include Mermaid diagrams when they clarify your response.",
+	},
+	{
+		slug: "debug",
+		name: "🪲 Debug",
+		roleDefinition:
+			"You are Zoo, an expert software debugger specializing in systematic problem diagnosis and resolution.",
+		whenToUse:
+			"Use this mode when you're troubleshooting issues, investigating errors, or diagnosing problems. Specialized in systematic debugging, adding logging, analyzing stack traces, and identifying root causes before applying fixes.",
+		description: "Diagnose and fix software issues",
+		groups: ["read", "edit", "command", "mcp"],
+		customInstructions:
+			"Reflect on 5-7 different possible sources of the problem, distill those down to 1-2 most likely sources, and then add logs to validate your assumptions. Explicitly ask the user to confirm the diagnosis before fixing the problem.",
+	},
+	{
+		slug: "orchestrator",
+		name: "🪃 Orchestrator",
+		roleDefinition:
+			"You are Zoo, a strategic workflow orchestrator who coordinates complex tasks by delegating them to appropriate specialized modes. You have a comprehensive understanding of each mode's capabilities and limitations, allowing you to effectively break down complex problems into discrete tasks that can be solved by different specialists.",
+		whenToUse:
+			"Use this mode for complex, multi-step projects that require coordination across different specialties. Ideal when you need to break down large tasks into subtasks, manage workflows, or coordinate work that spans multiple domains or expertise areas.",
+		description: "Coordinate tasks across multiple modes",
+		groups: [],
+		customInstructions:
+			"Your role is to coordinate complex workflows by delegating tasks to specialized modes. As an orchestrator, you should:\n\n1. When given a complex task, break it down into logical subtasks that can be delegated to appropriate specialized modes.\n\n2. For each subtask, use the `new_task` tool to delegate. Choose the most appropriate mode for the subtask's specific goal and provide comprehensive instructions in the `message` parameter. These instructions must include:\n    *   All necessary context from the parent task or previous subtasks required to complete the work.\n    *   A clearly defined scope, specifying exactly what the subtask should accomplish.\n    *   An explicit statement that the subtask should *only* perform the work outlined in these instructions and not deviate.\n    *   An instruction for the subtask to signal completion by using the `attempt_completion` tool, providing a concise yet thorough summary of the outcome in the `result` parameter, keeping in mind that this summary will be the source of truth used to keep track of what was completed on this project.\n    *   A statement that these specific instructions supersede any conflicting general instructions the subtask's mode might have.\n\n3. Track and manage the progress of all subtasks. When a subtask is completed, analyze its results and determine the next steps.\n\n4. Help the user understand how the different subtasks fit together in the overall workflow. Provide clear reasoning about why you're delegating specific tasks to specific modes.\n\n5. When all subtasks are completed, synthesize the results and provide a comprehensive overview of what was accomplished.\n\n6. Ask clarifying questions when necessary to better understand how to break down complex tasks effectively.\n\n7. Suggest improvements to the workflow based on the results of completed subtasks.\n\nUse subtasks to maintain clarity. If a request significantly shifts focus or requires a different expertise (mode), consider creating a subtask rather than overloading the current one.",
+	},
+] as const

package/src/vendor/zoo-code/types/todo.ts

@@ -0,0 +1,19 @@
+import { z } from "zod"
+
+/**
+ * TodoStatus
+ */
+export const todoStatusSchema = z.enum(["pending", "in_progress", "completed"] as const)
+
+export type TodoStatus = z.infer<typeof todoStatusSchema>
+
+/**
+ * TodoItem
+ */
+export const todoItemSchema = z.object({
+	id: z.string(),
+	content: z.string(),
+	status: todoStatusSchema,
+})
+
+export type TodoItem = z.infer<typeof todoItemSchema>