headlesscode 1.0.2

package/src/vendor/zoo-code/src/core/prompts/sections/capabilities.ts

@@ -0,0 +1,46 @@
+import { McpHub } from "../../../services/mcp/McpHub"
+
+/**
+ * Builds the CAPABILITIES section of the system prompt.
+ *
+ * The MCP availability line is only emitted when at least one MCP server is actually
+ * exposed to the current mode. When `allowedMcpServers` is provided, the hub's server
+ * list is filtered by that allowlist BEFORE deciding whether to advertise MCP, so the
+ * capability text matches the per-mode tool exposure:
+ *   - `undefined` allowlist  → all connected servers count (backward compatible)
+ *   - empty `[]` allowlist   → no servers count ⇒ MCP line omitted
+ *   - populated allowlist    → only listed servers count
+ *
+ * @param cwd Current working directory used in the prompt text.
+ * @param mcpHub Optional MCP hub. When omitted, the MCP line is never emitted.
+ * @param allowedMcpServers Optional per-mode allowlist of MCP server names. When provided,
+ *   the hub's servers are filtered to this set before determining MCP availability.
+ */
+export function getCapabilitiesSection(cwd: string, mcpHub?: McpHub, allowedMcpServers?: string[]): string {
+	// Determine whether any MCP server is actually available to the current mode.
+	// Filtering the hub's servers by the allowlist (when provided) keeps the capability
+	// text consistent with the tools that are exposed for the mode.
+	let hasMcpServers = false
+	if (mcpHub) {
+		let servers = mcpHub.getServers()
+		if (allowedMcpServers) {
+			const allowSet = new Set(allowedMcpServers)
+			servers = servers.filter((server) => allowSet.has(server.name))
+		}
+		hasMcpServers = servers.length > 0
+	}
+
+	return `====
+
+CAPABILITIES
+
+- You have access to tools that let you execute CLI commands on the user's computer, list files, view source code definitions, regex search, read and write files, and ask follow-up questions. These tools help you effectively accomplish a wide range of tasks, such as writing code, making edits or improvements to existing files, understanding the current state of a project, performing system operations, and much more.
+- When the user initially gives you a task, a recursive list of all filepaths in the current workspace directory ('${cwd}') will be included in environment_details. This provides an overview of the project's file structure, offering key insights into the project from directory/file names (how developers conceptualize and organize their code) and file extensions (the language used). This can also guide decision-making on which files to explore further. If you need to further explore directories such as outside the current workspace directory, you can use the list_files tool. If you pass 'true' for the recursive parameter, it will list files recursively. Otherwise, it will list files at the top level, which is better suited for generic directories where you don't necessarily need the nested structure, like the Desktop.
+- You can use the execute_command tool to run commands on the user's computer whenever you feel it can help accomplish the user's task. When you need to execute a CLI command, you must provide a clear explanation of what the command does. Prefer to execute complex CLI commands over creating executable scripts, since they are more flexible and easier to run. Interactive and long-running commands are allowed, since the commands are run in the user's VSCode terminal. The user may keep commands running in the background and you will be kept updated on their status along the way. Each command you execute is run in a new terminal instance.${
+		hasMcpServers
+			? `
+- You have access to MCP servers that may provide additional tools and resources. Each server may provide different capabilities that you can use to accomplish tasks more effectively.
+`
+			: ""
+	}`
+}

package/src/vendor/zoo-code/src/core/prompts/sections/custom-instructions.ts

