freddie 0.0.41

package/src/rl/atropos.js

@@ -0,0 +1,22 @@
+export class AtroposClient {
+    constructor(opts = {}) {
+        this.url = opts.url || process.env.ATROPOS_URL
+        this.token = opts.token || process.env.ATROPOS_TOKEN
+        this.platform = 'atropos'
+    }
+    getRequiredEnv() { return ['ATROPOS_URL', 'ATROPOS_TOKEN'] }
+    async start() {
+        if (!this.url) throw new Error('AtroposClient: ATROPOS_URL required')
+        const r = await fetch(`${this.url}/health`, { headers: this._headers() })
+        if (!r.ok) throw new Error('atropos health failed: ' + r.status)
+    }
+    _headers() { return this.token ? { authorization: `Bearer ${this.token}` } : {} }
+    async listRollouts() {
+        const r = await fetch(`${this.url}/rollouts`, { headers: this._headers() })
+        if (!r.ok) return []
+        return await r.json()
+    }
+    async submitTrajectory(traj) {
+        return fetch(`${this.url}/trajectories`, { method: 'POST', headers: { ...this._headers(), 'content-type': 'application/json' }, body: JSON.stringify(traj) }).then(r => r.json())
+    }
+}

package/src/rl/cli.js

@@ -0,0 +1,18 @@
+import { logger } from '../observability/log.js'
+
+const log = logger('rl')
+
+export function listRollouts() { return [] }
+export function replayTrajectory(_id) { throw new Error('rl.replay: atropos integration out of scope. Set ATROPOS_URL and provide an adapter.') }
+export function score(_traj) { throw new Error('rl.score: atropos integration out of scope.') }
+
+export function rlSubcommand({ args = [] } = {}) {
+    const [action] = args
+    if (!action || action === 'list') {
+        log.info('rl list')
+        console.log('No rollouts available. Tinker/Atropos integration is documented as a residual; configure ATROPOS_URL and provide an adapter to enable.')
+        return 0
+    }
+    console.log('rl: action "' + action + '" requires Atropos. See ARCHITECTURE residual.')
+    return 1
+}

package/src/sessions.js

