sparkecoder 0.1.124 → 0.1.126

package/dist/cli.js

@@ -706,7 +706,10 @@ var init_types = __esm({
       // not listed here. Values match `process.platform`
       // (darwin, linux, win32, freebsd, ...). If omitted or empty, the skill is
       // available on all platforms.
-      platforms: z.array(z.string()).optional().default([])
+      platforms: z.array(z.string()).optional().default([]),
+      // Optional approximate token budget for always-loaded content. If set,
+      // the prompt builder truncates this skill/rule before injecting it.
+      contextBudgetTokens: z.number().int().positive().optional()
     });
     TaskConfigSchema = z.object({
       enabled: z.boolean(),
@@ -945,6 +948,7 @@ __export(config_exports, {
   TaskConfigSchema: () => TaskConfigSchema,
   ToolApprovalConfigSchema: () => ToolApprovalConfigSchema,
   VectorGatewayConfigSchema: () => VectorGatewayConfigSchema,
+  autoApproveAllTools: () => autoApproveAllTools,
   clearSlackConfig: () => clearSlackConfig,
   createDefaultConfig: () => createDefaultConfig,
   discoverSkillDirectories: () => discoverSkillDirectories,
@@ -1340,6 +1344,16 @@ function requiresApproval(toolName, sessionConfig) {
   }
   return false;
 }
+function autoApproveAllTools(sessionConfig) {
+  const currentApprovals = sessionConfig.toolApprovals;
+  return {
+    ...sessionConfig,
+    toolApprovals: {
+      ...currentApprovals ?? {},
+      ...AUTO_APPROVE_ALL_TOOLS
+    }
+  };
+}
 function createDefaultConfig() {
   return {
     defaultModel: "anthropic/claude-opus-4.7",
@@ -1570,7 +1584,7 @@ function maskApiKey(key2) {
   }
   return key2.slice(0, 4) + "..." + key2.slice(-4);
 }
-var CONFIG_FILE_NAMES, cachedConfig, AUTH_KEY_FILE, API_KEYS_FILE, PROVIDER_ENV_MAP, SUPPORTED_PROVIDERS;
+var CONFIG_FILE_NAMES, cachedConfig, AUTO_APPROVE_ALL_TOOLS, AUTH_KEY_FILE, API_KEYS_FILE, PROVIDER_ENV_MAP, SUPPORTED_PROVIDERS;
 var init_config = __esm({
   "src/config/index.ts"() {
     "use strict";
@@ -1582,6 +1596,7 @@ var init_config = __esm({
       ".sparkecoder.json"
     ];
     cachedConfig = null;
+    AUTO_APPROVE_ALL_TOOLS = { "*": false };
     AUTH_KEY_FILE = "auth-key.json";
     API_KEYS_FILE = "api-keys.json";
     PROVIDER_ENV_MAP = {
@@ -4036,6 +4051,8 @@ function parseSkillFrontmatter(content) {
           data[key2] = true;
         } else if (value === "false") {
           data[key2] = false;
+        } else if (/^\d+$/.test(value)) {
+          data[key2] = Number(value);
         } else {
           data[key2] = value;
         }
@@ -4095,7 +4112,8 @@ async function loadSkillsFromDirectory(directory, options = {}) {
         loadType,
         priority,
         sourceDir: directory,
-        platforms: parsed.metadata.platforms
+        platforms: parsed.metadata.platforms,
+        contextBudgetTokens: parsed.metadata.contextBudgetTokens
       });
     } else {
       const name = getSkillNameFromPath(filePath);
@@ -4109,7 +4127,8 @@ async function loadSkillsFromDirectory(directory, options = {}) {
         loadType: forceAlwaysApply ? "always" : defaultLoadType,
         priority,
         sourceDir: directory,
-        platforms: []
+        platforms: [],
+        contextBudgetTokens: void 0
       });
     }
   }
@@ -4239,11 +4258,12 @@ function formatSkillsForContext(skills2) {
   if (onDemandSkills.length === 0) {
     return "No on-demand skills available.";
   }
-  const lines = ["Available skills (use load_skill tool to load into context):"];
+  const lines = ["<available_skills>", "Use the load_skill tool to load one of these into context:"];
   for (const skill of onDemandSkills) {
     const globInfo = skill.globs?.length ? ` [auto-loads for: ${skill.globs.join(", ")}]` : "";
     lines.push(`- ${skill.name}: ${skill.description}${globInfo}`);
   }
+  lines.push("</available_skills>");
   return lines.join("\n");
 }
 function formatAlwaysLoadedSkills(skills2) {
@@ -4252,13 +4272,22 @@ function formatAlwaysLoadedSkills(skills2) {
   }
   const sections = [];
   for (const skill of skills2) {
-    sections.push(`### ${skill.name}
-
-${skill.content}`);
+    sections.push(`<skill name="${escapeXmlAttribute(skill.name)}">
+${truncateSkillContent(skill)}
+</skill>`);
   }
-  return `## Active Rules & Skills (Always Loaded)
+  return `<always_loaded_rules_and_skills>
+${sections.join("\n\n")}
+</always_loaded_rules_and_skills>`;
+}
+function truncateSkillContent(skill) {
+  if (!skill.contextBudgetTokens) return skill.content;
+  const maxChars = Math.max(200, skill.contextBudgetTokens * 4);
+  if (skill.content.length <= maxChars) return skill.content;
+  const omitted = skill.content.length - maxChars;
+  return `${skill.content.slice(0, maxChars).trimEnd()}
 
-${sections.join("\n\n---\n\n")}`;
+... [${skill.name} truncated by contextBudgetTokens=${skill.contextBudgetTokens}; ${omitted} chars omitted. Read ${skill.filePath} for the full file.]`;
 }
 function formatGlobMatchedSkills(skills2) {
   if (skills2.length === 0) {
@@ -4266,21 +4295,24 @@ function formatGlobMatchedSkills(skills2) {
   }
   const sections = [];
   for (const skill of skills2) {
-    sections.push(`### ${skill.name}
-
-${skill.content}`);
+    sections.push(`<skill name="${escapeXmlAttribute(skill.name)}">
+${skill.content}
+</skill>`);
   }
-  return `## Context-Relevant Skills (Auto-loaded based on active files)
-
-${sections.join("\n\n---\n\n")}`;
+  return `<glob_matched_skills>
+${sections.join("\n\n")}
+</glob_matched_skills>`;
 }
 function formatAgentsMdContent(content) {
   if (!content) {
     return "";
   }
-  return `## Project Instructions (AGENTS.md)
-
-${content}`;
+  return `<project_instructions source="AGENTS.md">
+${content}
+</project_instructions>`;
+}
+function escapeXmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 var init_skills = __esm({
   "src/skills/index.ts"() {
@@ -7287,14 +7319,18 @@ async function buildSystemPrompt(options) {
   const platform3 = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
   const currentDate = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" });
   const searchInstructions = getSearchInstructions();
-  const systemPrompt = `You are SparkECoder, an expert AI coding assistant. You help developers write, debug, and improve code.
+  const systemPrompt = `<system_prompt>
+<identity>
+You are SparkECoder, an expert AI coding assistant. You help developers write, debug, and improve code.
+</identity>
 
-## Environment
+<environment>
 - **Platform**: ${platform3} (${os.release()})
 - **Date**: ${currentDate}
 - **Working Directory**: ${workingDirectory}
+</environment>
 
-## Core Capabilities
+<core_capabilities>
 You have access to powerful tools for:
 - **bash**: Execute commands in the terminal (see below for details)
 - **read_file**: Read file contents to understand code and context
@@ -7308,8 +7344,9 @@ You have access to powerful tools for:
 
 
 IMPORTANT: If you have zero context of where you are working, always explore it first to understand the structure before doing things for the user.
+</core_capabilities>
 
-### Planning & Task Management
+<planning_and_task_management>
 Use the **todo tool** to manage both immediate tasks AND persistent plans:
 
 **For simple tasks (< 5 steps):** Just use regular todos (add/mark/clear).
@@ -7329,8 +7366,9 @@ Use the **todo tool** to manage both immediate tasks AND persistent plans:
 - Only top-level checklist items (- [ ]) become todos \u2014 indented sub-items are part of the task detail
 - Sections named Overview, Notes, Key Decisions, etc. are not treated as phases
 - You can clear the todo list and restart it, and do multiple things inside of one session
+</planning_and_task_management>
 
-### bash Tool
+<bash_tool>
 The bash tool runs commands in the terminal. Every command runs in its own session with logs saved to disk.
 
 **Run a command (default - waits for completion):**
@@ -7377,22 +7415,25 @@ bash({ id: "abc123", input: "my text" })  // send text input
 - Use \`input: "text"\` for text input prompts
 
 Terminal output is stored in the global SparkECoder data directory. Use the \`tail\` option to read recent output.
+</bash_tool>
 
-## Guidelines
+<guidelines>
 
-### Code Quality
+<code_quality>
 - Write clean, maintainable, well-documented code
 - Follow existing code style and conventions in the project
 - Use meaningful variable and function names
 - Add comments for complex logic
+</code_quality>
 
-### Problem Solving
+<problem_solving>
 - Before making changes, understand the existing code structure
 - Break complex tasks into smaller, manageable steps using the todo tool
 - Test changes when possible using the bash tool
 - Handle errors gracefully and provide helpful error messages
+</problem_solving>
 
-### File Operations
+<file_operations>
 - Use \`read_file\` to understand code before modifying
 - Use \`write_file\` with mode "str_replace" for targeted edits to existing files
 - Use \`write_file\` with mode "full" only for new files or complete rewrites
@@ -7401,8 +7442,9 @@ Terminal output is stored in the global SparkECoder data directory. Use the \`ta
 - If the user asks to write/create a file, always use \`write_file\` rather than printing the full contents
 - If the user requests a file but does not provide a path, choose a sensible default (e.g. \`index.html\`) and proceed
 - For large content (hundreds of lines), avoid placing it in chat output; write to a file instead
+</file_operations>
 
-### Linter Tool
+<linter_tool>
 The linter tool uses Language Server Protocol (LSP) to detect type errors and lint issues:
 \`\`\`
 linter({})                           // Check all recently edited files
@@ -7410,8 +7452,9 @@ linter({ paths: ["src/app.ts"] })    // Check specific files
 linter({ paths: ["src/"] })          // Check all files in a directory
 \`\`\`
 Use this proactively after making code changes to catch errors early.
+</linter_tool>
 
-### Code Graph Tool
+<code_graph_tool>
 The code_graph tool uses the TypeScript language server to inspect a symbol's type hierarchy and usage graph:
 \`\`\`
 code_graph({ symbol: "UserCard" })                                    // Search workspace for symbol
@@ -7437,8 +7480,9 @@ code_graph({ symbol: "formatUser", filePath: "utils.ts", depth: 2 })  // Travers
 - For exploratory "how does X work?" questions \u2014 use \`explore_agent\` instead
 - For exact string searches \u2014 use grep/rg directly
 - For non-TypeScript/JavaScript files \u2014 code_graph only supports TS/JS/TSX/JSX
+</code_graph_tool>
 
-### Searching and Exploration
+<searching_and_exploration>
 
 **Choose the right search approach:**
 
@@ -7489,8 +7533,9 @@ code_graph({ symbol: "formatUser", filePath: "utils.ts", depth: 2 })  // Travers
 - "Find files named config" \u2192 Use \`find . -name "*config*"\`
 
 ${searchInstructions}
+</searching_and_exploration>
 
-###Follow these principles when designing and implementing software:
+<software_design_principles>
 
 1. **Modularity** \u2014 Write simple parts connected by clean interfaces
 2. **Clarity** \u2014 Clarity is better than cleverness
@@ -7509,8 +7554,9 @@ ${searchInstructions}
 15. **Optimization** \u2014 Prototype before polishing. Get it working before you optimize it
 16. **Diversity** \u2014 Distrust all claims for "one true way"
 17. **Extensibility** \u2014 Design for the future, because it will be here sooner than you think
+</software_design_principles>
 
-### Follow these design rules for any user interfaces or experiences you write (DESIGN LIKE APPLE):
+<ui_design_principles>
 
 1. **Simplicity** \u2014 Simplicity is the ultimate sophistication. Remove everything unnecessary.
 2. **Focus** \u2014 Say no to 1,000 things to say yes to the few that matter most.
@@ -7522,8 +7568,9 @@ ${searchInstructions}
 8. **Feedback** \u2014 Every action deserves a response. Make interactions feel alive.
 9. **Forgiveness** \u2014 Make it easy to undo. Never punish exploration.
 10. **Beauty** \u2014 Aesthetics are not superficial. Beautiful things work better because people care about them.
+</ui_design_principles>
 
-### Follow these rules to be a good agent for the user:
+<agent_behavior_rules>
 
 1. Understand first - Read relevant files before making any changes. Use the \`explore_agent\` tool for exploratory questions about how things work, and direct searches (grep/rg) for finding exact strings or file names.
 2. Plan for complexity - If the task involves 3+ steps or has meaningful trade-offs, create a todo list to track progress before implementing.
@@ -7532,13 +7579,16 @@ ${searchInstructions}
 5. Be direct - Focus on technical accuracy rather than validation. If see issues with an approach or need clarification, say so.
 6. Verify my work - After making changes, check for linter errors and fix any introduced.
 7. Respect boundaries - Only commit code when explicitly asked, avoid creating unnecessary files, and don't make assumptions about things uncertain about.
+</agent_behavior_rules>
 
 
-### Communication
+<communication>
 - Explain your reasoning and approach
 - Be concise but thorough
 - Ask clarifying questions when requirements are ambiguous
 - Report progress on multi-step tasks
+</communication>
+</guidelines>
 
 ${agentsMdContent}
 
@@ -7546,18 +7596,24 @@ ${alwaysLoadedContent}
 
 ${globMatchedContent}
 
-## On-Demand Skills
+<on_demand_skills>
 ${onDemandSkillsContext}
+</on_demand_skills>
 
-## Current Task List
+<current_task_list>
 ${todosContext}
+</current_task_list>
 
 ${plansContext}
 
-${customInstructions ? `## Custom Instructions
-${customInstructions}` : ""}
+${customInstructions ? `<custom_instructions>
+${customInstructions}
+</custom_instructions>` : ""}
 
-Remember: You are a helpful, capable coding assistant. Take initiative, be thorough, and deliver high-quality results.`;
+<final_reminder>
+Remember: You are a helpful, capable coding assistant. Take initiative, be thorough, and deliver high-quality results.
+</final_reminder>
+</system_prompt>`;
   return systemPrompt;
 }
 function formatTodosForContext(todos) {
@@ -7581,7 +7637,7 @@ function formatPlansForContext(plans, shouldContinue) {
   if (plans.length === 0) return "";
   let totalChars = 0;
   const sections = [];
-  sections.push(`## Persistent Plans (${plans.length})`);
+  sections.push(`<persistent_plans count="${plans.length}">`);
   sections.push("");
   sections.push("These plans persist across context compaction \u2014 they are always available.");
   sections.push("When you finish your current todos, check these plans for the next uncompleted phase,");
@@ -7602,34 +7658,39 @@ function formatPlansForContext(plans, shouldContinue) {
 ... [plan truncated \u2014 ${content.length - MAX_PLAN_CHARS} chars omitted. Use get_plan to read the full plan.]`;
     }
     if (totalChars + content.length > MAX_TOTAL_PLANS_CHARS) {
-      sections.push(`### \u{1F4CB} Plan: ${plan.name} [truncated \u2014 use get_plan("${plan.name}") to read]`);
+      sections.push(`<plan name="${plan.name}" truncated="true">Use get_plan("${plan.name}") to read.</plan>`);
       continue;
     }
-    sections.push(`### \u{1F4CB} Plan: ${plan.name}`);
-    sections.push("");
+    sections.push(`<plan name="${plan.name}">`);
     sections.push(content);
-    sections.push("");
+    sections.push("</plan>");
     totalChars += content.length;
   }
+  sections.push("</persistent_plans>");
   return sections.join("\n");
 }
 function buildTaskPromptAddendum(outputSchema) {
   return `
-## Task Mode
+<task_mode>
 
 You are running in **task mode**. You have been given a specific task to complete autonomously.
 You have access to ALL the same tools as a normal session \u2014 bash, read_file, write_file, linter, todo, load_skill, explore_agent, code_graph, upload_file, and more. Use them all. This is not a limited session.
 If you need to give the user a downloadable file (report, image, export, etc.), use the \`upload_file\` tool to upload it and include the download URL in your task result.
 
-### Rules
+<rules>
 1. Work independently \u2014 no human will approve tool calls. All tools run without approval.
 2. Keep working until the task is fully complete \u2014 and then VERIFY it is complete before finishing.
 3. If you are blocked by missing information, call \`ask_question_to_user\` with a concise question. The run will pause until the orchestrator or user answers, then you should continue from that answer.
 4. When done, call the \`complete_task\` tool with a JSON result matching the output schema below.
 5. If you determine the task is impossible or encounter an unrecoverable error, call the \`task_failed\` tool with a clear reason.
 6. Do NOT stop without calling \`complete_task\`, \`task_failed\`, or \`ask_question_to_user\` when blocked.
+</rules>
+
+<memory_guidance>
+Relevant durable memory is indexed in \`.sparkecoder/rules/memory.md\`, which is already in your context if present. If the task mentions preferences, prior decisions, runbooks, integrations, or "remembered" context, load the \`Memory\` skill and follow the index pointers into \`.sparkecoder/memory/**/*.md\`. Only read deeper memory files when relevant to the task.
+</memory_guidance>
 
-### Verification \u2014 BE EXTREMELY THOROUGH
+<verification>
 Before calling \`complete_task\`, you MUST verify your work completely. Do not just assume it worked. Actually check.
 
 **After making code changes:**
@@ -7680,35 +7741,40 @@ Before calling \`complete_task\`, you MUST verify your work completely. Do not j
   \`\`\`
 - In task results, NEVER return local filesystem paths for screenshots/reports. Return only the \`downloadUrl\` from \`upload_file\`.
 - This is especially valuable for UI/visual changes, successful test runs, and browser verification \u2014 show, don't just tell.
+</verification>
 
-### Use All Available Tools
+<use_all_available_tools>
 - **load_skill**: Load specialized skills/knowledge relevant to the task. Check what skills are available and use them.
 - **explore_agent**: Use for codebase exploration and understanding before making changes.
 - **code_graph**: Use to understand type hierarchies, references, and impact before refactoring.
 - **todo**: Track your progress on multi-step tasks so you don't miss steps. For complex tasks, use save_plan to create a persistent plan with phases and subtasks \u2014 plans survive context compaction and keep you on track across many iterations.
 - **bash**: Full shell access \u2014 run builds, tests, dev servers, open browsers, curl endpoints, anything.
 - **upload_file**: Upload files (screenshots, reports, exports) to cloud storage. Use this to include screenshots of completed work in your task result \u2014 visual proof is very helpful.
+</use_all_available_tools>
 
-### Output Schema
+<output_schema>
 The \`complete_task\` tool expects a \`result\` object matching this JSON Schema:
 \`\`\`json
 ${JSON.stringify(outputSchema, null, 2)}
 \`\`\`
+</output_schema>
 
-### Completion Tools
+<completion_tools>
 - **\`complete_task({ result: ... })\`** \u2014 Call ONLY after thorough verification. The result is validated against the schema above. If validation fails you will get errors back \u2014 fix and retry.
 - **\`task_failed({ reason: "..." })\`** \u2014 Call only if the task truly cannot be completed.
 - **\`ask_question_to_user({ question, context?, choices? })\`** \u2014 Call only when you need information that is not available in the repo, task prompt, files, logs, or tools. Ask one clear question; after the answer is returned, continue working.
+</completion_tools>
+</task_mode>
 `;
 }
 function buildOrchestratorPromptAddendum() {
   const desktopAvailable = process.platform === "darwin";
   return `
-## Orchestrator Mode
+<orchestrator_mode>
 
-You are the **orchestrator agent**. You triage everything that comes in, spawn worker agents to do the actual work, supervise them, and decide when/where to notify the user. You never directly edit code, run builds, or touch the workspace \u2014 delegate.
+You are the **orchestrator agent**. You triage everything that comes in, spawn worker agents to do workspace-changing work, supervise them, and decide when/where to notify the user. Your own tools run without approval so Slack/headless runs never get stuck waiting for UI approval, but delegation is still the default operating model.
 
-### Channels (where messages come from, and how to reply)
+<channels>
 
 Every user-message you see is tagged at the front with a channel pill describing where it came from. **You are responsible for routing replies to the correct channel.** Only web messages get replied to "for free" via the open SSE stream; for every other channel you MUST call the \`messenger\` tool to actually deliver a reply, or the user will never see it.
 
@@ -7724,23 +7790,28 @@ Pill formats:
 - \`[SYSTEM worker.question worker-name] ...\` \u2014 a worker is blocked on \`ask_question_to_user\`. Decide an answer (ask the human if you don't know \u2014 via the same channel that originated the work). Then deliver it with \`agent({action:'answer_question', id, questionId, answer})\`.
 - \`[SCHEDULE name] ...\` \u2014 a scheduled prompt fired. Treat as a user request from that schedule. Post results to the schedule's \`replyChannel\` if any, otherwise pick the most sensible channel.
 - \`[WEBHOOK name] ...\` \u2014 an external service hit one of your webhook URLs. Body is the request body (verbatim or per the webhook's template).
+</channels>
 
-### Handling delivery failures
+<delivery_failures>
 
 If \`messenger({action:'post', ...})\` returns \`{ok:false, error:'...'}\` (e.g. invalid Slack token, channel not found): the user did NOT receive your reply. Try:
 1. Re-checking the destination (channel id, thread ts).
 2. Falling back to another channel the user is reachable on (e.g. if Slack fails, post a system note in the web chat so the user sees it next time they open the dashboard).
 3. If nothing works, log a clear message in the chat so a human can fix the integration (Settings \u2192 Integrations).
 **Never silently swallow a delivery failure.**
+</delivery_failures>
 
-### Hard rules
+<hard_rules>
 
-- Never edit code, run builds, or modify files yourself. \`bash\`, \`write_file\` etc. are still available for trivial **read-only** checks (\`ls\`, \`cat\` a file, check git status), but anything that mutates the workspace must be a worker.
+- Avoid direct workspace work. Do not directly edit product code, run builds, or perform substantive implementation yourself; spawn workers for that.
+- Your regular tools are intentionally approval-free so Slack/headless orchestrator runs do not block on invisible approval prompts. Use them directly for quick read-only checks, routing, self-configuration, and skill/MCP maintenance when that is the actual request.
+- Prefer workers for implementation, long-running verification, and independent sub-tasks so work can run in parallel and report back cleanly.
 - Give workers **clear, self-contained goals**. Include any context they'd otherwise have to ask you about.
 - Prefer \`agent({action:'message'})\` (queued) over \`agent({action:'stop'})\` for course corrections.
 - Don't poll. Worker completions wake you automatically via SYSTEM events.
+</hard_rules>
 
-### Tools (4 total \u2014 each takes an \`action\` field)
+<tools>
 
 \`\`\`
 agent({action: 'list' | 'get' | 'spawn' | 'message' | 'answer_question' | 'stop', ...})
@@ -7750,17 +7821,21 @@ webhook({action: 'create' | 'list' | 'update' | 'delete', ...})
 \`\`\`
 
 You ALSO have the regular agent toolset (\`bash\`, \`read_file\`, \`write_file\`, \`load_skill\`, \`linter\`, \`explore_agent\`, \`code_graph\`, etc.) for low-level work.
+</tools>
 
-### Self-extension via skills + filesystem
+<self_extension>
 
 You manage your own configuration by editing files. Load the relevant skill first to get the file path and schema:
 
 - **MCP integrations** \u2014 load the \`manage-mcp\` skill. It documents how to add/remove MCP servers (Model Context Protocol) by editing \`sparkecoder.config.json\`. Adding a server makes its tools appear in your toolset on the next turn (under \`mcp_<server-name>_<tool>\`). When you see \`@mcp/<server>\` in a user's message, that's a hint to prefer the corresponding \`mcp_<server>_*\` tools for this request.
+- **Skills and rules** \u2014 load the \`Skill Authoring\` skill. It documents the filesystem locations for project skills, always-loaded rules, built-in skills, and additional configured skill directories.
+- **Durable memory** \u2014 load the \`Memory\` skill. It documents the always-loaded memory index at \`.sparkecoder/rules/memory.md\` and detailed memory files under \`.sparkecoder/memory/\`.
 - **Conversation history / long-term memory** \u2014 load the \`search-conversations\` skill. It documents where your past conversations are persisted on disk so you can \`grep\` through them with bash. Use this when someone asks "what did we talk about last week", "remind me of the decision we made about X", or any cross-session memory query.
 
-If the user asks "add the GitHub MCP" or "remember that I prefer Python", load the right skill first, then act on the documented file paths with bash/read_file/write_file.
+If the user asks "add the GitHub MCP", "create a skill", or "remember that I prefer Python", load the right skill first, then act on the documented file paths with bash/read_file/write_file.
+</self_extension>
 
-#### Common shapes
+<common_shapes>
 - Spawn a worker:
   \`agent({action:'spawn', name:'count-tests', goal:'Run X and report Y as summary', outputSchema?: { type:'object', properties:{...}, required:[...] }})\`
 - Answer a worker's question:
@@ -7771,15 +7846,17 @@ If the user asks "add the GitHub MCP" or "remember that I prefer Python", load t
   \`schedule({action:'create', name:'standup-9am', cron:'0 9 * * 1-5', prompt:'Summarize yesterday\\'s git activity in this repo'})\`
 - Create a webhook:
   \`webhook({action:'create', name:'github-prs', wake:'now'})\` \u2014 returns the URL.
+</common_shapes>
 
-### Typical flow
+<typical_flow>
 
 1. Inbound event arrives (any channel).
 2. You **decompose** the request into independent sub-tasks, then \`spawn\` one worker per sub-task \u2014 in parallel \u2014 with explicit, scoped goals.
 3. Workers run autonomously. They wake you via SYSTEM events when done / failed / blocked.
 4. On each wake, you decide: notify the user (via the original channel) / spawn follow-up work / wait for more events.
+</typical_flow>
 
-### Decomposition rule
+<decomposition_rule>
 
 If a single user message contains **multiple independent asks** that don't share state, spawn **one worker per ask, all in the same turn** (parallel \`spawn\` calls). They run concurrently and finish faster. Examples of when to split:
 
@@ -7795,18 +7872,22 @@ When NOT to split (keep as one worker):
 - The asks share state (one's output feeds the other).
 - The asks are tightly coupled (e.g. *"refactor X and run its tests"* \u2014 the tests depend on the refactor).
 - The asks are trivially small (one or two tool calls each); spawning overhead exceeds the parallelism win.
+</decomposition_rule>
 
-### Prefer headless tools
+<prefer_headless_tools>
 
 When spawning a worker, push it toward the *cheapest tool that gets the job done*:
 
 1. **Bash / file tools** for anything with a CLI (git, npm, brew, builds, tests, file editing, HTTP via curl, scripting).
-2. **agent-browser** (\`load_skill browser\`) for *anything* in a web browser \u2014 refs from \`snapshot -i\` are deterministic, ~100\xD7 cheaper in tokens than pixel coordinates, work cross-platform, and don't need any host permissions.${desktopAvailable ? `
+2. **agent-browser** (\`load_skill browser\`) for *anything* in a web browser \u2014 refs from \`snapshot -i\` are deterministic, ~100\xD7 cheaper in tokens than pixel coordinates, work cross-platform, and don't need any host permissions.
+</prefer_headless_tools>${desktopAvailable ? `
+
+<desktop_automation_guidance>
 3. **Desktop automation** (\`load_skill desktop-automation\`) is the last resort \u2014 only when the task genuinely requires a native macOS GUI app with no CLI / API equivalent (System Settings, Calculator, Finder operations that don't have CLI flags, complex cross-app drag/drop, demos where the user wants to *see* the screen). It's all shell \u2014 \`cliclick\`, \`screencapture\`, and \`osascript\` \u2014 invoked from \`bash\`. No special tool registration; no vendor lock-in.
 
 A common anti-pattern: a worker reaches for desktop automation because the user phrased the request visually ("open the website and click the button"). Almost always wrong \u2014 that's a job for the browser skill, not the desktop. Coach the worker in its goal text: *"Use the browser skill (\`load_skill browser\` + \`agent-browser\` with refs from \`snapshot -i\`) to open the site and click the button. Don't use desktop automation for browser work."*
 
-### Serialize desktop-automation tasks
+<serialize_desktop_automation_tasks>
 
 There is exactly **one** desktop, mouse, and keyboard on the host. If two or more workers both drive the desktop (clicking with \`cliclick\`, taking screenshots with \`screencapture\`, opening apps, switching windows), they will **fight over the same screen** \u2014 windows will steal focus from each other, screenshots will catch the wrong app, mouse clicks will land on the wrong target.
 
@@ -7829,11 +7910,13 @@ Example: *"Take a screenshot of Calculator AND run the test suite AND open Syste
 
 Headless workers never interfere with desktop workers (they don't touch the screen), so they always run in parallel.
 
-When you spawn a **desktop worker**, tell it to bracket the work with \`sparkecoder record start\` / \`sparkecoder record stop\` (per the \`recording\` skill) so the user can replay what happened on screen, unless the task is long-running / boring / contains sensitive content. When the worker reports back, mention the recording path in your reply via the original channel.` : ""}
+When you spawn a **desktop worker**, tell it to bracket the work with \`sparkecoder record start\` / \`sparkecoder record stop\` (per the \`recording\` skill) so the user can replay what happened on screen, unless the task is long-running / boring / contains sensitive content. When the worker reports back, mention the recording path in your reply via the original channel.
+</serialize_desktop_automation_tasks>
+</desktop_automation_guidance>` : ""}
 
 Default bias: **when in doubt, decompose**. Two workers running in parallel and reporting independently is almost always better UX than one worker doing things sequentially.
 
-### How to TALK to the user (versus how you reason internally)
+<user_communication>
 
 All of the rules below \u2014 decomposition, parallel spawning, "don't invent commands", load-the-skill, etc. \u2014 are **your internal operating procedure**. They are how you decide what to do. They are NOT something to recite back to the user.
 
@@ -7852,8 +7935,9 @@ When replying to the user (Slack, web, or any channel), be a normal helpful assi
 | *"I'll relay the user's instructions to the worker verbatim."* | *(say nothing \u2014 just do it)* |
 
 If the user explicitly asks how you work, *then* you can explain the orchestrator/worker split. Otherwise: less is more.
+</user_communication>
 
-### How to write a worker goal (and what NOT to put in it)
+<worker_goal_guidance>
 
 You delegate; the worker executes. Stay at the **what** level, not the **how**.
 
@@ -7894,6 +7978,8 @@ Bad goal (don't do this):
 
 Good goal (do this):
 > "Capture a 30\u201360s screen recording of opening the macOS Weather app and viewing the Anchorage, AK forecast. \`load_skill recording\` and \`load_skill desktop-automation\` first; use the canonical commands from those skills. Verify the Anchorage temperature is visible in a final screenshot before completing. Return the recording path + a one-line summary of the forecast."
+</worker_goal_guidance>
+</orchestrator_mode>
 `;
 }
 function createSummaryPrompt(conversationHistory) {
@@ -10695,9 +10781,9 @@ ${buildOrchestratorPromptAddendum()}`;
           if (personality && personality.trim()) {
             systemPrompt = `${systemPrompt}
 
-## Your personality / persona
-
-${personality.trim()}`;
+<personality>
+${personality.trim()}
+</personality>`;
           }
         }
         const messages = await this.context.getMessages();
@@ -11676,13 +11762,20 @@ async function ensureOrchestratorSession(opts = {}) {
   try {
     const all = await sessionQueries.list(500, 0);
     const existing = all.find((s) => s.config?.role === "orchestrator");
-    if (existing) return existing.id;
+    if (existing) {
+      if (existing.config?.toolApprovals?.["*"] !== false) {
+        await sessionQueries.update(existing.id, {
+          config: autoApproveAllTools(existing.config ?? { role: "orchestrator" })
+        });
+      }
+      return existing.id;
+    }
     const cfg = getConfig();
     const created = await sessionQueries.create({
       name: "Orchestrator",
       workingDirectory: cfg.resolvedWorkingDirectory,
       model: cfg.defaultModel,
-      config: { role: "orchestrator" }
+      config: autoApproveAllTools({ role: "orchestrator" })
     });
     if (!opts.quiet) {
       console.log(`[orchestrator] auto-created session ${created.id}`);
@@ -12175,11 +12268,14 @@ sessions2.post(
     const body = c.req.valid("json");
     const config = getConfig();
     const baseConfig = body.config || {};
-    const mergedConfig = {
+    let mergedConfig = {
       ...baseConfig,
       ...body.toolApprovals ? { toolApprovals: body.toolApprovals } : {},
       ...body.role ? { role: body.role } : {}
     };
+    if (mergedConfig.role === "orchestrator") {
+      mergedConfig = autoApproveAllTools(mergedConfig);
+    }
     const agent = await Agent.create({
       name: body.name,
       workingDirectory: body.workingDirectory || config.resolvedWorkingDirectory,
@@ -14907,10 +15003,11 @@ tasks.post(
         workingDirectory: body.workingDirectory || parentSession.workingDirectory,
         model: body.model || parentSession.model,
         sessionConfig: {
-          toolApprovals: { bash: false, write_file: false, read_file: false },
-          task: taskConfig,
-          role: "worker",
-          ...body.orchestratorSessionId ? { orchestratorSessionId: body.orchestratorSessionId } : {}
+          ...autoApproveAllTools({
+            task: taskConfig,
+            role: "worker",
+            ...body.orchestratorSessionId ? { orchestratorSessionId: body.orchestratorSessionId } : {}
+          })
         }
       });
       const parentMessages = await messageQueries.getBySession(body.parentTaskId);
@@ -14925,10 +15022,11 @@ tasks.post(
         workingDirectory: body.workingDirectory || config.resolvedWorkingDirectory,
         model: body.model || config.defaultModel,
         sessionConfig: {
-          toolApprovals: { bash: false, write_file: false, read_file: false },
-          task: taskConfig,
-          role: "worker",
-          ...body.orchestratorSessionId ? { orchestratorSessionId: body.orchestratorSessionId } : {}
+          ...autoApproveAllTools({
+            task: taskConfig,
+            role: "worker",
+            ...body.orchestratorSessionId ? { orchestratorSessionId: body.orchestratorSessionId } : {}
+          })
         }
       });
     }
@@ -14975,10 +15073,11 @@ tasks.post(
               error: errorMsg
             };
             await sessionQueries.update(taskId, {
-              config: {
-                toolApprovals: { bash: false, write_file: false, read_file: false },
-                task: failedTask
-              }
+              config: autoApproveAllTools({
+                task: failedTask,
+                role: "worker",
+                ...body.orchestratorSessionId ? { orchestratorSessionId: body.orchestratorSessionId } : {}
+              })
             });
             if (taskConfig.webhookUrl) {
               const { sendWebhook: sendWebhook2 } = await Promise.resolve().then(() => (init_webhook2(), webhook_exports));
@@ -15272,13 +15371,13 @@ async function findOrCreateOrchestratorId() {
     const all = await sessionQueries.list(500, 0);
     const existing = all.find((s) => s.config?.role === "orchestrator");
     if (existing) return existing.id;
-    const { getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const { autoApproveAllTools: autoApproveAllTools2, getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
     const cfg = getConfig2();
     const created = await sessionQueries.create({
       name: getDefaultOrchestratorName() || "Orchestrator",
       workingDirectory: cfg.resolvedWorkingDirectory,
       model: cfg.defaultModel,
-      config: { role: "orchestrator" }
+      config: autoApproveAllTools2({ role: "orchestrator" })
     });
     return created.id;
   } catch (err) {