freddie 0.0.90 → 0.0.92

package/AGENTS.md

@@ -9,7 +9,7 @@ Instructions for AI coding assistants working on Freddie.
 - `@mariozechner/pi-ai` — `complete`, `completeSimple`, `AssistantMessageEventStream`, `registerApiProvider`, `getModel`, `calculateCost`, `parseStreamingJson`, `isContextOverflow`. THE provider layer.
 - `@mariozechner/pi-tui` — TUI primitives (Ink-equivalent).
 - `floosie` v0.6.14 — `ProcessorMachine` (xstate). Use for gateway pipelines.
-- `anentrypoint-design` v0.0.27 — webjsx + ripple-ui. Use for any web UI; do NOT add React. Source in C:/dev/anentrypoint-design; freddie links via `file:../anentrypoint-design`.
+- `anentrypoint-design` ^0.0.94 — webjsx + ripple-ui. Use for any web UI; do NOT add React. Source in C:/dev/anentrypoint-design; freddie depends on the registry build (^0.0.94). For local SDK iteration, swap to `file:../anentrypoint-design` and rebuild via `node scripts/build.mjs`.
 - `xstate` v5 — every long-lived state machine (agent turns, gateway lifecycle, approvals).
 
 ## Plugin architecture (2026-05-03, pre-v1, no compat shims)
@@ -177,6 +177,9 @@ One `test.js` at project root. ≤200 lines. Plain assertions, real data, real s
 - **src/web/app.js 200-line policy violation** — File is 548 lines, violating gm hard cap (2.7× over). Only file in 283-file codebase over limit. Likely waived intentionally or is drift to fix. When touching app.js, prefer splitting into `{app,routes,components,state}.js` over expanding further. Do not add 50+ more lines without addressing the split.
 - **libsql async debt class** — `src/sessions.js` (listSessions/search/getMessages/createSession/appendMessage) and `src/cron/scheduler.js` (listJobs/createJob/cancelJob/deleteJob) are async after the libsql migration. Sync callsites silently wrap each call in a Promise that rejects on iteration, surfacing as `TypeError: ... is not iterable` via `node bin/freddie.js sessions` or `freddie cron list`. Rule: every call into those modules must be awaited; tool ACTIONS inner functions async + handler awaits dispatched fn. Fixed 2026-05-03 across bin/freddie.js, src/web/server.js, src/cli/dump.js, src/cli/status.js, src/tools/session_search.js, src/tools/cronjob.js, src/acp/session.js. test.js can pass while CLI is broken — exercise the cli verb in test.js or smoke `node bin/freddie.js <verb>` after changes.
 - **Bulk-rename: git grep is case-sensitive on literal patterns** — `git grep -lI <name>` only matches lowercase. For case-variant sweep during rename refactors, use `git grep -liI -e <lower> -e <Title> -e <UPPER>` (per-pattern `-i` requires `-e` form). Single-form check is a false-clean trap.
+- **codeinsight detector limits — regex-only** (2026-05-12) — `🔐 hardcoded secrets` and `🔐 SQL injection` flags are pure regex matches on identifier substrings, not value or AST analysis. Confirmed false positives across this codebase: env-var names like `DAYTONA_API_KEY` in `process.env.X` references; function param names like `secret` in HMAC helpers; URL query keys like `?appkey=&appsecret=` (DingTalk API spec); error-message string literals containing `_API_KEY`; HTTP `DELETE` URL paths flagged as SQL `DELETE FROM`. Treat hits as starting points, not findings — always read the actual line. Recurrence tell: if the flagged line is a `process.env.X` reference, a `fetch(...)` URL, or a function-signature parameter name, it's almost certainly an FP.
+- **codeinsight orphan detector blind spots** (2026-05-12) — Misses three reachability paths: (1) `await import('./path/' + variable + '.js')` dynamic strings (test.js line 143 enumerates 10 agent adapters this way); (2) plugin auto-discovery walking `plugins/<dir>/plugin.js` from `discoverPlugins()` in `src/host/host.js`; (3) HTTP-served static files like `src/web/app.js` referenced only from `src/web/index.html`. Real audit needs: scan dynamic-import strings in test.js, exempt plugin/handler files, exempt browser-served paths. 2026-05-12 cleanup: 19 confirmed-dead files deleted (zero references anywhere) — `src/cli/{mcp_config,auth_commands,voice,tips,skills_config,env_loader,plugins_cmd}.js` and `src/agent/{onboarding,skill_preprocessing,skill_utils,subdirectory_hints,lmstudio_reasoning,manual_compression_feedback,memory_manager,insights,prompt_builder,shell_hooks,moonshot_schema,copilot_acp_client}.js`. All were pre-plugin-migration CLI files no longer wired.
+- **createHost decomposition** (2026-05-12) — `src/host/host.js` was 197L with a 111L `createHost` body. Refactored: helper factories `makePi`, `makeGui`, `makeCcHooks`, `makeHooksRegistry`, `makeCcLoaders` (+ `reg`, `guard`, `scopedCfg`, `nullStore`) extracted to sibling `src/host/host_helpers.js` (152L). host.js shrinks to 64L; createHost body ~24L. Both well under 200L cap. Public API unchanged: `import { createHost, discoverPlugins } from './host/host.js'` still works. test.js 12/12 green post-refactor.
 - **freddie exec command Windows invocation** — `plugins/core-cli/plugin.js` registers the `exec` command (commit e5fb1b7) for non-interactive scripted use. Correct invocation on Windows: `bun run bin/freddie.js exec --prompt "..."`. Do NOT use `bun x freddie` — it hangs on Windows due to npm registry fetch timeouts. The command takes `--prompt` (required), `--model` (default ''), `--timeout` (default 60000ms) and is the validated entry point for CI pipelines.
 - **acptoapi-bridge max_tokens silent truncation** — `src/agent/acptoapi-bridge.js` line 20 controls max_tokens passed to the LLM. Prior to commit e5fb1b7, this was set to 1024, which silently truncated responses on generation tasks. Raised to 4096 to prevent hidden content loss. If generation output appears incomplete, verify max_tokens is 4096 or higher.
 - **GitHub Actions deploy-pages@v5 duplicate artifact rejection** — When using `actions/deploy-pages@v5` in a workflow, the action rejects if 2+ artifacts are named "github-pages" (e.g. from a previous failed run re-uploaded by `gh run rerun --failed`). Symptom: deployment step fails with "artifact with name github-pages already exists" or similar. Fix: trigger a fresh run via empty commit instead of rerunning the failed deploy step. `gh run rerun` can silently re-upload transient failures; avoid for deploy failures in particular.