@@ -0,0 +1,84 @@
+import { randomUUID } from 'node:crypto'
+import { db as getDb, closeDb as closeDbImpl, resetForTests as resetForTestsImpl } from './db.js'
+
+let _initialized = false
+
+async function initDb() {
+    const d = await getDb()
+    if (_initialized) return d
+    _initialized = true
+
+    await d.exec(`
+        CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY,
+            platform TEXT, user_id TEXT, chat_id TEXT, thread_id TEXT,
+            title TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, model TEXT
+        );
+        CREATE TABLE IF NOT EXISTS messages (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT NOT NULL, role TEXT NOT NULL, content TEXT,
+            tool_calls TEXT, tool_call_id TEXT, ts INTEGER NOT NULL,
+            FOREIGN KEY(session_id) REFERENCES sessions(id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_msg_session ON messages(session_id, ts);
+    `)
+
+    // libsql supports FTS5 natively; create FTS virtual table
+    try {
+        await d.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(content, session_id UNINDEXED, content='messages', content_rowid='id')`)
+        await d.prepare(`CREATE TRIGGER IF NOT EXISTS messages_ai AFTER INSERT ON messages BEGIN INSERT INTO messages_fts(rowid, content, session_id) VALUES (new.id, new.content, new.session_id); END`).run()
+    } catch (e) {
+        console.log('[sessions.js] FTS5 creation failed:', e.message);
+    }
+
+    return d
+}
+
+async function db() {
+    return await initDb()
+}
+
+export async function createSession({ platform = 'cli', userId = null, chatId = null, threadId = null, title = null, model = null } = {}) {
+    const d = await db()
+    const id = randomUUID()
+    const now = Date.now()
+    await d.prepare(`INSERT INTO sessions (id, platform, user_id, chat_id, thread_id, title, created_at, updated_at, model) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, platform, userId, chatId, threadId, title, now, now, model)
+    return id
+}
+
+export async function appendMessage(sessionId, { role, content = '', toolCalls = null, toolCallId = null }) {
+    const d = await db()
+    const now = Date.now()
+    const info = await d.prepare(`INSERT INTO messages (session_id, role, content, tool_calls, tool_call_id, ts) VALUES (?, ?, ?, ?, ?, ?)`)
+        .run(sessionId, role, content, toolCalls ? JSON.stringify(toolCalls) : null, toolCallId, now)
+    await d.prepare(`UPDATE sessions SET updated_at = ? WHERE id = ?`).run(now, sessionId)
+    return info.lastInsertRowid
+}
+
+export async function getMessages(sessionId) {
+    const d = await db()
+    const rows = await d.prepare(`SELECT id, role, content, tool_calls, tool_call_id, ts FROM messages WHERE session_id = ? ORDER BY ts ASC, id ASC`).all(sessionId)
+    return rows.map(r => ({ ...r, tool_calls: r.tool_calls ? JSON.parse(r.tool_calls) : null }))
+}
+
+export async function listSessions(limit = 50) {
+    const d = await db()
+    return await d.prepare(`SELECT id, platform, title, created_at, updated_at, model FROM sessions ORDER BY updated_at DESC LIMIT ?`).all(limit)
+}
+
+export async function search(query, limit = 20) {
+    const d = await db()
+    // Try FTS5 if available (libsql, but not busybase since triggers can't be created)
+    try {
+        const ftsResult = await d.prepare(`SELECT m.id, m.session_id, m.content FROM messages_fts f JOIN messages m ON m.id = f.rowid WHERE messages_fts MATCH ? ORDER BY rank LIMIT ?`).all(query, limit)
+        if (ftsResult && ftsResult.length > 0) return ftsResult
+    } catch (e) {
+        // FTS5 not available, fall through to LIKE
+    }
+    // Fallback to LIKE search
+    return await d.prepare(`SELECT id, session_id, content FROM messages WHERE content LIKE ? ORDER BY ts DESC LIMIT ?`).all(`%${query}%`, limit)
+}
+
+export function closeDb() { return closeDbImpl() }
+export function resetForTests() { return resetForTestsImpl() }

package/src/skills/index.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import yaml from 'js-yaml'
+import os from 'node:os'
+import { getFophHome } from '../home.js'
+
+const FRONTMATTER = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/
+
+export function listSkills(extraDirs = []) {
+    const dirs = [path.join(getFophHome(), 'skills'), path.join(process.cwd(), 'skills'), ...extraDirs]
+    const out = []
+    for (const d of dirs) {
+        if (!fs.existsSync(d)) continue
+        walk(d, out)
+    }
+    return out.filter(s => platformOk(s))
+}
+
+function walk(d, out) {
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+        const full = path.join(d, entry.name)
+        if (entry.isDirectory()) { walk(full, out); continue }
+        if (entry.name === 'SKILL.md') out.push(loadSkill(full))
+    }
+}
+
+export function loadSkill(file) {
+    const raw = fs.readFileSync(file, 'utf8')
+    const m = FRONTMATTER.exec(raw)
+    if (!m) return { file, name: path.basename(path.dirname(file)), description: '', body: raw, frontmatter: {} }
+    const fm = yaml.load(m[1]) || {}
+    return { file, name: fm.name || path.basename(path.dirname(file)), description: fm.description || '', frontmatter: fm, body: m[2], platforms: fm.platforms }
+}
+
+function platformOk(skill) {
+    const plats = skill.platforms || skill.frontmatter?.platforms
+    if (!Array.isArray(plats) || plats.length === 0) return true
+    const platform = os.platform() === 'darwin' ? 'macos' : os.platform()
+    return plats.includes(platform)
+}
+
+export function findSkill(name) { return listSkills().find(s => s.name === name) || null }
+
+export function skillAsUserMessage(name, args = '') {
+    const s = findSkill(name)
+    if (!s) return null
+    const prefix = args ? `Arguments: ${args}\n\n` : ''
+    return { role: 'user', content: `[skill:${name}]\n${prefix}${s.body}` }
+}

