skimpyclaw 0.3.14 → 0.4.0

package/dist/providers/utils.js

@@ -5,17 +5,7 @@ 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.)
-export const TOOL_GUARD = `You are a personal assistant running inside SkimpyClaw.
-You are NOT the full Claude Code CLI. Do NOT roleplay as Claude Code.
-
-## Tool Rules
-- You have ONLY the tools provided via the API tool_use mechanism.
-- Tool names are case-sensitive. Call tools exactly as listed.
-- NEVER output tool calls as text/XML/JSON. Use the API tool_use mechanism only.
-- NEVER fabricate tool results or file contents. If you haven't read a file, say so.
-- NEVER invent tools that are not in your tool list (no str_replace_editor, no view, etc.)
-- If a Browser tool is available, you DO have web-browsing access via that tool. Use it instead of claiming you can't browse.
-- If you need information, use a tool to get it. Do not guess.`;
+export const TOOL_GUARD = `You are SkimpyClaw (NOT Claude Code CLI). Use only API tool_use — never text/XML tools. Never fabricate results.`;
 // Track if using OAuth (requires Claude Code identity)
 let usingOAuth = false;
 export function setUsingOAuth(value) {
@@ -86,7 +76,7 @@ export function toOpenAITools(toolDefs) {
         function: {
             name: t.name,
             description: t.description,
-            parameters: t.input_schema,
+            parameters: t.input_schema && t.input_schema.type ? t.input_schema : { type: 'object', properties: {} },
         },
     }));
 }