@@ -242,7 +245,7 @@ All 21 named integration tests in `test.js` pass (exit 0). Subsystem coverage:
 ## LLM backends and acptoapi
 
 - **acptoapi bridge** — Integrated at `src/agent/acptoapi-bridge.js` + `src/agent/llm_resolver.js` (commit 5f55f1e). Localhost API (default port 4800) converting OpenAI/Anthropic SDK calls to multiple backends: Kilo Code, opencode, Claude CLI, Anthropic API, Gemini, Ollama, Bedrock. Endpoint `/v1/chat/completions`, OpenAI-compatible, accepts `Bearer none` auth.
-- **acptoapi dep pattern** (2026-05-10) — `package.json` pins `"acptoapi": "file:../acptoapi"` (same pattern as `anentrypoint-design`). Always tracks local SDK without publish cycles. CJS/ESM boundary bridged via `createRequire(import.meta.url)` in freddie ESM files that import acptoapi CJS exports.
+- **acptoapi dep pattern** (2026-05-12) — `package.json` now pins `"acptoapi": "^1.0.55"` from the npm registry (CI auto-bumps on each acptoapi push; restore-package.cjs ROOT FIX prevents file: regressions). For local SDK iteration, swap to `file:../acptoapi` temporarily. CJS/ESM boundary bridged via `createRequire(import.meta.url)` in freddie ESM files that import acptoapi CJS exports.
 - **LLM resolver priority** (2026-05-10) — (1) explicit provider+key, (2) acptoapi if `/v1/models` returns 200, (3) `agent.model_preference` config array (ordered failover, sampler-gated), (4) `sdk.buildAutoChain()` env-key scan, (5) throw. `PROVIDER_KEYS` and `PROVIDER_DEFAULTS` imported from `acptoapi` — not maintained in freddie. `sdk.chat()` returns OpenAI `{choices:[{message}]}` format; `sdkChat()` adapter in llm_resolver converts to freddie's `{content, tool_calls, raw}`.
 - **Model sampler — re-export shim** (2026-05-10) — `src/agent/model-sampler.js` is a 13-line re-export shim over acptoapi sampler. Sampler logic (5-step backoff 30s→480s, createSampler factory, singleton) lives in `c:\dev\acptoapi\lib\sampler.js`. Exports: `isAvailable`, `markFailed`, `markOk`, `resetAvailability`, `getStatus`, `probe`, `startSampler`, `stopSampler`, `createSampler`.
 - **model_preference config key** (2026-05-10) — `agent.model_preference: []` in `~/.freddie/config.yaml`. Array of `{ provider, model? }` objects; `resolveCallLLM` tries each in order, skipping unavailable (sampler-gated) and marking failures with backoff. Config v2 migration adds the key on upgrade from v1.

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
+### Refactored
+- `src/host/host.js`: createHost split from 111L → 24L body. Helper factories (`makePi`, `makeGui`, `makeCcHooks`, `makeHooksRegistry`, `makeCcLoaders`, plus `reg`/`guard`/`scopedCfg`/`nullStore`) extracted to new `src/host/host_helpers.js`. host.js drops from 197L → 64L, host_helpers.js is 152L. Both well under the 200L hard cap. Witnessed: test.js 12/12 green, plugins>=100, platforms>=18, memory>=8, surface guard + cycle errors still throw.
+- `test.js`: trimmed from 202L → 199L (within the 200L cap) by collapsing redundant blank lines and joining the final two control statements. Every assertion preserved. Witnessed 12/12 green.
+
+### Removed (dead code, post-plugin-migration cleanup)
+- 19 zero-import orphan files deleted after exhaustive reachability audit (no static import, no `await import()` string, no test reference, no AGENTS/CHANGELOG mention, no plugin handler call). Files: `src/cli/{mcp_config,auth_commands,voice,tips,skills_config,env_loader,plugins_cmd}.js`, `src/agent/{onboarding,skill_preprocessing,skill_utils,subdirectory_hints,lmstudio_reasoning,manual_compression_feedback,memory_manager,insights,prompt_builder,shell_hooks,moonshot_schema,copilot_acp_client}.js`. test.js 12/12 still green post-delete.
+
+### Witnessed false positives (codeinsight detector limits, documented for future runs)
+- "Hardcoded secrets" flags at `src/agent/auxiliary_client.js:6`, `src/cli/dingtalk_auth.js:10`, `plugins/platform-dingtalk/handler.js:{1,9,31}`, `src/gateway/helpers.js:17` are all detector regex matches on env-var identifiers, function parameter names (`secret`), URL query keys (`?appkey=&appsecret=` — DingTalk API spec), and error-message string literals. Zero actual secrets in source. Detector is regex-only; treat hits as identifier-substring matches, not values.
+- "SQL injection" flags at `src/tools/environments/{daytona,vercel_sandbox}.js`, `src/web/state.js:{35,46}`, `test.js:190` are HTTP DELETE/PUT URL templates in REST clients / browser fetch calls. No SQL anywhere in any of these files. Detector matches the literal `DELETE` keyword in URL paths.
+
+### Dependencies
+- `plugsdk`: ^1.0.15 → ^1.0.16 via `scripts/sync-upstream.mjs`. `acptoapi ^1.0.56`, `anentrypoint-design ^0.0.94`, `gm-cc ^2.0.727` already current.
+
+### Provider witness (2026-05-12, post acptoapi 1.0.56)
+- `.gm/llm-validation.json` regenerated: 5/15 pass — groq, mistral, **cloudflare (NEW, ACCOUNT_ID guard fix worked)**, sambanova, claude-cli all REAL_OK. openrouter regressed to backoff status due to upstream sampler chain ordering after nvidia (deepseek 410 Gone) failed first. kilo + opencode daemons not running (expected).
+
 ### Fixed
 - `src/agent/llm_resolver.js`: assistant tool_calls returning to provider on the second turn were missing OpenAI's required `type:"function"` and `function:{name,arguments:string}` wrapping. Added `toOpenAIMessages()` that wraps assistant tool_calls and stringifies tool message content. Witnessed: mistral previously errored 422 `messages.2.tool_calls.0.type : property "type" is missing`; after fix returns `Emperor Penguin` through full PLAN → EXECUTE → VERIFY → COMPLETE loop. Trajectory artifact at `penguins/.freddie/trajectories/2026-05-12T15-54-49-902-...json`.
 - `plugins/core-cli/plugin.js`: `freddie exec` now uses `resolveCallLLM` instead of hardcoded acptoapi `callLLM` — previously failed `fetch failed` when acptoapi daemon wasn't running, even with valid `--model` and provider key. Added `--provider`, `--skill`, `--cwd` flags; auto-parses `provider/model` from `--model`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.90",