package/src/skin/engine.js

@@ -0,0 +1,81 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import yaml from 'js-yaml'
+import { getFophHome } from '../home.js'
+import { getConfigValue, saveConfigValue } from '../config.js'
+
+const _BUILTIN_SKINS = {
+    default: {
+        name: 'default', description: 'Classic gold/kawaii',
+        colors: { banner_border: '#FFD700', banner_title: '#FFD700', banner_accent: '#FFA500', banner_dim: '#666666', banner_text: '#FFFFFF', response_border: '#FFD700' },
+        spinner: { waiting_faces: ['(◡‿◡)', '(◕‿◕)'], thinking_faces: ['(¬‿¬)', '(◔‿◔)'], thinking_verbs: ['thinking', 'pondering'], wings: [['', '']] },
+        branding: { agent_name: 'Freddie', welcome: 'Welcome to Freddie.', response_label: ' ✨ Freddie ', prompt_symbol: '> ' },
+        tool_prefix: '┊', tool_emojis: {},
+    },
+    ares: {
+        name: 'ares', description: 'Crimson/bronze war-god',
+        colors: { banner_border: '#C0392B', banner_title: '#E67E22', banner_accent: '#922B21', banner_dim: '#444444', banner_text: '#ECE0D1', response_border: '#922B21' },
+        spinner: { waiting_faces: ['⚔️ ', '🛡️ '], thinking_faces: ['🔥', '💢'], thinking_verbs: ['marshalling', 'forging'], wings: [['⟨⚔', '⚔⟩']] },
+        branding: { agent_name: 'Ares', welcome: 'Forge with Ares.', response_label: ' 🔥 Ares ', prompt_symbol: '⚔ ' },
+        tool_prefix: '▏',
+    },
+    mono: {
+        name: 'mono', description: 'Grayscale monochrome',
+        colors: { banner_border: '#999999', banner_title: '#FFFFFF', banner_accent: '#CCCCCC', banner_dim: '#555555', banner_text: '#EEEEEE', response_border: '#999999' },
+        spinner: { waiting_faces: ['…'], thinking_faces: ['·'], thinking_verbs: ['thinking'], wings: [['', '']] },
+        branding: { agent_name: 'Freddie', welcome: 'Mono.', response_label: ' Freddie ', prompt_symbol: '> ' },
+        tool_prefix: '|',
+    },
+    slate: {
+        name: 'slate', description: 'Cool blue developer',
+        colors: { banner_border: '#3498DB', banner_title: '#5DADE2', banner_accent: '#2874A6', banner_dim: '#566573', banner_text: '#D6EAF8', response_border: '#3498DB' },
+        spinner: { waiting_faces: ['◆'], thinking_faces: ['◇'], thinking_verbs: ['compiling'], wings: [['', '']] },
+        branding: { agent_name: 'Freddie', welcome: 'Slate ready.', response_label: ' ◆ Freddie ', prompt_symbol: '◆ ' },
+        tool_prefix: '┊',
+    },
+}
+
+let _active = null
+
+export function loadSkin(name) {
+    const userPath = path.join(getFophHome(), 'skins', `${name}.yaml`)
+    if (fs.existsSync(userPath)) {
+        const fromYaml = yaml.load(fs.readFileSync(userPath, 'utf8')) || {}
+        return mergeWithDefault(fromYaml)
+    }
+    if (_BUILTIN_SKINS[name]) return mergeWithDefault(_BUILTIN_SKINS[name])
+    return _BUILTIN_SKINS.default
+}
+
+function mergeWithDefault(skin) {
+    const base = JSON.parse(JSON.stringify(_BUILTIN_SKINS.default))
+    return deepMerge(base, skin)
+}
+
+function deepMerge(t, s) {
+    for (const k of Object.keys(s)) {
+        if (s[k] && typeof s[k] === 'object' && !Array.isArray(s[k]) && t[k] && typeof t[k] === 'object' && !Array.isArray(t[k])) deepMerge(t[k], s[k])
+        else t[k] = s[k]
+    }
+    return t
+}
+
+export function initSkinFromConfig() {
+    const name = getConfigValue('display.skin', 'default')
+    _active = loadSkin(name)
+    return _active
+}
+
+export function getActiveSkin() {
+    if (!_active) initSkinFromConfig()
+    return _active
+}
+
+export function setActiveSkin(name) {
+    _active = loadSkin(name)
+    saveConfigValue('display.skin', name)
+    return _active
+}
+
+export function listBuiltinSkins() { return Object.keys(_BUILTIN_SKINS) }
+export function resetForTests() { _active = null }

