skimpyclaw 0.3.14 → 0.4.0

package/dist/code-agents/executor.js

@@ -1,17 +1,29 @@
 // Code Agent Executor - Background execution logic
 import { spawn, exec, execSync } from 'child_process';
 import { createWriteStream, existsSync, readFileSync } from 'fs';
-import { join } from 'path';
+import { join, dirname } from 'path';
+/**
+ * Ensure PATH contains the directory of the running node binary. The claude /
+ * codex CLIs use `#!/usr/bin/env node` shebangs — when launchd-spawned processes
+ * inherit a minimal PATH, `env node` fails and spawn returns ENOENT.
+ */
+function ensureNodeInPath(env) {
+    const nodeDir = dirname(process.execPath);
+    const path = env.PATH ?? '';
+    if (!path.split(':').includes(nodeDir)) {
+        env.PATH = path ? `${nodeDir}:${path}` : nodeDir;
+    }
+}
 // SKIMPYCLAW_ROOT for log paths
 const SKIMPYCLAW_ROOT = join(import.meta.dirname || process.cwd(), '..', '..');
 import { toErrorMessage } from '../utils.js';
 import { VALIDATE_TIMEOUT_MS } from './types.js';
 import { getCodeAgentsDir, ensureCodeAgentsDir, writeCodeAgentTask, setCodeAgentCanceller, deleteCodeAgentCanceller, getCodeAgent, } from './registry.js';
-import { buildCodeAgentArgs, notifyCodeAgentResult } from './utils.js';
+import { buildCodeAgentArgs, buildCodeAgentSpawnEnv, notifyCodeAgentResult } from './utils.js';
+import { cleanupCodeAgentWorktree } from './worktrees.js';
 import { parseStreamJsonForLive, parseClaudeOutput, parseCodexOutput } from './parser.js';
 import { startTrace, addEvent, endTrace } from '../audit.js';
 import { buildUsageRecord, recordUsage } from '../usage.js';
-import { ensureContainer, SANDBOX_DEFAULTS, getRuntime } from '../sandbox/index.js';
 const CANCELLED_MESSAGE = 'Cancelled by user';
 /**
  * Detect the package manager for a project directory.
@@ -112,6 +124,11 @@ function getChangedPackageDirs(workdir) {
         return [];
     }
 }
+// Reject any value that could break out of an unquoted shell argument.
+// npm package names: optional "@scope/", then [a-zA-Z0-9._-]. Max 214 chars.
+const NPM_PKG_NAME_RE = /^(?:@[a-zA-Z0-9._-]+\/)?[a-zA-Z0-9._-]+$/;
+// Workspace directory paths derived from git: allow nested path segments only.
+const SAFE_PATH_RE = /^[a-zA-Z0-9._-]+(?:\/[a-zA-Z0-9._-]+)*$/;
 /**
  * Build scoped validation commands for a monorepo by detecting changed packages.
  * Returns a combined command that builds/tests only affected packages, or null
@@ -127,6 +144,11 @@ function buildMonorepoValidationCommand(workdir) {
     const pm = detectPackageManager(workdir);
     const parts = [];
     for (const dir of changedDirs) {
+        // Defence-in-depth: `dir` flows into shell command strings below.
+        if (!SAFE_PATH_RE.test(dir) || dir.length > 256) {
+            console.warn(`[validation] Skipping unsafe package dir: ${JSON.stringify(dir)}`);
+            continue;
+        }
         const pkgJsonPath = join(workdir, dir, 'package.json');
         if (!existsSync(pkgJsonPath))
             continue;
@@ -136,6 +158,13 @@ function buildMonorepoValidationCommand(workdir) {
             const scripts = pkg.scripts || {};
             if (!pkgName)
                 continue;
+            // pkgName comes from an untrusted package.json and is interpolated into
+            // a shell command executed by exec(). Enforce npm's legal name charset
+            // to prevent command injection via crafted "name" fields.
+            if (typeof pkgName !== 'string' || pkgName.length > 214 || !NPM_PKG_NAME_RE.test(pkgName)) {
+                console.warn(`[validation] Skipping package with unsafe name: ${JSON.stringify(pkgName)}`);
+                continue;
+            }
             // Build with workspace command
             if (scripts.build) {
                 if (pm === 'pnpm')
@@ -252,7 +281,7 @@ export function buildValidationCommand(workdir, validationCommands) {
     }
     return parts.join(' && ');
 }
-/** Run build/test validation. Shared by solo agents and team orchestrator. */
+/** Run build/test validation. */
 export function runValidation(workdir, validationCommands) {
     const cmd = buildValidationCommand(workdir, validationCommands);
     if (!cmd) {
@@ -323,7 +352,9 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             agent,
             workdir,
             model: input.model,
+            effort: input.effort,
             max_turns: input.max_turns,
+            sessionId: caTask.cliSessionId,
         });
     let stdout = '';
     let stderr = '';