@@ -0,0 +1,559 @@
+import fs from "fs/promises"
+import path from "path"
+import * as os from "os"
+import { Dirent } from "fs"
+
+import { isLanguage } from "../../../../types"
+
+import type { SystemPromptSettings } from "../types"
+
+import { LANGUAGES } from "../../../shared/language"
+import {
+	getRooDirectoriesForCwd,
+	getAllRooDirectoriesForCwd,
+	getAgentsDirectoriesForCwd,
+	getGlobalRooDirectory,
+} from "../../../services/roo-config"
+
+/**
+ * Safely read a file and return its trimmed content
+ */
+async function safeReadFile(filePath: string): Promise<string> {
+	try {
+		const content = await fs.readFile(filePath, "utf-8")
+		return content.trim()
+	} catch (err) {
+		const errorCode = (err as NodeJS.ErrnoException).code
+		if (!errorCode || !["ENOENT", "EISDIR"].includes(errorCode)) {
+			throw err
+		}
+		return ""
+	}
+}
+
+/**
+ * Check if a directory exists
+ */
+async function directoryExists(dirPath: string): Promise<boolean> {
+	try {
+		const stats = await fs.stat(dirPath)
+		return stats.isDirectory()
+	} catch (err) {
+		return false
+	}
+}
+
+const MAX_DEPTH = 5
+
+/**
+ * Recursively resolve directory entries and collect file paths
+ */
+async function resolveDirectoryEntry(
+	entry: Dirent,
+	dirPath: string,
+	fileInfo: Array<{ originalPath: string; resolvedPath: string }>,
+	depth: number,
+): Promise<void> {
+	// Avoid cyclic symlinks
+	if (depth > MAX_DEPTH) {
+		return
+	}
+
+	const fullPath = path.resolve(entry.parentPath || dirPath, entry.name)
+	if (entry.isFile()) {
+		// Regular file - both original and resolved paths are the same
+		fileInfo.push({ originalPath: fullPath, resolvedPath: fullPath })
+	} else if (entry.isSymbolicLink()) {
+		// Await the resolution of the symbolic link
+		await resolveSymLink(fullPath, fileInfo, depth + 1)
+	}
+}
+
+/**
+ * Recursively resolve a symbolic link and collect file paths
+ */
+async function resolveSymLink(
+	symlinkPath: string,
+	fileInfo: Array<{ originalPath: string; resolvedPath: string }>,
+	depth: number,
+): Promise<void> {
+	// Avoid cyclic symlinks
+	if (depth > MAX_DEPTH) {
+		return
+	}
+	try {
+		// Get the symlink target
+		const linkTarget = await fs.readlink(symlinkPath)
+		// Resolve the target path relative to the symlink's real parent directory.
+		// We must use realpath on the parent directory because the symlink itself
+		// may be inside a symlinked directory. Relative symlink targets are resolved
+		// by the filesystem relative to the symlink's actual location, not the path
+		// used to access it.
+		const symlinkDir = path.dirname(symlinkPath)
+		let realSymlinkDir: string
+		try {
+			realSymlinkDir = await fs.realpath(symlinkDir)
+		} catch {
+			realSymlinkDir = symlinkDir
+		}
+		const resolvedTarget = path.resolve(realSymlinkDir, linkTarget)
+
+		// Check if the target is a file
+		const stats = await fs.stat(resolvedTarget)
+		if (stats.isFile()) {
+			// For symlinks to files, store the symlink path as original and target as resolved
+			fileInfo.push({
+				originalPath: symlinkPath,
+				resolvedPath: resolvedTarget,
+			})
+		} else if (stats.isDirectory()) {
+			const anotherEntries = await fs.readdir(resolvedTarget, {
+				withFileTypes: true,
+				recursive: true,
+			})
+			// Collect promises for recursive calls within the directory
+			const directoryPromises: Promise<void>[] = []
+			for (const anotherEntry of anotherEntries) {
+				directoryPromises.push(resolveDirectoryEntry(anotherEntry, resolvedTarget, fileInfo, depth + 1))
+			}
+			// Wait for all entries in the resolved directory to be processed
+			await Promise.all(directoryPromises)
+		} else if (stats.isSymbolicLink()) {
+			// Handle nested symlinks by awaiting the recursive call
+			await resolveSymLink(resolvedTarget, fileInfo, depth + 1)
+		}
+	} catch (err) {
+		// Skip invalid symlinks
+	}
+}
+
+/**
+ * Read all text files from a directory in alphabetical order
+ */
+async function readTextFilesFromDirectory(dirPath: string): Promise<Array<{ filename: string; content: string }>> {
+	try {
+		const entries = await fs.readdir(dirPath, {
+			withFileTypes: true,
+			recursive: true,
+		})
+
+		// Process all entries - regular files and symlinks that might point to files
+		// Store both original path (for sorting) and resolved path (for reading)
+		const fileInfo: Array<{ originalPath: string; resolvedPath: string }> = []
+		// Collect promises for the initial resolution calls
+		const initialPromises: Promise<void>[] = []
+
+		for (const entry of entries) {
+			initialPromises.push(resolveDirectoryEntry(entry, dirPath, fileInfo, 0))
+		}
+
+		// Wait for all asynchronous operations (including recursive ones) to complete
+		await Promise.all(initialPromises)
+
+		const fileContents = await Promise.all(
+			fileInfo.map(async ({ originalPath, resolvedPath }) => {
+				try {
+					// Check if it's a file (not a directory)
+					const stats = await fs.stat(resolvedPath)
+					if (stats.isFile()) {
+						// Filter out cache files and system files that shouldn't be in rules
+						if (!shouldIncludeRuleFile(resolvedPath)) {
+							return null
+						}
+						const content = await safeReadFile(resolvedPath)
+						// Use resolvedPath for display to maintain existing behavior
+						return { filename: resolvedPath, content, sortKey: originalPath }
+					}
+					return null
+				} catch (err) {
+					return null
+				}
+			}),
+		)
+
+		// Filter out null values (directories, failed reads, or excluded files)
+		const filteredFiles = fileContents.filter(
+			(item): item is { filename: string; content: string; sortKey: string } => item !== null,
+		)
+
+		// Sort files alphabetically by the original filename (case-insensitive) to ensure consistent order
+		// For symlinks, this will use the symlink name, not the target name
+		return filteredFiles
+			.sort((a, b) => {
+				const filenameA = path.basename(a.sortKey).toLowerCase()
+				const filenameB = path.basename(b.sortKey).toLowerCase()
+				return filenameA.localeCompare(filenameB)
+			})
+			.map(({ filename, content }) => ({ filename, content }))
+	} catch (err) {
+		return []
+	}
+}
+
+/**
+ * Format content from multiple files with filenames as headers
+ * @param files - Array of files with filename (absolute path) and content
+ * @param cwd - Current working directory for computing relative paths
+ */
+function formatDirectoryContent(files: Array<{ filename: string; content: string }>, cwd: string): string {
+	if (files.length === 0) return ""
+
+	return files
+		.map((file) => {
+			// Compute relative path for display
+			const displayPath = path.relative(cwd, file.filename)
+			return `# Rules from ${displayPath}:\n${file.content}`
+		})
+		.join("\n\n")
+}
+
+/**
+ * Load rule files from global, project-local, and optionally subfolder directories
+ * Rules are loaded in order: global first, then project-local, then subfolders (alphabetically)
+ *
+ * @param cwd - Current working directory (project root)
+ * @param enableSubfolderRules - Whether to include rules from subdirectories (default: false)
+ */
+export async function loadRuleFiles(cwd: string, enableSubfolderRules: boolean = false): Promise<string> {
+	const rules: string[] = []
+	// Use recursive discovery only if enableSubfolderRules is true
+	const rooDirectories = enableSubfolderRules ? await getAllRooDirectoriesForCwd(cwd) : getRooDirectoriesForCwd(cwd)
+
+	// Check for .roo/rules/ directories in order (global, project-local, and optionally subfolders)
+	for (const rooDir of rooDirectories) {
+		const rulesDir = path.join(rooDir, "rules")
+		if (await directoryExists(rulesDir)) {
+			const files = await readTextFilesFromDirectory(rulesDir)
+			if (files.length > 0) {
+				const content = formatDirectoryContent(files, cwd)
+				rules.push(content)
+			}
+		}
+	}
+
+	// If we found rules in .roo/rules/ directories, return them
+	if (rules.length > 0) {
+		return "\n# Rules from .roo directories:\n\n" + rules.join("\n\n")
+	}
+
+	// Fall back to existing behavior for legacy .roorules/.clinerules files
+	const ruleFiles = [".roorules", ".clinerules"]
+
+	for (const file of ruleFiles) {
+		const content = await safeReadFile(path.join(cwd, file))
+		if (content) {
+			return `\n# Rules from ${file}:\n${content}\n`
+		}
+	}
+
+	return ""
+}
+
+/**
+ * Read content from an agent rules file (AGENTS.md, AGENT.md, etc.)
+ * Handles symlink resolution.
+ *
+ * @param filePath - Full path to the agent rules file
+ * @returns File content or empty string if file doesn't exist
+ */
+async function readAgentRulesFile(filePath: string): Promise<string> {
+	let resolvedPath = filePath
+
+	// Check if file exists and handle symlinks
+	try {
+		const stats = await fs.lstat(filePath)
+		if (stats.isSymbolicLink()) {
+			// Create a temporary fileInfo array to use with resolveSymLink
+			const fileInfo: Array<{
+				originalPath: string
+				resolvedPath: string
+			}> = []
+
+			// Use the existing resolveSymLink function to handle symlink resolution
+			await resolveSymLink(filePath, fileInfo, 0)
+
+			// Extract the resolved path from fileInfo
+			if (fileInfo.length > 0) {
+				resolvedPath = fileInfo[0].resolvedPath
+			}
+		}
+	} catch (err) {
+		// If lstat fails (file doesn't exist), return empty
+		return ""
+	}
+
+	// Read the content from the resolved path
+	return safeReadFile(resolvedPath)
+}
+
+/**
+ * Load AGENTS.md or AGENT.md file from a specific directory
+ * Checks for both AGENTS.md (standard) and AGENT.md (alternative) for compatibility
+ * Also loads AGENTS.local.md for personal overrides (not checked in to version control)
+ * AGENTS.local.md can be loaded even if AGENTS.md doesn't exist
+ *
+ * @param directory - Directory to check for AGENTS.md
+ * @param showPath - Whether to include the directory path in the header
+ * @param cwd - Current working directory for computing relative paths (optional)
+ */
+async function loadAgentRulesFileFromDirectory(
+	directory: string,
+	showPath: boolean = false,
+	cwd?: string,
+): Promise<string> {
+	// Try both filenames - AGENTS.md (standard) first, then AGENT.md (alternative)
+	const filenames = ["AGENTS.md", "AGENT.md"]
+	const results: string[] = []
+	const displayPath = cwd ? path.relative(cwd, directory) : directory
+
+	for (const filename of filenames) {
+		try {
+			const agentPath = path.join(directory, filename)
+			const content = await readAgentRulesFile(agentPath)
+
+			if (content) {
+				// Compute relative path for display if cwd is provided
+				const header = showPath
+					? `# Agent Rules Standard (${filename}) from ${displayPath}:`
+					: `# Agent Rules Standard (${filename}):`
+				results.push(`${header}\n${content}`)
+
+				// Found a standard file, don't check alternative
+				break
+			}
+		} catch (err) {
+			// Silently ignore errors - agent rules files are optional
+		}
+	}
+
+	// Always try to load AGENTS.local.md for personal overrides (even if AGENTS.md doesn't exist)
+	try {
+		const localFilename = "AGENTS.local.md"
+		const localPath = path.join(directory, localFilename)
+		const localContent = await readAgentRulesFile(localPath)
+
+		if (localContent) {
+			const localHeader = showPath
+				? `# Agent Rules Local (${localFilename}) from ${displayPath}:`
+				: `# Agent Rules Local (${localFilename}):`
+			results.push(`${localHeader}\n${localContent}`)
+		}
+	} catch (err) {
+		// Silently ignore errors - local agent rules file is optional
+	}
+
+	return results.join("\n\n")
+}
+
+/**
+ * Load AGENTS.md or AGENT.md file from the project root if it exists
+ * Checks for both AGENTS.md (standard) and AGENT.md (alternative) for compatibility
+ *
+ * @deprecated Use loadAllAgentRulesFiles for loading from all directories
+ */
+async function loadAgentRulesFile(cwd: string): Promise<string> {
+	return loadAgentRulesFileFromDirectory(cwd, false, cwd)
+}
+
+/**
+ * Load all AGENTS.md files from project root and optionally subdirectories with .roo folders
+ * Returns combined content with clear path headers for each file
+ *
+ * @param cwd - Current working directory (project root)
+ * @param enableSubfolderRules - Whether to include AGENTS.md from subdirectories (default: false)
+ * @returns Combined AGENTS.md content from all locations
+ */
+async function loadAllAgentRulesFiles(cwd: string, enableSubfolderRules: boolean = false): Promise<string> {
+	const agentRules: string[] = []
+
+	// When subfolder rules are disabled, only load from root
+	if (!enableSubfolderRules) {
+		const content = await loadAgentRulesFileFromDirectory(cwd, false, cwd)
+		if (content && content.trim()) {
+			agentRules.push(content.trim())
+		}
+		return agentRules.join("\n\n")
+	}
+
+	// When enabled, load from root and all subdirectories with .roo folders
+	const directories = await getAgentsDirectoriesForCwd(cwd)
+
+	for (const directory of directories) {
+		// Show path for all directories except the root
+		const showPath = directory !== cwd
+		const content = await loadAgentRulesFileFromDirectory(directory, showPath, cwd)
+		if (content && content.trim()) {
+			agentRules.push(content.trim())
+		}
+	}
+
+	return agentRules.join("\n\n")
+}
+
+export async function addCustomInstructions(
+	modeCustomInstructions: string,
+	globalCustomInstructions: string,
+	cwd: string,
+	mode: string,
+	options: {
+		language?: string
+		rooIgnoreInstructions?: string
+		settings?: SystemPromptSettings
+	} = {},
+): Promise<string> {
+	const sections = []
+
+	// Get the enableSubfolderRules setting (default: false)
+	const enableSubfolderRules = options.settings?.enableSubfolderRules ?? false
+
+	// Load mode-specific rules if mode is provided
+	let modeRuleContent = ""
+	let usedRuleFile = ""
+
+	if (mode) {
+		const modeRules: string[] = []
+		// Use recursive discovery only if enableSubfolderRules is true
+		const rooDirectories = enableSubfolderRules
+			? await getAllRooDirectoriesForCwd(cwd)
+			: getRooDirectoriesForCwd(cwd)
+
+		// Check for .roo/rules-${mode}/ directories in order (global, project-local, and optionally subfolders)
+		for (const rooDir of rooDirectories) {
+			const modeRulesDir = path.join(rooDir, `rules-${mode}`)
+			if (await directoryExists(modeRulesDir)) {
+				const files = await readTextFilesFromDirectory(modeRulesDir)
+				if (files.length > 0) {
+					const content = formatDirectoryContent(files, cwd)
+					modeRules.push(content)
+				}
+			}
+		}
+
+		// If we found mode-specific rules in .roo/rules-${mode}/ directories, use them
+		if (modeRules.length > 0) {
+			modeRuleContent = "\n" + modeRules.join("\n\n")
+			usedRuleFile = `rules-${mode} directories`
+		} else {
+			// Fall back to existing behavior for legacy files
+			const rooModeRuleFile = `.roorules-${mode}`
+			modeRuleContent = await safeReadFile(path.join(cwd, rooModeRuleFile))
+			if (modeRuleContent) {
+				usedRuleFile = rooModeRuleFile
+			} else {
+				const clineModeRuleFile = `.clinerules-${mode}`
+				modeRuleContent = await safeReadFile(path.join(cwd, clineModeRuleFile))
+				if (modeRuleContent) {
+					usedRuleFile = clineModeRuleFile
+				}
+			}
+		}
+	}
+
+	// Add language preference if provided
+	if (options.language) {
+		const languageName = isLanguage(options.language) ? LANGUAGES[options.language] : options.language
+		sections.push(
+			`Language Preference:\nYou should always speak and think in the "${languageName}" (${options.language}) language unless the user gives you instructions below to do otherwise.`,
+		)
+	}
+
+	// Add global instructions first
+	if (typeof globalCustomInstructions === "string" && globalCustomInstructions.trim()) {
+		sections.push(`Global Instructions:\n${globalCustomInstructions.trim()}`)
+	}
+
+	// Add mode-specific instructions after
+	if (typeof modeCustomInstructions === "string" && modeCustomInstructions.trim()) {
+		sections.push(`Mode-specific Instructions:\n${modeCustomInstructions.trim()}`)
+	}
+
+	// Add rules - include both mode-specific and generic rules if they exist
+	const rules = []
+
+	// Add mode-specific rules first if they exist
+	if (modeRuleContent && modeRuleContent.trim()) {
+		if (usedRuleFile.includes(path.join(".roo", `rules-${mode}`))) {
+			rules.push(modeRuleContent.trim())
+		} else {
+			rules.push(`# Rules from ${usedRuleFile}:\n${modeRuleContent}`)
+		}
+	}
+
+	if (options.rooIgnoreInstructions) {
+		rules.push(options.rooIgnoreInstructions)
+	}
+
+	// Add AGENTS.md content if enabled (default: true)
+	// Load from root and optionally subdirectories with .roo folders based on enableSubfolderRules setting
+	if (options.settings?.useAgentRules !== false) {
+		const agentRulesContent = await loadAllAgentRulesFiles(cwd, enableSubfolderRules)
+		if (agentRulesContent && agentRulesContent.trim()) {
+			rules.push(agentRulesContent.trim())
+		}
+	}
+
+	// Add generic rules
+	const genericRuleContent = await loadRuleFiles(cwd, enableSubfolderRules)
+	if (genericRuleContent && genericRuleContent.trim()) {
+		rules.push(genericRuleContent.trim())
+	}
+
+	if (rules.length > 0) {
+		sections.push(`Rules:\n\n${rules.join("\n\n")}`)
+	}
+
+	const joinedSections = sections.join("\n\n")
+
+	return joinedSections
+		? `
+====
+
+USER'S CUSTOM INSTRUCTIONS
+
+The following additional instructions are provided by the user, and should be followed to the best of your ability.
+
+${joinedSections}
+`
+		: ""
+}
+
+/**
+ * Check if a file should be included in rule compilation.
+ * Excludes cache files and system files that shouldn't be processed as rules.
+ */
+function shouldIncludeRuleFile(filename: string): boolean {
+	const basename = path.basename(filename)
+
+	const cachePatterns = [
+		"*.DS_Store",
+		"*.bak",
+		"*.cache",
+		"*.crdownload",
+		"*.db",
+		"*.dmp",
+		"*.dump",
+		"*.eslintcache",
+		"*.lock",
+		"*.log",
+		"*.old",
+		"*.part",
+		"*.partial",
+		"*.pyc",
+		"*.pyo",
+		"*.stackdump",
+		"*.swo",
+		"*.swp",
+		"*.temp",
+		"*.tmp",
+		"Thumbs.db",
+	]
+
+	return !cachePatterns.some((pattern) => {
+		if (pattern.startsWith("*.")) {
+			const extension = pattern.slice(1)
+			return basename.endsWith(extension)
+		} else {
+			return basename === pattern
+		}
+	})
+}