package/src/swe/runner.js

@@ -0,0 +1,26 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { runTurn } from '../agent/machine.js'
+import { logger } from '../observability/log.js'
+
+const log = logger('swe')
+
+export async function runMiniSwe({ task, model = null, callLLM = null, env = {}, timeoutMs = 600_000 } = {}) {
+    if (!task || !task.prompt) throw new Error('task.prompt required')
+    log.info('mini-swe start', { task: task.id || 'anon' })
+    const out = await runTurn({ prompt: task.prompt, model, callLLM, timeoutMs })
+    const passed = !out.error && (task.expect ? checkExpect(out.result, task.expect) : true)
+    log.info('mini-swe done', { passed })
+    return { passed, result: out.result, error: out.error, iterations: out.iterations, messages: out.messages }
+}
+function checkExpect(result, expect) {
+    if (typeof expect === 'string') return String(result || '').includes(expect)
+    if (expect instanceof RegExp) return expect.test(String(result || ''))
+    if (typeof expect === 'function') return Boolean(expect(result))
+    return true
+}
+export function loadTask(file) {
+    const txt = fs.readFileSync(file, 'utf8')
+    if (file.endsWith('.json')) return JSON.parse(txt)
+    return { id: path.basename(file, path.extname(file)), prompt: txt }
+}

package/src/time.js

@@ -0,0 +1,25 @@
+export function now() { return Date.now() }
+export function fmtIso(ms = Date.now()) { return new Date(ms).toISOString() }
+const UNITS = { ms: 1, s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000, w: 604_800_000 }
+export function parseDuration(s) {
+    if (typeof s === 'number') return s
+    const m = String(s).trim().match(/^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)$/i)
+    if (!m) throw new Error('bad duration: ' + s)
+    return Math.round(Number(m[1]) * UNITS[m[2].toLowerCase()])
+}
+export function humanizeDuration(ms) {
+    const abs = Math.abs(ms); const p = []
+    const d = Math.floor(abs / UNITS.d); if (d) p.push(d + 'd')
+    const h = Math.floor((abs % UNITS.d) / UNITS.h); if (h) p.push(h + 'h')
+    const m = Math.floor((abs % UNITS.h) / UNITS.m); if (m) p.push(m + 'm')
+    const s = Math.floor((abs % UNITS.m) / 1000); if (s) p.push(s + 's')
+    if (!p.length) p.push((abs % 1000) + 'ms')
+    return p.slice(0, 2).join(' ')
+}
+export function tsRelative(ms, ref = Date.now()) {
+    const diff = ref - ms
+    if (diff < 60_000) return 'just now'
+    if (diff < 3_600_000) return Math.floor(diff / 60_000) + 'm ago'
+    if (diff < 86_400_000) return Math.floor(diff / 3_600_000) + 'h ago'
+    return Math.floor(diff / 86_400_000) + 'd ago'
+}

package/src/tools/ansi_strip.js

@@ -0,0 +1,8 @@
+import { ansiStrip } from '../utils.js'
+import { registry } from './registry.js'
+registry.register({
+    name: 'ansi_strip',
+    toolset: 'core',
+    schema: { name: 'ansi_strip', description: 'Strip ANSI escape sequences.', parameters: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] } },
+    handler: async ({ text }) => ({ text: ansiStrip(text) }),
+})

