freddie 0.0.41 → 0.0.42

package/src/cli/dump.js

@@ -1,10 +1,12 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../home.js'
+import { getFreddieHome } from '../home.js'
 import { listSessions, getMessages } from '../sessions.js'
 import { loadConfig } from '../config.js'
 export async function dumpAll(outFile = null) {
-    const out = { ts: Date.now(), foph_home: getFophHome(), config: loadConfig(), sessions: listSessions(1000).map(s => ({ ...s, messages: getMessages(s.id) })) }
+    const sessions = await listSessions(1000)
+    const enriched = await Promise.all(sessions.map(async s => ({ ...s, messages: await getMessages(s.id) })))
+    const out = { ts: Date.now(), freddie_home: getFreddieHome(), config: loadConfig(), sessions: enriched }
     const json = JSON.stringify(out, null, 2)
     if (outFile) { fs.mkdirSync(path.dirname(outFile), { recursive: true }); fs.writeFileSync(outFile, json, 'utf8'); return { written: outFile, bytes: json.length } }
     return out

package/src/cli/env_loader.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../home.js'
+import { getFreddieHome } from '../home.js'
 const RE = /^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/
 function parse(text) {
     const out = {}
@@ -13,7 +13,7 @@ function parse(text) {
     return out
 }
 export function loadEnvFile(file = null) {
-    const candidates = file ? [file] : [path.join(getFophHome(), '.env'), path.join(process.cwd(), '.env')]
+    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

package/src/cli/gateway_cli.js

@@ -1,12 +1,11 @@
 import { Gateway } from '../gateway/run.js'
-import { WebhookAdapter } from '../gateway/platforms/webhook.js'
-import { ApiServerAdapter } from '../gateway/platforms/api_server.js'
+import { makePlatform } from '../gateway/platforms.js'
 import { registerBuiltinHooks } from '../gateway/builtin_hooks/index.js'
 let _gateway = null
 export async function startGateway({ port = 0, hooks = true } = {}) {
     if (_gateway) return _gateway
-    const wh = new WebhookAdapter({ port })
-    const api = new ApiServerAdapter({ port: 0 })
+    const wh = await makePlatform('webhook', { port })
+    const api = await makePlatform('api_server', { port: 0 })
     const gw = new Gateway({ platforms: { webhook: wh, api_server: api } })
     if (hooks) registerBuiltinHooks(gw)
     await gw.start()

package/src/cli/hooks.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../home.js'
-function file() { return path.join(getFophHome(), 'hooks.json') }
+import { getFreddieHome } from '../home.js'
+function file() { return path.join(getFreddieHome(), 'hooks.json') }
 export function loadHooks() { try { return JSON.parse(fs.readFileSync(file(), 'utf8')) } catch { return { pre_command: [], post_command: [], pre_tool: [], post_tool: [] } } }
 export function saveHooks(h) { fs.writeFileSync(file(), JSON.stringify(h, null, 2), 'utf8') }
 export function addHook(stage, command) { const h = loadHooks(); (h[stage] = h[stage] || []).push(command); saveHooks(h); return h }

package/src/cli/logs.js

@@ -1,13 +1,13 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../home.js'
+import { getFreddieHome } from '../home.js'
 export function listLogFiles() {
-    const dir = path.join(getFophHome(), 'logs')
+    const dir = path.join(getFreddieHome(), 'logs')
     if (!fs.existsSync(dir)) return []
     return fs.readdirSync(dir).filter(f => f.endsWith('.log')).map(f => f.replace(/\.log$/, ''))
 }
 export function tail(subsystem, { max = 100, level = null } = {}) {
-    const file = path.join(getFophHome(), 'logs', subsystem + '.log')
+    const file = path.join(getFreddieHome(), 'logs', subsystem + '.log')
     if (!fs.existsSync(file)) return []
     const lines = fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean)
     let parsed = lines.map(l => { try { return JSON.parse(l) } catch { return { raw: l } } })
@@ -15,7 +15,7 @@ export function tail(subsystem, { max = 100, level = null } = {}) {
     return parsed.slice(-max)
 }
 export async function followLog(subsystem, onLine) {
-    const file = path.join(getFophHome(), 'logs', subsystem + '.log')
+    const file = path.join(getFreddieHome(), 'logs', subsystem + '.log')
     let pos = fs.existsSync(file) ? fs.statSync(file).size : 0
     const watcher = fs.watch(path.dirname(file), (_, name) => {
         if (name !== subsystem + '.log') return

package/src/cli/mcp_config.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../home.js'
-function file() { return path.join(getFophHome(), 'mcp.json') }
+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] }

package/src/cli/plugins_cmd.js

@@ -1,19 +1,19 @@
 import { listPluginsInstalled, listHooks, listCliCommands } from './plugins.js'
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../home.js'
+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(getFophHome(), 'plugins', name)
+        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(getFophHome(), 'plugins', name)
+        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' }
     }

package/src/cli/status.js

@@ -6,5 +6,5 @@ import { totalLifetime } from '../agent/account_usage.js'
 import { runDoctor } from './doctor.js'
 export async function systemStatus() {
     const rt = await activeRuntime()
-    return { runtime: rt, profile: activeProfile(), skin: getActiveSkin().name, sessions: listSessions(5).length, lifetimeUsage: totalLifetime(), doctor: runDoctor().filter(c => !c.ok) }
+    return { runtime: rt, profile: activeProfile(), skin: getActiveSkin().name, sessions: (await listSessions(5)).length, lifetimeUsage: await totalLifetime(), doctor: runDoctor().filter(c => !c.ok) }
 }

package/src/cli/tools_config.js

@@ -1,8 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../home.js'
+import { getFreddieHome } from '../home.js'
 
-function file() { return path.join(getFophHome(), 'tools_config.json') }
+function file() { return path.join(getFreddieHome(), 'tools_config.json') }
 export function loadToolsConfig() { try { return JSON.parse(fs.readFileSync(file(), 'utf8')) } catch { return {} } }
 export function saveToolsConfig(cfg) { fs.writeFileSync(file(), JSON.stringify(cfg, null, 2), 'utf8') }
 export function setToolOverride(toolName, override) {

package/src/cli/uninstall.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs'
-import { getFophHome } from '../home.js'
+import { getFreddieHome } from '../home.js'
 export function uninstall({ keepData = true } = {}) {
-    const home = getFophHome()
+    const home = getFreddieHome()
     const removed = []
     if (!keepData && fs.existsSync(home)) { fs.rmSync(home, { recursive: true, force: true }); removed.push(home) }
     return { removed, keepData, hint: 'npm uninstall -g freddie (or remove your local checkout)' }

package/src/config.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import yaml from 'js-yaml'
-import { getFophHome } from './home.js'
+import { getFreddieHome } from './home.js'
 
 export const DEFAULT_CONFIG = {
     _config_version: 1,
@@ -19,7 +19,7 @@ const MIGRATIONS = {
     1: cfg => cfg,
 }
 
-export function configPath() { return path.join(getFophHome(), 'config.yaml') }
+export function configPath() { return path.join(getFreddieHome(), 'config.yaml') }
 
 export function loadConfig() {
     const p = configPath()

package/src/db.js

@@ -1,11 +1,11 @@
 import path from 'node:path'
 import fs from 'node:fs'
 import { createClient } from '@libsql/client'
-import { getFophHome } from './home.js'
+import { getFreddieHome } from './home.js'
 
 let _db = null
 let _dbPromise = null
-const DB_PATH = () => path.join(getFophHome(), 'state', 'sessions.db')
+const DB_PATH = () => path.join(getFreddieHome(), 'state', 'sessions.db')
 const USE_MEMORY_DB = () => process.env.FREDDIE_TEST_DB === 'memory'
 
 export async function db() {
@@ -20,7 +20,7 @@ export async function db() {
             // In-memory mode for tests: no file persistence
             client = createClient({ url: 'file::memory:' })
         } else {
-            const dir = path.join(getFophHome(), 'state')
+            const dir = path.join(getFreddieHome(), 'state')
             fs.mkdirSync(dir, { recursive: true })
             dbPath = DB_PATH()
             client = createClient({ url: `file:${dbPath}` })

package/src/gateway/platforms.js

@@ -0,0 +1,21 @@
+import { bootHost } from '../host/index.js'
+
+export async function getPlatformAdapter(name) {
+    const h = await bootHost()
+    const p = h.pi.platforms.get(name)
+    if (!p) throw new Error(`platform not registered: ${name}`)
+    const mod = p.module || {}
+    const cls = Object.values(mod).find(v => typeof v === 'function' && /Adapter$/.test(v.name)) || Object.values(mod).find(v => typeof v === 'function')
+    if (!cls) throw new Error(`platform ${name}: no adapter class exported`)
+    return cls
+}
+
+export async function makePlatform(name, opts = {}) {
+    const Cls = await getPlatformAdapter(name)
+    return new Cls(opts)
+}
+
+export async function listPlatformNames() {
+    const h = await bootHost()
+    return h.pi.platforms.list().map(p => p.name)
+}

package/src/home.js

@@ -4,7 +4,7 @@ import fs from 'node:fs'
 
 let _cached = null
 
-export function getFophHome() {
+export function getFreddieHome() {
     if (_cached) return _cached
     const env = process.env.FREDDIE_HOME
     if (env) { _cached = env; ensure(env); return env }
@@ -16,7 +16,7 @@ export function getFophHome() {
     return home
 }
 
-export function displayFophHome() {
+export function displayFreddieHome() {
     const profile = process.env.FREDDIE_PROFILE
     return profile ? `~/.freddie/profiles/${profile}` : '~/.freddie'
 }

package/src/host/contract.js

@@ -0,0 +1,39 @@
+export const SURFACES = ['pi', 'gui', 'both']
+
+export const PI_VERBS = ['tool', 'env', 'command', 'cron', 'platform', 'memory', 'skill', 'context', 'agentExt', 'cli']
+export const GUI_VERBS = ['route', 'page', 'nav', 'debug', 'api', 'asset']
+
+export const HOOK_NAMES = [
+    'preToolCall', 'postToolCall',
+    'preLlmCall', 'postLlmCall',
+    'onSessionStart', 'onSessionEnd',
+    'onTurnStart', 'onTurnEnd',
+    'onMessageInbound', 'onMessageOutbound',
+]
+
+export function validatePlugin(p) {
+    if (!p || typeof p !== 'object') throw new Error('plugin: object required')
+    if (!p.name || typeof p.name !== 'string') throw new Error('plugin.name: string required')
+    if (!SURFACES.includes(p.surfaces)) throw new Error(`plugin ${p.name}: surfaces must be one of ${SURFACES.join(',')}`)
+    if (typeof p.register !== 'function') throw new Error(`plugin ${p.name}: register(ctx) function required`)
+    if (p.requires && !Array.isArray(p.requires)) throw new Error(`plugin ${p.name}: requires must be array`)
+    return p
+}
+
+export function topoSort(plugins) {
+    const byName = new Map(plugins.map(p => [p.name, p]))
+    const seen = new Map()
+    const out = []
+    const visit = (name, stack) => {
+        if (seen.get(name) === 'done') return
+        if (seen.get(name) === 'visiting') throw new Error(`plugin cycle: ${[...stack, name].join(' -> ')}`)
+        const p = byName.get(name)
+        if (!p) throw new Error(`plugin missing: ${name} (required by ${stack[stack.length - 1] || 'root'})`)
+        seen.set(name, 'visiting')
+        for (const dep of p.requires || []) visit(dep, [...stack, name])
+        seen.set(name, 'done')
+        out.push(p)
+    }
+    for (const p of plugins) visit(p.name, [])
+    return out
+}

package/src/host/host.js

@@ -0,0 +1,159 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { validatePlugin, topoSort, HOOK_NAMES, PI_VERBS, GUI_VERBS } from './contract.js'
+
+function makePiSurface() {
+    const tools = new Map()
+    const envs = new Map()
+    const commands = new Map()
+    const crons = new Map()
+    const platforms = new Map()
+    const memory = new Map()
+    const skills = new Map()
+    const contexts = new Map()
+    const agentExts = new Map()
+    const cli = new Map()
+    return {
+        _state: { tools, envs, commands, crons, platforms, memory, skills, contexts, agentExts, cli },
+        tools: regOf(tools, 'tool'),
+        envs: regOf(envs, 'env'),
+        commands: regOf(commands, 'command'),
+        crons: regOf(crons, 'cron'),
+        platforms: regOf(platforms, 'platform'),
+        memory: regOf(memory, 'memory'),
+        skills: regOf(skills, 'skill'),
+        contexts: regOf(contexts, 'context'),
+        agentExts: regOf(agentExts, 'agentExt'),
+        cli: regOf(cli, 'cli'),
+        async dispatchTool(name, args = {}, ctx = {}) {
+            const t = 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 regOf(map, kind) {
+    return {
+        register(spec) { if (!spec?.name) throw new Error(`${kind}.name required`); map.set(spec.name, spec) },
+        get(name) { return map.get(name) },
+        list() { return [...map.values()] },
+        has(name) { return map.has(name) },
+        size() { return map.size },
+    }
+}
+
+function makeGuiSurface() {
+    const routes = []
+    const pages = new Map()
+    const nav = []
+    const debugs = new Map()
+    const apis = new Map()
+    const assets = new Map()
+    return {
+        _state: { routes, pages, nav, debugs, apis, assets },
+        route(method, path, handler) { routes.push({ method: method.toUpperCase(), path, handler }) },
+        page(slug, def) { pages.set(slug, def) },
+        nav(item) { nav.push(item) },
+        debug(name, snapshotFn) { debugs.set(name, snapshotFn) },
+        api(group, def) { apis.set(group, def) },
+        asset(p, content) { assets.set(p, content) },
+        routes: { list: () => routes },
+        pages: { get: (s) => pages.get(s), list: () => [...pages.values()], has: (s) => pages.has(s) },
+        navItems: { list: () => nav },
+        debugs: { list: () => [...debugs.entries()].map(([name, fn]) => ({ name, snapshot: fn })), get: (n) => debugs.get(n) },
+    }
+}
+
+function makeHooks() {
+    const reg = Object.fromEntries(HOOK_NAMES.map(n => [n, []]))
+    return {
+        on(name, fn) {
+            if (!HOOK_NAMES.includes(name)) throw new Error(`unknown hook: ${name}`)
+            reg[name].push(fn)
+        },
+        async invoke(name, payload) {
+            let cur = payload
+            for (const fn of reg[name] || []) { cur = (await fn(cur)) ?? cur }
+            return cur
+        },
+        names() { return HOOK_NAMES },
+        listeners(name) { return [...(reg[name] || [])] },
+    }
+}
+
+function guard(surfaceObj, allowed, pluginName, verbs) {
+    if (allowed) return surfaceObj
+    return new Proxy({}, {
+        get(_, key) {
+            if (verbs.includes(String(key))) {
+                return () => { throw new Error(`plugin ${pluginName}: surface verb '${String(key)}' not allowed (declared surfaces=${pluginName})`) }
+            }
+            return surfaceObj[key]
+        },
+    })
+}
+
+function scopedConfig(name, store) {
+    const key = `plugins.${name}`
+    return {
+        get(k, d) { return store.get(`${key}.${k}`, d) },
+        set(k, v) { return store.set(`${key}.${k}`, v) },
+        all() { return store.all(key) || {} },
+    }
+}
+
+function nullStore() {
+    const m = new Map()
+    return { get: (k, d) => m.has(k) ? m.get(k) : d, set: (k, v) => m.set(k, v), all: (prefix) => Object.fromEntries([...m.entries()].filter(([k]) => k.startsWith(prefix))) }
+}
+
+export function createHost({ surfaces = ['pi', 'gui'], configStore = nullStore(), env = process.env } = {}) {
+    const pi = makePiSurface()
+    const gui = makeGuiSurface()
+    const hooks = makeHooks()
+    const loaded = []
+    const host = {
+        pi: surfaces.includes('pi') ? pi : null,
+        gui: surfaces.includes('gui') ? gui : null,
+        hooks,
+        plugins: () => loaded.map(p => ({ name: p.name, version: p.version || null, surfaces: p.surfaces, requires: p.requires || [] })),
+        get: (name) => loaded.find(p => p.name === name) || null,
+    }
+    async function loadAll(plugins) {
+        const validated = plugins.map(validatePlugin)
+        const sorted = topoSort(validated)
+        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 = (level, msg, fields) => { const line = JSON.stringify({ ts: Date.now(), plugin: p.name, level, msg, ...(fields || {}) }); 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: scopedConfig(p.name, configStore), host, env }
+            await p.register(ctx)
+            loaded.push(p)
+        }
+        return loaded.length
+    }
+    host.load = loadAll
+    return host
+}
+
+export async function discoverPlugins(roots) {
+    const found = []
+    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 file = path.join(root, entry.name, 'plugin.js')
+            if (!fs.existsSync(file)) continue
+            const mod = await import(pathToFileURL(file).href)
+            const p = mod.default || mod.plugin
+            if (p) found.push(p)
+        }
+    }
+    return found
+}

package/src/host/index.js

@@ -0,0 +1,27 @@
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createHost, discoverPlugins } from './host.js'
+import { getFreddieHome } from '../home.js'
+
+let _host = null
+let _loaded = false
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const REPO_PLUGINS = path.resolve(__dirname, '..', '..', 'plugins')
+
+export function host() {
+    if (!_host) _host = createHost({ surfaces: ['pi', 'gui'] })
+    return _host
+}
+
+export async function bootHost(extraRoots = []) {
+    const h = host()
+    if (_loaded) return h
+    _loaded = true
+    const roots = [REPO_PLUGINS, path.join(getFreddieHome(), 'plugins'), path.join(process.cwd(), '.freddie', 'plugins'), ...extraRoots]
+    const plugins = await discoverPlugins(roots)
+    await h.load(plugins)
+    return h
+}
+
+export function resetHostForTests() { _host = null; _loaded = false }

package/src/index.js

@@ -2,7 +2,8 @@ export * from './home.js'
 export * from './config.js'
 export * from './sessions.js'
 export * from './toolsets.js'
-export { registry, discoverBuiltinTools } from './tools/registry.js'
+export { host, bootHost, resetHostForTests } from './host/index.js'
+export { createHost, discoverPlugins } from './host/host.js'
 export { runTurn, createAgentMachine } from './agent/machine.js'
 export { Gateway, bootMdHook } from './gateway/run.js'
 export { AcpServer } from './acp/server.js'

package/src/mcp/server.js

@@ -1,5 +1,5 @@
 import readline from 'node:readline'
-import { registry, discoverBuiltinTools } from '../tools/registry.js'
+import { bootHost } from '../host/index.js'
 import { listSkills } from '../skills/index.js'
 import { logger } from '../observability/log.js'
 
@@ -34,11 +34,12 @@ const METHODS = {
         serverInfo: { name: 'freddie-mcp', version: '0.4.0' },
     }),
     'tools/list': async () => {
-        await discoverBuiltinTools()
-        return { tools: registry.list().map(t => ({ name: t.name, description: t.schema.description, inputSchema: t.schema.parameters || {} })) }
+        const h = await bootHost()
+        return { tools: h.pi.tools.list().map(t => ({ name: t.name, description: t.schema?.description, inputSchema: t.schema?.parameters || {} })) }
     },
     'tools/call': async ({ name, arguments: args = {} }) => {
-        const out = await registry.dispatch(name, args)
+        const h = await bootHost()
+        const out = await h.pi.dispatchTool(name, args)
         return { content: [{ type: 'text', text: typeof out === 'string' ? out : JSON.stringify(out) }] }
     },
     'prompts/list': async () => {

package/src/observability/log.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../home.js'
+import { getFreddieHome } from '../home.js'
 
 const SEVERITIES = { debug: 10, info: 20, warning: 30, error: 40 }
 
@@ -8,7 +8,7 @@ let _streams = new Map()
 
 function streamFor(name) {
     if (_streams.has(name)) return _streams.get(name)
-    const dir = path.join(getFophHome(), 'logs')
+    const dir = path.join(getFreddieHome(), 'logs')
     fs.mkdirSync(dir, { recursive: true })
     const s = fs.createWriteStream(path.join(dir, `${name}.log`), { flags: 'a' })
     _streams.set(name, s)

package/src/plugins/disk_cleanup/index.js

@@ -1,12 +1,12 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import { getFophHome } from '../../home.js'
+import { getFreddieHome } from '../../home.js'
 
 const MAX_AGE_DAYS = { logs: 30, batches: 14, 'tool-results': 7, checkpoints: 90 }
 export function cleanup({ now = Date.now() } = {}) {
     const removed = []
     for (const [sub, days] of Object.entries(MAX_AGE_DAYS)) {
-        const dir = path.join(getFophHome(), sub)
+        const dir = path.join(getFreddieHome(), sub)
         if (!fs.existsSync(dir)) continue
         const cutoff = now - days * 86400_000
         for (const f of fs.readdirSync(dir)) {

package/src/plugins/manager.js

@@ -1,66 +1,16 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFophHome } from '../home.js'
-import { registry as toolRegistry } from '../tools/registry.js'
-import { logger } from '../observability/log.js'
-
-const log = logger('plugins')
-
-const HOOK_NAMES = ['preToolCall', 'postToolCall', 'preLlmCall', 'postLlmCall', 'onSessionStart', 'onSessionEnd']
-
-export class PluginManager {
-    constructor() {
-        this.plugins = []
-        this.hooks = Object.fromEntries(HOOK_NAMES.map(n => [n, []]))
-        this.cliCommands = []
-    }
-
-    async discoverPlugins(extraDirs = []) {
-        const dirs = [path.join(getFophHome(), 'plugins'), path.join(process.cwd(), '.freddie', 'plugins'), ...extraDirs]
-        for (const d of dirs) {
-            if (!fs.existsSync(d)) continue
-            for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
-                if (!entry.isDirectory()) continue
-                const pkg = path.join(d, entry.name, 'package.json')
-                if (!fs.existsSync(pkg)) continue
-                try { await this._loadPlugin(path.join(d, entry.name)) } catch (e) { log.error('plugin load failed', { name: entry.name, err: String(e) }) }
-            }
-        }
-        return this.plugins.length
-    }
-
-    async _loadPlugin(dir) {
-        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'))
-        const main = path.join(dir, pkg.main || 'index.js')
-        const mod = await import(`file://${main.replace(/\\/g, '/')}`)
-        const ctx = this._ctx()
-        if (typeof mod.register === 'function') await mod.register(ctx)
-        this.plugins.push({ name: pkg.name, dir, main })
-        log.info('plugin loaded', { name: pkg.name })
-    }
-
-    register(plugin) {
-        const ctx = this._ctx()
-        plugin.register?.(ctx)
-        this.plugins.push({ name: plugin.name || 'inline', ...plugin })
-    }
-
-    _ctx() {
-        const self = this
-        return {
-            registerHook: (name, fn) => { if (!HOOK_NAMES.includes(name)) throw new Error(`unknown hook: ${name}`); self.hooks[name].push(fn) },
-            registerTool: (spec) => toolRegistry.register(spec),
-            registerCliCommand: (def) => self.cliCommands.push(def),
-        }
-    }
-
-    async invoke(hook, payload) {
-        let cur = payload
-        for (const fn of this.hooks[hook] || []) {
-            try { cur = (await fn(cur)) || cur } catch (e) { log.error('hook failed', { hook, err: String(e) }) }
-        }
-        return cur
+import { bootHost, host } from '../host/index.js'
+
+class PluginManagerShim {
+    async discoverPlugins() { await bootHost(); return host().plugins().length }
+    get plugins() { return host().plugins() }
+    get hooks() {
+        const h = host().hooks
+        return Object.fromEntries(h.names().map(n => [n, h.listeners(n)]))
     }
+    get cliCommands() { return host().pi?.commands.list() || [] }
+    register() { throw new Error('legacy register() removed; use plugins/<name>/plugin.js with the new contract') }
+    async invoke(name, payload) { return host().hooks.invoke(name, payload) }
 }
 
-export const pluginManager = new PluginManager()
+export const PluginManager = PluginManagerShim
+export const pluginManager = new PluginManagerShim()