skimpyclaw 0.3.14 → 0.4.0

package/dist/code-agents/interactive-resume.js

@@ -0,0 +1,98 @@
+// Runs a single --resume turn against a live interactive coding session.
+// Called from the Discord thread-message handler when it detects a user message
+// in a thread that is mapped to an active interactive session.
+import { spawn } from 'child_process';
+import { CLAUDE_CLI_PATH, buildCodeAgentSpawnEnv } from './utils.js';
+import { enqueue, dequeue, markIdle, getSession, touchActivity, updateStatus } from './interactive-sessions.js';
+import { chunkForDiscord } from './stream-formatter.js';
+export async function handleInteractiveThreadMessage(opts) {
+    const { discordThreadId, userMessage, postToThread } = opts;
+    const session = getSession(discordThreadId);
+    if (!session)
+        return; // not ours — normal handler will take it
+    if (session.status !== 'active') {
+        await postToThread([`⚠ this session is ${session.status}; start a new interactive \`code_with_agent\` call to begin again`]);
+        return;
+    }
+    const { shouldStart } = enqueue(discordThreadId, userMessage);
+    if (!shouldStart)
+        return;
+    try {
+        for (;;) {
+            const pending = dequeue(discordThreadId);
+            if (!pending)
+                break;
+            try {
+                const stdout = await runClaudeResumeSubprocess(session.cliSessionId, pending.content);
+                touchActivity(discordThreadId);
+                const chunks = chunkForDiscord(stdout);
+                if (chunks.length > 0)
+                    await postToThread(chunks);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                updateStatus(discordThreadId, 'errored');
+                await postToThread([`✗ subprocess crashed: ${msg.slice(0, 500)}`]);
+                // Drain the rest of the queue so stranded messages don't sit forever.
+                // The session is errored — emit a single notice instead of retrying.
+                let dropped = 0;
+                while (dequeue(discordThreadId))
+                    dropped++;
+                if (dropped > 0) {
+                    await postToThread([`(dropped ${dropped} queued message${dropped === 1 ? '' : 's'} because the session errored)`]);
+                }
+                return;
+            }
+        }
+    }
+    finally {
+        markIdle(discordThreadId);
+    }
+}
+function runClaudeResumeSubprocess(cliSessionId, message) {
+    return new Promise((resolve, reject) => {
+        const env = buildCodeAgentSpawnEnv();
+        const args = [
+            '-p',
+            '--resume', cliSessionId,
+            '--dangerously-skip-permissions',
+            message,
+        ];
+        const msgPreview = message.length > 80 ? message.slice(0, 80) + '...' : message;
+        console.log(`[interactive-resume] spawn: claude -p --resume ${cliSessionId} "${msgPreview}"`);
+        const proc = spawn(CLAUDE_CLI_PATH, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env,
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', chunk => { stdout += chunk.toString(); });
+        proc.stderr.on('data', chunk => { stderr += chunk.toString(); });
+        // Safety: 10min cap per turn.
+        const timer = setTimeout(() => {
+            try {
+                proc.kill('SIGTERM');
+            }
+            catch { /* best effort */ }
+            reject(new Error('resume turn timed out after 10m'));
+        }, 10 * 60 * 1000);
+        proc.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve(stdout);
+            }
+            else if (stdout) {
+                // Non-zero exit but we still have output — surface it but log the failure.
+                console.warn(`[interactive-resume] claude exited ${code}; returning partial stdout (${stdout.length} chars). stderr: ${stderr.slice(0, 200)}`);
+                resolve(stdout);
+            }
+            else {
+                reject(new Error(`claude exited with code ${code}: ${stderr.slice(0, 500)}`));
+            }
+        });
+        proc.on('error', (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}

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

@@ -0,0 +1,20 @@
+import type { InteractiveSession, InteractiveSessionStatus } from '../types.js';
+interface PendingMessage {
+    content: string;
+    receivedAt: string;
+}
+export declare function addSession(s: InteractiveSession): void;
+export declare function getSession(discordThreadId: string): InteractiveSession | undefined;
+export declare function updateStatus(discordThreadId: string, status: InteractiveSessionStatus): void;
+export declare function touchActivity(discordThreadId: string): void;
+export declare function listSessions(): InteractiveSession[];
+export declare function enqueue(discordThreadId: string, content: string): {
+    shouldStart: boolean;
+};
+export declare function dequeue(discordThreadId: string): PendingMessage | undefined;
+export declare function markIdle(discordThreadId: string): void;
+export declare function hasPending(discordThreadId: string): boolean;
+export declare function addPendingSession(codeAgentTaskId: string, s: Omit<InteractiveSession, 'discordThreadId'>): void;
+export declare function linkThread(codeAgentTaskId: string, discordThreadId: string): boolean;
+export declare function _resetForTesting(): void;
+export {};

package/dist/code-agents/interactive-sessions.js

@@ -0,0 +1,132 @@
+// Interactive coding session state store.
+//
+// Maps Discord thread IDs to running CLI sessions (claude --session-id or
+// codex thread_id). Persisted to disk so sessions survive gateway restarts.
+// Per-session FIFO queue prevents concurrent --resume subprocesses against
+// the same session (which would corrupt history).
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+import { homedir } from 'os';
+import { join } from 'path';
+const STORE_PATH = join(homedir(), '.skimpyclaw', 'logs', 'code-agents', 'interactive-sessions.json');
+const sessions = new Map();
+const queues = new Map();
+// Pending sessions created before a Discord thread exists, keyed by coding-agent task ID.
+const pendingByTaskId = new Map();
+let loaded = false;
+function ensureLoaded() {
+    if (loaded)
+        return;
+    loaded = true;
+    if (!existsSync(STORE_PATH))
+        return;
+    try {
+        const raw = readFileSync(STORE_PATH, 'utf-8');
+        const parsed = JSON.parse(raw);
+        for (const s of parsed) {
+            sessions.set(s.discordThreadId, s);
+        }
+    }
+    catch (err) {
+        console.error('[interactive-sessions] Failed to load store:', err);
+    }
+}
+function persist() {
+    try {
+        mkdirSync(dirname(STORE_PATH), { recursive: true });
+        const arr = Array.from(sessions.values());
+        writeFileSync(STORE_PATH, JSON.stringify(arr, null, 2), 'utf-8');
+    }
+    catch (err) {
+        console.error('[interactive-sessions] Failed to persist store:', err);
+    }
+}
+export function addSession(s) {
+    ensureLoaded();
+    sessions.set(s.discordThreadId, s);
+    queues.set(s.discordThreadId, { inFlight: false, queue: [] });
+    persist();
+}
+export function getSession(discordThreadId) {
+    ensureLoaded();
+    return sessions.get(discordThreadId);
+}
+export function updateStatus(discordThreadId, status) {
+    ensureLoaded();
+    const s = sessions.get(discordThreadId);
+    if (!s)
+        return;
+    s.status = status;
+    s.lastActivityAt = new Date().toISOString();
+    persist();
+}
+export function touchActivity(discordThreadId) {
+    ensureLoaded();
+    const s = sessions.get(discordThreadId);
+    if (!s)
+        return;
+    s.lastActivityAt = new Date().toISOString();
+    persist();
+}
+export function listSessions() {
+    ensureLoaded();
+    return Array.from(sessions.values());
+}
+// `enqueue` returns shouldStart=true if the caller should begin draining;
+// false if a subprocess is already in flight and will pick up this message.
+export function enqueue(discordThreadId, content) {
+    ensureLoaded();
+    let q = queues.get(discordThreadId);
+    if (!q) {
+        q = { inFlight: false, queue: [] };
+        queues.set(discordThreadId, q);
+    }
+    q.queue.push({ content, receivedAt: new Date().toISOString() });
+    if (!q.inFlight) {
+        q.inFlight = true;
+        return { shouldStart: true };
+    }
+    return { shouldStart: false };
+}
+export function dequeue(discordThreadId) {
+    const q = queues.get(discordThreadId);
+    if (!q)
+        return undefined;
+    return q.queue.shift();
+}
+export function markIdle(discordThreadId) {
+    const q = queues.get(discordThreadId);
+    if (!q)
+        return;
+    q.inFlight = false;
+}
+export function hasPending(discordThreadId) {
+    const q = queues.get(discordThreadId);
+    if (!q)
+        return false;
+    return q.queue.length > 0;
+}
+// Register a session that doesn't yet have a Discord thread. Keyed by the
+// coding-agent task ID; the Discord handler re-keys by threadId via linkThread().
+export function addPendingSession(codeAgentTaskId, s) {
+    ensureLoaded();
+    pendingByTaskId.set(codeAgentTaskId, { ...s, discordThreadId: '' });
+}
+export function linkThread(codeAgentTaskId, discordThreadId) {
+    ensureLoaded();
+    const pending = pendingByTaskId.get(codeAgentTaskId);
+    if (!pending)
+        return false;
+    const full = { ...pending, discordThreadId };
+    sessions.set(discordThreadId, full);
+    queues.set(discordThreadId, { inFlight: false, queue: [] });
+    pendingByTaskId.delete(codeAgentTaskId);
+    persist();
+    return true;
+}
+export function _resetForTesting() {
+    sessions.clear();
+    queues.clear();
+    pendingByTaskId.clear();
+    loaded = false;
+}

package/dist/code-agents/parser.js

@@ -181,9 +181,13 @@ export function parseClaudeOutput(stdout) {
 export function parseCodexOutput(stdout) {
     const lines = stdout.trim().split('\n');
     const outputs = [];
+    let sawJsonEvent = false;
     for (const line of lines) {
         try {
             const obj = JSON.parse(line);
+            if (obj && typeof obj === 'object' && typeof obj.type === 'string') {
+                sawJsonEvent = true;
+            }
             // Standard output_text events
             if (obj.type === 'output_text' || obj.output_text) {
                 outputs.push(obj.output_text || obj.text || '');
@@ -198,5 +202,5 @@ export function parseCodexOutput(stdout) {
                 outputs.push(line);
         }
     }
-    return outputs.join('\n') || stdout || '(no output)';
+    return outputs.join('\n') || (sawJsonEvent ? '(no text output)' : stdout) || '(no output)';
 }

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

@@ -15,13 +15,19 @@ export declare function getAllCodeAgents(): CodeAgentTask[];
 export declare function getCodeAgent(id: string): CodeAgentTask | null;
 /** Store a task in the registry. */
 export declare function storeCodeAgentTask(task: CodeAgentTask): void;
+/**
+ * Find tasks spawned from a specific chat/channel that don't have a discordThreadId yet.
+ * Used by Discord handler to retroactively assign threads after runAgentTurn.
+ * Includes non-running tasks to handle fast-completing agents (race condition fix).
+ */
+export declare function getUnthreadedTasksForChat(chatId: number): CodeAgentTask[];
 /** Get the canceller function for a task. */
 export declare function getCodeAgentCanceller(id: string): (() => void) | undefined;
 /** Set the canceller function for a task. */
 export declare function setCodeAgentCanceller(id: string, canceller: () => void): void;
 /** Delete the canceller function for a task. */
 export declare function deleteCodeAgentCanceller(id: string): void;
-/** Cancel a running/pending code agent. For team coordinators, cascades to children. */
+/** Cancel a running/pending code agent. */
 export declare function cancelCodeAgent(id: string): CodeAgentTask | null;
 /** Restore code agent tasks from disk on startup. */
 export declare function restoreCodeAgentTasks(): void;

package/dist/code-agents/registry.js

@@ -57,6 +57,15 @@ export function getCodeAgent(id) {
 export function storeCodeAgentTask(task) {
     codeAgentTasks.set(task.id, task);
 }
+/**
+ * Find tasks spawned from a specific chat/channel that don't have a discordThreadId yet.
+ * Used by Discord handler to retroactively assign threads after runAgentTurn.
+ * Includes non-running tasks to handle fast-completing agents (race condition fix).
+ */
+export function getUnthreadedTasksForChat(chatId) {
+    return Array.from(codeAgentTasks.values()).filter(t => t.chatId === chatId &&
+        !t.discordThreadId);
+}
 /** Get the canceller function for a task. */
 export function getCodeAgentCanceller(id) {
     return codeAgentCancellers.get(id);
@@ -69,7 +78,7 @@ export function setCodeAgentCanceller(id, canceller) {
 export function deleteCodeAgentCanceller(id) {
     codeAgentCancellers.delete(id);
 }
-/** Cancel a running/pending code agent. For team coordinators, cascades to children. */
+/** Cancel a running/pending code agent. */
 export function cancelCodeAgent(id) {
     const task = codeAgentTasks.get(id);
     if (!task)
@@ -77,27 +86,6 @@ export function cancelCodeAgent(id) {
     const isTerminal = ['completed', 'failed', 'timeout', 'cancelled'].includes(task.status);
     if (isTerminal)
         return task;
-    for (const childId of task.childTaskIds || []) {
-        const child = codeAgentTasks.get(childId);
-        if (!child)
-            continue;
-        const childTerminal = ['completed', 'failed', 'timeout', 'cancelled'].includes(child.status);
-        if (childTerminal)
-            continue;
-        const childCanceller = codeAgentCancellers.get(childId);
-        if (childCanceller) {
-            try {
-                childCanceller();
-            }
-            catch { /* best effort */ }
-        }
-        child.status = 'cancelled';
-        child.endedAt = new Date().toISOString();
-        child.durationSeconds = Math.round((Date.now() - new Date(child.startedAt).getTime()) / 1000);
-        child.error = 'Cancelled by user';
-        child.liveOutput = undefined;
-        writeCodeAgentTask(child);
-    }
     const canceller = codeAgentCancellers.get(id);
     if (canceller) {
         try {
@@ -118,7 +106,7 @@ export function restoreCodeAgentTasks() {
     try {
         if (!existsSync(CODE_AGENTS_DIR))
             return;
-        const files = readdirSync(CODE_AGENTS_DIR).filter(f => f.endsWith('.json'));
+        const files = readdirSync(CODE_AGENTS_DIR).filter(f => /^ca-\d+\.json$/.test(f));
         let maxCounter = 0;
         for (const file of files) {
             try {

package/dist/code-agents/stream-formatter.d.ts

@@ -0,0 +1,8 @@
+export declare function stripAnsi(s: string): string;
+export declare function chunkForDiscord(raw: string, max?: number): string[];
+export interface CodexParseResult {
+    threadId?: string;
+    messages: string[];
+}
+export declare function parseCodexJsonl(stdout: string): CodexParseResult;
+export declare function formatCodexOutput(messages: string[]): string[];

package/dist/code-agents/stream-formatter.js

@@ -0,0 +1,92 @@
+// Stream formatter for interactive coding sessions.
+//
+// Converts raw CLI stdout into Discord-postable message chunks.
+// - Claude: plain text; strip ANSI; paragraph-aware chunking at <=1900 chars
+// - Codex: JSONL stream; emit agent_message text as messages; condense tool calls
+const MAX_CHUNK = 1900; // Discord hard limit is 2000; 100 char safety margin
+export function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+}
+// Paragraph-aware chunking: splits on blank-line runs, packs up to max, and
+// hard-splits any paragraph that alone exceeds the limit.
+export function chunkForDiscord(raw, max = MAX_CHUNK) {
+    const text = stripAnsi(raw).replace(/\r\n/g, '\n').trimEnd();
+    if (!text)
+        return [];
+    if (text.length <= max)
+        return [text];
+    const paragraphs = text.split(/\n{2,}/);
+    const chunks = [];
+    let current = '';
+    for (const p of paragraphs) {
+        if (p.length > max) {
+            // Paragraph too big by itself — flush current, then hard-split this paragraph.
+            if (current) {
+                chunks.push(current);
+                current = '';
+            }
+            for (let i = 0; i < p.length; i += max) {
+                chunks.push(p.slice(i, i + max));
+            }
+            continue;
+        }
+        const candidate = current ? current + '\n\n' + p : p;
+        if (candidate.length > max) {
+            chunks.push(current);
+            current = p;
+        }
+        else {
+            current = candidate;
+        }
+    }
+    if (current)
+        chunks.push(current);
+    return chunks;
+}
+export function parseCodexJsonl(stdout) {
+    const lines = stdout.split('\n').map(l => l.trim()).filter(Boolean);
+    const messages = [];
+    let threadId;
+    for (const line of lines) {
+        let ev;
+        try {
+            ev = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (ev.type === 'thread.started' && typeof ev.thread_id === 'string') {
+            threadId = ev.thread_id;
+            continue;
+        }
+        if (ev.type === 'item.completed' && ev.item) {
+            const item = ev.item;
+            if (item.type === 'agent_message' && typeof item.text === 'string' && item.text) {
+                messages.push(item.text);
+                continue;
+            }
+            if (item.type === 'command_execution') {
+                const cmd = typeof item.command === 'string' ? item.command : 'command';
+                const status = item.status === 'completed' ? '✓' : item.status === 'failed' ? '✗' : '…';
+                const trimmed = cmd.length > 80 ? cmd.slice(0, 80) + '…' : cmd;
+                messages.push(`\`[${status} ${trimmed}]\``);
+                continue;
+            }
+            if (item.type === 'file_change' && Array.isArray(item.changes)) {
+                const paths = item.changes.map((c) => c?.path).filter(Boolean).join(', ');
+                messages.push(`\`[edit ✓ ${paths}]\``);
+                continue;
+            }
+        }
+        // Ignore turn.started, turn.completed, and other low-signal events
+    }
+    return { threadId, messages };
+}
+export function formatCodexOutput(messages) {
+    const chunks = [];
+    for (const m of messages) {
+        chunks.push(...chunkForDiscord(m));
+    }
+    return chunks;
+}

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

@@ -1,10 +1,12 @@
-import type { SandboxConfig } from '../types.js';
+import type { CodeAgentWorktreeCleanupResult, CodeAgentWorktreeConfig } from './worktrees.js';
 export interface CodeAgentTask {
     id: string;
     agent: string;
     task: string;
     status: 'running' | 'validating' | 'completed' | 'failed' | 'timeout' | 'pending' | 'cancelled';
     chatId?: number;
+    discordThreadId?: string;
+    discordChannelId?: string;
     startedAt: string;
     endedAt?: string;
     durationSeconds?: number;
@@ -15,24 +17,22 @@ export interface CodeAgentTask {
     liveOutput?: string;
     error?: string;
     workdir: string;
+    sourceWorkdir?: string;
+    worktreePath?: string;
+    worktreeRef?: string;
+    worktreeCleanup?: CodeAgentWorktreeCleanupResult;
     model?: string;
+    modelLabel?: string;
+    effort?: string;
     retryCount?: number;
     totalCost?: number;
     inputTokens?: number;
     outputTokens?: number;
-    parentTaskId?: string;
-    childTaskIds?: string[];
-    subtask?: string;
-    synthesisResult?: string;
-    dependsOn?: number[];
-    wave?: number;
-}
-export interface DecomposedSubtask {
-    description: string;
-    dependsOn: number[];
+    interactive?: boolean;
+    cliSessionId?: string;
 }
 export interface CodeAgentBackgroundOptions {
-    /** Extra env vars to set (e.g. CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS) */
+    /** Extra env vars to set on the spawned CLI process */
     env?: Record<string, string>;
     /** Override args builder (returns { cmd, args } instead of buildCodeAgentArgs) */
     buildArgs?: () => {
@@ -43,31 +43,23 @@ export interface CodeAgentBackgroundOptions {
     defaultTimeoutMinutes?: number;
     /** Max timeout in minutes (overrides 30min cap) */
     maxTimeoutMinutes?: number;
-    /** Skip sending notification on completion (parent handles it) */
-    skipNotification?: boolean;
     /** Per-project validation command overrides from config */
     validationCommands?: Record<string, string>;
-    /** Sandbox configuration — when enabled, run CLI inside container */
-    sandboxConfig?: SandboxConfig;
-    /** Paths to mount into the sandbox container */
-    allowedPaths?: string[];
+    /** Worktree cleanup config */
+    worktreeConfig?: CodeAgentWorktreeConfig;
 }
 export interface BuildCodeAgentArgsInput {
     task: string;
     agent?: string;
     workdir?: string;
     model?: string;
+    effort?: string;
     max_turns?: number;
+    sessionId?: string;
 }
 export interface ValidationResult {
     passed: boolean;
     output: string;
 }
-export interface ChildResult {
-    subtask: string;
-    status: string;
-    output?: string;
-    error?: string;
-}
 export declare const CODE_AGENT_TIMEOUT_MS: number;
 export declare const VALIDATE_TIMEOUT_MS: number;

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

@@ -1,24 +1,42 @@
 import type { BuildCodeAgentArgsInput, CodeAgentTask } from './types.js';
 import type { Config } from '../types.js';
+export declare const CLAUDE_CLI_PATH: string;
+/**
+ * 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 declare function buildCodeAgentSpawnEnv(base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** Return supported coding CLIs currently available on PATH. */
-export declare function getAvailableCodingCliTools(commandChecker?: (name: string) => boolean): Array<'codex' | 'claude' | 'kimi'>;
+export declare function getAvailableCodingCliTools(commandChecker?: (name: string) => boolean): Array<'codex' | 'claude'>;
 /** Return preflight error when no supported coding CLI is installed. */
 export declare function getCodingCliPreflightError(commandChecker?: (name: string) => boolean): string | null;
 /**
  * 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 declare function normalizeCodeAgent(agent: string | undefined): 'claude' | 'codex' | 'kimi' | null;
+export declare function normalizeCodeAgent(agent: string | undefined): 'claude' | 'codex' | 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 declare function resolveSelectedCodeAgent(requestedAgent: string | undefined, defaultAgent: string | undefined, model?: string): 'claude' | 'codex' | 'kimi' | null;
+export declare function isModelCompatibleWithAgent(model: string, agent: 'claude' | 'codex'): boolean;
+export declare function resolveSelectedCodeAgent(requestedAgent: string | undefined, defaultAgent: string | undefined, model?: string): 'claude' | 'codex' | null;
 /** Set the config reference used for auto-notifications on completion. */
 export declare function setCodeAgentConfig(config: Config): void;
 export declare function getCodeAgentConfig(): Config | null;
+/** Read Claude Code's configured default model, if present. */
+export declare function readClaudeCodeDefaultModel(settingsPath?: string): string | undefined;
+/** Resolve the model text shown in dashboards/reports without changing CLI args. */
+export declare function resolveCodeAgentModelLabel(agent: string | undefined, model?: string): string;
+export declare function withCodeAgentModelLabel(task: CodeAgentTask): CodeAgentTask;
 /** Build CLI args for code_with_agent. Exported for testing. */
 export declare function buildCodeAgentArgs(input: BuildCodeAgentArgsInput): {
     cmd: string;
@@ -26,15 +44,21 @@ export declare function buildCodeAgentArgs(input: BuildCodeAgentArgsInput): {
 };
 /** Format duration as human-readable string. */
 export declare function formatDuration(seconds: number | undefined): string;
-/** Build notification for a team-coordinator task with child results. */
-export declare function buildTeamNotification(task: CodeAgentTask, getChildTask: (id: string) => CodeAgentTask | null): string;
 /** Build notification for a single code agent. */
 export declare function buildSoloNotification(task: CodeAgentTask): string;
+interface CodeAgentDiscordNotification {
+    content: string;
+    attachment?: {
+        name: string;
+        content: string;
+        description?: string;
+    };
+}
+export declare function buildCodeAgentDiscordNotification(task: CodeAgentTask): CodeAgentDiscordNotification;
 /** Send auto-notification to active channel on completion/failure. */
-export declare function notifyCodeAgentResult(task: CodeAgentTask, getChildTask: (id: string) => CodeAgentTask | null): Promise<void>;
+export declare function notifyCodeAgentResult(task: CodeAgentTask): Promise<void>;
 /** Check workdir against allowed paths. */
 export declare function resolveWorkdir(rawWorkdir: string | undefined, projects: Record<string, string>, skimpyclawRoot: string): string;
 /** Resolve model alias to real model ID. */
 export declare function resolveModelAlias(model: string | undefined, aliases: Record<string, string> | undefined): string | undefined;
-/** @deprecated Removed — old Claude CLI team state reader. Kept for backward compat. */
-export declare function readTeamState(): null;
+export {};