package/src/tools/approval.js

@@ -0,0 +1,15 @@
+import { registry } from './registry.js'
+
+registry.register({
+    name: 'approval',
+    toolset: 'core',
+    schema: {
+        name: 'approval',
+        description: 'Request approval for a destructive action. Returns the user decision (allow|deny). In non-interactive contexts, defaults to deny unless config.acp.always_allow includes this action.',
+        parameters: { type: 'object', properties: { action: { type: 'string' }, reason: { type: 'string' } }, required: ['action'] },
+    },
+    handler: async ({ action, reason = '' }, ctx = {}) => {
+        if (typeof ctx.askApproval === 'function') return await ctx.askApproval({ action, reason })
+        return { decision: 'deny', reason: 'no interactive approval channel; supply ctx.askApproval' }
+    },
+})

package/src/tools/bash.js

@@ -0,0 +1,35 @@
+import { spawn } from 'node:child_process'
+import { registry } from './registry.js'
+
+registry.register({
+    name: 'bash',
+    toolset: 'core',
+    schema: {
+        name: 'bash',
+        description: 'Run a shell command. Returns stdout/stderr/exitCode.',
+        parameters: {
+            type: 'object',
+            properties: {
+                command: { type: 'string', description: 'Shell command to execute' },
+                cwd: { type: 'string', description: 'Working directory' },
+                timeout_ms: { type: 'number', description: 'Hard timeout in ms', default: 60000 },
+                background: { type: 'boolean', default: false },
+            },
+            required: ['command'],
+        },
+    },
+    handler: async (args) => {
+        const { command, cwd = process.cwd(), timeout_ms = 60000 } = args
+        return await new Promise((resolve) => {
+            const sh = process.platform === 'win32' ? 'cmd' : 'sh'
+            const flag = process.platform === 'win32' ? '/c' : '-c'
+            const child = spawn(sh, [flag, command], { cwd, env: process.env })
+            let stdout = '', stderr = ''
+            const t = setTimeout(() => { try { child.kill('SIGKILL') } catch {} resolve({ exitCode: -1, stdout, stderr: stderr + '\n[timeout]', timedOut: true }) }, timeout_ms)
+            child.stdout?.on('data', d => stdout += d.toString())
+            child.stderr?.on('data', d => stderr += d.toString())
+            child.on('close', code => { clearTimeout(t); resolve({ exitCode: code, stdout, stderr }) })
+            child.on('error', e => { clearTimeout(t); resolve({ exitCode: -1, stdout, stderr: stderr + '\n' + e.message }) })
+        })
+    },
+})

package/src/tools/binary_extensions.js

@@ -0,0 +1,22 @@
+import { registry } from './registry.js'
+
+export const BINARY_EXTENSIONS = new Set([
+    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.ico', '.tiff',
+    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
+    '.zip', '.tar', '.gz', '.bz2', '.xz', '.7z', '.rar',
+    '.exe', '.dll', '.so', '.dylib', '.bin',
+    '.mp3', '.mp4', '.mov', '.avi', '.flac', '.ogg',
+    '.ttf', '.otf', '.woff', '.woff2',
+    '.wasm', '.class', '.jar',
+])
+export function isBinary(filename) {
+    const lower = String(filename).toLowerCase()
+    for (const ext of BINARY_EXTENSIONS) if (lower.endsWith(ext)) return true
+    return false
+}
+registry.register({
+    name: 'binary_extensions',
+    toolset: 'core',
+    schema: { name: 'binary_extensions', description: 'Check whether a filename has a known binary extension.', parameters: { type: 'object', properties: { filename: { type: 'string' } }, required: ['filename'] } },
+    handler: async ({ filename }) => ({ binary: isBinary(filename), known: BINARY_EXTENSIONS.size }),
+})

package/src/tools/browser.js