+  "version": "0.0.92",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -23,11 +23,11 @@
     "floosie": "^0.6.14",
     "gm-cc": "^2.0.727",
     "js-yaml": "^4.1.0",
-    "plugsdk": "^1.0.15",
+    "plugsdk": "^1.0.16",
     "xstate": "^5.31.0",
     "zod": "^4.0.0",
     "anentrypoint-design": "^0.0.94",
-    "acptoapi": "^1.0.55"
+    "acptoapi": "^1.0.56"
   },
   "optionalDependencies": {
     "@libsql/darwin-arm64": "0.3.19",

package/src/host/host.js

@@ -1,108 +1,33 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
-import { loadClaudePlugin, createHost as createPluginHost } from 'plugsdk'
-import { validatePlugin, topoSort, HOOK_NAMES, PI_VERBS, GUI_VERBS, FREDDIE_TO_NATIVE_HOOK } from './contract.js'
+import { createHost as createPluginHost } from 'plugsdk'
+import { validatePlugin, topoSort, PI_VERBS, GUI_VERBS } from './contract.js'
+import { makePi, makeGui, guard, scopedCfg, nullStore, makeCcHooks, makeHooksRegistry, makeCcLoaders } from './host_helpers.js'
 
-function reg(map, kind) {
-    return {
-        register(spec) { if (!spec?.name) throw new Error(`${kind}.name required`); map.set(spec.name, spec) },
-        get: (n) => map.get(n), list: () => [...map.values()], has: (n) => map.has(n), size: () => map.size,
-    }
-}
-
-function makePi() {
-    const m = { tools:new Map(), envs:new Map(), commands:new Map(), crons:new Map(), platforms:new Map(),
-                memory:new Map(), skills:new Map(), contexts:new Map(), agentExts:new Map(), cli:new Map() }
-    return {
-        _state: m,
-        tools: reg(m.tools, 'tool'), envs: reg(m.envs, 'env'),
-        commands: reg(m.commands, 'command'), crons: reg(m.crons, 'cron'),
-        platforms: reg(m.platforms, 'platform'), memory: reg(m.memory, 'memory'),
-        skills: reg(m.skills, 'skill'), contexts: reg(m.contexts, 'context'),
-        agentExts: reg(m.agentExts, 'agentExt'), cli: reg(m.cli, 'cli'),
-        async dispatchTool(name, args = {}, ctx = {}) {
-            const t = m.tools.get(name)
-            if (!t) return JSON.stringify({ error: `unknown tool: ${name}` })
-            if (t.checkFn && t.checkFn(t) === false) return JSON.stringify({ error: `tool unavailable: ${name}`, requires: t.requiresEnv || [] })
-            try { const r = await t.handler(args, ctx); return typeof r === 'string' ? r : JSON.stringify(r) }
-            catch (e) { return JSON.stringify({ error: String(e?.message || e), tool: name }) }
-        },
-    }
-}
-
-function makeGui() {
-    const r=[], pages=new Map(), nav=[], debugs=new Map(), apis=new Map(), assets=new Map()
-    return {
-        _state: { routes:r, pages, nav, debugs, apis, assets },
-        route:(method,p,h)=>r.push({method:method.toUpperCase(),path:p,handler:h}),
-        page:(s,d)=>pages.set(s,d), nav:(i)=>nav.push(i),
-        debug:(n,fn)=>debugs.set(n,fn), api:(g,d)=>apis.set(g,d), asset:(p,c)=>assets.set(p,c),
-        routes:{ list:()=>r }, pages:{ get:(s)=>pages.get(s), list:()=>[...pages.values()], has:(s)=>pages.has(s) },
-        navItems:{ list:()=>nav },
-        debugs:{ list:()=>[...debugs.entries()].map(([n,f])=>({name:n,snapshot:f})), get:(n)=>debugs.get(n) },
+function makePluginLoader({ surfaces, pi, gui, hooks, configStore, env, host, loaded }) {
+    return async function load(plugins) {
+        const sorted = topoSort(plugins.map(validatePlugin))
+        for (const p of sorted) {
+            const want = p.surfaces
+            const ctxPi  = (want === 'pi'  || want === 'both') && surfaces.includes('pi')  ? pi  : guard(pi, false, p.name, PI_VERBS)
+            const ctxGui = (want === 'gui' || want === 'both') && surfaces.includes('gui') ? gui : guard(gui, false, p.name, GUI_VERBS)
+            const log = (lv, m, f) => { const line = JSON.stringify({ ts: Date.now(), plugin: p.name, level: lv, msg: m, ...(f || {}) }); if (env.FREDDIE_LOG_STDOUT) console.log(line) }
+            const logger = { info:(m,f)=>log('info',m,f), warn:(m,f)=>log('warn',m,f), error:(m,f)=>log('error',m,f) }
+            const ctx = { pi: ctxPi, gui: ctxGui, hooks, log: logger, config: scopedCfg(p.name, configStore), host, env }
+            await p.register(ctx)
+            loaded.push(p)
+        }
+        return loaded.length
     }
 }
 
-function ccPayloadFor(name, payload) {
-    if (name === 'preToolCall' || name === 'postToolCall')
-        return { tool_name: payload?.name, tool_input: payload?.args || payload?.input, tool_response: payload?.result }
-    if (name === 'onMessageInbound' || name === 'onMessageOutbound')
-        return { prompt: payload?.content || payload?.text || '' }
-    return payload || {}
-}
-
-function guard(surface, allowed, name, verbs) {
-    if (allowed) return surface
-    return new Proxy({}, { get(_, key) {
-        if (verbs.includes(String(key))) return () => { throw new Error(`plugin ${name}: surface verb '${String(key)}' not allowed (declared surfaces=${name})`) }
-        return surface[key]
-    } })
-}
-
-function scopedCfg(name, store) {
-    const k = `plugins.${name}`
-    return { get:(kk,d)=>store.get(`${k}.${kk}`,d), set:(kk,v)=>store.set(`${k}.${kk}`,v), all:()=>store.all(k)||{} }
-}
-
-const nullStore = () => { const m=new Map(); return { get:(k,d)=>m.has(k)?m.get(k):d, set:(k,v)=>m.set(k,v), all:(p)=>Object.fromEntries([...m.entries()].filter(([k])=>k.startsWith(p))) } }
-
 export function createHost({ surfaces = ['pi','gui'], configStore = nullStore(), env = process.env } = {}) {
     const pi = makePi(), gui = makeGui()
     const binPaths = []
     const inboundListeners = []
-    const ccHost = createPluginHost({ env, on: {
-        onSkill:        (p, s) => surfaces.includes('pi') && pi.skills.register({ name: p.manifest.name + ':' + s.name, description: s.description, content: s.body, source: 'cc:' + p.manifest.name, frontmatter: s.fields, file: s.file }),
-        onAgent:        (p, a) => surfaces.includes('pi') && pi.agentExts.register({ name: p.manifest.name + ':' + a.name, description: a.description, frontmatter: a.fields, body: a.body, source: 'cc:' + p.manifest.name, file: a.file }),
-        onCommand:      (p, c) => surfaces.includes('pi') && pi.commands.register({ name: p.manifest.name + ':' + c.name, description: c.description, body: c.body, frontmatter: c.fields, source: 'cc:' + p.manifest.name }),
-        onTheme:        (p, t) => surfaces.includes('pi') && pi.contexts.register({ name: 'theme:' + p.manifest.name + ':' + t.slug, description: t.name, theme: t }),
-        onOutputStyle:  (p, o) => surfaces.includes('pi') && pi.contexts.register({ name: 'style:' + p.manifest.name + ':' + o.name, description: o.description, body: o.body, frontmatter: o.fields }),
-        onChannel:      (p, c) => surfaces.includes('pi') && pi.platforms.register({ name: 'cc:' + p.manifest.name + ':' + c.server, server: c.server, userConfig: c.userConfig || {}, source: 'cc:' + p.manifest.name }),
-        onSetting:      (p, s) => { if (s.agent && surfaces.includes('pi') && !pi.agentExts.has('default')) pi.agentExts.register({ name: 'default', target: p.manifest.name + ':' + s.agent }) },
-        onBin:          (_, dir) => binPaths.push(dir),
-        onMcpTool:      (p, server, tool, call) => surfaces.includes('pi') && pi.tools.register({ name: 'cc:' + p.manifest.name + ':' + server + ':' + tool.name, schema: { name: tool.name, description: tool.description || '', parameters: tool.inputSchema || {} }, handler: (args) => call(args) }),
-        onMonitorLine:  (p, mon, line) => { for (const fn of inboundListeners) fn({ source: 'monitor:' + p.manifest.name + ':' + mon.name, text: line }) },
-    } })
-
-    const reg2 = Object.fromEntries(HOOK_NAMES.map(n => [n, []]))
-    const hooks = {
-        on(name, fn) { if (!HOOK_NAMES.includes(name)) throw new Error(`unknown hook: ${name}`); reg2[name].push(fn) },
-        async invoke(name, payload) {
-            let cur = payload
-            for (const fn of reg2[name] || []) cur = (await fn(cur)) ?? cur
-            const native = FREDDIE_TO_NATIVE_HOOK[name]
-            if (native && ccHost.plugins().length) {
-                const r = await ccHost.dispatch(native, ccPayloadFor(name, cur))
-                if (r.decision === 'block') return { ...cur, behavior: 'block', reason: r.reason }
-                const pd = r.hookSpecificOutput?.permissionDecision
-                if (pd === 'deny') return { ...cur, behavior: 'block', reason: r.hookSpecificOutput?.permissionDecisionReason || 'denied' }
-                if (r.hookSpecificOutput?.updatedInput) return { ...cur, ...r.hookSpecificOutput.updatedInput }
-            }
-            return cur
-        },
-        names: () => HOOK_NAMES, listeners: (n) => [...(reg2[n] || [])],
-    }
-
+    const ccHost = createPluginHost({ env, on: makeCcHooks({ surfaces, pi, binPaths, inboundListeners }) })
+    const hooks = makeHooksRegistry(ccHost)
     const loaded = []
     const host = {
         pi: surfaces.includes('pi') ? pi : null,
@@ -115,67 +40,10 @@ export function createHost({ surfaces = ['pi','gui'], configStore = nullStore(),
         get: (n) => loaded.find(p => p.name === n) || null,
         shutdown: () => ccHost.shutdown(),
     }
-
-    async function load(plugins) {
-        const sorted = topoSort(plugins.map(validatePlugin))
-        for (const p of sorted) {
-            const want = p.surfaces
-            const ctxPi  = (want === 'pi'  || want === 'both') && surfaces.includes('pi')  ? pi  : guard(pi, false, p.name, PI_VERBS)
-            const ctxGui = (want === 'gui' || want === 'both') && surfaces.includes('gui') ? gui : guard(gui, false, p.name, GUI_VERBS)
-            const log = (lv, m, f) => { const line = JSON.stringify({ ts: Date.now(), plugin: p.name, level: lv, msg: m, ...(f || {}) }); if (env.FREDDIE_LOG_STDOUT) console.log(line) }
-            const logger = { info:(m,f)=>log('info',m,f), warn:(m,f)=>log('warn',m,f), error:(m,f)=>log('error',m,f) }
-            const ctx = { pi: ctxPi, gui: ctxGui, hooks, log: logger, config: scopedCfg(p.name, configStore), host, env }
-            await p.register(ctx)
-            loaded.push(p)
-        }
-        return loaded.length
-    }
-    function isCcPluginDir(dir) {
-        if (fs.existsSync(path.join(dir, '.claude-plugin', 'plugin.json'))) return true
-        if (!fs.existsSync(path.join(dir, 'plugin.json'))) return false
-        return fs.existsSync(path.join(dir, 'hooks', 'hooks.json'))
-            || fs.existsSync(path.join(dir, 'skills'))
-            || fs.existsSync(path.join(dir, 'agents'))
-    }
-    async function useCcDir(dir) {
-        try { await ccHost.use(loadClaudePlugin(dir)) }
-        catch (e) { if (env.FREDDIE_LOG_STDOUT) console.error(`cc-plugin ${dir} failed: ${e.message}`) }
-    }
-    async function loadCcPlugins(roots) {
-        for (const root of roots) {
-            if (!root || !fs.existsSync(root)) continue
-            for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
-                if (!entry.isDirectory()) continue
-                const dir = path.join(root, entry.name)
-                if (isCcPluginDir(dir)) await useCcDir(dir)
-            }
-        }
-        return ccHost.plugins().length
-    }
-    async function loadCcFromNodeModules(startDir) {
-        const seen = new Set(ccHost.plugins().map(p => p.root))
-        let cur = path.resolve(startDir)
-        while (true) {
-            const nm = path.join(cur, 'node_modules')
-            if (fs.existsSync(nm)) for (const entry of fs.readdirSync(nm, { withFileTypes: true })) {
-                if (!entry.isDirectory()) continue
-                const dirs = entry.name.startsWith('@')
-                    ? fs.readdirSync(path.join(nm, entry.name), { withFileTypes: true }).filter(e => e.isDirectory()).map(e => path.join(nm, entry.name, e.name))
-                    : [path.join(nm, entry.name)]
-                for (const d of dirs) {
-                    if (seen.has(d) || !isCcPluginDir(d)) continue
-                    seen.add(d); await useCcDir(d)
-                }
-            }
-            const parent = path.dirname(cur)
-            if (parent === cur) break
-            cur = parent
-        }
-        return ccHost.plugins().length
-    }
-    host.load = load
-    host.loadCcPlugins = loadCcPlugins
-    host.loadCcFromNodeModules = loadCcFromNodeModules
+    host.load = makePluginLoader({ surfaces, pi, gui, hooks, configStore, env, host, loaded })
+    const cc = makeCcLoaders(ccHost, env)
+    host.loadCcPlugins = cc.loadCcPlugins
+    host.loadCcFromNodeModules = cc.loadCcFromNodeModules
     return host
 }
 

package/src/host/host_helpers.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { loadClaudePlugin } from 'plugsdk'
+import { HOOK_NAMES, FREDDIE_TO_NATIVE_HOOK } from './contract.js'
+
+export function reg(map, kind) {
+    return {
+        register(spec) { if (!spec?.name) throw new Error(`${kind}.name required`); map.set(spec.name, spec) },
+        get: (n) => map.get(n), list: () => [...map.values()], has: (n) => map.has(n), size: () => map.size,
+    }
+}
+
+export function makePi() {
+    const m = { tools:new Map(), envs:new Map(), commands:new Map(), crons:new Map(), platforms:new Map(),
+                memory:new Map(), skills:new Map(), contexts:new Map(), agentExts:new Map(), cli:new Map() }
+    return {
+        _state: m,
+        tools: reg(m.tools, 'tool'), envs: reg(m.envs, 'env'),
+        commands: reg(m.commands, 'command'), crons: reg(m.crons, 'cron'),
+        platforms: reg(m.platforms, 'platform'), memory: reg(m.memory, 'memory'),
+        skills: reg(m.skills, 'skill'), contexts: reg(m.contexts, 'context'),
+        agentExts: reg(m.agentExts, 'agentExt'), cli: reg(m.cli, 'cli'),
+        async dispatchTool(name, args = {}, ctx = {}) {
+            const t = m.tools.get(name)
+            if (!t) return JSON.stringify({ error: `unknown tool: ${name}` })
+            if (t.checkFn && t.checkFn(t) === false) return JSON.stringify({ error: `tool unavailable: ${name}`, requires: t.requiresEnv || [] })
+            try { const r = await t.handler(args, ctx); return typeof r === 'string' ? r : JSON.stringify(r) }
+            catch (e) { return JSON.stringify({ error: String(e?.message || e), tool: name }) }
+        },
+    }
+}
+
+export function makeGui() {
+    const r=[], pages=new Map(), nav=[], debugs=new Map(), apis=new Map(), assets=new Map()
+    return {
+        _state: { routes:r, pages, nav, debugs, apis, assets },
+        route:(method,p,h)=>r.push({method:method.toUpperCase(),path:p,handler:h}),
+        page:(s,d)=>pages.set(s,d), nav:(i)=>nav.push(i),
+        debug:(n,fn)=>debugs.set(n,fn), api:(g,d)=>apis.set(g,d), asset:(p,c)=>assets.set(p,c),
+        routes:{ list:()=>r }, pages:{ get:(s)=>pages.get(s), list:()=>[...pages.values()], has:(s)=>pages.has(s) },
+        navItems:{ list:()=>nav },
+        debugs:{ list:()=>[...debugs.entries()].map(([n,f])=>({name:n,snapshot:f})), get:(n)=>debugs.get(n) },
+    }
+}
+
+function ccPayloadFor(name, payload) {
+    if (name === 'preToolCall' || name === 'postToolCall')
+        return { tool_name: payload?.name, tool_input: payload?.args || payload?.input, tool_response: payload?.result }
+    if (name === 'onMessageInbound' || name === 'onMessageOutbound')
+        return { prompt: payload?.content || payload?.text || '' }
+    return payload || {}
+}
+
+export function guard(surface, allowed, name, verbs) {
+    if (allowed) return surface
+    return new Proxy({}, { get(_, key) {
+        if (verbs.includes(String(key))) return () => { throw new Error(`plugin ${name}: surface verb '${String(key)}' not allowed (declared surfaces=${name})`) }
+        return surface[key]
+    } })
+}
+
+export function scopedCfg(name, store) {
+    const k = `plugins.${name}`
+    return { get:(kk,d)=>store.get(`${k}.${kk}`,d), set:(kk,v)=>store.set(`${k}.${kk}`,v), all:()=>store.all(k)||{} }
+}
+
+export const nullStore = () => { const m=new Map(); return { get:(k,d)=>m.has(k)?m.get(k):d, set:(k,v)=>m.set(k,v), all:(p)=>Object.fromEntries([...m.entries()].filter(([k])=>k.startsWith(p))) } }
+
+export function makeCcHooks({ surfaces, pi, binPaths, inboundListeners }) {
+    const pi_ok = surfaces.includes('pi')
+    return {
+        onSkill:        (p, s) => pi_ok && pi.skills.register({ name: p.manifest.name + ':' + s.name, description: s.description, content: s.body, source: 'cc:' + p.manifest.name, frontmatter: s.fields, file: s.file }),
+        onAgent:        (p, a) => pi_ok && pi.agentExts.register({ name: p.manifest.name + ':' + a.name, description: a.description, frontmatter: a.fields, body: a.body, source: 'cc:' + p.manifest.name, file: a.file }),
+        onCommand:      (p, c) => pi_ok && pi.commands.register({ name: p.manifest.name + ':' + c.name, description: c.description, body: c.body, frontmatter: c.fields, source: 'cc:' + p.manifest.name }),
+        onTheme:        (p, t) => pi_ok && pi.contexts.register({ name: 'theme:' + p.manifest.name + ':' + t.slug, description: t.name, theme: t }),
+        onOutputStyle:  (p, o) => pi_ok && pi.contexts.register({ name: 'style:' + p.manifest.name + ':' + o.name, description: o.description, body: o.body, frontmatter: o.fields }),
+        onChannel:      (p, c) => pi_ok && pi.platforms.register({ name: 'cc:' + p.manifest.name + ':' + c.server, server: c.server, userConfig: c.userConfig || {}, source: 'cc:' + p.manifest.name }),
+        onSetting:      (p, s) => { if (s.agent && pi_ok && !pi.agentExts.has('default')) pi.agentExts.register({ name: 'default', target: p.manifest.name + ':' + s.agent }) },
+        onBin:          (_, dir) => binPaths.push(dir),
+        onMcpTool:      (p, server, tool, call) => pi_ok && pi.tools.register({ name: 'cc:' + p.manifest.name + ':' + server + ':' + tool.name, schema: { name: tool.name, description: tool.description || '', parameters: tool.inputSchema || {} }, handler: (args) => call(args) }),
+        onMonitorLine:  (p, mon, line) => { for (const fn of inboundListeners) fn({ source: 'monitor:' + p.manifest.name + ':' + mon.name, text: line }) },
+    }
+}
+
+export function makeHooksRegistry(ccHost) {
+    const reg2 = Object.fromEntries(HOOK_NAMES.map(n => [n, []]))
+    return {
+        on(name, fn) { if (!HOOK_NAMES.includes(name)) throw new Error(`unknown hook: ${name}`); reg2[name].push(fn) },
+        async invoke(name, payload) {
+            let cur = payload
+            for (const fn of reg2[name] || []) cur = (await fn(cur)) ?? cur
+            const native = FREDDIE_TO_NATIVE_HOOK[name]
+            if (native && ccHost.plugins().length) {
+                const r = await ccHost.dispatch(native, ccPayloadFor(name, cur))
+                if (r.decision === 'block') return { ...cur, behavior: 'block', reason: r.reason }
+                const pd = r.hookSpecificOutput?.permissionDecision
+                if (pd === 'deny') return { ...cur, behavior: 'block', reason: r.hookSpecificOutput?.permissionDecisionReason || 'denied' }
+                if (r.hookSpecificOutput?.updatedInput) return { ...cur, ...r.hookSpecificOutput.updatedInput }
+            }
+            return cur
+        },
+        names: () => HOOK_NAMES, listeners: (n) => [...(reg2[n] || [])],
+    }
+}
+
+function isCcPluginDir(dir) {
+    if (fs.existsSync(path.join(dir, '.claude-plugin', 'plugin.json'))) return true
+    if (!fs.existsSync(path.join(dir, 'plugin.json'))) return false
+    return fs.existsSync(path.join(dir, 'hooks', 'hooks.json'))
+        || fs.existsSync(path.join(dir, 'skills'))
+        || fs.existsSync(path.join(dir, 'agents'))
+}
+
+export function makeCcLoaders(ccHost, env) {
+    async function useCcDir(dir) {
+        try { await ccHost.use(loadClaudePlugin(dir)) }
+        catch (e) { if (env.FREDDIE_LOG_STDOUT) console.error(`cc-plugin ${dir} failed: ${e.message}`) }
+    }
+    async function loadCcPlugins(roots) {
+        for (const root of roots) {
+            if (!root || !fs.existsSync(root)) continue
+            for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!entry.isDirectory()) continue
+                const dir = path.join(root, entry.name)
+                if (isCcPluginDir(dir)) await useCcDir(dir)
+            }
+        }
+        return ccHost.plugins().length
+    }
+    async function loadCcFromNodeModules(startDir) {
+        const seen = new Set(ccHost.plugins().map(p => p.root))
+        let cur = path.resolve(startDir)
+        while (true) {
+            const nm = path.join(cur, 'node_modules')
+            if (fs.existsSync(nm)) for (const entry of fs.readdirSync(nm, { withFileTypes: true })) {
+                if (!entry.isDirectory()) continue
+                const dirs = entry.name.startsWith('@')
+                    ? fs.readdirSync(path.join(nm, entry.name), { withFileTypes: true }).filter(e => e.isDirectory()).map(e => path.join(nm, entry.name, e.name))
+                    : [path.join(nm, entry.name)]
+                for (const d of dirs) {
+                    if (seen.has(d) || !isCcPluginDir(d)) continue
+                    seen.add(d); await useCcDir(d)
+                }
+            }
+            const parent = path.dirname(cur)
+            if (parent === cur) break
+            cur = parent
+        }
+        return ccHost.plugins().length
+    }
+    return { loadCcPlugins, loadCcFromNodeModules }
+}

package/src/agent/copilot_acp_client.js

@@ -1,6 +0,0 @@
-export class CopilotAcpClient {
-    constructor({ url, token } = {}) { this.url = url || process.env.COPILOT_ACP_URL; this.token = token || process.env.COPILOT_TOKEN }
-    headers() { return this.token ? { authorization: 'Bearer ' + this.token } : {} }
-    async listModels() { if (!this.url) throw new Error('COPILOT_ACP_URL required'); return await (await fetch(this.url + '/models', { headers: this.headers() })).json() }
-    async chat({ messages, model }) { if (!this.url) throw new Error('COPILOT_ACP_URL required'); return await (await fetch(this.url + '/chat', { method: 'POST', headers: { ...this.headers(), 'content-type': 'application/json' }, body: JSON.stringify({ messages, model }) })).json() }
-}

package/src/agent/insights.js

@@ -1,9 +0,0 @@
-import { db } from '../sessions.js'
-import { calculateCost } from './usage_pricing.js'
-export function modelInsights() {
-    const rows = db().prepare(`SELECT model, SUM(prompt_tokens) AS p, SUM(completion_tokens) AS c, SUM(cost_usd) AS cost, COUNT(*) AS calls FROM account_usage GROUP BY model`).all()
-    return rows.map(r => ({ ...r, has_pricing: calculateCost({ model: r.model, prompt_tokens: 1, completion_tokens: 1 }) > 0 }))
-}
-export function sessionInsights(sessionId) {
-    return db().prepare(`SELECT model, SUM(prompt_tokens) AS p, SUM(completion_tokens) AS c, SUM(cost_usd) AS cost FROM account_usage WHERE session_id = ? GROUP BY model`).all(sessionId)
-}

package/src/agent/lmstudio_reasoning.js

@@ -1,13 +0,0 @@
-export function extractReasoning(content) {
-    const tags = [/<think>([\s\S]*?)<\/think>/g, /<reasoning>([\s\S]*?)<\/reasoning>/g]
-    const reasoning = []
-    let cleaned = String(content || '')
-    for (const re of tags) {
-        for (const m of cleaned.matchAll(re)) reasoning.push(m[1])
-        cleaned = cleaned.replace(re, '')
-    }
-    return { reasoning: reasoning.join('\n').trim(), content: cleaned.trim() }
-}
-export function isLmStudio(provider, baseUrl) {
-    return provider === 'lmstudio' || /(^|\.)lmstudio\.|:1234\b|:8000\b/.test(String(baseUrl || ''))
-}

package/src/agent/manual_compression_feedback.js

@@ -1,5 +0,0 @@
-import { db } from '../db.js'
-async function init() { const d = await db(); await d.exec(`CREATE TABLE IF NOT EXISTS compression_feedback (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, summary TEXT, rating INTEGER, notes TEXT, ts INTEGER NOT NULL)`); return d }
-export async function record({ sessionId, summary, rating, notes = '' }) { await (await init()).prepare(`INSERT INTO compression_feedback (session_id, summary, rating, notes, ts) VALUES (?, ?, ?, ?, ?)`).run(sessionId, summary || '', rating, notes, Date.now()); return { recorded: true } }
-export async function listForSession(sessionId) { return await (await init()).prepare(`SELECT * FROM compression_feedback WHERE session_id = ? ORDER BY id DESC`).all(sessionId) }
-export async function aggregate() { return await (await init()).prepare(`SELECT AVG(rating) AS avg, COUNT(*) AS n FROM compression_feedback`).get() }

package/src/agent/memory_manager.js

@@ -1,14 +0,0 @@
-import { createMemoryProvider, listMemoryProviders } from '../plugins/memory/provider.js'
-import { getConfigValue } from '../config.js'
-let _provider = null
-export function getMemoryProvider() {
-    if (_provider) return _provider
-    const name = getConfigValue('memory.provider')
-    if (!name) return null
-    try { _provider = createMemoryProvider(name, getConfigValue('memory.options', {})) } catch { _provider = null }
-    return _provider
-}
-export async function syncTurnIfConfigured(messages) { const p = getMemoryProvider(); if (p) try { return await p.syncTurn(messages) } catch (e) { return { error: String(e.message || e) } } return null }
-export async function prefetchIfConfigured(query) { const p = getMemoryProvider(); if (p) try { return await p.prefetch(query) } catch { return { items: [] } } return { items: [] } }
-export function listAvailable() { return listMemoryProviders() }
-export function resetForTests() { _provider = null }

package/src/agent/moonshot_schema.js

@@ -1,11 +0,0 @@
-export function adaptToolSchema(tool) {
-    const s = { type: 'function', function: { name: tool.name, description: tool.description, parameters: tool.input_schema || tool.parameters || { type: 'object', properties: {} } } }
-    if (s.function.parameters.required && !s.function.parameters.required.length) delete s.function.parameters.required
-    return s
-}
-export function adaptMessages(messages) {
-    return messages.map(m => {
-        if (m.role === 'tool') return { role: 'tool', tool_call_id: m.tool_call_id, content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content) }
-        return m
-    })
-}

package/src/agent/onboarding.js

@@ -1,16 +0,0 @@
-import { getConfigValue, saveConfigValue } from '../config.js'
-import { getAuthStore } from '../auth.js'
-const STEPS = ['provider', 'api-key', 'model', 'skin', 'memory']
-export async function isOnboardingComplete() { return Boolean(getConfigValue('onboarding.completed')) }
-export async function nextStep() {
-    if (!getConfigValue('agent.provider')) return 'provider'
-    const provider = getConfigValue('agent.provider')
-    const env = (provider || '').toUpperCase() + '_API_KEY'
-    if (!process.env[env] && !(await getAuthStore().getCredential(env))) return 'api-key'
-    if (!getConfigValue('agent.model')) return 'model'
-    if (!getConfigValue('display.skin')) return 'skin'
-    if (!getConfigValue('memory.provider')) return 'memory'
-    return null
-}
-export async function markComplete() { saveConfigValue('onboarding.completed', Date.now()) }
-export const ONBOARDING_STEPS = STEPS

package/src/agent/prompt_builder.js

@@ -1,12 +0,0 @@
-import { SUMMARY_PREFIX } from './compress/index.js'
-export function buildSystemPrompt({ persona = '', skills = [], context = [], cacheBreakpoint = true } = {}) {
-    const parts = []
-    if (persona) parts.push(persona)
-    if (skills.length) parts.push('## Available skills\n' + skills.map(s => '- ' + s.name + ': ' + (s.description || '')).join('\n'))
-    if (context.length) parts.push('## Context\n' + context.map(c => '[' + c.name + ']\n' + c.body).join('\n\n'))
-    return { content: parts.join('\n\n'), cacheBreakpoint }
-}
-export function injectSummaryHandoff(messages, summary) {
-    if (!summary) return messages
-    return [...messages, { role: 'user', content: SUMMARY_PREFIX + '\n\n' + summary }]
-}

package/src/agent/shell_hooks.js

@@ -1,16 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFreddieHome } from '../home.js'
-function hookFile() { return path.join(getFreddieHome(), 'shell-hooks.json') }
-export function loadHooks() { try { return JSON.parse(fs.readFileSync(hookFile(), 'utf8')) } catch { return { pre_run: [], post_run: [] } } }
-export function saveHooks(h) { fs.writeFileSync(hookFile(), JSON.stringify(h, null, 2), 'utf8') }
-export function addHook(stage, command) { const h = loadHooks(); (h[stage] = h[stage] || []).push(command); saveHooks(h); return h }
-export async function runHooks(stage, ctx = {}) {
-    const { spawnSync } = await import('node:child_process')
-    const out = []
-    for (const cmd of (loadHooks()[stage] || [])) {
-        const r = spawnSync(process.platform === 'win32' ? 'cmd' : 'sh', [process.platform === 'win32' ? '/c' : '-c', cmd], { encoding: 'utf8', env: { ...process.env, ...ctx.env } })
-        out.push({ cmd, exitCode: r.status, stdout: r.stdout, stderr: r.stderr })
-    }
-    return out
-}