@@ -331,29 +362,25 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
     const logPath = join(getCodeAgentsDir(), `${id}.log`);
     ensureCodeAgentsDir();
     const logStream = createWriteStream(logPath, { flags: 'w' });
-    logStream.write(`=== ${id} | ${agent} | ${new Date().toISOString()} ===\n`);
-    logStream.write(`Task: ${task.slice(0, 500)}\n`);
-    logStream.write(`Workdir: ${workdir}\n\n`);
+    let logStreamEnded = false;
+    const logWrite = (data) => { if (!logStreamEnded)
+        logStream.write(data); };
+    logWrite(`=== ${id} | ${agent} | ${new Date().toISOString()} ===\n`);
+    logWrite(`Task: ${task.slice(0, 500)}\n`);
+    logWrite(`Workdir: ${workdir}\n\n`);
+    if (caTask.sourceWorkdir)
+        logWrite(`Source workdir: ${caTask.sourceWorkdir}\n`);
+    if (caTask.worktreePath)
+        logWrite(`Worktree: ${caTask.worktreePath}\n`);
     try {
-        // Resolve sandbox container name if enabled (used for spawn wrapping)
-        let sandboxContainer;
-        if (options?.sandboxConfig?.enabled) {
-            const merged = { ...SANDBOX_DEFAULTS, ...options.sandboxConfig };
-            sandboxContainer = await ensureContainer(`code-${id}`, merged, options.allowedPaths || [workdir]);
-            console.log(`[code-agent] Running in sandbox container: ${sandboxContainer}`);
-        }
         ensureNotCancelled();
         const exitCode = await new Promise((resolvePromise, reject) => {
-            const spawnEnv = { ...process.env };
-            delete spawnEnv.CLAUDECODE;
-            // Apply extra env vars (e.g. team mode feature flag)
+            const spawnEnv = buildCodeAgentSpawnEnv();
+            ensureNodeInPath(spawnEnv);
             if (options?.env)
                 Object.assign(spawnEnv, options.env);
-            // When sandbox is enabled, wrap the spawn: container exec <name> <cmd> <args>
-            const spawnCmd = sandboxContainer ? getRuntime() : cmd;
-            const spawnArgs = sandboxContainer ? ['exec', sandboxContainer, cmd, ...args] : args;
-            const proc = spawn(spawnCmd, spawnArgs, {
-                cwd: sandboxContainer ? undefined : workdir, // container has its own cwd
+            const proc = spawn(cmd, args, {
+                cwd: workdir,
                 stdio: ['ignore', 'pipe', 'pipe'],
                 env: spawnEnv,
             });
@@ -362,7 +389,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             const STATUS_WRITE_INTERVAL = 3000;
             proc.stdout.on('data', (chunk) => {
                 stdout += chunk.toString();
-                logStream.write(chunk);
+                logWrite(chunk);
                 const now = Date.now();
                 if (now - lastStatusWrite > STATUS_WRITE_INTERVAL) {
                     lastStatusWrite = now;
@@ -375,7 +402,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             });
             proc.stderr.on('data', (chunk) => {
                 stderr += chunk.toString();
-                logStream.write(chunk);
+                logWrite(chunk);
                 const now = Date.now();
                 if (now - lastStatusWrite > STATUS_WRITE_INTERVAL) {
                     lastStatusWrite = now;
@@ -412,8 +439,11 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
                     clearTimeout(activeTimer);
                 activeTimer = null;
                 activeProc = null;
-                logStream.write(`\n=== EXIT ${code} | ${new Date().toISOString()} ===\n`);
-                logStream.end();
+                if (!logStreamEnded) {
+                    logStreamEnded = true;
+                    logStream.write(`\n=== EXIT ${code} | ${new Date().toISOString()} ===\n`);
+                    logStream.end();
+                }
                 if (cancelled || caTask.status === 'cancelled') {
                     reject(new Error(CANCELLED_MESSAGE));
                     return;
@@ -430,8 +460,11 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
                     clearTimeout(activeTimer);
                 activeTimer = null;
                 activeProc = null;
-                logStream.write(`\n=== ERROR: ${err.message} ===\n`);
-                logStream.end();
+                if (!logStreamEnded) {
+                    logStreamEnded = true;
+                    logStream.write(`\n=== ERROR: ${err.message} ===\n`);
+                    logStream.end();
+                }
                 reject(err);
             });
         });
@@ -479,8 +512,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
                 liveOutput: undefined,
             });
             writeCodeAgentTask(caTask);
-            if (!options?.skipNotification)
-                await notifyCodeAgentResult(caTask, (id) => getCodeAgent(id) ?? null);
+            await notifyCodeAgentResult(caTask);
             return;
         }
         // Post-validation gate
@@ -490,6 +522,25 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             caTask.liveOutput = undefined;
             writeCodeAgentTask(caTask);
             const validationCmd = buildValidationCommand(workdir, options?.validationCommands);
+            if (!validationCmd) {
+                // No build/test scripts — skip validation, mark complete
+                const endedAt = new Date();
+                const duration = Math.round((endedAt.getTime() - startedAt.getTime()) / 1000);
+                addEvent(traceId, { type: 'validation', summary: 'Skipped (no build/test scripts found)', durationMs: Date.now() - startedAt.getTime() });
+                await endTrace(traceId, 'ok');
+                Object.assign(caTask, {
+                    status: 'completed',
+                    endedAt: endedAt.toISOString(),
+                    durationSeconds: duration,
+                    exitCode,
+                    validationPassed: true,
+                    validationOutput: undefined,
+                    outputPreview: agentOutput.slice(0, 5000),
+                });
+                writeCodeAgentTask(caTask);
+                await notifyCodeAgentResult(caTask);
+                return;
+            }
             const runValidationPromise = () => new Promise((res) => {
                 const validationProc = exec(validationCmd, {
                     cwd: workdir,
@@ -531,15 +582,14 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
                     agent,
                     workdir,
                     model: input.model,
+                    effort: input.effort,
                     max_turns: input.max_turns,
                 });
                 const retryExitCode = await new Promise((resolveRetry, rejectRetry) => {
-                    const spawnEnv = { ...process.env };
-                    delete spawnEnv.CLAUDECODE;
-                    const retrySpawnCmd = sandboxContainer ? getRuntime() : retryCmd;
-                    const retrySpawnArgs = sandboxContainer ? ['exec', sandboxContainer, retryCmd, ...retryArgs] : retryArgs;
-                    const retryProc = spawn(retrySpawnCmd, retrySpawnArgs, {
-                        cwd: sandboxContainer ? undefined : workdir,
+                    const spawnEnv = buildCodeAgentSpawnEnv();
+                    ensureNodeInPath(spawnEnv);
+                    const retryProc = spawn(retryCmd, retryArgs, {
+                        cwd: workdir,
                         stdio: ['ignore', 'pipe', 'pipe'],
                         env: spawnEnv,
                     });
@@ -633,7 +683,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
                         }
                     }
                     else {
-                        agentOutput = stdout || '(no output)';
+                        agentOutput = parseCodexOutput(stdout);
                     }
                     caTask.status = 'validating';
                     caTask.liveOutput = undefined;
@@ -659,8 +709,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
                     error: 'Validation failed',
                 });
                 writeCodeAgentTask(caTask);
-                if (!options?.skipNotification)
-                    await notifyCodeAgentResult(caTask, (id) => getCodeAgent(id) ?? null);
+                await notifyCodeAgentResult(caTask);
                 return;
             }
             addEvent(traceId, { type: 'validation', summary: 'Build/test validation passed', durationMs: Date.now() - startedAt.getTime() });
@@ -675,8 +724,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
                 outputPreview: agentOutput.slice(0, 5000),
             });
             writeCodeAgentTask(caTask);
-            if (!options?.skipNotification)
-                await notifyCodeAgentResult(caTask, (id) => getCodeAgent(id) ?? null);
+            await notifyCodeAgentResult(caTask);
             return;
         }
         // No validation — mark complete
@@ -691,8 +739,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             liveOutput: undefined,
         });
         writeCodeAgentTask(caTask);