@@ -0,0 +1,48 @@
+import { registry } from './registry.js'
+
+let _puppeteerAvail = null
+async function probe() {
+    if (_puppeteerAvail !== null) return _puppeteerAvail
+    try { await import('puppeteer-core'); _puppeteerAvail = true } catch { _puppeteerAvail = false }
+    return _puppeteerAvail
+}
+
+registry.register({
+    name: 'browser',
+    toolset: 'browse',
+    schema: {
+        name: 'browser',
+        description: 'Browser automation: navigate, click, type, evaluate, screenshot. Requires puppeteer-core.',
+        parameters: {
+            type: 'object',
+            properties: {
+                action: { type: 'string', enum: ['navigate', 'click', 'type', 'evaluate', 'screenshot', 'text'] },
+                url: { type: 'string' },
+                selector: { type: 'string' },
+                text: { type: 'string' },
+                script: { type: 'string' },
+                path: { type: 'string' },
+            },
+            required: ['action'],
+        },
+    },
+    checkFn: () => true,
+    requiresEnv: ['puppeteer-core'],
+    handler: async (args) => {
+        const ok = await probe()
+        if (!ok) return { error: 'puppeteer-core not installed. Run: npm install puppeteer-core' }
+        const puppeteer = (await import('puppeteer-core')).default
+        const browser = await puppeteer.launch({ headless: 'new' })
+        try {
+            const page = await browser.newPage()
+            const a = args.action
+            if (a === 'navigate') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); return { url: page.url(), title: await page.title() } }
+            if (a === 'click') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); await page.click(args.selector); return { ok: true } }
+            if (a === 'type') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); await page.type(args.selector, args.text); return { ok: true } }
+            if (a === 'evaluate') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); return { result: await page.evaluate(args.script) } }
+            if (a === 'text') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); return { text: await page.evaluate(() => document.body.innerText) } }
+            if (a === 'screenshot') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); await page.screenshot({ path: args.path }); return { saved: args.path } }
+            return { error: 'unknown action: ' + a }
+        } finally { await browser.close() }
+    },
+})

package/src/tools/budget_config.js