package/src/agent/skill_preprocessing.js

@@ -1,12 +0,0 @@
-import { findSkill } from '../skills/index.js'
-const REF_RE = /@skill\/([\w-]+)(?:\s+([^\n@]*))?/g
-export function preprocessSkillRefs(text) {
-    if (!text || typeof text !== 'string') return text
-    return text.replace(REF_RE, (m, name, args) => {
-        const s = findSkill(name)
-        return s ? '\n[skill:' + name + ']\n' + s.body + '\n' : m
-    })
-}
-export function listSkillRefs(text) {
-    return [...String(text || '').matchAll(REF_RE)].map(m => ({ name: m[1], args: m[2]?.trim() || '' }))
-}

package/src/agent/skill_utils.js

@@ -1,14 +0,0 @@
-import { listSkills, findSkill } from '../skills/index.js'
-export function fuzzyFindSkill(needle) {
-    const all = listSkills()
-    const lower = String(needle).toLowerCase()
-    const exact = all.find(s => s.name.toLowerCase() === lower)
-    if (exact) return exact
-    const starts = all.find(s => s.name.toLowerCase().startsWith(lower))
-    if (starts) return starts
-    return all.find(s => s.name.toLowerCase().includes(lower)) || null
-}
-export function skillByCategory(category) {
-    return listSkills().filter(s => s.frontmatter?.category === category)
-}
-export function skillExists(name) { return Boolean(findSkill(name)) }