package/src/vendor/zoo-code/src/core/prompts/sections/index.ts

@@ -0,0 +1,10 @@
+export { getRulesSection } from "./rules"
+export { getSystemInfoSection } from "./system-info"
+export { getObjectiveSection } from "./objective"
+export { addCustomInstructions } from "./custom-instructions"
+export { getSharedToolUseSection } from "./tool-use"
+export { getToolUseGuidelinesSection } from "./tool-use-guidelines"
+export { getCapabilitiesSection } from "./capabilities"
+export { getModesSection } from "./modes"
+export { markdownFormattingSection } from "./markdown-formatting"
+export { getSkillsSection } from "./skills"

package/src/vendor/zoo-code/src/core/prompts/sections/markdown-formatting.ts

@@ -0,0 +1,7 @@
+export function markdownFormattingSection(): string {
+	return `====
+
+MARKDOWN RULES
+
+ALL responses MUST show ANY \`language construct\` OR filename reference as clickable, exactly as [\`filename OR language.declaration()\`](relative/file/path.ext:line); line is required for \`syntax\` and optional for filename links. This applies to ALL markdown responses and ALSO those in attempt_completion`
+}

package/src/vendor/zoo-code/src/core/prompts/sections/modes.ts

@@ -0,0 +1,35 @@
+import * as vscode from "../../../../shim/vscode"
+
+import type { ModeConfig } from "../../../../types"
+
+import { getAllModesWithPrompts } from "../../../shared/modes"
+import { ensureSettingsDirectoryExists } from "../../../utils/globalContext"
+
+export async function getModesSection(context: vscode.ExtensionContext): Promise<string> {
+	// Make sure path gets created
+	await ensureSettingsDirectoryExists(context)
+
+	// Get all modes with their overrides from extension state
+	const allModes = await getAllModesWithPrompts(context)
+
+	const modesContent = `====
+
+MODES
+
+- These are the currently available modes:
+${allModes
+	.map((mode: ModeConfig) => {
+		let description: string
+		if (mode.whenToUse && mode.whenToUse.trim() !== "") {
+			// Use whenToUse as the primary description, indenting subsequent lines for readability
+			description = mode.whenToUse.replace(/\n/g, "\n    ")
+		} else {
+			// Fallback to the first sentence of roleDefinition if whenToUse is not available
+			description = mode.roleDefinition.split(".")[0]
+		}
+		return `  * "${mode.name}" mode (${mode.slug}) - ${description}`
+	})
+	.join("\n")}`
+
+	return modesContent
+}