-        if (!options?.skipNotification)
-            await notifyCodeAgentResult(caTask, (id) => getCodeAgent(id) ?? null);
+        await notifyCodeAgentResult(caTask);
     }
     catch (err) {
         const errMsg = toErrorMessage(err);
@@ -710,8 +757,8 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             liveOutput: undefined,
         });
         writeCodeAgentTask(caTask);
-        if (!options?.skipNotification && caTask.status !== 'cancelled')
-            await notifyCodeAgentResult(caTask, getCodeAgent);
+        if (caTask.status !== "cancelled")
+            await notifyCodeAgentResult(caTask);
     }
     finally {
         if (activeTimer)
@@ -719,6 +766,15 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
         activeTimer = null;
         activeProc = null;
         activeExecProc = null;
+        if (caTask.worktreePath && !['running', 'validating', 'pending'].includes(caTask.status)) {
+            caTask.worktreeCleanup = cleanupCodeAgentWorktree({
+                sourceWorkdir: caTask.sourceWorkdir,
+                worktreePath: caTask.worktreePath,
+                worktreeRef: caTask.worktreeRef,
+                config: options?.worktreeConfig,
+            });
+            writeCodeAgentTask(caTask);
+        }
         deleteCodeAgentCanceller(id);
     }
 }

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