package/src/agent/subdirectory_hints.js

@@ -1,17 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-const HINT_FILES = ['CLAUDE.md', 'AGENTS.md', '.freddie-context', 'README.md']
-export function collectHints({ cwd = process.cwd(), maxDepth = 3 } = {}) {
-    const hints = []
-    let dir = cwd
-    for (let d = 0; d < maxDepth; d++) {
-        for (const f of HINT_FILES) {
-            const p = path.join(dir, f)
-            if (fs.existsSync(p)) { try { hints.push({ path: p, body: fs.readFileSync(p, 'utf8').slice(0, 4000) }) } catch {} }
-        }
-        const parent = path.dirname(dir)
-        if (parent === dir) break
-        dir = parent
-    }
-    return hints
-}

package/src/cli/auth_commands.js

@@ -1,17 +0,0 @@
-import { getAuthStore } from '../auth.js'
-import { listProviders, resolveKey } from '../agent/credential_sources.js'
-export async function login(provider, key) {
-    const env = (provider.toUpperCase() + '_API_KEY')
-    await getAuthStore().setCredential(env, key)
-    return { provider, stored: env }
-}
-export async function logout(provider) {
-    const env = (provider.toUpperCase() + '_API_KEY')
-    await getAuthStore().deleteCredential(env)
-    return { provider, removed: env }
-}
-export async function status() {
-    const out = []
-    for (const p of listProviders()) { const k = await resolveKey(p); out.push({ provider: p, source: k.source, hasKey: k.value != null }) }
-    return out
-}

