skimpyclaw 0.3.6 → 0.3.8

package/dist/__tests__/structured-context.test.js

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { parseAgentOutput, formatStructuredContext } from '../code-agents/structured-context.js';
+describe('parseAgentOutput', () => {
+    it('returns empty files and errors for plain text', () => {
+        const result = parseAgentOutput('Everything looks good.');
+        expect(result.summary).toBe('Everything looks good.');
+        expect(result.files).toEqual([]);
+        expect(result.errors).toEqual([]);
+    });
+    it('extracts backtick-quoted file paths', () => {
+        const raw = 'Updated `src/agent.ts` and `src/types.ts` to add the new field.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).toContain('src/agent.ts');
+        expect(result.files).toContain('src/types.ts');
+    });
+    it('extracts absolute file paths', () => {
+        const raw = 'Wrote changes to /Users/katre/Sites/skimpyclaw/src/agent.ts successfully.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).toContain('/Users/katre/Sites/skimpyclaw/src/agent.ts');
+    });
+    it('ignores backtick tokens without dots (not file paths)', () => {
+        const raw = 'Call `myFunction` and `anotherMethod` to do the work.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).toEqual([]);
+    });
+    it('ignores backtick tokens with spaces (commands, not paths)', () => {
+        const raw = 'Run `pnpm build && pnpm test` to verify.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).toEqual([]);
+    });
+    it('extracts error lines', () => {
+        const raw = 'Build completed.\nError: Cannot find module src/missing.js\nAll tests passed.';
+        const result = parseAgentOutput(raw);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toContain('Cannot find module');
+    });
+    it('caps errors at 5', () => {
+        const lines = Array.from({ length: 10 }, (_, i) => `Error: problem ${i}`).join('\n');
+        const result = parseAgentOutput(lines);
+        expect(result.errors.length).toBeLessThanOrEqual(5);
+    });
+    it('caps files at 15', () => {
+        const lines = Array.from({ length: 20 }, (_, i) => `Updated \`src/file${i}.ts\`.`).join('\n');
+        const result = parseAgentOutput(lines);
+        expect(result.files.length).toBeLessThanOrEqual(15);
+    });
+    it('deduplicates file paths', () => {
+        const raw = 'Updated `src/agent.ts`. Also modified `src/agent.ts` again.';
+        const result = parseAgentOutput(raw);
+        const count = result.files.filter(f => f === 'src/agent.ts').length;
+        expect(count).toBe(1);
+    });
+    it('truncates summary to 500 chars', () => {
+        const raw = 'x'.repeat(1000);
+        const result = parseAgentOutput(raw);
+        expect(result.summary).toHaveLength(500);
+    });
+    it('strips trailing punctuation from absolute paths', () => {
+        const raw = 'Modified /src/foo.ts, and /src/bar.ts.';
+        const result = parseAgentOutput(raw);
+        expect(result.files).not.toContain('/src/foo.ts,');
+        expect(result.files).not.toContain('/src/bar.ts.');
+    });
+});
+describe('formatStructuredContext', () => {
+    it('formats summary only when no files or errors', () => {
+        const result = formatStructuredContext({ summary: 'Done.', files: [], errors: [] });
+        expect(result).toBe('Summary: Done.');
+    });
+    it('includes files line when files present', () => {
+        const result = formatStructuredContext({
+            summary: 'Updated auth.',
+            files: ['src/auth.ts', 'src/types.ts'],
+            errors: [],
+        });
+        expect(result).toContain('Files: src/auth.ts, src/types.ts');
+    });
+    it('includes errors line when errors present', () => {
+        const result = formatStructuredContext({
+            summary: 'Build failed.',
+            files: [],
+            errors: ['Error: missing export'],
+        });
+        expect(result).toContain('Errors: Error: missing export');
+    });
+    it('separates multiple errors with pipe', () => {
+        const result = formatStructuredContext({
+            summary: 'Done.',
+            files: [],
+            errors: ['Error: foo', 'Error: bar'],
+        });
+        expect(result).toContain('Error: foo | Error: bar');
+    });
+    it('produces a shorter output than raw 1000-char input', () => {
+        const raw = 'x'.repeat(1000);
+        const parsed = parseAgentOutput(raw);
+        const formatted = formatStructuredContext(parsed);
+        expect(formatted.length).toBeLessThan(raw.length);
+    });
+});

