@iaforged/context-code 1.0.77 → 1.0.80

package/dist/src/services/limits/adapters/ollama.js

@@ -102,7 +102,7 @@ export const ollamaLimitAdapter = {
             return {
                 ...base,
                 status: 'ok',
-                plan: 'Ollama local (ilimitado)',
+                plan: 'Ollama (ilimitado)',
                 tokensLimit: null,
                 costLimitUsd: null,
                 message: 'Ollama corre localmente; no hay limite de proveedor.',
@@ -142,10 +142,10 @@ export const ollamaCloudLimitAdapter = {
                 return {
                     ...base,
                     status: 'ok',
-                    plan: 'Ollama local (ilimitado)',
+                    plan: 'Ollama (ilimitado)',
                     tokensLimit: null,
                     costLimitUsd: null,
-                    message: 'El perfil ollama-cloud apunta a un host local; se trata como Ollama local ilimitado.',
+                    message: 'El perfil ollama-cloud apunta a un host local; se trata como Ollama ilimitado.',
                     raw,
                 };
             }

package/dist/src/services/oauth/geminiCli.js

@@ -0,0 +1,107 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { GEMINI_CLI_OAUTH_AUTHORIZE_URL, GEMINI_CLI_OAUTH_CALLBACK_PATH, GEMINI_CLI_OAUTH_CALLBACK_PORT, GEMINI_CLI_OAUTH_CLIENT_ID, GEMINI_CLI_OAUTH_CLIENT_SECRET, GEMINI_CLI_OAUTH_REDIRECT_URI, GEMINI_CLI_OAUTH_SCOPES, GEMINI_CLI_OAUTH_TOKEN_URL, } from '../../constants/geminiOAuth.js';
+import { openBrowser } from '../../utils/browser.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { AuthCodeListener } from './auth-code-listener.js';
+function base64Url(value) {
+    return value
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/g, '');
+}
+function generateCodeVerifier() {
+    return base64Url(randomBytes(32));
+}
+function generateCodeChallenge(verifier) {
+    return base64Url(createHash('sha256').update(verifier).digest());
+}
+async function discoverGoogleProject(accessToken) {
+    const envProjectId = process.env.GEMINI_GOOGLE_PROJECT_ID?.trim() || undefined;
+    try {
+        const response = await fetch('https://cloudcode-pa.googleapis.com/v1internal:loadCodeAssist', {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                cloudaicompanionProject: envProjectId,
+                metadata: {
+                    ideType: 'IDE_UNSPECIFIED',
+                    platform: 'PLATFORM_UNSPECIFIED',
+                    pluginType: 'GEMINI',
+                    duetProject: envProjectId,
+                },
+            }),
+        });
+        if (response.ok) {
+            const data = (await response.json());
+            return data.cloudaicompanionProject;
+        }
+    }
+    catch (error) {
+        logForDebugging(`Gemini CLI project discovery failed: ${String(error)}`, {
+            level: 'debug',
+        });
+    }
+    return envProjectId;
+}
+export async function startGeminiCliOAuthFlow() {
+    const listener = new AuthCodeListener(GEMINI_CLI_OAUTH_CALLBACK_PATH);
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const state = randomBytes(16).toString('hex');
+    await listener.start(GEMINI_CLI_OAUTH_CALLBACK_PORT, 'localhost');
+    const authUrl = new URL(GEMINI_CLI_OAUTH_AUTHORIZE_URL);
+    authUrl.searchParams.set('client_id', GEMINI_CLI_OAUTH_CLIENT_ID);
+    authUrl.searchParams.set('redirect_uri', GEMINI_CLI_OAUTH_REDIRECT_URI);
+    authUrl.searchParams.set('response_type', 'code');
+    authUrl.searchParams.set('scope', GEMINI_CLI_OAUTH_SCOPES.join(' '));
+    authUrl.searchParams.set('state', state);
+    authUrl.searchParams.set('code_challenge', codeChallenge);
+    authUrl.searchParams.set('code_challenge_method', 'S256');
+    authUrl.searchParams.set('access_type', 'offline');
+    authUrl.searchParams.set('prompt', 'consent');
+    try {
+        const authorizationCode = await listener.waitForAuthorization(state, async () => {
+            await openBrowser(authUrl.toString());
+        });
+        const tokenResponse = await fetch(GEMINI_CLI_OAUTH_TOKEN_URL, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                grant_type: 'authorization_code',
+                code: authorizationCode,
+                redirect_uri: GEMINI_CLI_OAUTH_REDIRECT_URI,
+                client_id: GEMINI_CLI_OAUTH_CLIENT_ID,
+                client_secret: GEMINI_CLI_OAUTH_CLIENT_SECRET,
+                code_verifier: codeVerifier,
+            }),
+        });
+        if (!tokenResponse.ok) {
+            const message = await tokenResponse.text().catch(() => tokenResponse.statusText);
+            throw new Error(`Gemini CLI OAuth token exchange failed: ${message}`);
+        }
+        const data = (await tokenResponse.json());
+        const projectId = await discoverGoogleProject(data.access_token);
+        listener.handleSuccessRedirect([], 'openai', response => {
+            response.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            response.end('<html><body style="font-family:sans-serif;padding:2rem;text-align:center"><h2>Conectado a Gemini</h2><p>Puedes cerrar esta ventana y volver a Context Code.</p></body></html>');
+        });
+        return {
+            accessToken: data.access_token,
+            refreshToken: data.refresh_token ?? null,
+            expiresAt: data.expires_in
+                ? Date.now() + data.expires_in * 1000
+                : null,
+            scopes: data.scope?.split(/\s+/).filter(Boolean) ?? GEMINI_CLI_OAUTH_SCOPES,
+            subscriptionType: null,
+            rateLimitTier: null,
+            projectId,
+        };
+    }
+    finally {
+        listener.close();
+    }
+}