@@ -1,11 +1,10 @@
 import type { ToolConfig } from '../types.js';
 import type { ExecuteToolContext } from '../tools/execute-context.js';
-export type { CodeAgentTask, DecomposedSubtask, CodeAgentBackgroundOptions, BuildCodeAgentArgsInput, ValidationResult, ChildResult, } from './types.js';
+export type { CodeAgentTask, CodeAgentBackgroundOptions, BuildCodeAgentArgsInput, ValidationResult, } from './types.js';
 export { CODE_AGENT_TIMEOUT_MS, VALIDATE_TIMEOUT_MS } from './types.js';
 export { getActiveCodeAgents, getRecentCodeAgents, getAllCodeAgents, getCodeAgent, cancelCodeAgent, restoreCodeAgentTasks, getCodeAgentsDir, } from './registry.js';
 export { runCodeAgentBackground, runValidation } from './executor.js';
-export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, gatherCodebaseContext, } from './orchestrator.js';
-export { setCodeAgentConfig, getCodeAgentConfig, buildCodeAgentArgs, resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, readTeamState, } from './utils.js';
+export { setCodeAgentConfig, getCodeAgentConfig, buildCodeAgentArgs, resolveSelectedCodeAgent, resolveCodeAgentModelLabel, resolveWorkdir, resolveModelAlias, } from './utils.js';
 export { parseStreamJsonForLive, parseClaudeOutput, parseCodexOutput } from './parser.js';
 export type { ClaudeOutputResult } from './parser.js';
 /**
@@ -16,7 +15,3 @@ export declare function executeCheckCodeAgent(input: Record<string, any>): strin
  * Execute code_with_agent tool - single agent mode.
  */
 export declare function executeCodeWithAgent(input: Record<string, any>, config: ToolConfig, context?: ExecuteToolContext): Promise<string>;