package/dist/__tests__/tools.test.js

@@ -59,6 +59,42 @@ describe('getToolDefinitions', () => {
         const tools = await getToolDefinitions();
         expect(tools.map(t => t.name)).not.toContain('Browser');
     });
+    describe('tool profiles', () => {
+        it('minimal returns exactly 4 built-in tools', async () => {
+            const config = { ...toolConfig, toolProfile: 'minimal' };
+            const tools = await getToolDefinitions(config, { includeAgentTools: true, includeMcp: true });
+            expect(tools).toHaveLength(4);
+            expect(tools.map(t => t.name)).toEqual(['Read', 'Write', 'Glob', 'Bash']);
+        });
+        it('minimal excludes Browser even when browser.enabled is true', async () => {
+            const config = { ...toolConfig, toolProfile: 'minimal', browser: { enabled: true } };
+            const tools = await getToolDefinitions(config);
+            expect(tools.map(t => t.name)).not.toContain('Browser');
+        });
+        it('minimal excludes MCP tools', async () => {
+            const config = { ...toolConfig, toolProfile: 'minimal' };
+            const tools = await getToolDefinitions(config, { includeMcp: true });
+            expect(tools.every(t => !t.name.startsWith('mcp__'))).toBe(true);
+        });
+        it('coding includes code_with_agent and check_code_agent but not code_with_team', async () => {
+            const config = { ...toolConfig, toolProfile: 'coding' };
+            const tools = await getToolDefinitions(config, { includeAgentTools: true });
+            const names = tools.map(t => t.name);
+            expect(names).toContain('code_with_agent');
+            expect(names).toContain('check_code_agent');
+            expect(names).not.toContain('code_with_team');
+        });
+        it('coding excludes MCP tools', async () => {
+            const config = { ...toolConfig, toolProfile: 'coding' };
+            const tools = await getToolDefinitions(config, { includeMcp: true });
+            expect(tools.every(t => !t.name.startsWith('mcp__'))).toBe(true);
+        });
+        it('full profile behaves like default (no profile set)', async () => {
+            const defaultTools = await getToolDefinitions(toolConfig);
+            const fullTools = await getToolDefinitions({ ...toolConfig, toolProfile: 'full' });
+            expect(fullTools.map(t => t.name)).toEqual(defaultTools.map(t => t.name));
+        }, 15000);
+    });
 });
 describe('tool name mapping', () => {
     it('maps Claude Code names to internal names', () => {
@@ -192,6 +228,32 @@ describe('bash', () => {
         const result = await executeTool('delete_everything', {}, toolConfig);
         expect(result).toContain('Error: Unknown tool');
     });
+    describe('exec approval in unattended contexts', () => {
+        it('fast-denies tier 3 inline interpreter scripts in subagent context', async () => {
+            const result = await executeTool('Bash', { command: 'node -e "console.log(1)"' }, toolConfig, { channel: 'subagent' });
+            expect(result).toContain('⛔');
+            expect(result).toContain('tier 3');
+            expect(result).not.toContain('approved');
+        });
+        it('fast-denies tier 2 commands in subagent context', async () => {
+            const result = await executeTool('Bash', { command: 'gh pr review --approve' }, toolConfig, { channel: 'subagent' });
+            expect(result).toContain('⛔');
+            expect(result).toContain('tier 2');
+        });
+        it('fast-denies tier 3 commands in cron context', async () => {
+            const result = await executeTool('Bash', { command: 'node -e "console.log(1)"' }, toolConfig, { isCronJob: true });
+            expect(result).toContain('⛔');
+            expect(result).toContain('tier 3');
+        });
+        it('fast-denies when no approver and no chatId', async () => {
+            const result = await executeTool('Bash', { command: 'kubectl delete pods --all' }, toolConfig, {});
+            expect(result).toContain('⛔');
+        });
+        it('allows safe tier 0 commands in subagent context', async () => {
+            const result = await executeTool('Bash', { command: 'echo hello' }, toolConfig, { channel: 'subagent' });
+            expect(result.trim()).toBe('hello');
+        });
+    });
 });
 describe('browser', () => {
     const browserDisabledConfig = {
@@ -286,7 +348,7 @@ describe('code_with_agent', () => {
             expect(props).toContain('validate');
         });
         it('is included in getToolDefinitions when includeSpawnSubagent is true', async () => {
-            const tools = await getToolDefinitions(toolConfig, { includeSpawnSubagent: true });
+            const tools = await getToolDefinitions(toolConfig, { includeAgentTools: true });
             expect(tools.map(t => t.name)).toContain('code_with_agent');
         });
         it('is excluded from getToolDefinitions when includeSpawnSubagent is false', async () => {
@@ -401,7 +463,7 @@ describe('code_with_agent', () => {
             expect(CHECK_CODE_AGENT_TOOL.input_schema.properties).toHaveProperty('id');
         });
         it('is included in getToolDefinitions when includeSpawnSubagent is true', async () => {
-            const tools = await getToolDefinitions(toolConfig, { includeSpawnSubagent: true });
+            const tools = await getToolDefinitions(toolConfig, { includeAgentTools: true });
             expect(tools.map(t => t.name)).toContain('check_code_agent');
         });
         it('is excluded from getToolDefinitions when includeSpawnSubagent is false', async () => {
@@ -453,7 +515,7 @@ describe('code_with_team', () => {
             expect(props).not.toContain('max_turns');
         });
         it('is included in getToolDefinitions when includeSpawnSubagent is true', async () => {
-            const tools = await getToolDefinitions(toolConfig, { includeSpawnSubagent: true });
+            const tools = await getToolDefinitions(toolConfig, { includeAgentTools: true });
             expect(tools.map(t => t.name)).toContain('code_with_team');
         });
         it('is excluded from getToolDefinitions when includeSpawnSubagent is false', async () => {

package/dist/agent.js

@@ -1,8 +1,9 @@
 // Agent runner: loads templates, calls models, manages memory
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, unlinkSync } from 'fs';
 import { join } from 'path';
 import { getAgentDir } from './config.js';
 import { buildSafeSystemPrompt, sanitizeUserInput } from './security.js';
+import { toErrorMessage } from './utils.js';
 import { startTrace, endTrace } from './audit.js';
 import { loadSkills, getSkillsForContext, formatSkillsPrompt } from './skills.js';
 import { getLangfuseConfig, isLangfuseEnabled } from './langfuse.js';
@@ -73,9 +74,7 @@ export function appendToMemory(agentId, entry) {
     }
     const path = getTodayMemoryPath(agentId);
     const timestamp = new Date().toISOString();
-    const content = existsSync(path) ? readFileSync(path, 'utf-8') : '';
-    const newContent = content + `\n## ${timestamp}\n\n${entry}\n`;
-    writeFileSync(path, newContent.trim() + '\n');
+    appendFileSync(path, `\n## ${timestamp}\n\n${entry}\n`, 'utf-8');
 }
 // --- Agent Turn ---
 // Langfuse app tagging
@@ -230,7 +229,7 @@ export async function runAgentTurn(agentId, userMessage, config, modelOverride,
             return result;
         }
         catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
+            const errorMessage = toErrorMessage(err);
             agentObs.update({
                 level: 'ERROR',
                 statusMessage: errorMessage,

package/dist/api.js

@@ -1,14 +1,13 @@
 // Dashboard API endpoints
 import { readFileSync, writeFileSync, existsSync, readdirSync, statSync, mkdirSync, rmSync } from 'fs';
-import { timingSafeEqual } from 'crypto';
+import { validateBearerToken } from './utils.js';
 import { join, basename, resolve } from 'path';
 import { homedir } from 'os';
-import { loadConfig, loadRawConfig, saveConfig, getSessionsDir, getLogsDir, getAgentDir, listMemoryFiles, readMemoryFile, } from './config.js';
+import { loadConfig, loadRawConfig, saveConfig, getSessionsDir, getLogsDir, getAgentDir, isValidAgentId, listMemoryFiles, readMemoryFile, } from './config.js';
 import { TEMPLATE_FILES, getAgentTemplateContent, saveAgentTemplate, } from './agent.js';
 import { getCronJobs, getCronJobDetails, runCronJob } from './cron.js';
 import { getCurrentModel, setCurrentModel, getLastMessage, setGatewayConfig } from './gateway.js';
 import { redactSecrets } from './security.js';
-import { getActiveTasks, getRecentTasks } from './subagent.js';
 import { readAuditTraces } from './audit.js';
 import { getUsageSummary, readUsageRecords } from './usage.js';
 import { getAllCodeAgents, getCodeAgent, cancelCodeAgent } from './tools.js';
@@ -36,10 +35,7 @@ const DEFAULT_MODEL_ALIASES = {
 function validateFilename(filename) {
     return !filename.includes('..') && filename === basename(filename);
 }
-function validateAgentId(agentId) {
-    // Agent IDs should be simple identifiers: alphanumeric, hyphens, underscores
-    return /^[a-zA-Z0-9_-]+$/.test(agentId);
-}
+// Use isValidAgentId from config.ts
 function validateSkillName(name) {
     return /^[a-zA-Z0-9-]+$/.test(name) && name.length <= 100;
 }
@@ -98,30 +94,14 @@ export function registerDashboardAPI(fastify, config) {
         if (!token) {
             return; // No token configured, allow access
         }
-        const authHeader = request.headers.authorization;
-        if (!authHeader || !authHeader.startsWith('Bearer ')) {
-            return reply.code(401).send({ error: 'Unauthorized: Bearer token required' });
-        }
-        const providedToken = authHeader.slice(7);
-        // Timing-safe comparison to prevent token extraction via timing attacks
-        const tokenBuf = Buffer.from(token, 'utf8');
-        const providedBuf = Buffer.from(providedToken, 'utf8');
-        if (tokenBuf.length !== providedBuf.length || !timingSafeEqual(tokenBuf, providedBuf)) {
-            return reply.code(401).send({ error: 'Unauthorized: Invalid token' });
+        if (!validateBearerToken(token, request.headers.authorization)) {
+            return reply.code(401).send({ error: 'Unauthorized: Invalid or missing token' });
         }
     });
     // --- Status ---
     fastify.get('/api/dashboard/status', async () => {
         const jobs = getCronJobs();
         const uptime = process.uptime();
-        const activeTasks = getActiveTasks();
-        const recentTasks = getRecentTasks(20);
-        const pendingCount = activeTasks.filter(t => t.status === 'pending').length;
-        const runningCount = activeTasks.filter(t => t.status === 'running').length;
-        const recentCompleted = recentTasks.filter(t => t.status === 'completed').length;
-        const recentFailed = recentTasks.filter(t => t.status === 'failed').length;
-        const recentCancelled = recentTasks.filter(t => t.status === 'cancelled').length;
-        const maxConcurrent = runtimeConfig.subagents?.maxConcurrent ?? 5;
         return {
             uptime,
             model: getCurrentModel(),
@@ -129,34 +109,6 @@ export function registerDashboardAPI(fastify, config) {
             lastMessage: getLastMessage(),
             activeChannel: getActiveChannelId() ?? runtimeConfig.channels.active ?? null,
             cronJobs: jobs,
-            subagents: {
-                maxConcurrent,
-                active: activeTasks.length,
-                running: runningCount,
-                pending: pendingCount,
-                recentTotal: recentTasks.length,
-                recentCompleted,
-                recentFailed,
-                recentCancelled,
-            },
-            activeSubagents: activeTasks
-                .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
-                .map(task => {
-                const started = task.startedAt || task.createdAt;
-                return {
-                    id: task.id,
-                    type: task.type,
-                    status: task.status,
-                    model: task.model,
-                    label: task.label,
-                    promptPreview: task.prompt.slice(0, 120),
-                    retryCount: task.retryCount ?? 0,
-                    maxRetries: task.maxRetries ?? 2,
-                    createdAt: task.createdAt,
-                    startedAt: task.startedAt,
-                    elapsedSeconds: Math.max(0, Math.round((Date.now() - started.getTime()) / 1000)),
-                };
-            }),
         };
     });
     // --- Sessions ---
@@ -306,7 +258,7 @@ export function registerDashboardAPI(fastify, config) {
     // --- Memory ---
     fastify.get('/api/dashboard/memory/:agentId', async (request, reply) => {
         const { agentId } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         const files = listMemoryFiles(agentId);
@@ -314,7 +266,7 @@ export function registerDashboardAPI(fastify, config) {
     });
     fastify.get('/api/dashboard/memory/:agentId/:filename', async (request, reply) => {
         const { agentId, filename } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         // Special case: "curated" reads MEMORY.md from the agent root
@@ -455,7 +407,7 @@ export function registerDashboardAPI(fastify, config) {
     // --- Templates ---
     fastify.get('/api/dashboard/templates/:agentId', async (request, reply) => {
         const { agentId } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         const agentDir = getAgentDir(agentId);
@@ -472,7 +424,7 @@ export function registerDashboardAPI(fastify, config) {
     });
     fastify.get('/api/dashboard/templates/:agentId/:name', async (request, reply) => {
         const { agentId, name } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         const content = getAgentTemplateContent(agentId, name);
@@ -483,7 +435,7 @@ export function registerDashboardAPI(fastify, config) {
     });
     fastify.put('/api/dashboard/templates/:agentId/:name', async (request, reply) => {
         const { agentId, name } = request.params;
-        if (!validateAgentId(agentId)) {
+        if (!isValidAgentId(agentId)) {
             return reply.code(400).send({ error: 'Invalid agent ID' });
         }
         const { content } = request.body;

package/dist/audit.js

@@ -1,15 +1,10 @@
 // Audit log reader/writer for ~/.skimpyclaw/logs/audit/YYYY-MM-DD.jsonl
 import { randomUUID } from 'crypto';
-import { readFileSync, appendFileSync, existsSync, mkdirSync, readdirSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { formatDate, readJsonlDir } from './utils.js';
 const AUDIT_DIR = join(homedir(), '.skimpyclaw', 'logs', 'audit');
-function formatDate(date) {
-    const y = date.getFullYear();
-    const m = String(date.getMonth() + 1).padStart(2, '0');
-    const d = String(date.getDate()).padStart(2, '0');
-    return `${y}-${m}-${d}`;
-}
 // --- In-memory trace lifecycle ---
 /** Active traces keyed by traceId */
 const activeTraces = new Map();
@@ -60,52 +55,11 @@ export async function readAuditTraces(options = {}) {
     const limit = options.limit ?? 50;
     const offset = options.offset ?? 0;
     const triggerFilter = options.trigger;
-    // Determine date range
     const endDate = options.endDate ?? new Date();
-    const startDate = options.startDate ?? new Date(endDate.getTime() - 90 * 24 * 60 * 60 * 1000); // 90 days back
-    // Get all audit JSONL files in the directory
-    if (!existsSync(AUDIT_DIR)) {
-        return { traces: [], total: 0 };
-    }
-    const files = readdirSync(AUDIT_DIR)
-        .filter(f => f.endsWith('.jsonl'))
-        .sort()
-        .reverse(); // Newest first
-    const startStr = formatDate(startDate);
-    const endStr = formatDate(endDate);
-    // Collect all matching traces
-    const allTraces = [];
-    for (const file of files) {
-        const dateStr = file.replace('.jsonl', '');
-        if (dateStr < startStr || dateStr > endStr)
-            continue;
-        const filePath = join(AUDIT_DIR, file);
-        try {
-            const content = readFileSync(filePath, 'utf-8');
-            const lines = content.trim().split('\n').filter(Boolean);
-            // Parse lines in reverse (newest first within file)
-            for (let i = lines.length - 1; i >= 0; i--) {
-                try {
-                    const trace = JSON.parse(lines[i]);
-                    if (triggerFilter && trace.trigger !== triggerFilter)
-                        continue;
-                    allTraces.push(trace);
-                }
-                catch {
-                    // Skip malformed lines
-                }
-            }
-        }
-        catch {
-            // Skip unreadable files
-        }
-    }
+    const startDate = options.startDate ?? new Date(endDate.getTime() - 90 * 24 * 60 * 60 * 1000);
+    const allTraces = readJsonlDir(AUDIT_DIR, formatDate(startDate), formatDate(endDate), triggerFilter ? (t) => t.trigger === triggerFilter : undefined);
     // Sort newest first by startedAt
-    allTraces.sort((a, b) => {
-        const dateA = new Date(b.startedAt || b.endedAt).getTime();
-        const dateB = new Date(a.startedAt || a.endedAt).getTime();
-        return dateA - dateB;
-    });
+    allTraces.sort((a, b) => Date.parse(b.startedAt || b.endedAt) - Date.parse(a.startedAt || a.endedAt));
     const total = allTraces.length;
     const paged = allTraces.slice(offset, offset + limit);
     return { traces: paged, total };

package/dist/channels/telegram/handlers.js

@@ -4,7 +4,6 @@ import { spawnSync } from 'child_process';
 import { getCurrentModel, setCurrentModel, getLastMessage } from '../../gateway.js';
 import { getCronJobs, runCronJob } from '../../cron.js';
 import { runHeartbeatCheck } from '../../heartbeat.js';
-import { cancelTask, getActiveTasks, getRecentTasks } from '../../subagent.js';
 import { getActiveCodeAgents, getRecentCodeAgents } from '../../code-agents/index.js';
 import { listApprovals, approveRequest, denyRequest, getApproval, onApprovalEvent } from '../../exec-approval.js';
 import { loadSkills } from '../../skills.js';
@@ -47,28 +46,9 @@ export async function handleStatus(ctx, cfg) {
     const model = getCurrentModel();
     const last = getLastMessage();
     const jobs = getCronJobs();
-    const activeTasks = getActiveTasks();
-    const recentTasks = getRecentTasks(20);
     const jobList = jobs
         .map((j) => `  - ${j.name}: ${j.nextRun?.toLocaleString() || 'unknown'}`)
         .join('\n');
-    const pendingCount = activeTasks.filter((t) => t.status === 'pending').length;
-    const runningCount = activeTasks.filter((t) => t.status === 'running').length;
-    const maxConcurrent = cfg.subagents?.maxConcurrent ?? 5;
-    const recentCompleted = recentTasks.filter((t) => t.status === 'completed').length;
-    const recentFailed = recentTasks.filter((t) => t.status === 'failed').length;
-    const recentCancelled = recentTasks.filter((t) => t.status === 'cancelled').length;
-    const activePreview = activeTasks
-        .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
-        .slice(0, 3)
-        .map((task) => {
-        const started = task.startedAt || task.createdAt;
-        const elapsedSeconds = Math.max(0, Math.round((Date.now() - started.getTime()) / 1000));
-        const elapsed = elapsedSeconds < 60 ? `${elapsedSeconds}s` : `${Math.round(elapsedSeconds / 60)}m`;
-        const label = task.label ? ` (${task.label})` : '';
-        return `  - ${task.id} [${task.type}] ${task.status}${label} • ${elapsed}`;
-    })
-        .join('\n');
     // Coding agents status (multi-agent)
     const caActive = getActiveCodeAgents();
     const caRecent = getRecentCodeAgents(20);
@@ -109,9 +89,6 @@ export async function handleStatus(ctx, cfg) {
         `Last message: ${last?.toLocaleString() || 'never'}\n` +
         `Silence until: ${state.silenceUntil?.toLocaleTimeString() || 'not silenced'}\n\n` +
         `${caLine}\n\n` +
-        `Subagents: ${activeTasks.length}/${maxConcurrent} active (running: ${runningCount}, pending: ${pendingCount})\n` +
-        `Recent (last ${recentTasks.length}): ✅ ${recentCompleted} • ❌ ${recentFailed} • 🚫 ${recentCancelled}\n` +
-        `${activePreview ? `Active now:\n${activePreview}\n\n` : '\n'}` +
         `Scheduled jobs:\n${jobList || '  (none)'}`);
 }
 export async function handleCron(ctx, cfg) {
@@ -182,45 +159,10 @@ export async function handleRestart(ctx, cfg) {
     }
 }
 export async function handleTasks(ctx, cfg) {
-    const active = getActiveTasks();
-    const recent = getRecentTasks(5);
-    if (recent.length === 0) {
-        await ctx.reply('No agent tasks yet. Subagents spawn automatically for complex requests.');
-        return;
-    }
-    const formatTask = (t) => {
-        const elapsed = ((t.completedAt || new Date()).getTime() - t.createdAt.getTime()) / 1000;
-        const elapsedStr = elapsed < 60 ? `${Math.round(elapsed)}s` : `${Math.round(elapsed / 60)}m`;
-        const status = {
-            pending: '⏳ Pending',
-            running: `🔄 Running (${elapsedStr})`,
-            completed: `✅ Done (${elapsedStr})`,
-            failed: `❌ Failed (${elapsedStr})`,
-            cancelled: '🚫 Cancelled'
-        };
-        const promptPreview = t.prompt.slice(0, 60) + (t.prompt.length > 60 ? '...' : '');
-        return `${t.id}: ${status[t.status] || t.status} [${t.type}] ${promptPreview}`;
-    };
-    const lines = [...active, ...recent].slice(0, 10).map(formatTask).join('\n');
-    await ctx.reply(`Agent tasks:\n\n${lines}`);
+    await ctx.reply('Use /agents to list active coding agents, or /cron to manage scheduled tasks.');
 }
 export async function handleCancel(ctx, cfg) {
-    const id = String(ctx.match || '').trim();
-    if (!id) {
-        await ctx.reply('Usage: /cancel <task-id>\nExample: /cancel t1');
-        return;
-    }
-    const task = cancelTask(id);
-    if (!task) {
-        await ctx.reply(`No task found: ${id}`);
-        return;
-    }
-    if (task.status === 'cancelled') {
-        await ctx.reply(`Cancelled ${id}.`);
-    }
-    else {
-        await ctx.reply(`Task ${id} is already ${task.status}.`);
-    }
+    await ctx.reply('Use the dashboard to cancel coding agents, or /cron to manage scheduled tasks.');
 }
 export async function handleSkills(ctx, cfg) {
     const skillConfig = cfg.skills;

package/dist/channels/telegram/index.js

@@ -3,7 +3,6 @@ import { Bot, GrammyError, HttpError, InputFile } from 'grammy';
 import { run } from '@grammyjs/runner';
 import { isAllowed, isRateLimited } from '../../security.js';
 import { runAgentTurn } from '../../agent.js';
-import { initSubagentSystem } from '../../subagent.js';
 import { getCurrentModel } from '../../gateway.js';
 import { getApproval, approveRequest, denyRequest } from '../../exec-approval.js';
 import { transcribeAudio, synthesizeSpeech } from '../../voice.js';
@@ -93,12 +92,6 @@ export async function initTelegram(cfg) {
     }
     const bot = new Bot(cfg.channels.telegram.token);
     activeBot = bot;
-    // Initialize subagent system with message delivery callback
-    initSubagentSystem(async (chatId, message) => {
-        if (!activeBot)
-            return;
-        await sendLongMessage({ reply: (text) => activeBot.api.sendMessage(chatId, text) }, message);
-    });
     // Register commands with Telegram for the / menu
     bot.api.setMyCommands(BOT_COMMANDS).catch((err) => {
         console.error('[telegram] Failed to set bot commands:', err);

package/dist/channels.js

@@ -27,7 +27,7 @@ function resolveChannelPreference(config) {
 }
 async function loadAdapter(channel) {
     if (channel === 'telegram') {
-        const telegram = await import('./telegram.js');
+        const telegram = await import('./channels/telegram/index.js');
         return {
             init: async (config) => (await telegram.initTelegram(config)) !== null,
             start: telegram.startTelegram,