package/src/vendor/zoo-code/src/core/prompts/sections/objective.ts

@@ -0,0 +1,13 @@
+export function getObjectiveSection(): string {
+	return `====
+
+OBJECTIVE
+
+You accomplish a given task iteratively, breaking it down into clear steps and working through them methodically.
+
+1. Analyze the user's task and set clear, achievable goals to accomplish it. Prioritize these goals in a logical order.
+2. Work through these goals sequentially, utilizing available tools one at a time as necessary. Each goal should correspond to a distinct step in your problem-solving process. You will be informed on the work completed and what's remaining as you go.
+3. Remember, you have extensive capabilities with access to a wide range of tools that can be used in powerful and clever ways as necessary to accomplish each goal. Before calling a tool, do some analysis. First, analyze the file structure provided in environment_details to gain context and insights for proceeding effectively. Next, think about which of the provided tools is the most relevant tool to accomplish the user's task. Go through each of the required parameters of the relevant tool and determine if the user has directly provided or given enough information to infer a value. When deciding if the parameter can be inferred, carefully consider all the context to see if it supports a specific value. If all of the required parameters are present or can be reasonably inferred, proceed with the tool use. BUT, if one of the values for a required parameter is missing, DO NOT invoke the tool (not even with fillers for the missing params) and instead, ask the user to provide the missing parameters using the ask_followup_question tool. DO NOT ask for more information on optional parameters if it is not provided.
+4. Once you've completed the user's task, you must use the attempt_completion tool to present the result of the task to the user.
+5. The user may provide feedback, which you can use to make improvements and try again. But DO NOT continue in pointless back and forth conversations, i.e. don't end your responses with questions or offers for further assistance.`
+}