@@ -0,0 +1,13 @@
+import { registry } from './registry.js'
+import { getConfigValue, saveConfigValue } from '../config.js'
+
+registry.register({
+    name: 'budget_config',
+    toolset: 'core',
+    schema: { name: 'budget_config', description: 'Read/write per-session token budget limits.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['get', 'set'] }, max_tokens: { type: 'number' }, max_cost_usd: { type: 'number' } }, required: ['action'] } },
+    handler: async ({ action, max_tokens, max_cost_usd }) => {
+        if (action === 'get') return { max_tokens: getConfigValue('budget.max_tokens'), max_cost_usd: getConfigValue('budget.max_cost_usd') }
+        if (action === 'set') { if (typeof max_tokens === 'number') saveConfigValue('budget.max_tokens', max_tokens); if (typeof max_cost_usd === 'number') saveConfigValue('budget.max_cost_usd', max_cost_usd); return { saved: true } }
+        return { error: 'unknown action' }
+    },
+})

package/src/tools/checkpoint.js

@@ -0,0 +1,29 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+import { registry } from './registry.js'
+
+function dir() { const d = path.join(getFophHome(), 'checkpoints'); fs.mkdirSync(d, { recursive: true }); return d }
+
+const ACTIONS = {
+    save: ({ name, data }) => {
+        if (!name) return { error: 'name required' }
+        const p = path.join(dir(), name + '.json')
+        fs.writeFileSync(p, JSON.stringify(data || {}, null, 2), 'utf8')
+        return { saved: p }
+    },
+    load: ({ name }) => {
+        const p = path.join(dir(), name + '.json')
+        if (!fs.existsSync(p)) return { error: 'not found' }
+        return { data: JSON.parse(fs.readFileSync(p, 'utf8')) }
+    },
+    list: () => ({ items: fs.readdirSync(dir()).filter(f => f.endsWith('.json')).map(f => f.replace(/\.json$/, '')) }),
+    delete: ({ name }) => { const p = path.join(dir(), name + '.json'); if (fs.existsSync(p)) fs.unlinkSync(p); return { deleted: name } },
+}
+
+registry.register({
+    name: 'checkpoint',
+    toolset: 'core',
+    schema: { name: 'checkpoint', description: 'Save/load/list/delete named JSON checkpoints under ~/.freddie/checkpoints.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, name: { type: 'string' }, data: {} }, required: ['action'] } },
+    handler: async (args) => { const fn = ACTIONS[args.action]; return fn ? fn(args) : { error: 'unknown action' } },
+})

package/src/tools/clarify.js

@@ -0,0 +1,15 @@
+import { registry } from './registry.js'
+
+registry.register({
+    name: 'clarify',
+    toolset: 'core',
+    schema: {
+        name: 'clarify',
+        description: 'Pose a clarifying question to the user before proceeding. Returns the user response. In non-interactive contexts, returns { error } so the agent must proceed with stated assumption.',
+        parameters: { type: 'object', properties: { question: { type: 'string' }, options: { type: 'array', items: { type: 'string' } } }, required: ['question'] },
+    },
+    handler: async ({ question, options = [] }, ctx = {}) => {
+        if (typeof ctx.askUser === 'function') return await ctx.askUser({ question, options })
+        return { error: 'no interactive channel; assume defaults', question, options }
+    },
+})

package/src/tools/code_execution.js

@@ -0,0 +1,27 @@
+import { spawn } from 'node:child_process'
+import { registry } from './registry.js'
+
+const RUNNERS = {
+    python: ['python', '-c'], python3: ['python3', '-c'],
+    node: ['node', '-e'], deno: ['deno', 'eval'],
+    ruby: ['ruby', '-e'], bash: ['bash', '-c'],
+}
+
+registry.register({
+    name: 'code_execution',
+    toolset: 'core',
+    schema: { name: 'code_execution', description: 'Execute a code snippet in a chosen runner (python, node, deno, ruby, bash). Returns stdout/stderr/exitCode.', parameters: { type: 'object', properties: { code: { type: 'string' }, runner: { type: 'string', enum: Object.keys(RUNNERS), default: 'python' }, timeout_ms: { type: 'number', default: 30000 } }, required: ['code'] } },
+    handler: async ({ code, runner = 'python', timeout_ms = 30000 }) => {
+        const cmd = RUNNERS[runner]
+        if (!cmd) return { error: 'unknown runner: ' + runner }
+        return await new Promise(resolve => {
+            const child = spawn(cmd[0], [cmd[1], code], { env: process.env })
+            let stdout = '', stderr = ''
+            const t = setTimeout(() => { try { child.kill('SIGKILL') } catch {} resolve({ exitCode: -1, stdout, stderr: stderr + '\n[timeout]' }) }, timeout_ms)
+            child.stdout?.on('data', d => stdout += d.toString())
+            child.stderr?.on('data', d => stderr += d.toString())
+            child.on('close', code => { clearTimeout(t); resolve({ exitCode: code, stdout, stderr }) })
+            child.on('error', e => { clearTimeout(t); resolve({ exitCode: -1, stdout, stderr: stderr + '\n' + e.message }) })
+        })
+    },
+})

package/src/tools/credential_files.js

@@ -0,0 +1,16 @@
+import { getAuthStore } from '../auth.js'
+import { registry } from './registry.js'
+
+registry.register({
+    name: 'credential_files',
+    toolset: 'core',
+    schema: { name: 'credential_files', description: 'Get/set credentials in ~/.freddie/auth/.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['get', 'set', 'list', 'delete'] }, name: { type: 'string' }, value: {} }, required: ['action'] } },
+    handler: async ({ action, name, value }) => {
+        const s = getAuthStore()
+        if (action === 'get') return { credential: await s.getCredential(name) }
+        if (action === 'set') return await s.setCredential(name, value)
+        if (action === 'list') return { credentials: await s.listCredentials() }
+        if (action === 'delete') return await s.deleteCredential(name)
+        return { error: 'unknown action' }
+    },
+})

package/src/tools/cronjob.js

@@ -0,0 +1,16 @@
+import { createJob, listJobs, cancelJob, deleteJob } from '../cron/scheduler.js'
+import { registry } from './registry.js'
+
+const ACTIONS = {
+    add: ({ cron, prompt, model = null }) => ({ id: createJob({ cron, prompt, model }) }),
+    list: () => ({ jobs: listJobs() }),
+    cancel: ({ id }) => { cancelJob(id); return { id, cancelled: true } },
+    delete: ({ id }) => { deleteJob(id); return { id, deleted: true } },
+}
+
+registry.register({
+    name: 'cronjob',
+    toolset: 'core',
+    schema: { name: 'cronjob', description: 'Manage agent cron jobs (add, list, cancel, delete).', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, cron: { type: 'string' }, prompt: { type: 'string' }, model: { type: 'string' }, id: { type: 'number' } }, required: ['action'] } },
+    handler: async (args) => { const fn = ACTIONS[args.action]; if (!fn) return { error: 'unknown action' }; try { return fn(args) } catch (e) { return { error: String(e.message || e) } } },
+})

package/src/tools/debug_helpers.js

@@ -0,0 +1,9 @@
+import { registry } from './registry.js'
+import { snapshotAll, listDebug } from '../observability/debug.js'
+
+registry.register({
+    name: 'debug_helpers',
+    toolset: 'core',
+    schema: { name: 'debug_helpers', description: 'Inspect any registered /debug subsystem.', parameters: { type: 'object', properties: { name: { type: 'string' } } } },
+    handler: async ({ name }) => name ? snapshotAll()[name] || { error: 'unknown subsystem: ' + name } : { subsystems: listDebug() },
+})

package/src/tools/delegate.js

@@ -0,0 +1,28 @@
+import { registry } from './registry.js'
+import { runTurn } from '../agent/machine.js'
+
+const MAX_DEPTH = 3
+
+registry.register({
+    name: 'delegate',
+    toolset: 'core',
+    schema: {
+        name: 'delegate',
+        description: 'Spawn a sub-agent to handle a focused task. Returns the sub-agent final result.',
+        parameters: {
+            type: 'object',
+            properties: {
+                task: { type: 'string' },
+                model: { type: 'string' },
+                max_iterations: { type: 'number', default: 30 },
+            },
+            required: ['task'],
+        },
+    },
+    handler: async ({ task, model, max_iterations = 30 }, ctx = {}) => {
+        const depth = (ctx.depth || 0) + 1
+        if (depth > MAX_DEPTH) return { error: `delegate recursion depth exceeded (${MAX_DEPTH})` }
+        const out = await runTurn({ prompt: task, model, callLLM: ctx.callLLM, maxIterations: max_iterations, timeoutMs: 60000 })
+        return { result: out.result, error: out.error, iterations: out.iterations, depth }
+    },
+})

package/src/tools/discord_tool.js

@@ -0,0 +1,13 @@
+import { registry } from './registry.js'
+registry.register({
+    name: 'discord_tool',
+    toolset: 'core',
+    schema: { name: 'discord_tool', description: 'Send a message to a Discord channel via REST.', parameters: { type: 'object', properties: { channel_id: { type: 'string' }, content: { type: 'string' } }, required: ['channel_id', 'content'] } },
+    requiresEnv: ['DISCORD_BOT_TOKEN'],
+    checkFn: () => Boolean(process.env.DISCORD_BOT_TOKEN),
+    handler: async ({ channel_id, content }) => {
+        if (!process.env.DISCORD_BOT_TOKEN) return { error: 'DISCORD_BOT_TOKEN required' }
+        const r = await fetch(`https://discord.com/api/v10/channels/${channel_id}/messages`, { method: 'POST', headers: { authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`, 'content-type': 'application/json' }, body: JSON.stringify({ content }) })
+        return await r.json()
+    },
+})