package/dist/src/services/orchestration/execution/AgentTaskExecutor.js

@@ -6,6 +6,8 @@ const DEFAULT_BASE_URLS = {
     openrouter: 'https://openrouter.ai/api/v1',
     ollama: 'http://localhost:11434/v1',
     'ollama-cloud': 'http://localhost:11434/v1',
+    'gemini-api': 'https://generativelanguage.googleapis.com/v1beta/openai',
+    'gemini-google': 'https://generativelanguage.googleapis.com/v1beta/openai',
     zai: 'https://api.z.ai/api/coding/paas/v4',
     minimax: 'https://api.minimax.io/anthropic',
 };
@@ -78,7 +80,7 @@ function buildSystemPrompt(input) {
     const capabilities = input.capabilities.length > 0 ? input.capabilities.join(', ') : 'sin declarar';
     return [
         input.agent.systemPrompt?.trim() ||
-            `Eres ${input.agent.name}, agente del escuadron ${domainName}.`,
+            `Eres ${input.agent.name}, agente del equipo ${domainName}.`,
         `Rol: ${input.agent.roleKind ?? 'general'}.`,
         `Capacidades: ${capabilities}.`,
         'Responde con un reporte ejecutivo y accionable para el orquestador global.',
@@ -92,13 +94,13 @@ function buildUserPrompt(input) {
         : 'sin miembros internos';
     return [
         `Objetivo global: ${input.run.goal}`,
-        `Dominio: ${domainName}`,
+        `Equipo: ${domainName}`,
         `Tarea: ${input.task.title}`,
         `Instrucciones: ${input.task.instructions}`,
         `Miembros del escuadron: ${memberText}`,
         '',
         'Entrega:',
-        '1. Resultado del dominio.',
+        '1. Resultado del equipo.',
         '2. Decisiones tomadas.',
         '3. Riesgos o bloqueos.',
         '4. Siguientes pasos recomendados.',

package/dist/src/services/orchestration/execution/OrchestrationExecutionRuntime.js

@@ -47,7 +47,7 @@ function rowToTask(row) {
         runId: typed.run_id,
         parentTaskId: typed.parent_task_id ?? null,
         scopeType: typed.scope_type,
-        teamDomainId: typed.team_domain_id ?? null,
+        teamDomainId: typed.team_unit_id ?? null,
         assignedAgentId: typed.assigned_agent_id ?? null,
         title: typed.title,
         instructions: typed.instructions,
@@ -92,7 +92,7 @@ function validateRunTransition(current, next) {
         return;
     }
     if (!RUN_TRANSITIONS[current].includes(next)) {
-        throw new Error(`No se puede transicionar una corrida de ${current} a ${next}.`);
+        throw new Error(`No se puede transicionar una ejecucion de ${current} a ${next}.`);
     }
 }
 function validateTaskTransition(current, next) {
@@ -205,7 +205,7 @@ async function loadRunState(runId) {
     }
     const db = await getOrchestrationDatabase();
     const tasks = db
-        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_domain_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
        FROM orchestration_tasks
        WHERE run_id = ?
        ORDER BY created_at, id`)
@@ -225,7 +225,7 @@ async function loadRunState(runId) {
 async function loadTaskAndRunState(taskId) {
     const db = await getOrchestrationDatabase();
     const row = db
-        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_domain_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
        FROM orchestration_tasks
        WHERE id = ?`)
         .get(requireText(taskId, 'taskId'));
@@ -242,7 +242,7 @@ async function loadTaskAndRunState(taskId) {
 async function updateTasksByRun(runId, transform) {
     const db = await getOrchestrationDatabase();
     const rows = db
-        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_domain_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
+        .prepare(`SELECT id, run_id, parent_task_id, scope_type, team_unit_id, assigned_agent_id, title, instructions, status, result_summary, created_at, finished_at
        FROM orchestration_tasks
        WHERE run_id = ?`)
         .all(requireText(runId, 'runId'))
@@ -385,8 +385,8 @@ async function finalizeRunFromTasks(runId) {
         finishedAt: nowIso(),
     });
     await new OrchestrationExecutionRuntime().appendMessage(runId, nextStatus === 'completed' ? 'run.completed' : 'run.failed', nextStatus === 'completed'
-        ? 'Todos los dominios ejecutables reportaron resultado al orquestador global.'
-        : 'La corrida termino con dominios bloqueados o fallidos.', null, state.run.globalOrchestratorAgentId, null);
+        ? 'Todos los equipos ejecutables reportaron resultado al orquestador global.'
+        : 'La ejecucion termino con equipos bloqueados o fallidos.', null, state.run.globalOrchestratorAgentId, null);
 }
 export class OrchestrationExecutionRuntime {
     async getRunState(runId) {
@@ -402,7 +402,7 @@ export class OrchestrationExecutionRuntime {
             throw new Error(`Orchestration run not found: ${runId}`);
         }
         if (runState.run.status === 'completed') {
-            throw new Error('No se puede iniciar una corrida completada.');
+            throw new Error('No se puede iniciar una ejecucion completada.');
         }
         const changed = runState.run.status !== 'in_progress';
         await withOrchestrationTransaction(async (db) => {
@@ -447,7 +447,7 @@ export class OrchestrationExecutionRuntime {
             throw new Error(`Orchestration run not found: ${runId}`);
         }
         if (runState.run.status === 'completed') {
-            throw new Error('No se puede reanudar una corrida completada.');
+            throw new Error('No se puede reanudar una ejecucion completada.');
         }
         const changed = runState.run.status !== 'in_progress';
         await withOrchestrationTransaction(async (db) => {
@@ -594,10 +594,10 @@ export class OrchestrationExecutionRuntime {
             throw new Error(`Orchestration run not found: ${runId}`);
         }
         if (initial.run.status === 'completed') {
-            throw new Error('No se puede ejecutar una corrida completada.');
+            throw new Error('No se puede ejecutar una ejecucion completada.');
         }
         if (initial.run.status === 'cancelled') {
-            throw new Error('No se puede ejecutar una corrida cancelada.');
+            throw new Error('No se puede ejecutar una ejecucion cancelada.');
         }
         const readyTasks = initial.tasks
             .filter(task => task.status === 'ready')
@@ -646,7 +646,7 @@ export class OrchestrationExecutionRuntime {
                 progressPercent: progressPercent(),
             });
             if (!selectedAgentId) {
-                const summary = `Dominio ${domainName} bloqueado: no hay agente asignado ni miembros disponibles.`;
+                const summary = `Equipo ${domainName} bloqueado: no hay agente asignado ni miembros disponibles.`;
                 const blockedAt = nowIso();
                 input.onProgress?.({
                     runId,
@@ -681,7 +681,7 @@ export class OrchestrationExecutionRuntime {
                         localOrchestratorAgentId,
                         status: 'needs_revision',
                         summary,
-                        blockers: 'No hay agente disponible para ejecutar el dominio.',
+                        blockers: 'No hay agente disponible para ejecutar el equipo.',
                         output: summary,
                         metricsJson: JSON.stringify({
                             completedTasks: 0,
@@ -702,7 +702,7 @@ export class OrchestrationExecutionRuntime {
                     memberAgentIds: members.map(member => member.agentId),
                     status: 'blocked',
                     summary,
-                    blockers: ['No hay agente disponible para ejecutar el dominio.'],
+                    blockers: ['No hay agente disponible para ejecutar el equipo.'],
                     completedAt: blockedAt,
                 });
                 processedReadyTasks += 1;
@@ -711,7 +711,7 @@ export class OrchestrationExecutionRuntime {
             const agent = await getProviderAgentById(selectedAgentId);
             const capabilities = sortCapabilities(agent ? await listProviderAgentCapabilities(agent.id) : []);
             if (!agent || !agent.isEnabled) {
-                const summary = `Dominio ${domainName} bloqueado: el agente asignado no existe o esta deshabilitado.`;
+                const summary = `Equipo ${domainName} bloqueado: el agente asignado no existe o esta deshabilitado.`;
                 const blockedAt = nowIso();
                 input.onProgress?.({
                     runId,
@@ -777,7 +777,7 @@ export class OrchestrationExecutionRuntime {
             const workspace = await getProviderWorkspaceById(agent.workspaceId);
             const agentLabel = workspace ? `${workspace.provider}/${agent.name}` : agent.name;
             if (!workspace || !workspace.isEnabled) {
-                const summary = `Dominio ${domainName} bloqueado: el workspace del agente no existe o esta deshabilitado.`;
+                const summary = `Equipo ${domainName} bloqueado: el workspace del agente no existe o esta deshabilitado.`;
                 const blockedAt = nowIso();
                 input.onProgress?.({
                     runId,
@@ -846,7 +846,7 @@ export class OrchestrationExecutionRuntime {
            WHERE id = ?`).run('in_progress', selectedAgentId, task.id);
                 db.prepare(`INSERT INTO orchestration_messages (
             id, run_id, task_id, from_agent_id, to_agent_id, message_type, content, created_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, task.id, initial.run.globalOrchestratorAgentId, selectedAgentId, 'task.dispatch', `Dominio ${domainName}: tarea enviada a ${agent.name}.`, nowIso());
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, task.id, initial.run.globalOrchestratorAgentId, selectedAgentId, 'task.dispatch', `Equipo ${domainName}: tarea enviada a ${agent.name}.`, nowIso());
             });
             input.onProgress?.({
                 runId,
@@ -1026,7 +1026,7 @@ export class OrchestrationExecutionRuntime {
                 domainReports: report.domainReports,
             }),
             risks: report.failedTasks > 0 || report.blockedTasks > 0
-                ? 'Hay tareas fallidas o bloqueadas que requieren revision antes de cerrar la corrida.'
+                ? 'Hay tareas fallidas o bloqueadas que requieren revision antes de cerrar la ejecucion.'
                 : null,
             nextSteps: report.openTasks > 0
                 ? 'Ejecutar /run resume <run-id> para continuar las tareas abiertas.'

package/dist/src/services/orchestration/global/reporting.js

@@ -438,13 +438,13 @@ function buildClosureRecommendation(domain, reports, blockers, artifacts, nextAc
 function buildConsolidatedRecommendations(domainSummaries, blockers) {
     const recommendations = [];
     if (blockers.length > 0) {
-        recommendations.push('Resolver bloqueos de escuadron antes de cerrar la corrida global.');
+        recommendations.push('Resolver bloqueos de escuadron antes de cerrar la ejecucion global.');
     }
     if (domainSummaries.some(summary => summary.status === 'in_progress')) {
         recommendations.push('Esperar reportes finales de dominios en progreso.');
     }
     if (domainSummaries.every(summary => summary.status === 'completed')) {
-        recommendations.push('Consolidar resultado final y cerrar la corrida.');
+        recommendations.push('Consolidar resultado final y cerrar la ejecucion.');
     }
     if (domainSummaries.some(summary => summary.closureRecommendation.action === 'retry')) {
         recommendations.push('Reintentar dominios con fallo, baja confianza o evidencia insuficiente.');

package/dist/src/services/toolUseSummary/toolUseSummaryGenerator.js

@@ -10,15 +10,15 @@ import { logError } from '../../utils/log.js';
 import { jsonStringify } from '../../utils/slowOperations.js';
 import { asSystemPrompt } from '../../utils/systemPromptType.js';
 import { queryHaiku } from '../api/claude.js';
-const TOOL_USE_SUMMARY_SYSTEM_PROMPT = `Write a short summary label describing what these tool calls accomplished. It appears as a single-line row in a mobile app and truncates around 30 characters, so think git-commit-subject, not sentence.
-
-Keep the verb in past tense and the most distinctive noun. Drop articles, connectors, and long location context first.
-
-Examples:
-- Searched in auth/
-- Fixed NPE in UserService
-- Created signup endpoint
-- Read config.json
+const TOOL_USE_SUMMARY_SYSTEM_PROMPT = `Write a short summary label describing what these tool calls accomplished. It appears as a single-line row in a mobile app and truncates around 30 characters, so think git-commit-subject, not sentence.
+
+Keep the verb in past tense and the most distinctive noun. Drop articles, connectors, and long location context first.
+
+Examples:
+- Searched in auth/
+- Fixed NPE in UserService
+- Created signup endpoint
+- Read config.json
 - Ran failing tests`;
 /**
  * Generates a human-readable summary of completed tools.

package/dist/src/skills/bundled/batch.js

@@ -7,89 +7,89 @@ import { getIsGit } from '../../utils/git.js';
 import { registerBundledSkill } from '../bundledSkills.js';
 const MIN_AGENTS = 5;
 const MAX_AGENTS = 30;
-const WORKER_INSTRUCTIONS = `After you finish implementing the change:
-1. **Simplify** — Invoke the \`${SKILL_TOOL_NAME}\` tool with \`skill: "simplify"\` to review and clean up your changes.
-2. **Run unit tests** — Run the project's test suite (check for package.json scripts, Makefile targets, or common commands like \`npm test\`, \`bun test\`, \`pytest\`, \`go test\`). If tests fail, fix them.
-3. **Test end-to-end** — Follow the e2e test recipe from the coordinator's prompt (below). If the recipe says to skip e2e for this unit, skip it.
-4. **Commit and push** — Commit all changes with a clear message, push the branch, and create a PR with \`gh pr create\`. Use a descriptive title. If \`gh\` is not available or the push fails, note it in your final message.
+const WORKER_INSTRUCTIONS = `After you finish implementing the change:
+1. **Simplify** — Invoke the \`${SKILL_TOOL_NAME}\` tool with \`skill: "simplify"\` to review and clean up your changes.
+2. **Run unit tests** — Run the project's test suite (check for package.json scripts, Makefile targets, or common commands like \`npm test\`, \`bun test\`, \`pytest\`, \`go test\`). If tests fail, fix them.
+3. **Test end-to-end** — Follow the e2e test recipe from the coordinator's prompt (below). If the recipe says to skip e2e for this unit, skip it.
+4. **Commit and push** — Commit all changes with a clear message, push the branch, and create a PR with \`gh pr create\`. Use a descriptive title. If \`gh\` is not available or the push fails, note it in your final message.
 5. **Report** — End with a single line: \`PR: <url>\` so the coordinator can track it. If no PR was created, end with \`PR: none — <reason>\`.`;
 function buildPrompt(instruction) {
-    return `# Batch: Parallel Work Orchestration
-
-You are orchestrating a large, parallelizable change across this codebase.
-
-## User Instruction
-
-${instruction}
-
-## Phase 1: Research and Plan (Plan Mode)
-
-Call the \`${ENTER_PLAN_MODE_TOOL_NAME}\` tool now to enter plan mode, then:
-
-1. **Understand the scope.** Launch one or more subagents (in the foreground — you need their results) to deeply research what this instruction touches. Find all the files, patterns, and call sites that need to change. Understand the existing conventions so the migration is consistent.
-
-2. **Decompose into independent units.** Break the work into ${MIN_AGENTS}–${MAX_AGENTS} self-contained units. Each unit must:
-   - Be independently implementable in an isolated git worktree (no shared state with sibling units)
-   - Be mergeable on its own without depending on another unit's PR landing first
-   - Be roughly uniform in size (split large units, merge trivial ones)
-
-   Scale the count to the actual work: few files → closer to ${MIN_AGENTS}; hundreds of files → closer to ${MAX_AGENTS}. Prefer per-directory or per-module slicing over arbitrary file lists.
-
-3. **Determine the e2e test recipe.** Figure out how a worker can verify its change actually works end-to-end — not just that unit tests pass. Look for:
-   - A \`claude-in-chrome\` skill or browser-automation tool (for UI changes: click through the affected flow, screenshot the result)
-   - A \`tmux\` or CLI-verifier skill (for CLI changes: launch the app interactively, exercise the changed behavior)
-   - A dev-server + curl pattern (for API changes: start the server, hit the affected endpoints)
-   - An existing e2e/integration test suite the worker can run
-
-   If you cannot find a concrete e2e path, use the \`${ASK_USER_QUESTION_TOOL_NAME}\` tool to ask the user how to verify this change end-to-end. Offer 2–3 specific options based on what you found (e.g., "Screenshot via chrome extension", "Run \`bun run dev\` and curl the endpoint", "No e2e — unit tests are sufficient"). Do not skip this — the workers cannot ask the user themselves.
-
-   Write the recipe as a short, concrete set of steps that a worker can execute autonomously. Include any setup (start a dev server, build first) and the exact command/interaction to verify.
-
-4. **Write the plan.** In your plan file, include:
-   - A summary of what you found during research
-   - A numbered list of work units — for each: a short title, the list of files/directories it covers, and a one-line description of the change
-   - The e2e test recipe (or "skip e2e because …" if the user chose that)
-   - The exact worker instructions you will give each agent (the shared template)
-
-5. Call \`${EXIT_PLAN_MODE_TOOL_NAME}\` to present the plan for approval.
-
-## Phase 2: Spawn Workers (After Plan Approval)
-
-Once the plan is approved, spawn one background agent per work unit using the \`${AGENT_TOOL_NAME}\` tool. **All agents must use \`isolation: "worktree"\` and \`run_in_background: true\`.** Launch them all in a single message block so they run in parallel.
-
-For each agent, the prompt must be fully self-contained. Include:
-- The overall goal (the user's instruction)
-- This unit's specific task (title, file list, change description — copied verbatim from your plan)
-- Any codebase conventions you discovered that the worker needs to follow
-- The e2e test recipe from your plan (or "skip e2e because …")
-- The worker instructions below, copied verbatim:
-
-\`\`\`
-${WORKER_INSTRUCTIONS}
-\`\`\`
-
-Use \`subagent_type: "general-purpose"\` unless a more specific agent type fits.
-
-## Phase 3: Track Progress
-
-After launching all workers, render an initial status table:
-
-| # | Unit | Status | PR |
-|---|------|--------|----|
-| 1 | <title> | running | — |
-| 2 | <title> | running | — |
-
-As background-agent completion notifications arrive, parse the \`PR: <url>\` line from each agent's result and re-render the table with updated status (\`done\` / \`failed\`) and PR links. Keep a brief failure note for any agent that did not produce a PR.
-
-When all agents have reported, render the final table and a one-line summary (e.g., "22/24 units landed as PRs").
+    return `# Batch: Parallel Work Orchestration
+
+You are orchestrating a large, parallelizable change across this codebase.
+
+## User Instruction
+
+${instruction}
+
+## Phase 1: Research and Plan (Plan Mode)
+
+Call the \`${ENTER_PLAN_MODE_TOOL_NAME}\` tool now to enter plan mode, then:
+
+1. **Understand the scope.** Launch one or more subagents (in the foreground — you need their results) to deeply research what this instruction touches. Find all the files, patterns, and call sites that need to change. Understand the existing conventions so the migration is consistent.
+
+2. **Decompose into independent units.** Break the work into ${MIN_AGENTS}–${MAX_AGENTS} self-contained units. Each unit must:
+   - Be independently implementable in an isolated git worktree (no shared state with sibling units)
+   - Be mergeable on its own without depending on another unit's PR landing first
+   - Be roughly uniform in size (split large units, merge trivial ones)
+
+   Scale the count to the actual work: few files → closer to ${MIN_AGENTS}; hundreds of files → closer to ${MAX_AGENTS}. Prefer per-directory or per-module slicing over arbitrary file lists.
+
+3. **Determine the e2e test recipe.** Figure out how a worker can verify its change actually works end-to-end — not just that unit tests pass. Look for:
+   - A \`claude-in-chrome\` skill or browser-automation tool (for UI changes: click through the affected flow, screenshot the result)
+   - A \`tmux\` or CLI-verifier skill (for CLI changes: launch the app interactively, exercise the changed behavior)
+   - A dev-server + curl pattern (for API changes: start the server, hit the affected endpoints)
+   - An existing e2e/integration test suite the worker can run
+
+   If you cannot find a concrete e2e path, use the \`${ASK_USER_QUESTION_TOOL_NAME}\` tool to ask the user how to verify this change end-to-end. Offer 2–3 specific options based on what you found (e.g., "Screenshot via chrome extension", "Run \`bun run dev\` and curl the endpoint", "No e2e — unit tests are sufficient"). Do not skip this — the workers cannot ask the user themselves.
+
+   Write the recipe as a short, concrete set of steps that a worker can execute autonomously. Include any setup (start a dev server, build first) and the exact command/interaction to verify.
+
+4. **Write the plan.** In your plan file, include:
+   - A summary of what you found during research
+   - A numbered list of work units — for each: a short title, the list of files/directories it covers, and a one-line description of the change
+   - The e2e test recipe (or "skip e2e because …" if the user chose that)
+   - The exact worker instructions you will give each agent (the shared template)
+
+5. Call \`${EXIT_PLAN_MODE_TOOL_NAME}\` to present the plan for approval.
+
+## Phase 2: Spawn Workers (After Plan Approval)
+
+Once the plan is approved, spawn one background agent per work unit using the \`${AGENT_TOOL_NAME}\` tool. **All agents must use \`isolation: "worktree"\` and \`run_in_background: true\`.** Launch them all in a single message block so they run in parallel.
+
+For each agent, the prompt must be fully self-contained. Include:
+- The overall goal (the user's instruction)
+- This unit's specific task (title, file list, change description — copied verbatim from your plan)
+- Any codebase conventions you discovered that the worker needs to follow
+- The e2e test recipe from your plan (or "skip e2e because …")
+- The worker instructions below, copied verbatim:
+
+\`\`\`
+${WORKER_INSTRUCTIONS}
+\`\`\`
+
+Use \`subagent_type: "general-purpose"\` unless a more specific agent type fits.
+
+## Phase 3: Track Progress
+
+After launching all workers, render an initial status table:
+
+| # | Unit | Status | PR |
+|---|------|--------|----|
+| 1 | <title> | running | — |
+| 2 | <title> | running | — |
+
+As background-agent completion notifications arrive, parse the \`PR: <url>\` line from each agent's result and re-render the table with updated status (\`done\` / \`failed\`) and PR links. Keep a brief failure note for any agent that did not produce a PR.
+
+When all agents have reported, render the final table and a one-line summary (e.g., "22/24 units landed as PRs").
 `;
 }
 const NOT_A_GIT_REPO_MESSAGE = `This is not a git repository. The \`/batch\` command requires a git repo because it spawns agents in isolated git worktrees and creates PRs from each. Initialize a repo first, or run this from inside an existing one.`;
-const MISSING_INSTRUCTION_MESSAGE = `Provide an instruction describing the batch change you want to make.
-
-Examples:
-  /batch migrate from react to vue
-  /batch replace all uses of lodash with native equivalents
+const MISSING_INSTRUCTION_MESSAGE = `Provide an instruction describing the batch change you want to make.
+
+Examples:
+  /batch migrate from react to vue
+  /batch replace all uses of lodash with native equivalents
   /batch add type annotations to all untyped function parameters`;
 export function registerBatchSkill() {
     registerBundledSkill({

package/dist/src/skills/bundled/claudeApi.js

@@ -60,40 +60,40 @@ function buildInlineReference(filePaths, content) {
     }
     return sections.join('\n\n');
 }
-const INLINE_READING_GUIDE = `## Reference Documentation
-
-The relevant documentation for your detected language is included below in \`<doc>\` tags. Each tag has a \`path\` attribute showing its original file path. Use this to find the right section:
-
-### Quick Task Reference
-
-**Single text classification/summarization/extraction/Q&A:**
-→ Refer to \`{lang}/claude-api/README.md\`
-
-**Chat UI or real-time response display:**
-→ Refer to \`{lang}/claude-api/README.md\` + \`{lang}/claude-api/streaming.md\`
-
-**Long-running conversations (may exceed context window):**
-→ Refer to \`{lang}/claude-api/README.md\` — see Compaction section
-
-**Prompt caching / optimize caching / "why is my cache hit rate low":**
-→ Refer to \`shared/prompt-caching.md\` + \`{lang}/claude-api/README.md\` (Prompt Caching section)
-
-**Function calling / tool use / agents:**
-→ Refer to \`{lang}/claude-api/README.md\` + \`shared/tool-use-concepts.md\` + \`{lang}/claude-api/tool-use.md\`
-
-**Batch processing (non-latency-sensitive):**
-→ Refer to \`{lang}/claude-api/README.md\` + \`{lang}/claude-api/batches.md\`
-
-**File uploads across multiple requests:**
-→ Refer to \`{lang}/claude-api/README.md\` + \`{lang}/claude-api/files-api.md\`
-
-**Agent with built-in tools (file/web/terminal) (Python & TypeScript only):**
-→ Refer to \`{lang}/agent-sdk/README.md\` + \`{lang}/agent-sdk/patterns.md\`
-
-**Error handling:**
-→ Refer to \`shared/error-codes.md\`
-
-**Latest docs via WebFetch:**
+const INLINE_READING_GUIDE = `## Reference Documentation
+
+The relevant documentation for your detected language is included below in \`<doc>\` tags. Each tag has a \`path\` attribute showing its original file path. Use this to find the right section:
+
+### Quick Task Reference
+
+**Single text classification/summarization/extraction/Q&A:**
+→ Refer to \`{lang}/claude-api/README.md\`
+
+**Chat UI or real-time response display:**
+→ Refer to \`{lang}/claude-api/README.md\` + \`{lang}/claude-api/streaming.md\`
+
+**Long-running conversations (may exceed context window):**
+→ Refer to \`{lang}/claude-api/README.md\` — see Compaction section
+
+**Prompt caching / optimize caching / "why is my cache hit rate low":**
+→ Refer to \`shared/prompt-caching.md\` + \`{lang}/claude-api/README.md\` (Prompt Caching section)
+
+**Function calling / tool use / agents:**
+→ Refer to \`{lang}/claude-api/README.md\` + \`shared/tool-use-concepts.md\` + \`{lang}/claude-api/tool-use.md\`
+
+**Batch processing (non-latency-sensitive):**
+→ Refer to \`{lang}/claude-api/README.md\` + \`{lang}/claude-api/batches.md\`
+
+**File uploads across multiple requests:**
+→ Refer to \`{lang}/claude-api/README.md\` + \`{lang}/claude-api/files-api.md\`
+
+**Agent with built-in tools (file/web/terminal) (Python & TypeScript only):**
+→ Refer to \`{lang}/agent-sdk/README.md\` + \`{lang}/agent-sdk/patterns.md\`
+
+**Error handling:**
+→ Refer to \`shared/error-codes.md\`
+
+**Latest docs via WebFetch:**
 → Refer to \`shared/live-sources.md\` for URLs`;
 function buildPrompt(lang, args, content) {
     // Take the SKILL.md content up to the "Reading Guide" section

package/dist/src/skills/bundled/claudeInChrome.js

@@ -3,10 +3,10 @@ import { BASE_CHROME_PROMPT } from '../../utils/claudeInChrome/prompt.js';
 import { shouldAutoEnableClaudeInChrome } from '../../utils/claudeInChrome/setup.js';
 import { registerBundledSkill } from '../bundledSkills.js';
 const CLAUDE_IN_CHROME_MCP_TOOLS = BROWSER_TOOLS.map(tool => `mcp__claude-in-chrome__${tool.name}`);
-const SKILL_ACTIVATION_MESSAGE = `
-Now that this skill is invoked, you have access to Chrome browser automation tools. You can now use the mcp__claude-in-chrome__* tools to interact with web pages.
-
-IMPORTANT: Start by calling mcp__claude-in-chrome__tabs_context_mcp to get information about the user's current browser tabs.
+const SKILL_ACTIVATION_MESSAGE = `
+Now that this skill is invoked, you have access to Chrome browser automation tools. You can now use the mcp__claude-in-chrome__* tools to interact with web pages.
+
+IMPORTANT: Start by calling mcp__claude-in-chrome__tabs_context_mcp to get information about the user's current browser tabs.
 `;
 export function registerClaudeInChromeSkill() {
     registerBundledSkill({