-/**
- * Execute code_with_team tool - multi-agent team mode.
- */
-export declare function executeCodeWithTeam(input: Record<string, any>, config: ToolConfig, context?: ExecuteToolContext): Promise<string>;

package/dist/code-agents/index.js

@@ -1,25 +1,26 @@
 // Code Agents - Public API
 // Background multi-agent coding task execution
 import { resolve } from 'path';
+import { randomUUID } from 'crypto';
 import { isPathAllowed } from '../tools/path-utils.js';
 import { getNextCodeAgentId, storeCodeAgentTask, writeCodeAgentTask, getActiveCodeAgents, getRecentCodeAgents, getCodeAgent, } from './registry.js';
 import { runCodeAgentBackground } from './executor.js';
-import { runTeamOrchestrator } from './orchestrator.js';
-import { resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, getCodingCliPreflightError, } from './utils.js';
+import { addPendingSession } from './interactive-sessions.js';
+import { resolveSelectedCodeAgent, resolveCodeAgentModelLabel, isModelCompatibleWithAgent, resolveWorkdir, resolveModelAlias, getCodingCliPreflightError, } from './utils.js';
+import { normalizeWorktreeRequest, prepareCodeAgentWorktree, shouldUseCodeAgentWorktree, } from './worktrees.js';
 // Re-export timeout constants
 export { CODE_AGENT_TIMEOUT_MS, VALIDATE_TIMEOUT_MS } from './types.js';
 // Re-export registry functions
 export { getActiveCodeAgents, getRecentCodeAgents, getAllCodeAgents, getCodeAgent, cancelCodeAgent, restoreCodeAgentTasks, getCodeAgentsDir, } from './registry.js';
 // Re-export executor functions
 export { runCodeAgentBackground, runValidation } from './executor.js';
-// Re-export orchestrator functions
-export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, gatherCodebaseContext, } from './orchestrator.js';
 // Re-export utility functions
-export { setCodeAgentConfig, getCodeAgentConfig, buildCodeAgentArgs, resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, readTeamState, } from './utils.js';
+export { setCodeAgentConfig, getCodeAgentConfig, buildCodeAgentArgs, resolveSelectedCodeAgent, resolveCodeAgentModelLabel, resolveWorkdir, resolveModelAlias, } from './utils.js';
 // Re-export parser functions
 export { parseStreamJsonForLive, parseClaudeOutput, parseCodexOutput } from './parser.js';
 // SKIMPYCLAW_ROOT for workdir default
 const SKIMPYCLAW_ROOT = resolve(import.meta.dirname || process.cwd(), '..', '..');
+const EFFORT_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh']);
 /**
  * Execute check_code_agent tool — list all or get details for one agent.
  */
@@ -35,7 +36,12 @@ export function executeCheckCodeAgent(input) {
             status: task.status,
             task: task.task,
             workdir: task.workdir,
+            sourceWorkdir: task.sourceWorkdir,
+            worktreePath: task.worktreePath,
+            worktreeRef: task.worktreeRef,
             model: task.model,
+            modelLabel: task.modelLabel || resolveCodeAgentModelLabel(task.agent, task.model),
+            effort: task.effort,
             startedAt: task.startedAt,
             endedAt: task.endedAt,
             durationSeconds: task.durationSeconds,
@@ -58,7 +64,9 @@ export function executeCheckCodeAgent(input) {
             ? (t.durationSeconds < 60 ? `${t.durationSeconds}s` : `${Math.floor(t.durationSeconds / 60)}m`)
             : (Math.round((Date.now() - new Date(t.startedAt).getTime()) / 1000) + 's');
         const taskPreview = t.task.length > 60 ? t.task.slice(0, 60) + '...' : t.task;
-        return `${t.id}: ${t.status.toUpperCase()} (${t.agent}, ${elapsed}) — ${taskPreview}`;
+        const model = `, ${t.modelLabel || resolveCodeAgentModelLabel(t.agent, t.model)}`;
+        const effort = t.effort ? `, effort ${t.effort}` : '';
+        return `${t.id}: ${t.status.toUpperCase()} (${t.agent}${model}${effort}, ${elapsed}) — ${taskPreview}`;
     });
     return lines.join('\n');
 }