package/src/cli/env_loader.js

@@ -1,25 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFreddieHome } from '../home.js'
-const RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/
-function parse(text) {
-    const out = {}
-    for (const line of String(text).split('\n')) {
-        const t = line.trim()
-        if (!t || t.startsWith('#')) continue
-        const m = t.match(RE)
-        if (m) out[m[1]] = m[2].replace(/^["']|["']$/g, '')
-    }
-    return out
-}
-export function loadEnvFile(file = null) {
-    const candidates = file ? [file] : [path.join(getFreddieHome(), '.env'), path.join(process.cwd(), '.env')]
-    const merged = {}
-    for (const f of candidates) if (fs.existsSync(f)) Object.assign(merged, parse(fs.readFileSync(f, 'utf8')))
-    return merged
-}
-export function applyEnvFile(file = null) {
-    const env = loadEnvFile(file)
-    for (const [k, v] of Object.entries(env)) if (!(k in process.env)) process.env[k] = v
-    return Object.keys(env).length
-}

package/src/cli/mcp_config.js

@@ -1,9 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFreddieHome } from '../home.js'
-function file() { return path.join(getFreddieHome(), 'mcp.json') }
-export function loadMcpConfig() { try { return JSON.parse(fs.readFileSync(file(), 'utf8')) } catch { return { servers: {} } } }
-export function saveMcpConfig(cfg) { fs.writeFileSync(file(), JSON.stringify(cfg, null, 2), 'utf8') }
-export function addServer(name, { command, args = [], env = {} }) { const c = loadMcpConfig(); c.servers[name] = { command, args, env }; saveMcpConfig(c); return c.servers[name] }
-export function removeServer(name) { const c = loadMcpConfig(); delete c.servers[name]; saveMcpConfig(c); return name }
-export function listServers() { return Object.entries(loadMcpConfig().servers).map(([n, s]) => ({ name: n, ...s })) }

package/src/cli/plugins_cmd.js

@@ -1,21 +0,0 @@
-import { listPluginsInstalled, listHooks, listCliCommands } from './plugins.js'
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFreddieHome } from '../home.js'
-export async function pluginsSubcommand(action = 'list', { name, body } = {}) {
-    if (action === 'list') return { plugins: await listPluginsInstalled(), hooks: listHooks(), cliCommands: listCliCommands().length }
-    if (action === 'install') {
-        if (!name || !body) return { error: 'name + body required' }
-        const dir = path.join(getFreddieHome(), 'plugins', name)
-        fs.mkdirSync(dir, { recursive: true })
-        fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify({ name, main: 'index.js' }, null, 2))
-        fs.writeFileSync(path.join(dir, 'index.js'), body, 'utf8')
-        return { installed: dir }
-    }
-    if (action === 'uninstall') {
-        const dir = path.join(getFreddieHome(), 'plugins', name)
-        if (fs.existsSync(dir)) { fs.rmSync(dir, { recursive: true, force: true }); return { uninstalled: name } }
-        return { error: 'not found' }
-    }
-    return { error: 'unknown action' }
-}

