freddie 0.0.91 → 0.0.93

package/AGENTS.md

@@ -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.

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+### Added
+- Dynamic per-(provider × model × access_mode) availability matrix system. New `scripts/build-model-availability.js` enumerates models via existing `discoverModels()` and cross-probes each (model, mode) cell across 7 modes: `direct_api`, `acptoapi_passthrough` (:4800), `freddie_v1` (:4900), `kilo_acp` (:4780), `opencode_acp` (:4790), `claude_cli`, `freddie_agent_loop`. Sampler-aware (`markFailed` on per-cell failure), per-cell timeout 15s, per-provider model cap 5 (both env-tunable). Output: `.gm/model-availability.json` with `{timestamp, config, daemons, providers[].models[].modes{}, sampler, summary}`. Every cell is one of `{ok:true, latency_ms, excerpt}`, `{ok:false, latency_ms, error}`, or `{ok:false, skipped:true, reason}` — no blanks. Witnessed 2026-05-13: 23 providers × up to 5 models × 7 modes; 3 models green-in-any-mode (groq/gpt-oss-20b + claude-cli/haiku + claude-cli/sonnet); 8 individual cells green.
+- `src/agent/model-matrix.js` (28L): `loadMatrix()` + `matrixUsable(provider, model)`. 24h TTL on consumption.
+- `src/agent/llm_resolver.js`: `buildAutoChain` now consults `matrixUsable` and drops links marked `ok:false in all modes`. Matrix-absent path unchanged (preserves existing behavior). Side effect: stale defaults like `nvidia/deepseek-r1` (410 Gone) auto-drop without editing static lists.
+- `plugins/gui-models-discover/plugin.js`: 3 new endpoints — `GET /api/models/availability` (200 with full matrix, 404 if absent), `GET /api/models/availability/summary` (lightweight), `POST /api/models/availability/rebuild` (202 background spawn, 409 if rebuild in flight).
+- `scripts/validate-llm-providers.js`: now invokes the matrix builder by default. `--single-shot` retains the legacy one-model-per-provider behavior; `--with-single-shot` runs both.
+- `test.js`: asserts both `scripts/build-model-availability.js` exists and the `/api/models/availability` endpoint returns 200|404 with valid schema when present.
+
+### 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.91",
+  "version": "0.0.93",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -23,7 +23,7 @@
     "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",

package/plugins/gui-models-discover/plugin.js

@@ -2,6 +2,12 @@ import { discoverAndPersist, listKnownProviders } from '../../src/agent/model-di
 import { PROVIDER_KEYS, DEFAULTS } from '../../src/agent/llm_resolver.js'
 import { getConfigValue, saveConfigValue } from '../../src/config.js'
 import { getStatus } from '../../src/agent/model-sampler.js'
+import fs from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+
+const MATRIX_PATH = path.resolve(new URL('.', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1'), '..', '..', '.gm', 'model-availability.json')
+let _rebuildInFlight = null
 
 export default {
     name: 'gui-models-discover', surfaces: 'gui',
@@ -28,5 +34,22 @@ export default {
             res.json({ ok: true })
         })
         gui.route('GET', '/api/models/sampler', (_, res) => res.json({ status: getStatus() }))
+        gui.route('GET', '/api/models/availability', (_, res) => {
+            if (!fs.existsSync(MATRIX_PATH)) return res.status(404).json({ error: 'not_found', hint: 'run: node scripts/build-model-availability.js' })
+            try { res.json(JSON.parse(fs.readFileSync(MATRIX_PATH, 'utf8'))) }
+            catch (e) { res.status(500).json({ error: String(e.message || e) }) }
+        })
+        gui.route('GET', '/api/models/availability/summary', (_, res) => {
+            if (!fs.existsSync(MATRIX_PATH)) return res.status(404).json({ error: 'not_found' })
+            try { const j = JSON.parse(fs.readFileSync(MATRIX_PATH, 'utf8')); res.json({ timestamp: j.timestamp, daemons: j.daemons, summary: j.summary }) }
+            catch (e) { res.status(500).json({ error: String(e.message || e) }) }
+        })
+        gui.route('POST', '/api/models/availability/rebuild', (_, res) => {
+            if (_rebuildInFlight && !_rebuildInFlight.killed) return res.status(409).json({ error: 'rebuild_in_progress', pid: _rebuildInFlight.pid })
+            const script = path.resolve(path.dirname(MATRIX_PATH), '..', 'scripts', 'build-model-availability.js')
+            _rebuildInFlight = spawn(process.execPath, [script], { detached: true, stdio: 'ignore', cwd: path.dirname(path.dirname(MATRIX_PATH)) })
+            _rebuildInFlight.unref()
+            res.status(202).json({ ok: true, pid: _rebuildInFlight.pid, jobId: String(Date.now()) })
+        })
     },
 }

package/src/agent/llm_resolver.js

@@ -3,6 +3,8 @@ import { callLLM as acptoapiCall, isReachable as acptoapiReachable } from './acp
 import { isAvailable, markFailed, getStatus } from './model-sampler.js'
 import { getConfigValue } from '../config.js'
 import { resolveKey } from './credential_sources.js'
+import { matrixUsable } from './model-matrix.js'
+export { matrixUsable } from './model-matrix.js'
 
 const _require = createRequire(import.meta.url)
 const sdk = _require('acptoapi')
@@ -174,7 +176,10 @@ export function resolveCallLLM({ provider, model } = {}) {
         const links = sdk.buildAutoChain(model || input.model)
         const availableLinks = (await Promise.all(links.map(async l => {
             const prefix = l.model.split('/')[0]
-            return (await hasKey(prefix)) && isAvailable(prefix) ? l : null
+            if (!(await hasKey(prefix)) || !isAvailable(prefix)) return null
+            const mu = matrixUsable(prefix, l.model.replace(/^[^/]+\//, ''))
+            if (mu === false) return null
+            return l
         }))).filter(Boolean)
 
         for (const link of availableLinks) {

package/src/agent/model-matrix.js

@@ -0,0 +1,27 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const MATRIX_PATH = path.resolve(new URL('.', import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, '$1'), '..', '..', '.gm', 'model-availability.json')
+const MATRIX_TTL_MS = 24 * 60 * 60 * 1000
+let _cache = null
+
+export function loadMatrix() {
+    if (_cache && Date.now() - _cache.loadedAt < 60_000) return _cache.data
+    if (!fs.existsSync(MATRIX_PATH)) return null
+    try {
+        const data = JSON.parse(fs.readFileSync(MATRIX_PATH, 'utf8'))
+        if (Date.now() - new Date(data.timestamp).getTime() > MATRIX_TTL_MS) return null
+        _cache = { data, loadedAt: Date.now() }
+        return data
+    } catch { return null }
+}
+
+export function matrixUsable(provider, model) {
+    const m = loadMatrix(); if (!m) return null
+    const p = m.providers.find(x => x.id === provider); if (!p) return null
+    if (!model) return p.models.some(mm => mm.usable_in_any_mode)
+    const mm = p.models.find(x => x.id === model || x.id === model.replace(/^[^/]+\//, ''))
+    return mm ? mm.usable_in_any_mode : null
+}
+
+export const MATRIX_FILE = MATRIX_PATH

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') }