skimpyclaw 0.3.15 → 0.4.0

package/dist/code-agents/utils.js

@@ -1,5 +1,6 @@
 // Code Agent Utilities
 import { execSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
 import { resolve, join } from 'path';
 import { homedir } from 'os';
 import { buildValidationCommand } from './executor.js';
@@ -21,9 +22,25 @@ function isCommandAvailable(name) {
         return false;
     }
 }
-const CLAUDE_CLI_PATH = resolveCliPath('claude');
+export const CLAUDE_CLI_PATH = resolveCliPath('claude');
 const CODEX_CLI_PATH = resolveCliPath('codex');
-const KIMI_CLI_PATH = resolveCliPath('kimi');
+const DEFAULT_CODEX_HOME = join(homedir(), '.codex');
+/**
+ * Prepare env for spawning a coding-agent CLI (claude/codex):
+ * - Drops CLAUDECODE so nested `claude` invocations start cleanly.
+ * - Drops GH_TOKEN/GITHUB_TOKEN so `gh` falls back to keychain auth instead
+ *   of a stale process token.
+ * - Pins Codex to the standard CLI state directory so auth/config come from ~/.codex.
+ */
+export function buildCodeAgentSpawnEnv(base = process.env) {
+    const env = { ...base };
+    env.HOME ||= homedir();
+    env.CODEX_HOME = DEFAULT_CODEX_HOME;
+    delete env.CLAUDECODE;
+    delete env.GH_TOKEN;
+    delete env.GITHUB_TOKEN;
+    return env;
+}
 /** Return supported coding CLIs currently available on PATH. */
 export function getAvailableCodingCliTools(commandChecker = isCommandAvailable) {
     const available = [];
@@ -31,19 +48,17 @@ export function getAvailableCodingCliTools(commandChecker = isCommandAvailable)
         available.push('codex');
     if (commandChecker('claude') || commandChecker('claude-code'))
         available.push('claude');
-    if (commandChecker('kimi'))
-        available.push('kimi');
     return available;
 }
 /** Return preflight error when no supported coding CLI is installed. */
 export function getCodingCliPreflightError(commandChecker = isCommandAvailable) {
     if (getAvailableCodingCliTools(commandChecker).length > 0)
         return null;
-    return 'Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).';
+    return 'Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`) or Claude Code CLI (`claude` or `claude-code`).';
 }
 /**
  * Normalize legacy/default agent values to supported CLI agent IDs.
- * Accepts strict IDs and older alias-like values (e.g. "claude-think").
+ * Accepts strict IDs and older alias-like values (e.g. "claude-coder").
  */
 export function normalizeCodeAgent(agent) {
     if (!agent)
@@ -53,16 +68,25 @@ export function normalizeCodeAgent(agent) {
         return 'claude';
     if (value === 'codex' || value.startsWith('codex'))
         return 'codex';
-    if (value === 'kimi' || value.startsWith('kimi'))
-        return 'kimi';
     return null;
 }
 /**
  * Resolve requested/default agent selection to a supported CLI agent ID.
  * Preference order: explicit request -> configured default -> "claude".
- * If no agent is explicit and the model is a GPT/OpenAI model, auto-select codex.
- * If the model is a kimi model, auto-select kimi.
+ * If no agent is explicit and the model is a GPT/Codex model, auto-select codex.
  */
+/**
+ * Check if a model string is compatible with a given agent CLI.
+ * e.g. gpt-5.3-codex is NOT compatible with 'claude', claude-opus IS.
+ */
+export function isModelCompatibleWithAgent(model, agent) {
+    const m = model.toLowerCase();
+    if (agent === 'codex') {
+        return /^(gpt|codex|o[134]|openai\/)/i.test(m);
+    }
+    // claude: compatible if NOT a known non-Claude model
+    return !/^(gpt|codex|o[134]|openai\/)/i.test(m);
+}
 export function resolveSelectedCodeAgent(requestedAgent, defaultAgent, model) {
     // If no explicit agent was requested, infer from model
     if (!requestedAgent && model) {
@@ -70,8 +94,6 @@ export function resolveSelectedCodeAgent(requestedAgent, defaultAgent, model) {
         if (m.includes('gpt') || m.includes('codex') || m.startsWith('openai/') || m.startsWith('o1') || m.startsWith('o3') || m.startsWith('o4')) {
             return 'codex';
         }
-        if (m.includes('kimi'))
-            return 'kimi';
     }
     const candidate = requestedAgent || defaultAgent || 'claude';
     return normalizeCodeAgent(candidate);
@@ -85,6 +107,41 @@ export function setCodeAgentConfig(config) {
 export function getCodeAgentConfig() {
     return _codeAgentConfig;
 }
+function stripProviderPrefix(model) {
+    return model.includes('/') ? model.split('/').slice(1).join('/') : model;
+}
+/** Read Claude Code's configured default model, if present. */
+export function readClaudeCodeDefaultModel(settingsPath = join(homedir(), '.claude', 'settings.json')) {
+    try {
+        if (!existsSync(settingsPath))
+            return undefined;
+        const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+        const model = settings?.model;
+        return typeof model === 'string' && model.trim() ? model.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Resolve the model text shown in dashboards/reports without changing CLI args. */
+export function resolveCodeAgentModelLabel(agent, model) {
+    if (model)
+        return stripProviderPrefix(model);
+    const normalizedAgent = normalizeCodeAgent(agent);
+    if (normalizedAgent === 'claude') {
+        const defaultModel = readClaudeCodeDefaultModel();
+        return defaultModel ? `${defaultModel} default` : 'claude default';
+    }
+    if (normalizedAgent === 'codex')
+        return 'codex default';
+    return `${agent || 'agent'} default`;
+}
+export function withCodeAgentModelLabel(task) {
+    return {
+        ...task,
+        modelLabel: task.modelLabel || resolveCodeAgentModelLabel(task.agent, task.model),
+    };
+}
 /** Build CLI args for code_with_agent. Exported for testing. */
 export function buildCodeAgentArgs(input) {
     const agent = input.agent || 'claude';
@@ -101,51 +158,32 @@ export function buildCodeAgentArgs(input) {
             args.push('-C', input.workdir);
         if (input.model)
             args.push('-m', input.model);
+        if (input.effort)
+            args.push('-c', `model_reasoning_effort=${input.effort}`);
         args.push(input.task);
         return { cmd: CODEX_CLI_PATH, args };
     }
-    if (agent === 'kimi') {
-        const args = [
-            '--yolo',
-            '-p', input.task,
-        ];
-        if (input.workdir)
-            args.push('-w', input.workdir);
-        if (input.model)
-            args.push('-m', input.model);
-        return { cmd: KIMI_CLI_PATH, args };
-    }
     // Default: claude
     // Each --allowedTools flag takes one tool name — repeat the flag per tool
     // --allowedTools restricts which tools are available (not just permissions).
-    // Include Playwright MCP tools so the agent can use the browser.
-    const allowedTools = ['Edit', 'Read', 'Write', 'Bash', 'Glob', 'Grep', 'mcp__playwright__*'];
+    const allowedTools = ['Edit', 'Read', 'Write', 'Bash', 'Glob', 'Grep'];
     const toolArgs = allowedTools.flatMap(t => ['--allowedTools', t]);
-    // Pass Playwright MCP server so coding agents share SkimpyClaw's browser profile
-    // Must use chromium (not chrome) to match SkimpyClaw's browser-tool.ts persistent context
-    const playwrightMcp = JSON.stringify({
-        mcpServers: {
-            playwright: {
-                command: 'npx',
-                args: ['-y', '@playwright/mcp@latest', '--browser', 'chromium',
-                    '--user-data-dir', join(homedir(), '.skimpyclaw', 'browser-profile'),
-                    '--caps', 'vision'],
-            },
-        },
-    });
     const args = [
         '-p',
         '--verbose',
         '--output-format', 'stream-json',
         '--dangerously-skip-permissions',
-        '--mcp-config', playwrightMcp,
         ...toolArgs,
         '--max-turns', maxTurns,
         '--append-system-prompt', `Output text only. Never use say or TTS. Focus on the coding task. Run ${buildValidationCommand(input.workdir || process.cwd())} to verify changes.`,
     ];
+    // Interactive mode: pin this turn to a known session UUID so follow-ups can --resume it.
+    if (input.sessionId) {
+        args.push('--session-id', input.sessionId);
+    }
     // Only pass model to Claude CLI if it's not a known non-Claude model.
-    // GPT/Codex/Kimi/o-series models would be rejected by the Claude CLI.
-    if (input.model && !/^(gpt|codex|kimi|o[134]|openai\/)/i.test(input.model)) {
+    // GPT/Codex/o-series models would be rejected by the Claude CLI.
+    if (input.model && !/^(gpt|codex|o[134]|openai\/)/i.test(input.model)) {
         args.push('--model', input.model);
     }
     args.push(input.task);
@@ -157,42 +195,6 @@ export function formatDuration(seconds) {
         return '?';
     return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
 }
-/** Build notification for a team-coordinator task with child results. */
-export function buildTeamNotification(task, getChildTask) {
-    const dur = formatDuration(task.durationSeconds);
-    const taskPreview = task.task.length > 100 ? task.task.slice(0, 100) + '...' : task.task;
-    const statusIcon = task.status === 'completed' ? '✅' : task.status === 'timeout' ? '⏰' : '❌';
-    const validation = task.validationPassed ? ' Tests pass.' : '';
-    const lines = [];
-    lines.push(`${statusIcon} Team ${task.id} ${task.status} (${dur}).${validation}`);
-    lines.push(`Task: ${taskPreview}`);
-    // Per-child summary
-    const childIds = task.childTaskIds || [];
-    if (childIds.length > 0) {
-        lines.push('');
-        for (const childId of childIds) {
-            const child = getChildTask(childId);
-            if (!child)
-                continue;
-            const childIcon = child.status === 'completed' ? '✅' : child.status === 'failed' ? '❌' : child.status === 'timeout' ? '⏰' : '❓';
-            const childDur = formatDuration(child.durationSeconds);
-            const subtask = (child.subtask || child.task || '').slice(0, 80);
-            lines.push(`  ${childIcon} ${child.id} (${childDur}): ${subtask}`);
-        }
-    }
-    // Synthesis result
-    if (task.outputPreview) {
-        lines.push(`\nResult: ${task.outputPreview}`);
-    }
-    // Errors
-    if (task.error && task.error !== 'Validation failed') {
-        lines.push(`\nError: ${task.error}`);
-    }
-    if (task.validationOutput) {
-        lines.push(`\nValidation:\n${task.validationOutput.slice(0, 800)}`);
-    }
-    return lines.join('\n');
-}
 /** Build notification for a single code agent. */
 export function buildSoloNotification(task) {
     const dur = formatDuration(task.durationSeconds);
@@ -219,30 +221,282 @@ export function buildSoloNotification(task) {
         return message;
     }
 }
+function shorten(value, maxChars) {
+    const trimmed = value.trim();
+    if (trimmed.length <= maxChars)
+        return trimmed;
+    return `${trimmed.slice(0, maxChars - 3).trim()}...`;
+}
+function normalizeOutputPaths(value, workdir) {
+    if (!value)
+        return value;
+    const normalizedWorkdir = workdir.replace(/\/+$/, '');
+    if (!normalizedWorkdir)
+        return value;
+    return value
+        .split(`${normalizedWorkdir}/`).join('')
+        .split(normalizedWorkdir).join('.');
+}
+function extractStreamJsonText(line) {
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (!event || typeof event !== 'object' || typeof event.type !== 'string') {
+        return null;
+    }
+    if ((event.type === 'output_text' || event.output_text) && (event.output_text || event.text)) {
+        return String(event.output_text || event.text).trim() || null;
+    }
+    if (event.type === 'result' && typeof event.result === 'string') {
+        return event.result.trim() || null;
+    }
+    if ((event.type === 'item.completed' || event.type === 'item.delta') && event.item?.type === 'agent_message' && event.item?.text) {
+        return String(event.item.text).trim() || null;
+    }
+    return '';
+}
+function looksLikeRawStreamJson(line) {
+    const trimmed = line.trim();
+    return trimmed.startsWith('{') && /"type"\s*:|"item"\s*:|"thread_id"\s*:/.test(trimmed);
+}
+function stripStreamJsonNoise(value) {
+    const lines = value.split('\n');
+    const cleaned = [];
+    let sawStreamJson = false;
+    for (const line of lines) {
+        const extracted = extractStreamJsonText(line);
+        if (extracted !== null) {
+            sawStreamJson = true;
+            if (extracted)
+                cleaned.push(extracted);
+            continue;
+        }
+        if (looksLikeRawStreamJson(line)) {
+            sawStreamJson = true;
+            continue;
+        }
+        cleaned.push(line);
+    }
+    const result = cleaned.join('\n').trim();
+    return sawStreamJson ? result : value.trim();
+}
+function normalizeHeading(line) {
+    const normalized = line
+        .trim()
+        .replace(/^#{1,6}\s*/, '')
+        .replace(/^\*\*/, '')
+        .replace(/\*\*$/, '')
+        .replace(/:$/, '')
+        .trim()
+        .toLowerCase();
+    const allowed = new Set(['decision', 'summary', 'findings', 'risk checks', 'tests', 'recommendation']);
+    return allowed.has(normalized) ? normalized : null;
+}
+function extractReportSections(value) {
+    const sections = {};
+    let current = 'summary';
+    for (const line of value.split('\n')) {
+        const heading = normalizeHeading(line);
+        if (heading) {
+            current = heading;
+            sections[current] ||= [];
+            continue;
+        }
+        sections[current] ||= [];
+        sections[current].push(line);
+    }
+    return Object.fromEntries(Object.entries(sections)
+        .map(([key, lines]) => [key, lines.join('\n').trim()])
+        .filter(([, text]) => text));
+}
+function firstMeaningfulLines(value, maxChars) {
+    const lines = value
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean)
+        .filter(line => !looksLikeRawStreamJson(line))
+        .filter(line => !/^i('|’)ll\b/i.test(line))
+        .filter(line => !/^i am\b/i.test(line));
+    return shorten(lines.join('\n'), maxChars);
+}
+function formatAgentDisplay(task) {
+    const agent = task.agent === 'team-coordinator' ? 'TEAM' : task.agent.toUpperCase();
+    const model = task.modelLabel || resolveCodeAgentModelLabel(task.agent, task.model);
+    const effort = task.effort ? ` · effort ${task.effort}` : '';
+    return `${agent} · ${model}${effort}`;
+}
+function buildReportMarkdown(task, result) {
+    const validation = task.validationPassed === true
+        ? 'pass'
+        : task.validationPassed === false
+            ? 'fail'
+            : 'not run';
+    return [
+        `# Code Agent ${task.id}`,
+        '',
+        `- Status: ${task.status}`,
+        `- Agent: ${task.agent}`,
+        `- Model: ${task.modelLabel || resolveCodeAgentModelLabel(task.agent, task.model)}`,
+        `- Effort: ${task.effort || 'default'}`,
+        `- Duration: ${formatDuration(task.durationSeconds)}`,
+        `- Validation: ${validation}`,
+        `- Workdir: ${task.workdir}`,
+        task.sourceWorkdir ? `- Source Workdir: ${task.sourceWorkdir}` : '',
+        task.worktreePath ? `- Worktree: ${task.worktreePath}` : '',
+        task.worktreeCleanup ? `- Worktree Cleanup: ${task.worktreeCleanup.status}${task.worktreeCleanup.reason ? ` (${task.worktreeCleanup.reason})` : ''}` : '',
+        '',
+        '## Task',
+        '',
+        task.task,
+        '',
+        '## Result',
+        '',
+        result || task.error || '(No result captured.)',
+        task.validationOutput ? `\n## Validation Output\n\n${task.validationOutput}` : '',
+    ].filter(Boolean).join('\n');
+}
+function buildDiscordResultSummary(task, result) {
+    if (!result.trim())
+        return task.error ? `Error: ${shorten(task.error, 700)}` : '';
+    const sections = extractReportSections(result);
+    const lines = [];
+    const decision = sections.decision || sections.recommendation;
+    if (decision) {
+        lines.push(`**Decision**\n${shorten(firstMeaningfulLines(decision, 450), 450)}`);
+    }
+    if (sections.findings) {
+        lines.push(`**Findings**\n${shorten(firstMeaningfulLines(sections.findings, 650), 650)}`);
+    }
+    if (sections['risk checks']) {
+        lines.push(`**Risk Checks**\n${shorten(firstMeaningfulLines(sections['risk checks'], 420), 420)}`);
+    }
+    if (sections.tests) {
+        lines.push(`**Tests**\n${shorten(firstMeaningfulLines(sections.tests, 240), 240)}`);
+    }
+    if (lines.length > 0)
+        return lines.join('\n\n');
+    return shorten(firstMeaningfulLines(result, 950), 950);
+}
+export function buildCodeAgentDiscordNotification(task) {
+    const dur = formatDuration(task.durationSeconds);
+    const icon = task.status === 'completed' ? '✅' : task.status === 'timeout' ? '⏰' : '❌';
+    const status = task.status === 'completed'
+        ? 'completed'
+        : task.status === 'timeout'
+            ? 'timed out'
+            : 'failed';
+    const validation = task.validationPassed === true
+        ? 'Build/tests pass'
+        : task.validationPassed === false
+            ? 'Build/tests failed'
+            : task.status === 'completed'
+                ? 'Validation not run'
+                : undefined;
+    const rawResult = normalizeOutputPaths(stripStreamJsonNoise(task.outputPreview || task.liveOutput || task.validationOutput || task.error || ''), task.workdir);
+    const taskPreview = normalizeOutputPaths(shorten(task.task, 350), task.workdir);
+    const summary = buildDiscordResultSummary(task, rawResult);
+    const contentParts = [
+        `${icon} \`${task.id}\` ${status} · ${formatAgentDisplay(task)} · ${dur}`,
+        validation ? `**Validation:** ${validation}` : undefined,
+        task.retryCount ? `**Retries:** ${task.retryCount}` : undefined,
+        `**Task:** ${taskPreview}`,
+        summary ? `\n${summary}` : undefined,
+    ].filter(Boolean);
+    const needsAttachment = rawResult.length > 1_200 || task.validationOutput || task.task.length > 350;
+    const attachment = needsAttachment
+        ? {
+            name: `${task.id}-report.md`,
+            description: `Full report for ${task.id}`,
+            content: buildReportMarkdown(task, rawResult),
+        }
+        : undefined;
+    const content = [
+        contentParts.join('\n'),
+        attachment ? '\nFull report attached.' : undefined,
+    ].filter(Boolean).join('\n');
+    return { content, attachment };
+}
+function resolveDiscordThreadId(task) {
+    return task.discordThreadId;
+}
+function resolveDiscordChannelId(task) {
+    return task.discordChannelId;
+}
+/**
+ * Try to send a notification to a Discord thread associated with this task.
+ * Returns true if successfully sent to thread.
+ */
+async function trySendToDiscordThread(task, notification) {
+    const threadId = resolveDiscordThreadId(task);
+    if (!threadId)
+        return false;
+    try {
+        const { sendToDiscordThread, sendToDiscordThreadWithAttachments } = await import('../channels/discord/index.js');
+        const sent = notification.attachment
+            ? await sendToDiscordThreadWithAttachments(threadId, notification.content, [notification.attachment])
+            : await sendToDiscordThread(threadId, notification.content);
+        if (sent) {
+            console.log(`[code-agent] Notification for ${task.id} sent to thread ${threadId}`);
+        }
+        return sent;
+    }
+    catch (err) {
+        console.error(`[code-agent] Failed to send to Discord thread for ${task.id}:`, err);
+        return false;
+    }
+}
+/**
+ * Try to send a notification to the originating Discord channel for this task.
+ * Returns true if successfully sent to channel.
+ */
+async function trySendToDiscordChannel(task, notification) {
+    const channelId = resolveDiscordChannelId(task);
+    if (!channelId)
+        return false;
+    try {
+        const { sendDiscordProactiveMessage, sendDiscordProactiveMessageWithAttachments } = await import('../channels/discord/index.js');
+        if (notification.attachment) {
+            await sendDiscordProactiveMessageWithAttachments(channelId, notification.content, [notification.attachment]);
+        }
+        else {
+            await sendDiscordProactiveMessage(channelId, notification.content);
+        }
+        console.log(`[code-agent] Notification for ${task.id} sent to Discord channel ${channelId}`);
+        return true;
+    }
+    catch (err) {
+        console.error(`[code-agent] Failed to send to Discord channel for ${task.id}:`, err);
+        return false;
+    }
+}
+function hasDiscordRouting(task) {
+    return !!(resolveDiscordThreadId(task) || resolveDiscordChannelId(task));
+}
 /** Send auto-notification to active channel on completion/failure. */
-export async function notifyCodeAgentResult(task, getChildTask) {
+export async function notifyCodeAgentResult(task) {
     if (!_codeAgentConfig)
         return;
     const { sendActiveChannelProactiveMessage } = await import('../channels.js');
-    let message;
-    // Team coordinator gets a structured notification
-    if (task.agent === 'team-coordinator') {
-        message = buildTeamNotification(task, getChildTask);
+    const message = buildSoloNotification(task);
+    const discordNotification = buildCodeAgentDiscordNotification(task);
+    // Prefer task-scoped Discord routing over global active-channel fallback.
+    const threadSent = await trySendToDiscordThread(task, discordNotification);
+    const channelSent = threadSent ? true : await trySendToDiscordChannel(task, discordNotification);
+    if (!threadSent && !channelSent && !hasDiscordRouting(task)) {
         const sent = await sendActiveChannelProactiveMessage(_codeAgentConfig, message).catch((err) => {
-            console.error(`[code-agent] Failed to send team notification for ${task.id}:`, err);
+            console.error(`[code-agent] Failed to send notification for ${task.id}:`, err);
             return false;
         });
         if (!sent)
-            console.warn(`[code-agent] Team notification not delivered for ${task.id} (no active channel or target)`);
-        return;
+            console.warn(`[code-agent] Notification not delivered for ${task.id} (no active channel or target)`);
+    }
+    else if (!threadSent && !channelSent) {
+        console.warn(`[code-agent] Notification not delivered for ${task.id} (Discord thread/channel unavailable)`);
     }
-    message = buildSoloNotification(task);
-    const sent = await sendActiveChannelProactiveMessage(_codeAgentConfig, message).catch((err) => {
-        console.error(`[code-agent] Failed to send notification for ${task.id}:`, err);
-        return false;
-    });
-    if (!sent)
-        console.warn(`[code-agent] Notification not delivered for ${task.id} (no active channel or target)`);
 }
 /** Check workdir against allowed paths. */
 export function resolveWorkdir(rawWorkdir, projects, skimpyclawRoot) {
@@ -269,9 +523,8 @@ export function resolveModelAlias(model, aliases) {
     if (/^claude[-.]3[-.]5[-.]haiku(?:[-_.].*)?$/i.test(model)) {
         return 'claude-haiku-4-5';
     }
+    if (/^claude[-.]opus[-.]4[-_.]6$/i.test(model)) {
+        return 'claude-opus-4-6';
+    }
     return model;
 }
-/** @deprecated Removed — old Claude CLI team state reader. Kept for backward compat. */
-export function readTeamState() {
-    return null;
-}

package/dist/code-agents/worktrees.d.ts

@@ -0,0 +1,37 @@
+export type CodeAgentWorktreeMode = 'off' | 'auto' | 'always';
+export type CodeAgentWorktreeRequest = boolean | 'auto' | undefined;
+export interface CodeAgentWorktreeConfig {
+    enabled?: boolean;
+    mode?: CodeAgentWorktreeMode;
+    root?: string;
+    cleanup?: boolean;
+}
+export interface PreparedCodeAgentWorktree {
+    sourceWorkdir: string;
+    worktreePath: string;
+    runWorkdir: string;
+    worktreeRef: string;
+    gitRoot: string;
+}
+export interface CodeAgentWorktreeCleanupResult {
+    status: 'removed' | 'preserved' | 'skipped' | 'failed';
+    path?: string;
+    reason?: string;
+    at: string;
+}
+export declare function normalizeWorktreeRequest(value: unknown): CodeAgentWorktreeRequest;
+export declare function shouldAutoWorktreeTask(task: string): boolean;
+export declare function shouldUseCodeAgentWorktree(task: string, request: CodeAgentWorktreeRequest, config?: CodeAgentWorktreeConfig): boolean;
+export declare function findGitRoot(workdir: string): string | null;
+export declare function prepareCodeAgentWorktree(options: {
+    id: string;
+    sourceWorkdir: string;
+    config?: CodeAgentWorktreeConfig;
+    required?: boolean;
+}): PreparedCodeAgentWorktree | undefined;
+export declare function cleanupCodeAgentWorktree(options: {
+    sourceWorkdir?: string;
+    worktreePath?: string;
+    worktreeRef?: string;
+    config?: CodeAgentWorktreeConfig;
+}): CodeAgentWorktreeCleanupResult;