package/src/cli/skills_config.js

@@ -1,6 +0,0 @@
-import { getConfigValue, saveConfigValue } from '../config.js'
-export function getSkillsConfig() { return getConfigValue('skills.config', {}) || {} }
-export function setSkillConfig(name, opts) { const cfg = getSkillsConfig(); cfg[name] = { ...(cfg[name] || {}), ...opts }; saveConfigValue('skills.config', cfg); return cfg[name] }
-export function disableSkill(name) { return setSkillConfig(name, { disabled: true }) }
-export function enableSkill(name) { const cfg = getSkillsConfig(); delete cfg[name]?.disabled; saveConfigValue('skills.config', cfg); return cfg[name] }
-export function isSkillEnabled(name) { return !getSkillsConfig()[name]?.disabled }

package/src/cli/tips.js

@@ -1,14 +0,0 @@
-export const TIPS = [
-    'Use /skill <name> to inject a skill body as a user message — preserves prompt cache.',
-    'Profiles isolate state: freddie profile create <name>; FREDDIE_PROFILE=<name> freddie ...',
-    'freddie doctor checks env, deps, config — run when something feels off.',
-    'freddie dump exports your config + sessions to JSON for backup.',
-    'Set FREDDIE_DEBUG=1 to see verbose logs.',
-    'freddie dashboard runs a webjsx UI on a local port.',
-    '/cron add "*/15 * * * *" "your prompt" schedules a recurring run.',
-    'freddie batch <file.txt> runs many prompts in parallel.',
-    'Skin not for you? freddie skin ares|mono|slate.',
-    'Memory provider: freddie memory-setup.',
-]
-export function randomTip() { return TIPS[Math.floor(Math.random() * TIPS.length)] }
-export function listTips() { return TIPS }

package/src/cli/voice.js

@@ -1,6 +0,0 @@
-import { getConfigValue, saveConfigValue } from '../config.js'
-export function voiceState() { return Boolean(getConfigValue('voice.enabled')) }
-export function enable() { saveConfigValue('voice.enabled', true); return { enabled: true } }
-export function disable() { saveConfigValue('voice.enabled', false); return { enabled: false } }
-export function setBackend(name) { saveConfigValue('voice.backend', name); return { backend: name } }
-export function getBackend() { return getConfigValue('voice.backend', 'openai') }