@@ -70,7 +78,7 @@ export async function executeCodeWithAgent(input, config, context) {
     if (!task)
         return 'Error: task is required';
     // Resolve model alias first so agent auto-selection can inspect it.
-    // Fall back to current session model so codex/kimi models auto-select the right CLI.
+    // Fall back to current session model so Codex models auto-select the right CLI.
     let rawModel = input.model;
     if (!rawModel) {
         try {
@@ -84,7 +92,42 @@ export async function executeCodeWithAgent(input, config, context) {
     const requestedAgent = input.agent;
     const agent = resolveSelectedCodeAgent(requestedAgent, configDefault, resolvedModel);
     if (!agent) {
-        return `Error: Invalid agent "${requestedAgent}". Must be claude, codex, or kimi.`;
+        return `Error: Invalid agent "${requestedAgent}". Must be claude or codex.`;
+    }
+    // Interactive mode prerequisites: Discord server channel (NOT DM) + claude only.
+    // Discord DMs do not support threads, which interactive mode requires.
+    const isInteractive = input.interactive === true;
+    if (isInteractive) {
+        if (context?.channel !== 'discord') {
+            return 'Error: interactive mode requires Discord. Telegram and other channels are not supported yet.';
+        }
+        if (context?.isDm === true) {
+            return 'Error: interactive mode requires a Discord server channel. Direct messages do not support threads. Please move to a server channel and try again.';
+        }
+        if (agent !== 'claude' && agent !== 'codex') {
+            return `Error: interactive mode supports claude and codex only (requested: ${agent}).`;
+        }
+        if (agent === 'codex') {
+            return 'Error: interactive mode for codex is not yet implemented. Use claude for now.';
+        }
+    }
+    // Don't pass a non-matching session model to a different agent CLI.
+    // e.g. if session is gpt-5.3-codex but agent is claude, let claude use its own default.
+    const isModelFromSession = !input.model;
+    const modelIncompatible = isModelFromSession && resolvedModel && !isModelCompatibleWithAgent(resolvedModel, agent);
+    const modelForAgent = modelIncompatible ? undefined : resolvedModel;
+    const effortInput = typeof input.effort === 'string'
+        ? input.effort
+        : typeof input.thinking === 'string'
+            ? input.thinking
+            : typeof input.reasoning_effort === 'string'
+                ? input.reasoning_effort
+                : undefined;
+    const effort = effortInput
+        ? effortInput.trim().toLowerCase().replace(/^x[-_ ]?high$/, 'xhigh')
+        : undefined;
+    if (effort && !EFFORT_LEVELS.has(effort)) {
+        return `Error: Invalid effort "${effortInput}". Use none, low, medium, high, or xhigh.`;
     }
     const projects = context?.fullConfig?.projects ?? {};
     const rawWorkdir = input.workdir;
@@ -112,96 +155,84 @@ export async function executeCodeWithAgent(input, config, context) {
     // Create task with unique ID
     const id = getNextCodeAgentId();
     const startedAt = new Date();
+    const worktreeRequest = normalizeWorktreeRequest(input.worktree);
+    const worktreeConfig = context?.fullConfig?.codeAgents?.worktrees;
+    const useWorktree = shouldUseCodeAgentWorktree(task, worktreeRequest, worktreeConfig);
+    const worktreeRequired = worktreeRequest === true || worktreeConfig?.mode === 'always';
+    let executionWorkdir = workdir;
+    let sourceWorkdir;
+    let worktreePath;
+    let worktreeRef;
+    let agentTask = task;
+    if (useWorktree) {
+        try {
+            const worktree = prepareCodeAgentWorktree({
+                id,
+                sourceWorkdir: workdir,
+                config: worktreeConfig,
+                required: worktreeRequired,
+            });
+            if (worktree) {
+                executionWorkdir = worktree.runWorkdir;
+                sourceWorkdir = worktree.sourceWorkdir;
+                worktreePath = worktree.worktreePath;
+                worktreeRef = worktree.worktreeRef;
+                agentTask = `${task}\n\nSkimpyClaw worktree isolation:\n- Source checkout: ${sourceWorkdir}\n- Isolated worktree: ${worktreePath}\n- Run all repository commands from the isolated worktree, not the source checkout.\n- If rebasing a branch that is already checked out elsewhere, create a temporary branch in this worktree and report before pushing.`;
+            }
+        }
+        catch (err) {
+            return `Error: ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    // Interactive mode: generate session UUID up-front so --session-id can pin it.
+    const cliSessionId = (isInteractive && agent === 'claude') ? randomUUID() : undefined;
     const caTask = {
         id,
         agent,
         task,
         status: 'running',
         chatId: context?.chatId,
+        discordThreadId: context?.discordThreadId,
+        discordChannelId: context?.discordChannelId,
         startedAt: startedAt.toISOString(),
-        workdir,
-        model: resolvedModel,
+        workdir: executionWorkdir,
+        sourceWorkdir,
+        worktreePath,
+        worktreeRef,
+        model: modelForAgent,
+        modelLabel: resolveCodeAgentModelLabel(agent, modelForAgent),
+        effort,
+        interactive: isInteractive || undefined,
+        cliSessionId,
     };
     storeCodeAgentTask(caTask);
     writeCodeAgentTask(caTask);
+    // Register a pending interactive session keyed by the task ID.
+    // The Discord thread-creation handler will call linkThread(taskId, threadId)
+    // to promote it into the threadId-keyed map so follow-up messages work.
+    if (isInteractive && cliSessionId) {
+        addPendingSession(id, {
+            cliSessionId,
+            cliAgent: agent,
+            status: 'active',
+            createdAt: startedAt.toISOString(),
+            lastActivityAt: startedAt.toISOString(),
+            initialTask: task,
+        });
+    }
     // Fire-and-forget: spawn background process
     const configTimeout = context?.fullConfig?.codeAgents?.timeoutMinutes ?? 30;
     const soloTimeout = Math.min(input.timeout_minutes || configTimeout, 60);
-    const resolvedInput = { ...input, model: resolvedModel, timeout_minutes: soloTimeout };
-    runCodeAgentBackground(id, agent, task, workdir, validate, resolvedInput, startedAt, {
+    const resolvedInput = { ...input, model: modelForAgent, effort, timeout_minutes: soloTimeout };
+    runCodeAgentBackground(id, agent, agentTask, executionWorkdir, validate, resolvedInput, startedAt, {
         defaultTimeoutMinutes: soloTimeout,
         maxTimeoutMinutes: 60,
         validationCommands: context?.fullConfig?.codeAgents?.validationCommands,
+        worktreeConfig,
     }).catch((err) => {
         console.error(`[code-agent] Background error for ${id}:`, err);
     });
     const taskPreview = task.length > 100 ? task.slice(0, 100) + '...' : task;
-    return `Started coding agent ${id} (${agent}). Task: ${taskPreview}\n\nUse check_code_agent to poll status.`;
-}
-/**
- * Execute code_with_team tool - multi-agent team mode.
- */
-export async function executeCodeWithTeam(input, config, context) {
-    const task = input.task;
-    if (!task)
-        return 'Error: task is required';
-    // Resolve model alias. Only fall back to session model when an explicit model
-    // was requested — otherwise the session model (e.g. gpt-5.3-codex) would
-    // override agent selection even when the user wants claude.
-    const rawTeamModel = input.model;
-    const resolvedModel = rawTeamModel
-        ? resolveModelAlias(rawTeamModel, context?.fullConfig?.models?.aliases)
-        : undefined;
-    const configDefault = context?.fullConfig?.codeAgents?.defaultAgent || 'claude';
-    const requestedAgent = input.agent;
-    const agent = resolveSelectedCodeAgent(requestedAgent, configDefault, resolvedModel);
-    if (!agent) {
-        return `Error: Invalid agent "${requestedAgent}". Must be claude, codex, or kimi.`;
-    }
-    const teamSize = Math.max(2, Math.min(5, input.team_size || 3));
-    const projects = context?.fullConfig?.projects ?? {};
-    const rawWorkdir = input.workdir;
-    // Resolve project name → path
-    const workdir = resolveWorkdir(rawWorkdir, projects, SKIMPYCLAW_ROOT);
-    // Project paths are always allowed
-    const projectPaths = Object.values(projects).map(p => resolve(p));
-    const effectiveAllowedPaths = [...config.allowedPaths, ...projectPaths];
-    if (!isPathAllowed(workdir, effectiveAllowedPaths)) {
-        const projectNames = Object.keys(projects).length > 0
-            ? ` (or project names: ${Object.keys(projects).join(', ')})`
-            : '';
-        return `Error: Working directory not allowed. Permitted: ${config.allowedPaths.join(', ')}${projectNames}`;
-    }
-    const validate = input.validate !== false;
-    // Concurrency check — need room for teamSize children
-    const maxConcurrent = context?.fullConfig?.codeAgents?.maxConcurrent ?? 5;
-    const activeCount = getActiveCodeAgents().length;
-    if (activeCount + teamSize > maxConcurrent) {
-        return `Error: Concurrency limit — need ${teamSize} slots but only ${maxConcurrent - activeCount} available (${activeCount}/${maxConcurrent} running). Wait for agents to finish.`;
-    }
-    const cliPreflightError = getCodingCliPreflightError();
-    if (cliPreflightError)
-        return cliPreflightError;
-    // Create parent task
-    const id = getNextCodeAgentId();
-    const startedAt = new Date();
-    const caTask = {
-        id,
-        agent: 'team-coordinator',
-        task,
-        status: 'running',
-        chatId: context?.chatId,
-        startedAt: startedAt.toISOString(),
-        workdir,
-        model: resolvedModel,
-        childTaskIds: [],
-    };
-    storeCodeAgentTask(caTask);
-    writeCodeAgentTask(caTask);
-    // Fire-and-forget: orchestrator decomposes, spawns children, monitors, synthesizes
-    runTeamOrchestrator(id, task, teamSize, workdir, validate, agent, resolvedModel, startedAt, context).catch((err) => {
-        console.error(`[code-team] Background error for ${id}:`, err);
-    });
-    const taskPreview = task.length > 100 ? task.slice(0, 100) + '...' : task;
-    return `Started coding team ${id} (${teamSize} parallel ${agent} agents). Task: ${taskPreview}\n\nUse check_code_agent to poll status.`;
+    const worktreeLine = worktreePath ? `\nWorktree: ${worktreePath}` : '';
+    return `Started coding agent ${id} (${agent}). Task: ${taskPreview}${worktreeLine}\n\nUse check_code_agent to poll status.`;
 }

package/dist/code-agents/interactive-resume.d.ts

@@ -0,0 +1,6 @@
+export interface ResumeOptions {
+    discordThreadId: string;
+    userMessage: string;
+    postToThread: (chunks: string[]) => Promise<void>;
+}
+export declare function handleInteractiveThreadMessage(opts: ResumeOptions): Promise<void>;