skimpyclaw 0.3.8 → 0.3.10

package/dist/__tests__/code-agents-preflight.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/code-agents-preflight.test.js

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const PRECHECK_ERROR = 'Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).';
+const toolConfig = {
+    enabled: true,
+    allowedPaths: [process.cwd()],
+    maxIterations: 5,
+    bashTimeout: 5000,
+};
+async function loadSubject(preflightError) {
+    vi.resetModules();
+    const runCodeAgentBackground = vi.fn().mockResolvedValue(undefined);
+    const runTeamOrchestrator = vi.fn().mockResolvedValue(undefined);
+    vi.doMock('../code-agents/utils.js', async () => {
+        const actual = await vi.importActual('../code-agents/utils.js');
+        return {
+            ...actual,
+            getCodingCliPreflightError: () => preflightError,
+        };
+    });
+    vi.doMock('../code-agents/executor.js', () => ({
+        runCodeAgentBackground,
+        runValidation: vi.fn(),
+        buildValidationCommand: vi.fn(() => 'pnpm build && pnpm test'),
+    }));
+    vi.doMock('../code-agents/orchestrator.js', () => ({
+        runTeamOrchestrator,
+        computeWaves: vi.fn(),
+        decomposeTask: vi.fn(),
+        synthesizeResults: vi.fn(),
+        gatherCodebaseContext: vi.fn(),
+    }));
+    vi.doMock('../code-agents/registry.js', () => ({
+        getNextCodeAgentId: vi.fn(() => 'ca_test_1'),
+        storeCodeAgentTask: vi.fn(),
+        writeCodeAgentTask: vi.fn(),
+        getActiveCodeAgents: vi.fn(() => []),
+        getRecentCodeAgents: vi.fn(() => []),
+        getAllCodeAgents: vi.fn(() => []),
+        getCodeAgent: vi.fn(() => null),
+        cancelCodeAgent: vi.fn(),
+        restoreCodeAgentTasks: vi.fn(),
+        getCodeAgentsDir: vi.fn(() => process.cwd()),
+    }));
+    const subject = await import('../code-agents/index.js');
+    return { ...subject, runCodeAgentBackground, runTeamOrchestrator };
+}
+afterEach(() => {
+    vi.doUnmock('../code-agents/utils.js');
+    vi.doUnmock('../code-agents/executor.js');
+    vi.doUnmock('../code-agents/orchestrator.js');
+    vi.doUnmock('../code-agents/registry.js');
+    vi.clearAllMocks();
+    vi.resetModules();
+});
+describe('coding CLI preflight guard', () => {
+    it('fails code_with_agent before spawning when no supported CLI is available', async () => {
+        const { executeCodeWithAgent, runCodeAgentBackground } = await loadSubject(PRECHECK_ERROR);
+        const result = await executeCodeWithAgent({ task: 'Fix bug', workdir: process.cwd() }, toolConfig, {
+            fullConfig: { codeAgents: { maxConcurrent: 99 } },
+        });
+        expect(result).toBe(PRECHECK_ERROR);
+        expect(runCodeAgentBackground).not.toHaveBeenCalled();
+    });
+    it('fails code_with_team before spawning when no supported CLI is available', async () => {
+        const { executeCodeWithTeam, runTeamOrchestrator } = await loadSubject(PRECHECK_ERROR);
+        const result = await executeCodeWithTeam({ task: 'Refactor auth', workdir: process.cwd() }, toolConfig, {
+            fullConfig: { codeAgents: { maxConcurrent: 99 } },
+        });
+        expect(result).toBe(PRECHECK_ERROR);
+        expect(runTeamOrchestrator).not.toHaveBeenCalled();
+    });
+    it('allows code_with_agent when at least one supported CLI exists', async () => {
+        const { executeCodeWithAgent, runCodeAgentBackground } = await loadSubject(null);
+        const result = await executeCodeWithAgent({ task: 'Fix bug', workdir: process.cwd() }, toolConfig, {
+            fullConfig: { codeAgents: { maxConcurrent: 99 } },
+        });
+        expect(result).toContain('Started coding agent');
+        expect(runCodeAgentBackground).toHaveBeenCalledTimes(1);
+    });
+    it('allows code_with_team when at least one supported CLI exists', async () => {
+        const { executeCodeWithTeam, runTeamOrchestrator } = await loadSubject(null);
+        const result = await executeCodeWithTeam({ task: 'Refactor auth', workdir: process.cwd() }, toolConfig, {
+            fullConfig: { codeAgents: { maxConcurrent: 99 } },
+        });
+        expect(result).toContain('Started coding team');
+        expect(runTeamOrchestrator).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/__tests__/code-agents-utils.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { normalizeCodeAgent, resolveSelectedCodeAgent } from '../code-agents/utils.js';
+import { normalizeCodeAgent, resolveSelectedCodeAgent, getAvailableCodingCliTools, getCodingCliPreflightError, } from '../code-agents/utils.js';
 describe('normalizeCodeAgent', () => {
     it('accepts strict ids', () => {
         expect(normalizeCodeAgent('claude')).toBe('claude');
@@ -39,3 +39,14 @@ describe('resolveSelectedCodeAgent', () => {
         expect(resolveSelectedCodeAgent('claude', 'claude', 'gpt-4.1')).toBe('claude');
     });
 });
+describe('coding CLI preflight', () => {
+    it('returns a clear error when no supported CLI is found on PATH', () => {
+        expect(getAvailableCodingCliTools(() => false)).toEqual([]);
+        expect(getCodingCliPreflightError(() => false)).toBe('Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).');
+    });
+    it('accepts claude-code binary as claude support', () => {
+        const hasCommand = (name) => name === 'claude-code';
+        expect(getAvailableCodingCliTools(hasCommand)).toEqual(['claude']);
+        expect(getCodingCliPreflightError(hasCommand)).toBeNull();
+    });
+});

package/dist/__tests__/skills.test.js

@@ -294,31 +294,58 @@ describe('formatSkillsPrompt', () => {
     it('returns empty string for no skills', () => {
         expect(formatSkillsPrompt([])).toBe('');
     });
-    it('formats single skill with header', () => {
-        const result = formatSkillsPrompt([makeSkill('greet', 'Say hello.')]);
-        expect(result).toContain('## Active Skills');
-        expect(result).toContain('### greet');
-        expect(result).toContain('Say hello.');
-    });
-    it('includes emoji in header when present', () => {
-        const result = formatSkillsPrompt([makeSkill('greet', 'Say hello.', '👋')]);
-        expect(result).toContain('### 👋 greet');
-    });
-    it('separates multiple skills with dividers', () => {
-        const result = formatSkillsPrompt([
-            makeSkill('a', 'A body'),
-            makeSkill('b', 'B body'),
-        ]);
-        expect(result).toContain('---');
-        expect(result).toContain('### a');
-        expect(result).toContain('### b');
-    });
-    it('does not skip skills based on prompt budget argument', () => {
-        const result = formatSkillsPrompt([
-            makeSkill('small', 'tiny'),
-            makeSkill('big', 'x'.repeat(50000)),
-        ], 100);
-        expect(result).toContain('### small');
-        expect(result).toContain('### big');
+    describe('dynamic loading (default)', () => {
+        it('formats skill catalog with names, descriptions, and paths', () => {
+            const result = formatSkillsPrompt([makeSkill('greet', 'Say hello.')]);
+            expect(result).toContain('## Skills');
+            expect(result).toContain('read the SKILL.md file');
+            expect(result).toContain('greet');
+            expect(result).toContain('`/fake/greet/SKILL.md`');
+        });
+        it('includes emoji in catalog', () => {
+            const result = formatSkillsPrompt([makeSkill('greet', 'Say hello.', '👋')]);
+            expect(result).toContain('👋 greet');
+        });
+        it('does not include skill body', () => {
+            const result = formatSkillsPrompt([makeSkill('greet', 'Say hello.')]);
+            expect(result).not.toContain('Say hello.');
+        });
+        it('lists multiple skills', () => {
+            const result = formatSkillsPrompt([
+                makeSkill('a', 'A body'),
+                makeSkill('b', 'B body'),
+            ]);
+            expect(result).toContain('| a |');
+            expect(result).toContain('| b |');
+        });
+    });
+    describe('inline loading (dynamicLoading=false)', () => {
+        it('formats single skill with header and body', () => {
+            const result = formatSkillsPrompt([makeSkill('greet', 'Say hello.')], undefined, false);
+            expect(result).toContain('## Active Skills');
+            expect(result).toContain('### greet');
+            expect(result).toContain('Say hello.');
+        });
+        it('includes emoji in header when present', () => {
+            const result = formatSkillsPrompt([makeSkill('greet', 'Say hello.', '👋')], undefined, false);
+            expect(result).toContain('### 👋 greet');
+        });
+        it('separates multiple skills with dividers', () => {
+            const result = formatSkillsPrompt([
+                makeSkill('a', 'A body'),
+                makeSkill('b', 'B body'),
+            ], undefined, false);
+            expect(result).toContain('---');
+            expect(result).toContain('### a');
+            expect(result).toContain('### b');
+        });
+        it('does not skip skills based on prompt budget argument', () => {
+            const result = formatSkillsPrompt([
+                makeSkill('small', 'tiny'),
+                makeSkill('big', 'x'.repeat(50000)),
+            ], 100, false);
+            expect(result).toContain('### small');
+            expect(result).toContain('### big');
+        });
     });
 });

package/dist/__tests__/token-efficiency.test.js

@@ -1,27 +1,49 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, afterAll } from 'vitest';
 import { truncateToolResult } from '../providers/utils.js';
+import { existsSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const scratchDir = join(homedir(), '.skimpyclaw', 'scratch');
+// Clean up scratch files created during tests
+afterAll(() => {
+    try {
+        if (existsSync(scratchDir)) {
+            for (const f of readdirSync(scratchDir)) {
+                try {
+                    unlinkSync(join(scratchDir, f));
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+    catch { /* ignore */ }
+});
 describe('token efficiency', () => {
     describe('truncateToolResult', () => {
         it('returns short results unchanged', () => {
             const result = 'short result';
             expect(truncateToolResult(result)).toBe(result);
         });
-        it('truncates at exact boundary', () => {
-            const result = 'x'.repeat(10_240);
-            expect(truncateToolResult(result)).toBe(result); // exactly at limit
+        it('returns results under mask threshold unchanged', () => {
+            const result = 'x'.repeat(7_999);
+            expect(truncateToolResult(result)).toBe(result);
         });
-        it('truncates over limit with notice', () => {
-            const result = 'x'.repeat(20_000);
-            const truncated = truncateToolResult(result);
-            expect(truncated.length).toBeLessThan(result.length);
-            expect(truncated).toContain('[Truncated: 20000 chars total]');
-            expect(truncated.startsWith('x'.repeat(10_240))).toBe(true);
+        it('masks large results to scratch file with summary', () => {
+            const result = 'START' + 'x'.repeat(10_000) + 'END';
+            const masked = truncateToolResult(result);
+            expect(masked.length).toBeLessThan(result.length);
+            expect(masked).toContain('[Full output');
+            expect(masked).toContain('saved to');
+            expect(masked).toContain('.skimpyclaw/scratch/');
+            expect(masked).toContain('use Read tool to access');
+            // Summary includes head and tail
+            expect(masked).toContain('START');
+            expect(masked).toContain('END');
         });
-        it('respects custom maxBytes', () => {
-            const result = 'abcdefghij'; // 10 chars
-            const truncated = truncateToolResult(result, 5);
-            expect(truncated).toContain('[Truncated: 10 chars total]');
-            expect(truncated.startsWith('abcde')).toBe(true);
+        it('includes char count in masked output', () => {
+            const result = 'y'.repeat(20_000);
+            const masked = truncateToolResult(result);
+            expect(masked).toContain('20000 chars');
         });
     });
     describe('retry prompt compression', () => {

package/dist/agent.js

@@ -52,7 +52,7 @@ export function buildSystemPrompt(agentId, skillsContext) {
             cronJobId: skillsContext?.cronJobId,
             tags: skillsContext?.tags,
         });
-        skillsSection = formatSkillsPrompt(contextSkills, skillsContext?.skillConfig?.maxPromptTokens);
+        skillsSection = formatSkillsPrompt(contextSkills, skillsContext?.skillConfig?.maxPromptTokens, skillsContext?.skillConfig?.dynamicLoading);
     }
     const base = [soul, identity, tools, skillsSection].filter(Boolean).join('\n\n---\n\n');
     const userContext = [user, memory].filter(Boolean).join('\n\n');

package/dist/code-agents/index.js

@@ -5,7 +5,7 @@ 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, } from './utils.js';
+import { resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, getCodingCliPreflightError, } from './utils.js';
 // Re-export timeout constants
 export { CODE_AGENT_TIMEOUT_MS, VALIDATE_TIMEOUT_MS } from './types.js';
 // Re-export registry functions
@@ -105,6 +105,9 @@ export async function executeCodeWithAgent(input, config, context) {
     if (activeCount >= maxConcurrent) {
         return `Error: Concurrency limit reached (${activeCount}/${maxConcurrent} coding agents running). Wait for one to finish or increase codeAgents.maxConcurrent.`;
     }
+    const cliPreflightError = getCodingCliPreflightError();
+    if (cliPreflightError)
+        return cliPreflightError;
     const validate = input.validate !== false; // default true
     // Create task with unique ID
     const id = getNextCodeAgentId();
@@ -176,6 +179,9 @@ export async function executeCodeWithTeam(input, config, context) {
     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();

package/dist/code-agents/orchestrator.js

@@ -567,6 +567,27 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
         if (getCodeAgent(parentId)?.status === 'cancelled')
             throw new Error(CANCELLED_MESSAGE);
         parentTask.liveOutput = 'Phase: Synthesizing results...';
+        // Aggregate cost/tokens from all children into parent
+        let totalCost = 0;
+        let totalInput = 0;
+        let totalOutput = 0;
+        let hasCostData = false;
+        for (const cid of childIds) {
+            const child = getCodeAgent(cid);
+            if (child?.totalCost != null) {
+                totalCost += child.totalCost;
+                hasCostData = true;
+            }
+            if (child?.inputTokens != null)
+                totalInput += child.inputTokens;
+            if (child?.outputTokens != null)
+                totalOutput += child.outputTokens;
+        }
+        if (hasCostData) {
+            parentTask.totalCost = totalCost;
+            parentTask.inputTokens = totalInput;
+            parentTask.outputTokens = totalOutput;
+        }
         writeCodeAgentTask(parentTask);
         const childResults = childIds.map(id => {
             const child = getCodeAgent(id);

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

@@ -1,5 +1,9 @@
 import type { BuildCodeAgentArgsInput, CodeAgentTask } from './types.js';
 import type { Config } from '../types.js';
+/** Return supported coding CLIs currently available on PATH. */
+export declare function getAvailableCodingCliTools(commandChecker?: (name: string) => boolean): Array<'codex' | 'claude' | 'kimi'>;
+/** 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").

package/dist/code-agents/utils.js

@@ -12,9 +12,35 @@ function resolveCliPath(name) {
         return name;
     }
 }
+function isCommandAvailable(name) {
+    try {
+        execSync(`command -v ${name}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 const CLAUDE_CLI_PATH = resolveCliPath('claude');
 const CODEX_CLI_PATH = resolveCliPath('codex');
 const KIMI_CLI_PATH = resolveCliPath('kimi');
+/** Return supported coding CLIs currently available on PATH. */
+export function getAvailableCodingCliTools(commandChecker = isCommandAvailable) {
+    const available = [];
+    if (commandChecker('codex'))
+        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`).';
+}
 /**
  * Normalize legacy/default agent values to supported CLI agent IDs.
  * Accepts strict IDs and older alias-like values (e.g. "claude-think").

package/dist/providers/utils.d.ts

@@ -54,8 +54,12 @@ export declare function getProvider(model: string): string;
  * Strip provider prefix from model name.
  */
 export declare function stripProvider(model: string, openaiClients?: Map<string, unknown>, responsesApiProviders?: Set<string>): string;
-/** Truncate tool result to maxBytes. Appends truncation notice. */
-export declare function truncateToolResult(result: string, maxBytes?: number): string;
+/**
+ * Mask large tool outputs by writing to scratch files.
+ * Returns the original result if small enough, or a summary + file path if large.
+ * Falls back to simple truncation if file write fails.
+ */
+export declare function truncateToolResult(result: string, _maxBytes?: number): string;
 /**
  * Build thinking config based on thinking level.
  */

package/dist/providers/utils.js

@@ -1,4 +1,7 @@
 // Provider Utilities
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
 // Anti-hallucination instructions injected between the Claude Code identity
 // block and the actual system prompt. Prevents the model from roleplaying
 // Claude Code's full behavior (XML tool calls, fabricated output, etc.)
@@ -178,10 +181,39 @@ export function stripProvider(model, openaiClients, responsesApiProviders) {
     return model;
 }
 /** Truncate tool result to maxBytes. Appends truncation notice. */
-export function truncateToolResult(result, maxBytes = 10_240) {
-    if (result.length <= maxBytes)
+/**
+ * Observation masking threshold. Tool outputs above this size are written to
+ * a scratch file and replaced with a compact summary + file path.
+ * Outputs below this are returned inline (no file I/O overhead).
+ */
+const MASK_THRESHOLD = 8_000; // ~2000 tokens
+/**
+ * Mask large tool outputs by writing to scratch files.
+ * Returns the original result if small enough, or a summary + file path if large.
+ * Falls back to simple truncation if file write fails.
+ */
+export function truncateToolResult(result, _maxBytes = 10_240) {
+    if (result.length <= MASK_THRESHOLD)
         return result;
-    return result.slice(0, maxBytes) + `\n\n[Truncated: ${result.length} chars total]`;
+    try {
+        const scratchDir = join(homedir(), '.skimpyclaw', 'scratch');
+        if (!existsSync(scratchDir))
+            mkdirSync(scratchDir, { recursive: true });
+        const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const filePath = join(scratchDir, `${id}.txt`);
+        writeFileSync(filePath, result);
+        // Build a compact summary: first 500 chars + last 500 chars
+        const head = result.slice(0, 500);
+        const tail = result.slice(-500);
+        const summary = head + (result.length > 1000 ? '\n...\n' + tail : '');
+        console.log(`[context-manager] Masked ${result.length} chars → ${filePath}`);
+        return `${summary}\n\n[Full output (${result.length} chars) saved to ${filePath} — use Read tool to access]`;
+    }
+    catch (err) {
+        // Fallback: simple truncation
+        console.warn(`[context-manager] Masking failed: ${err instanceof Error ? err.message : err}`);
+        return result.slice(0, MASK_THRESHOLD) + `\n\n[Truncated: ${result.length} chars total]`;
+    }
 }
 /**
  * Build thinking config based on thinking level.

package/dist/service.js

@@ -6,12 +6,37 @@ import { initProviders } from './agent.js';
 import { initLangfuse, shutdownLangfuse } from './langfuse.js';
 import { restoreCodeAgentTasks, setCodeAgentConfig } from './tools.js';
 import { releaseAll, cleanupOrphans, setRuntime, probeRuntime } from './sandbox/index.js';
+/** Clean up old scratch files (observation masking). Keeps files < 24h. */
+function cleanupScratch() {
+    try {
+        const { readdirSync, statSync, unlinkSync } = require('fs');
+        const { join } = require('path');
+        const { homedir } = require('os');
+        const dir = join(homedir(), '.skimpyclaw', 'scratch');
+        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
+        let count = 0;
+        for (const f of readdirSync(dir)) {
+            const p = join(dir, f);
+            try {
+                if (statSync(p).mtimeMs < cutoff) {
+                    unlinkSync(p);
+                    count++;
+                }
+            }
+            catch { /* skip */ }
+        }
+        if (count > 0)
+            console.log(`[scratch] Cleaned up ${count} old file(s)`);
+    }
+    catch { /* dir doesn't exist yet, fine */ }
+}
 export async function startRuntime(config) {
     const smokeTest = process.env.SKIMPYCLAW_SMOKE_TEST === '1';
     initLangfuse(config);
     initProviders(config);
     restoreCodeAgentTasks();
     setCodeAgentConfig(config);
+    cleanupScratch();
     // Initialize sandbox runtime if configured — auto-disable if no runtime available
     if (config.sandbox?.enabled) {
         const detected = probeRuntime(config.sandbox.runtime);

package/dist/setup.js

@@ -1085,10 +1085,8 @@ export async function runSetup(options = {}) {
         sectionHeader('Starter Packs (optional)');
         const localTz = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
         const addTechNewsCron = /^y(es)?$/i.test(await ask(rl, '   Add starter cron: top 10 Hacker News daily? [y/N]: '));
-        const addWeatherCron = /^y(es)?$/i.test(await ask(rl, '   Add starter cron: weather check daily at 7:00am? [y/N]: '));
         let cronTimezone = localTz;
-        let weatherLocation = 'New York, NY';
-        if (addTechNewsCron || addWeatherCron) {
+        if (addTechNewsCron) {
             const tzInput = await ask(rl, `   Timezone for starter cron jobs [${localTz}]: `);
             cronTimezone = tzInput || localTz;
             try {
@@ -1099,21 +1097,15 @@ export async function runSetup(options = {}) {
                 cronTimezone = localTz;
             }
         }
-        if (addWeatherCron) {
-            const locationInput = await ask(rl, '   Weather location (city, state/country) [New York, NY]: ');
-            weatherLocation = locationInput || 'New York, NY';
-        }
         const addDailyNotesSkill = /^y(es)?$/i.test(await ask(rl, '   Add starter skill: daily-notes? [y/N]: '));
-        const addWeatherSkill = /^y(es)?$/i.test(await ask(rl, '   Add starter skill: weather? [y/N]: '));
-        const addWebSearchSkill = /^y(es)?$/i.test(await ask(rl, '   Add starter skill: web-search (uses Browser tool)? [y/N]: '));
         const starters = {
             cronTechNews: addTechNewsCron,
-            cronWeather: addWeatherCron,
+            cronWeather: false,
             timezone: cronTimezone,
-            weatherLocation,
+            weatherLocation: '',
             skillDailyNotes: addDailyNotesSkill,
-            skillWeather: addWeatherSkill,
-            skillWebSearch: addWebSearchSkill,
+            skillWeather: false,
+            skillWebSearch: false,
         };
         const { envContent, config: generatedConfig } = buildSetupArtifacts({
             workspaceDir: extraAllowedPaths[0] || join(homedir(), '.skimpyclaw'),
@@ -1320,6 +1312,11 @@ export async function runSetup(options = {}) {
         console.log('   skimpyclaw status');
         console.log(`${step++}. Optional daemon controls: skimpyclaw stop | skimpyclaw restart`);
         console.log(`${step++}. Send /help in your ${useDiscord ? 'Discord bot DM/server' : 'Telegram bot'}`);
+        console.log('');
+        console.log(`${c.yellow('Note:')} The /team and /code tools require an external coding CLI on your PATH:`);
+        console.log('   • Claude Code CLI  →  https://docs.anthropic.com/en/docs/claude-code');
+        console.log('   • Codex CLI        →  https://github.com/openai/codex');
+        console.log('   Install at least one to use code_with_agent / code_with_team.');
         console.log('\n👙🦞 Enjoy!');
     }
     finally {

package/dist/skills-types.d.ts

@@ -62,4 +62,10 @@ export interface SkillConfig {
     entries?: Record<string, boolean>;
     /** Max approximate tokens for injected skills prompt (default: 4000) */
     maxPromptTokens?: number;
+    /**
+     * Dynamic loading: only include skill names and descriptions in the system prompt.
+     * Full skill content is loaded on-demand via the Read tool.
+     * Default: true (progressive disclosure)
+     */
+    dynamicLoading?: boolean;
 }

package/dist/skills.d.ts

@@ -27,5 +27,9 @@ export declare function getSkillsForContext(skills: LoadedSkill[], context?: {
 }): LoadedSkill[];
 /**
  * Format eligible, context-filtered skills into a markdown prompt section.
+ *
+ * When dynamicLoading is true (default), only skill names, descriptions, and
+ * file paths are included. The agent loads full content on-demand via the Read tool.
+ * When false, full skill bodies are inlined (legacy behavior).
  */
-export declare function formatSkillsPrompt(skills: LoadedSkill[], _maxTokens?: number): string;
+export declare function formatSkillsPrompt(skills: LoadedSkill[], _maxTokens?: number, dynamicLoading?: boolean): string;

package/dist/skills.js

@@ -237,12 +237,35 @@ export function getSkillsForContext(skills, context) {
 }
 /**
  * Format eligible, context-filtered skills into a markdown prompt section.
+ *
+ * When dynamicLoading is true (default), only skill names, descriptions, and
+ * file paths are included. The agent loads full content on-demand via the Read tool.
+ * When false, full skill bodies are inlined (legacy behavior).
  */
-export function formatSkillsPrompt(skills, _maxTokens) {
+export function formatSkillsPrompt(skills, _maxTokens, dynamicLoading) {
     if (skills.length === 0)
         return '';
+    // Default to dynamic loading
+    const useDynamic = dynamicLoading !== false;
+    if (useDynamic) {
+        const lines = [
+            '## Skills',
+            '',
+            'Available skills — read the SKILL.md file with the Read tool when the task matches a skill\'s description.',
+            '',
+            '| Skill | Description | Path |',
+            '|-------|-------------|------|',
+        ];
+        for (const skill of skills) {
+            const emoji = skill.frontmatter.emoji ? `${skill.frontmatter.emoji} ` : '';
+            const desc = skill.frontmatter.description || '(no description)';
+            const path = join(skill.dirPath, 'SKILL.md');
+            lines.push(`| ${emoji}${skill.name} | ${desc} | \`${path}\` |`);
+        }
+        return lines.join('\n');
+    }
+    // Legacy: inline full skill bodies
     const sections = [];
-    // Header
     const header = '## Active Skills\n';
     for (const skill of skills) {
         const emoji = skill.frontmatter.emoji ? `${skill.frontmatter.emoji} ` : '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skimpyclaw",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "description": "Lightweight personal AI assistant with Telegram and Discord integration",
   "type": "module",
   "main": "dist/index.js",