@@ -110,9 +100,12 @@ function migrateDeprecatedModelSpec(modelSpec) {
     else if (/^claude[-.]3[-.]5[-.]haiku(?:[-_.].*)?$/i.test(bare) || bare === 'claude-haiku') {
         migratedBare = 'claude-haiku-4-5';
     }
-    else if (/^claude[-.]opus[-.]4(?:[-_.].*)?$/i.test(bare)) {
+    else if (/^claude[-.]opus[-.]4[-_.]6$/i.test(bare)) {
         migratedBare = 'claude-opus-4-6';
     }
+    else if (/^claude[-.]opus[-.]4$/i.test(bare)) {
+        migratedBare = 'claude-opus-4-7';
+    }
     if (migratedBare === bare)
         return modelSpec;
     return hasProvider ? `${provider}/${migratedBare}` : migratedBare;
@@ -142,22 +135,21 @@ export function shouldUseCodexAliasProvider(provider, isCodexModel, codexProvide
  * Get provider name from model spec.
  */
 export function getProvider(model) {
-    // Explicit prefix: "openrouter/google/gemini-2.0-flash" → "openrouter"
     const slashIdx = model.indexOf('/');
     if (slashIdx > 0) {
         const prefix = model.slice(0, slashIdx);
-        // Known Anthropic prefix
         if (prefix === 'anthropic')
             return 'anthropic';
-        // Any other prefix = provider name (openai, openrouter, groq, together, etc.)
+        if (prefix === 'codex')
+            return 'codex';
+        if (prefix === 'openai' && /\bcodex\b/i.test(model.slice(slashIdx + 1)))
+            return 'openai';
         return prefix;
     }
-    // No prefix: infer from model name
     if (model.includes('claude'))
         return 'anthropic';
-    if (model.includes('gpt'))
-        return 'openai';
-    // Default to anthropic
+    if (model.includes('gpt') || model.includes('codex'))
+        return 'codex';
     return 'anthropic';
 }
 /**
@@ -186,7 +178,7 @@ export function stripProvider(model, openaiClients, responsesApiProviders) {
  * 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
+const MASK_THRESHOLD = 4000; // ~1000 tokens — must be high enough for typical file reads
 /**
  * Mask large tool outputs by writing to scratch files.
  * Returns the original result if small enough, or a summary + file path if large.
@@ -196,18 +188,16 @@ export function truncateToolResult(result, _maxBytes = 10_240) {
     if (result.length <= MASK_THRESHOLD)
         return result;
     try {
-        const scratchDir = join(homedir(), '.skimpyclaw', 'scratch');
+        const scratchDir = join(homedir(), '.skimpyclaw', 's');
         if (!existsSync(scratchDir))
             mkdirSync(scratchDir, { recursive: true });
-        const id = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        const filePath = join(scratchDir, `${id}.txt`);
+        const id = Math.random().toString(36).slice(2, 5);
+        const filePath = join(scratchDir, id);
         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 : '');
+        const home = homedir().replace(/\/+$/, '');
+        const shortFP = filePath.startsWith(home) ? '~' + filePath.slice(home.length) : filePath;
         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]`;
+        return `→${shortFP}`;
     }
     catch (err) {
         // Fallback: simple truncation
@@ -215,6 +205,86 @@ export function truncateToolResult(result, _maxBytes = 10_240) {
         return result.slice(0, MASK_THRESHOLD) + `\n\n[Truncated: ${result.length} chars total]`;
     }
 }
+/**
+ * Write full output to a scratch file. Returns the file path, or null on failure.
+ */
+function writeScratchFile(result) {
+    try {
+        const scratchDir = join(homedir(), '.skimpyclaw', 's');
+        if (!existsSync(scratchDir))
+            mkdirSync(scratchDir, { recursive: true });
+        const id = Math.random().toString(36).slice(2, 5);
+        const filePath = join(scratchDir, id);
+        writeFileSync(filePath, result);
+        return filePath;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Structured split tool results: generates a semantic summary based on tool type.
+ * For small results (<= MASK_THRESHOLD), returns unchanged.
+ * For large results, writes full output to scratch file and returns a compact,
+ * tool-aware summary with the scratch file path.
+ */
+export function splitToolResult(toolName, toolInput, result) {
+    // Never split scratch file reads — these are already split results being retrieved
+    const nameLower0 = toolName.toLowerCase();
+    if (nameLower0 === 'read' || nameLower0 === 'read_file') {
+        const filePath = toolInput.file_path || toolInput.path || '';
+        const scratchPrefix = join(homedir(), '.skimpyclaw', 's');
+        if (typeof filePath === 'string' && (filePath.startsWith(scratchPrefix) || filePath.startsWith('~/.skimpyclaw/s/') || filePath.startsWith('~/.skimpyclaw/scratch/'))) {
+            return result;
+        }
+    }
+    if (result.length <= MASK_THRESHOLD)
+        return result;
+    const scratchPath = writeScratchFile(result);
+    if (!scratchPath) {
+        // Fallback to legacy truncation
+        return truncateToolResult(result);
+    }
+    // Use tilde-prefixed path in output to save tokens
+    const home = homedir().replace(/\/+$/, '');
+    const shortPath = scratchPath.startsWith(home) ? '~' + scratchPath.slice(home.length) : scratchPath;
+    console.log(`[context-manager] Split ${result.length} chars (${toolName}) → ${scratchPath}`);
+    const nameLower = toolName.toLowerCase();
+    // Bash: include exit code, errors, and preview
+    if (nameLower === 'bash') {
+        const exitMatch = result.match(/exit code[:\s]+(\d+)/i);
+        const exitInfo = exitMatch && exitMatch[1] !== '0' ? `exit=${exitMatch[1]}\n` : '';
+        const lines = result.split('\n');
+        const errLines = lines.filter(l => /^(error|fatal|ERR!)/i.test(l.trim()));
+        const errNote = errLines.length > 0 ? errLines.slice(0, 3).join('\n') + '\n' : '';
+        const preview = result.slice(0, 600);
+        const truncNote = result.length > 600 ? `\n... (${result.length} chars total)` : '';
+        return `${exitInfo}${errNote}${preview}${truncNote}\nFull output saved to ${scratchPath} — use Read tool to retrieve.`;
+    }
+    // All other tools: include preview so the model has usable data
+    const preview = result.slice(0, 800);
+    const truncNote = result.length > 800 ? `\n... (${result.length} chars total)` : '';
+    return `${preview}${truncNote}\nFull output saved to ${scratchPath} — use Read tool to retrieve.`;
+}
+/**
+ * Compact old tool results in Anthropic-format messages.
+ * Replaces tool_result content with '✓' for all results except the last
+ * `keepRecent` messages. The model has already processed these results,
+ * so we only need to preserve the structure (tool_use_id matching).
+ *
+ * Mutates the messages array in place for efficiency.
+ */
+export function compactOldResults(messages, keepRecent = 2) {
+    if (messages.length <= keepRecent)
+        return;
+    const cutoff = messages.length - keepRecent;
+    // Remove old messages entirely — keep only recent
+    messages.splice(0, cutoff);
+    // Ensure first message is user role (API requirement)
+    if (messages.length > 0 && messages[0].role !== 'user') {
+        messages.unshift({ role: 'user', content: '·' });
+    }
+}
 /**
  * Build thinking config based on thinking level.
  */
@@ -225,6 +295,7 @@ export function buildThinkingConfig(thinking) {
         low: 2048,
         medium: 8192,
         high: 16384,
+        xhigh: 32768,
     };
     const budget = budgetTokens[thinking] || 2048;
     return {

package/dist/secure-store.d.ts

@@ -0,0 +1,8 @@
+export declare function secureStoreAvailable(): {
+    ok: boolean;
+    detail?: string;
+};
+export declare function clearSecureStoreAvailabilityCacheForTests(): void;
+export declare function requireSecureStore(purpose: string): void;
+export declare function getSecureValue(service: string, account: string): string | null;
+export declare function setSecureValue(service: string, account: string, value: string): void;

package/dist/secure-store.js

@@ -0,0 +1,80 @@
+import { spawnSync } from 'child_process';
+function runSecurityCommand(args) {
+    const result = spawnSync('security', args, {
+        encoding: 'utf-8',
+        timeout: 5000,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    if (result.error) {
+        return { ok: false, detail: result.error.message };
+    }
+    if (result.status !== 0) {
+        const detail = (result.stderr || result.stdout || '').trim() || `exit ${result.status}`;
+        return { ok: false, detail };
+    }
+    return { ok: true, detail: (result.stdout || '').trim() };
+}
+let availabilityCache = {
+    checked: false,
+    ok: false,
+};
+export function secureStoreAvailable() {
+    if (availabilityCache.checked) {
+        return { ok: availabilityCache.ok, detail: availabilityCache.detail };
+    }
+    if (process.platform !== 'darwin') {
+        availabilityCache = {
+            checked: true,
+            ok: false,
+            detail: 'macOS Keychain is only available on darwin',
+        };
+        return { ok: false, detail: availabilityCache.detail };
+    }
+    const probe = runSecurityCommand(['list-keychains']);
+    availabilityCache = {
+        checked: true,
+        ok: probe.ok,
+        detail: probe.ok ? undefined : probe.detail,
+    };
+    return { ok: availabilityCache.ok, detail: availabilityCache.detail };
+}
+export function clearSecureStoreAvailabilityCacheForTests() {
+    availabilityCache = { checked: false, ok: false };
+}
+export function requireSecureStore(purpose) {
+    const availability = secureStoreAvailable();
+    if (!availability.ok) {
+        throw new Error(`[secure-store] ${purpose} requires macOS Keychain, but it is unavailable${availability.detail ? `: ${availability.detail}` : ''}`);
+    }
+}
+export function getSecureValue(service, account) {
+    requireSecureStore('Secret retrieval');
+    const result = runSecurityCommand([
+        'find-generic-password',
+        '-s',
+        service,
+        '-a',
+        account,
+        '-w',
+    ]);
+    if (!result.ok) {
+        return null;
+    }
+    return (result.detail || '').trim();
+}
+export function setSecureValue(service, account, value) {
+    requireSecureStore('Secret storage');
+    const result = runSecurityCommand([
+        'add-generic-password',
+        '-U',
+        '-s',
+        service,
+        '-a',
+        account,
+        '-w',
+        value,
+    ]);
+    if (!result.ok) {
+        throw new Error(`[secure-store] Failed writing ${service}/${account}: ${result.detail || 'unknown error'}`);
+    }
+}

package/dist/service.js

@@ -1,3 +1,6 @@
+import { readdirSync, statSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { createGateway } from './gateway.js';
 import { initCron, stopCron } from './cron.js';
 import { initHeartbeat, stopHeartbeat } from './heartbeat.js';
@@ -5,13 +8,9 @@ import { initActiveChannel, startActiveChannel, stopActiveChannel } from './chan
 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;
@@ -37,29 +36,6 @@ export async function startRuntime(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);
-        if (detected) {
-            setRuntime(detected);
-            if (detected !== config.sandbox.runtime) {
-                console.log(`[sandbox] Configured runtime "${config.sandbox.runtime}" not found, using "${detected}" instead`);
-            }
-            // Clean up orphaned sandbox containers from previous runs
-            try {
-                const count = await cleanupOrphans();
-                if (count > 0)
-                    console.log(`[sandbox] Cleaned up ${count} orphaned container(s)`);
-            }
-            catch (err) {
-                console.warn('[sandbox] Failed to clean up orphaned containers:', err instanceof Error ? err.message : err);
-            }
-        }
-        else {
-            console.warn('[sandbox] No container runtime found (docker/container not installed). Sandbox disabled.');
-            config.sandbox.enabled = false;
-        }
-    }
     const port = smokeTest ? (parseInt(process.env.SKIMPYCLAW_SMOKE_PORT || '19999', 10)) : config.gateway.port;
     const gateway = await createGateway(config);
     const host = config.gateway.host ?? '127.0.0.1';
@@ -77,7 +53,6 @@ export async function startRuntime(config) {
         config,
         gateway,
         stop: async () => {
-            await releaseAll();
             stopCron();
             stopHeartbeat();
             await stopActiveChannel();

package/dist/sessions.d.ts

@@ -1,5 +1,7 @@
 import type { ChatMessage } from './types.js';
 export declare const MAX_HISTORY_PAIRS = 5;
+/** Reset session key cache between tests to prevent cross-test leakage. */
+export declare function clearSessionKeyCacheForTests(): void;
 /** Override sessions directory. Used in tests. */
 export declare function setSessionsDir(dir: string): void;
 export interface SessionEntry {
@@ -9,6 +11,7 @@ export interface SessionEntry {
     summary?: true;
     proactive?: true;
 }
+export declare function readSessionEntriesFromFile(filePath: string): SessionEntry[];
 /**
  * Load last MAX_HISTORY_PAIRS exchanges from disk.
  * Returns [] if file doesn't exist.

package/dist/sessions.js

@@ -1,11 +1,23 @@
-// Persistent conversation history — append-only JSONL per chat
+// Persistent conversation history — encrypted JSONL per chat
 // Storage: ~/.skimpyclaw/sessions/{platform}-{chatId}.jsonl
-// Each line: {"ts":"...","user":"...","assistant":"..."}
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from 'crypto';
+import { getSecureValue, setSecureValue } from './secure-store.js';
 let SESSIONS_DIR = join(homedir(), '.skimpyclaw', 'sessions');
 export const MAX_HISTORY_PAIRS = 5;
+const ENCRYPTED_PREFIX = 'ENCv1:';
+const SESSION_KEY_SERVICE = 'skimpyclaw-history';
+const SESSION_KEY_ACCOUNT = 'session-key-v1';
+const SESSION_KEY_ENV = 'SKIMPYCLAW_HISTORY_KEY';
+let sessionKeyCache = null;
+let warnedUnavailable = false;
+/** Reset session key cache between tests to prevent cross-test leakage. */
+export function clearSessionKeyCacheForTests() {
+    sessionKeyCache = null;
+    warnedUnavailable = false;
+}
 /** Override sessions directory. Used in tests. */
 export function setSessionsDir(dir) {
     SESSIONS_DIR = dir;
@@ -18,28 +30,142 @@ function ensureDir() {
         mkdirSync(SESSIONS_DIR, { recursive: true });
     }
 }
-/**
- * Load last MAX_HISTORY_PAIRS exchanges from disk.
- * Returns [] if file doesn't exist.
- */
-export async function loadHistory(platform, chatId) {
-    const filePath = sessionPath(platform, chatId);
+function deriveKeyFromEnv(raw) {
+    const trimmed = raw.trim();
+    if (/^[a-f0-9]{64}$/i.test(trimmed)) {
+        return Buffer.from(trimmed, 'hex');
+    }
+    const base64 = Buffer.from(trimmed, 'base64');
+    if (base64.length === 32) {
+        return base64;
+    }
+    return createHash('sha256').update(trimmed).digest();
+}
+function getSessionKey() {
+    if (sessionKeyCache) {
+        return sessionKeyCache;
+    }
+    const envKey = process.env[SESSION_KEY_ENV];
+    if (envKey) {
+        sessionKeyCache = deriveKeyFromEnv(envKey);
+        return sessionKeyCache;
+    }
+    if (process.platform !== 'darwin') {
+        throw new Error(`[sessions] Encrypted history requires macOS Keychain or ${SESSION_KEY_ENV} on non-macOS environments.`);
+    }
+    const existing = getSecureValue(SESSION_KEY_SERVICE, SESSION_KEY_ACCOUNT);
+    if (existing) {
+        sessionKeyCache = deriveKeyFromEnv(existing);
+        return sessionKeyCache;
+    }
+    const generated = randomBytes(32).toString('base64');
+    setSecureValue(SESSION_KEY_SERVICE, SESSION_KEY_ACCOUNT, generated);
+    sessionKeyCache = Buffer.from(generated, 'base64');
+    return sessionKeyCache;
+}
+function encryptEntry(entry) {
+    const key = getSessionKey();
+    const iv = randomBytes(12);
+    const cipher = createCipheriv('aes-256-gcm', key, iv);
+    const plaintext = Buffer.from(JSON.stringify(entry), 'utf-8');
+    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const payload = Buffer.concat([iv, tag, ciphertext]).toString('base64');
+    return `${ENCRYPTED_PREFIX}${payload}`;
+}
+function decryptEntry(line) {
+    const key = getSessionKey();
+    const payload = Buffer.from(line.slice(ENCRYPTED_PREFIX.length), 'base64');
+    if (payload.length < 29) {
+        throw new Error('Encrypted session entry payload is invalid');
+    }
+    const iv = payload.subarray(0, 12);
+    const tag = payload.subarray(12, 28);
+    const ciphertext = payload.subarray(28);
+    const decipher = createDecipheriv('aes-256-gcm', key, iv);
+    decipher.setAuthTag(tag);
+    const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString('utf-8');
+    return JSON.parse(plaintext);
+}
+function parseLine(line) {
+    if (!line)
+        return { entry: null, wasPlaintext: false };
+    try {
+        if (line.startsWith(ENCRYPTED_PREFIX)) {
+            return { entry: decryptEntry(line), wasPlaintext: false };
+        }
+        return { entry: JSON.parse(line), wasPlaintext: true };
+    }
+    catch {
+        return { entry: null, wasPlaintext: false };
+    }
+}
+function canEncrypt() {
+    try {
+        getSessionKey();
+        return true;
+    }
+    catch (err) {
+        if (!warnedUnavailable) {
+            warnedUnavailable = true;
+            console.error('[sessions] Encryption unavailable:', err instanceof Error ? err.message : String(err));
+        }
+        return false;
+    }
+}
+function migratePlaintextFile(filePath, entries) {
+    if (!entries.length || !canEncrypt())
+        return;
+    try {
+        const encryptedLines = entries.map(entry => encryptEntry(entry));
+        writeFileSync(filePath, encryptedLines.join('\n') + '\n', 'utf-8');
+        console.log(`[sessions] Migrated plaintext history to encrypted format: ${filePath}`);
+    }
+    catch (err) {
+        console.error('[sessions] Failed to migrate session file:', err);
+    }
+}
+function appendEncryptedEntry(filePath, entry) {
+    if (!canEncrypt()) {
+        throw new Error('Encrypted session storage is unavailable. Configure macOS Keychain access or SKIMPYCLAW_HISTORY_KEY.');
+    }
+    appendFileSync(filePath, encryptEntry(entry) + '\n', 'utf-8');
+}
+export function readSessionEntriesFromFile(filePath) {
     if (!existsSync(filePath))
         return [];
     try {
         const content = readFileSync(filePath, 'utf-8');
         const lines = content.trim().split('\n').filter(Boolean);
-        // Parse all valid lines
         const entries = [];
+        let foundPlaintext = false;
         for (const line of lines) {
-            try {
-                const entry = JSON.parse(line);
-                entries.push(entry);
-            }
-            catch {
-                // Skip malformed lines
+            const parsed = parseLine(line);
+            if (parsed.entry) {
+                entries.push(parsed.entry);
+                if (parsed.wasPlaintext)
+                    foundPlaintext = true;
             }
         }
+        if (foundPlaintext) {
+            migratePlaintextFile(filePath, entries);
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Load last MAX_HISTORY_PAIRS exchanges from disk.
+ * Returns [] if file doesn't exist.
+ */
+export async function loadHistory(platform, chatId) {
+    const filePath = sessionPath(platform, chatId);
+    if (!existsSync(filePath))
+        return [];
+    try {
+        const entries = readSessionEntriesFromFile(filePath);
         // Take last MAX_HISTORY_PAIRS entries
         const usable = entries.filter((entry) => {
             if (entry.summary)
@@ -81,7 +207,7 @@ export async function saveExchange(platform, chatId, userMsg, assistantMsg) {
             user: userMsg,
             assistant: assistantMsg,
         };
-        appendFileSync(filePath, JSON.stringify(entry) + '\n', 'utf-8');
+        appendEncryptedEntry(filePath, entry);
     }
     catch (err) {
         console.error('[sessions] Failed to save exchange:', err);
@@ -100,7 +226,7 @@ export async function saveProactiveMessage(platform, chatId, message) {
             user: message,
             proactive: true,
         };
-        appendFileSync(filePath, JSON.stringify(entry) + '\n', 'utf-8');
+        appendEncryptedEntry(filePath, entry);
     }
     catch (err) {
         console.error('[sessions] Failed to save proactive message:', err);
@@ -120,7 +246,10 @@ export async function replaceWithSummary(platform, chatId, summary) {
             assistant: summary,
             summary: true,
         };
-        writeFileSync(filePath, JSON.stringify(entry) + '\n', 'utf-8');
+        if (!canEncrypt()) {
+            throw new Error('Encrypted session storage is unavailable. Configure macOS Keychain access or SKIMPYCLAW_HISTORY_KEY.');
+        }
+        writeFileSync(filePath, encryptEntry(entry) + '\n', 'utf-8');
     }
     catch (err) {
         console.error('[sessions] Failed to replace with summary:', err);

package/dist/setup-templates.js

@@ -39,25 +39,24 @@ When asked about weather or generating a daily briefing:
 `,
     'web-search': `---
 name: web-search
-description: Search the web using the Browser tool. Opens DuckDuckGo, reads results, and returns findings.
+description: Search the web using Fetch against DuckDuckGo HTML results.
 triggers: ["search", "look up", "google", "find online", "web search"]
 priority: 50
 ---
 
 When asked to search the web:
-1. Use the Browser tool to open https://html.duckduckgo.com/html/?q=<URL-encoded query>
-2. Use getText to read the search results page.
-3. If a specific result looks promising, open that URL and extract the relevant content.
+1. Use Fetch on https://html.duckduckgo.com/html/?q=<URL-encoded query>
+2. Read the returned text for relevant result links and snippets.
+3. If a specific result looks promising, Fetch that URL and extract the relevant content.
 4. Summarize findings concisely — include source URLs.
-5. Close the browser when done.
 
 Do NOT fabricate results. If the search returns nothing useful, say so.
 `,
     'duckduckgo-html-search': `---
 name: duckduckgo-html-search
-description: Search the web via DuckDuckGo HTML results using the Browser tool
+description: Search the web via DuckDuckGo HTML results using Fetch
 emoji: 🦆
-tags: [search, web, browser]
+tags: [search, web, fetch]
 priority: 45
 enabled: true
 ---
@@ -67,15 +66,13 @@ enabled: true
 Use this skill when the user asks for web search, source gathering, or lightweight browsing.
 
 ## Priority rule
-DuckDuckGo HTML via Browser is the default search path.
-- Prefer DuckDuckGo first, even if \\\`$web_search\\\` is available.
-- Use \\\`$web_search\\\` only when the user explicitly asks for it, DuckDuckGo is blocked, or Browser is unavailable.
+DuckDuckGo HTML via Fetch is the default search path.
+- Prefer DuckDuckGo first.
 
 ## Default workflow
 1. Build query URL: \\\`https://duckduckgo.com/html/?q=<urlencoded query>\\\`
-2. Open the URL with Browser.
-3. Wait for result anchors (\\\`a.result__a\\\`) or fallback body text.
-4. Extract results using one Browser \\\`evaluate\\\` call when possible.
+2. Fetch the URL.
+3. Extract result titles, URLs, and snippets from the returned HTML/text when possible.
 5. Return only actually extracted items (never pad count).
 
 ## Extraction requirements
@@ -92,13 +89,6 @@ If a field is missing, set it to \\\`UNAVAILABLE\\\`.
 - Never mix real and invented entries.
 - Include source URLs in output.
 
-## Browser strategy
-- Prefer one-page extraction via \\\`evaluate\\\`:
-  - Collect \\\`a.result__a\\\` for title + href
-  - Collect nearby snippet nodes (\\\`.result__snippet\\\`) when present
-- Use minimal actions: open → waitFor → evaluate → optional screenshot.
-- If selectors change, fallback to visible text extraction and clearly mark reduced confidence.
-
 ## Output format (concise)
 - Query used
 - Result count actually extracted
@@ -148,7 +138,7 @@ export function buildStarterCronJobs(starters) {
     jobs.push({
         id: 'memory-trim',
         name: 'Memory Trim',
-        model: 'claude-fast',
+        model: 'anthropic/claude-haiku-4-5',
         schedule: {
             kind: 'cron',
             expr: '0 0,12 * * *',
@@ -177,13 +167,12 @@ export function buildStarterCronJobs(starters) {
             },
             payload: {
                 kind: 'agentTurn',
-                message: 'Use the Browser tool to visit https://news.ycombinator.com and fetch today\'s top 10 stories. Reply with title, URL, and 1-line summary for each item.',
+                message: 'Use Fetch to read https://news.ycombinator.com and fetch today\'s top 10 stories. Reply with title, URL, and 1-line summary for each item.',
                 tools: {
                     enabled: true,
                     allowedPaths: [`${homedir()}/.skimpyclaw`],
                     maxIterations: 30,
                     bashTimeout: 30000,
-                    browser: { enabled: true, headless: true },
                 },
             },
         });
@@ -199,13 +188,12 @@ export function buildStarterCronJobs(starters) {
             },
             payload: {
                 kind: 'agentTurn',
-                message: `Use the Browser tool to check current weather and today's forecast for ${starters.weatherLocation}. Keep it concise: current temp/conditions, highs/lows, precipitation chance, and 1 recommendation.`,
+                message: `Use Fetch to check current weather and today's forecast for ${starters.weatherLocation}. Keep it concise: current temp/conditions, highs/lows, precipitation chance, and 1 recommendation.`,
                 tools: {
                     enabled: true,
                     allowedPaths: [`${homedir()}/.skimpyclaw`],
                     maxIterations: 30,
                     bashTimeout: 30000,
-                    browser: { enabled: true, headless: true },
                 },
             },
         });