freddie 0.0.121 → 0.0.123

package/src/agent/tool_call_text.js

@@ -0,0 +1,68 @@
+// Some fast/weak models emit tool calls as plain TEXT in their own native token
+// format instead of structured OpenAI `tool_calls` (especially when the system
+// prompt is rich). The agent loop only acts on structured tool_calls, so without
+// recovery it stalls after one turn. parseTextToolCalls() extracts both observed
+// formats from a content string and returns OpenAI-shaped {id,name,arguments}[].
+//
+// Formats handled:
+//   - kimi / moonshot section format:
+//       <|tool_calls_section_begin|>
+//         <|tool_call_begin|> functions.<name>:<idx>
+//         <|tool_call_argument_begin|> {json-args}
+//         <|tool_call_end|>
+//       <|tool_calls_section_end|>
+//   - llama python_tag format:
+//       <|python_tag|>name({...})  or  name("query")  or  name(key="value")
+//
+// Returns [] when the content holds no recognizable text tool call.
+
+function randId() {
+    return 'call_' + Math.random().toString(36).slice(2, 10)
+}
+
+function parseKimiSection(content) {
+    if (!content.includes('<|tool_call_begin|>')) return []
+    const re = /<\|tool_call_begin\|>\s*([\s\S]*?)\s*<\|tool_call_argument_begin\|>\s*([\s\S]*?)\s*<\|tool_call_end\|>/g
+    const out = []
+    let m
+    while ((m = re.exec(content)) !== null) {
+        const name = (m[1] || '').replace(/^functions\./, '').replace(/:\d+\s*$/, '').trim()
+        let args
+        try { args = JSON.parse((m[2] || '').trim()) } catch { args = {} }
+        if (name) out.push({ id: randId(), name, arguments: args })
+    }
+    return out
+}
+
+function parsePythonTag(content) {
+    if (!content.includes('<|python_tag|>')) return []
+    const after = content.slice(content.indexOf('<|python_tag|>') + '<|python_tag|>'.length).trim().split('\n')[0]
+    const mc = /^([A-Za-z_][A-Za-z0-9_.]*)\s*\(([\s\S]*?)\)\s*$/.exec(after)
+    if (!mc) return []
+    const name = mc[1].split('.')[0]
+    const inner = mc[2].trim()
+    let args = {}
+    if (/^\{[\s\S]*\}$/.test(inner)) { try { args = JSON.parse(inner) } catch { args = {} } }
+    else if (/^"[\s\S]*"$/.test(inner)) { const s = inner.slice(1, -1); args = { query: s, input: s } }
+    else if (/=/.test(inner)) {
+        const kwRe = /([A-Za-z_][A-Za-z0-9_]*)\s*=\s*("([^"\\]|\\.)*"|'([^'\\]|\\.)*'|[\d.]+|true|false|null)/g
+        let mm
+        while ((mm = kwRe.exec(inner)) !== null) {
+            let v = mm[2]
+            if (/^["']/.test(v)) v = v.slice(1, -1)
+            else if (/^[\d.]+$/.test(v)) v = Number(v)
+            else if (v === 'true') v = true
+            else if (v === 'false') v = false
+            else if (v === 'null') v = null
+            args[mm[1]] = v
+        }
+    } else if (inner) args = { query: inner, input: inner }
+    return name ? [{ id: randId(), name, arguments: args }] : []
+}
+
+export function parseTextToolCalls(content) {
+    if (typeof content !== 'string' || !content) return []
+    const kimi = parseKimiSection(content)
+    if (kimi.length) return kimi
+    return parsePythonTag(content)
+}

package/src/batch.js

@@ -5,7 +5,6 @@ import { getFreddieHome } from './home.js'
 import { randomUUID } from 'node:crypto'
 import { createMachine, assign, fromPromise } from 'xstate'
 import { createPersistentActor } from './machines/persistent-actor.js'
-import { load } from './machines/snapshot-store.js'
 import { runStep, clearSteps } from './machines/step-journal.js'
 
 // Run one prompt and append its result to the batch jsonl file.
@@ -77,10 +76,12 @@ export async function runBatch({ prompts = [], concurrency = 4, model, callLLM,
 // yet in context.done get re-run. Returns null if no live snapshot for the id.
 export async function resumeBatch({ batchId, model, callLLM } = {}) {
     if (!batchId) throw new Error('resumeBatch requires batchId')
-    if (!(await load('batch', batchId))) return null
     const machine = createBatchMachine({ model, callLLM })
+    // One read only: createPersistentActor.load() handles the missing-snapshot
+    // case (pa.resumed=false), so the prior pre-check load() was a redundant read
+    // that opened a TOCTOU window against a concurrent delete.
     const pa = await createPersistentActor(machine, { kind: 'batch', key: batchId, input: { id: batchId, file: '', model, concurrency: 4, prompts: [] } })
-    if (!pa.resumed) { await pa.forget(); return null }
+    if (!pa.resumed) return null
     return await driveBatch(pa)
 }
 

package/src/browser/index.js

@@ -11,6 +11,10 @@
 export { bootHost, host, resetHostForTests } from '../host/index.js'
 export { createAgentMachine, runTurn } from '../agent/machine.js'
 export { createActor, createMachine, assign, fromPromise, waitFor } from 'xstate'
+// Text-format tool-call recovery (kimi <|tool_call_begin|> / llama <|python_tag|>).
+// Exported so hosts that supply their own callLLM (e.g. thebird's gateway path)
+// can reuse the same parser instead of duplicating it.
+export { parseTextToolCalls } from '../agent/tool_call_text.js'
 
 // Re-export config defaults under the documented browser name.
 import { DEFAULT_CONFIG } from '../config.js'

package/src/cli/cli_output.js

@@ -1,12 +1,12 @@
 import { getActiveSkin } from '../skin/engine.js'
 import { hex } from './colors.js'
 export function info(msg) { return hex(getActiveSkin().colors.banner_text, msg) }
-export function success(msg) { return hex('#22c55e', '✓ ' + msg) }
+export function success(msg) { return hex('#22c55e', '[ok] ' + msg) }
 export function warning(msg) { return hex('#fbbf24', '! ' + msg) }
-export function error(msg) { return hex('#ef4444', '✗ ' + msg) }
+export function error(msg) { return hex('#ef4444', '[x] ' + msg) }
 export function box(title, body) {
-    const line = '─'.repeat(Math.max(20, title.length + 4))
-    return '┌' + line + '┐\n│ ' + title + ' '.repeat(line.length - title.length - 1) + '│\n├' + line + '┤\n' + body.split('\n').map(l => '│ ' + l + ' '.repeat(Math.max(0, line.length - l.length - 1)) + '│').join('\n') + '\n└' + line + '┘'
+    const line = '-'.repeat(Math.max(20, title.length + 4))
+    return '+' + line + '+\n| ' + title + ' '.repeat(line.length - title.length - 1) + '|\n+' + line + '+\n' + body.split('\n').map(l => '| ' + l + ' '.repeat(Math.max(0, line.length - l.length - 1)) + '|').join('\n') + '\n+' + line + '+'
 }
 export function table(rows) {
     if (!rows.length) return ''

package/src/cli/interactive.js

@@ -1,10 +1,15 @@
 import readline from 'node:readline'
 import { runTurn } from '../agent/machine.js'
-import { resolveCommand, COMMAND_REGISTRY, COMMANDS_BY_CATEGORY } from '../commands/registry.js'
+import { resolveCommand, COMMANDS_BY_CATEGORY } from '../commands/registry.js'
 import { getActiveSkin } from '../skin/engine.js'
-import { createSession, appendMessage } from '../sessions.js'
+import { createSession, appendMessage, listSessions, getMessages } from '../sessions.js'
 import { listAllProfiles, switchProfile } from '../commands/profile.js'
+import { listAuthProviders, hasUsableSecret, envForProvider } from '../auth.js'
+import { listProjects, getActiveProject, setActiveProject } from '../projects.js'
 
+// REPL slash-command handlers. Each returns a string to print (or sets
+// state.exit / mutates state for resume). Handlers may be async — the line
+// loop awaits them.
 const HANDLERS = {
     help: () => {
         const out = []
@@ -12,6 +17,7 @@ const HANDLERS = {
             out.push(`\n# ${cat}`)
             for (const c of cmds) out.push(`  /${c.name}${c.args_hint ? ' ' + c.args_hint : ''}\t${c.description}`)
         }
+        out.push('\n# Conversation\n  /sessions\tList recent conversations\n  /resume <id>\tContinue a past conversation\n  /keys\tShow which provider keys are set\n  /project [name]\tShow or switch active project')
         return out.join('\n')
     },
     quit: (state) => { state.exit = true; return 'bye.' },
@@ -20,13 +26,55 @@ const HANDLERS = {
         if (args[0] === 'switch' && args[1]) { switchProfile(args[1]); return 'switched: ' + args[1] }
         return 'usage: /profile [list|switch <name>]'
     },
-    sessions: () => 'Use the CLI: freddie sessions',
+    sessions: async () => {
+        const rows = await listSessions(20)
+        if (!rows.length) return '(no sessions yet)'
+        return rows.map(s => `  ${s.id.slice(0, 8)}  ${new Date(s.updated_at).toISOString().slice(0, 16).replace('T', ' ')}  ${s.title || '(untitled)'}`).join('\n')
+    },
+    resume: async (state, args) => {
+        const wanted = args[0]
+        const rows = await listSessions(50)
+        if (!rows.length) return '(no sessions to resume)'
+        const target = wanted
+            ? rows.find(s => s.id === wanted || s.id.startsWith(wanted))
+            : rows[0]
+        if (!target) return `no session matching: ${wanted}`
+        const msgs = await getMessages(target.id)
+        state.session = target.id
+        state.messages = msgs.map(m => ({ role: m.role, content: m.content, tool_calls: m.tool_calls || undefined, tool_call_id: m.tool_call_id || undefined }))
+        return `resumed ${target.id.slice(0, 8)} (${msgs.length} messages) — ${target.title || '(untitled)'}`
+    },
+    keys: async () => {
+        const lines = []
+        for (const p of listAuthProviders()) {
+            const ok = await hasUsableSecret(p)
+            lines.push(`  ${p.padEnd(12)} ${envForProvider(p) || ''}\t${ok ? '[set]' : '[--]'}`)
+        }
+        return lines.join('\n')
+    },
+    project: (_s, args) => {
+        if (!args[0]) {
+            const active = getActiveProject()
+            return listProjects().map(p => `  ${p.name === active.name ? '[*]' : '[ ]'} ${p.name.padEnd(16)} ${p.path}`).join('\n')
+        }
+        try { const p = setActiveProject(args[0]); return `switched to project: ${p.name} (${p.path})\nrestart the REPL to load this project's plugins` }
+        catch (e) { return 'error: ' + e.message }
+    },
     clear: (state) => { state.messages = []; return 'cleared.' },
 }
 
-export async function interactive({ callLLM, input = process.stdin, output = process.stdout } = {}) {
+export async function interactive({ callLLM, resume = null, input = process.stdin, output = process.stdout } = {}) {
     const skin = getActiveSkin()
-    const state = { messages: [], session: createSession({ platform: 'cli' }), exit: false }
+    const state = { messages: [], session: null, exit: false }
+    // Resume a prior conversation when requested (--resume [id]); otherwise start
+    // a fresh session. createSession/listSessions are async (libsql) and MUST be
+    // awaited — a bare call silently wraps in a rejecting Promise so the row is
+    // never persisted and history is lost.
+    if (resume !== null && resume !== false) {
+        const msg = await HANDLERS.resume(state, typeof resume === 'string' ? [resume] : [])
+        output.write(msg + '\n')
+    }
+    if (!state.session) state.session = await createSession({ platform: 'cli' })
     output.write(`${skin.branding.welcome}\n`)
     const rl = readline.createInterface({ input, output, terminal: input.isTTY })
     const prompt = () => { if (!state.exit) rl.setPrompt(skin.branding.prompt_symbol); rl.prompt() }
@@ -35,21 +83,22 @@ export async function interactive({ callLLM, input = process.stdin, output = pro
         if (!line) return prompt()
         if (line.startsWith('/')) {
             const parts = line.slice(1).split(/\s+/)
-            const name = resolveCommand('/' + parts[0])
+            const name = resolveCommand('/' + parts[0]) || parts[0]
             const handler = HANDLERS[name]
             if (!handler) { output.write(`unknown command: /${parts[0]}\n`); return prompt() }
-            output.write(handler(state, parts.slice(1)) + '\n')
+            try { output.write((await handler(state, parts.slice(1))) + '\n') }
+            catch (e) { output.write(`error: ${e.message}\n`) }
             if (state.exit) rl.close()
             else prompt()
             return
         }
-        appendMessage(state.session, { role: 'user', content: line })
+        await appendMessage(state.session, { role: 'user', content: line })
         try {
             const out = await runTurn({ prompt: line, messages: state.messages, callLLM, timeoutMs: 60000 })
             state.messages = out.messages
             const reply = out.result || out.error || '(no response)'
             output.write(`${skin.branding.response_label}${reply}\n`)
-            appendMessage(state.session, { role: 'assistant', content: reply })
+            await appendMessage(state.session, { role: 'assistant', content: reply })
         } catch (e) {
             output.write(`error: ${e.message}\n`)
         }

package/src/cli/memory_setup.js

@@ -1,12 +1,26 @@
 import { saveConfigValue } from '../config.js'
 import { getAuthStore } from '../auth.js'
 import { listMemoryProviders } from '../plugins/memory/provider.js'
-export const PROVIDER_ENV = { honcho: 'HONCHO_API_KEY', mem0: 'MEM0_API_KEY', supermemory: 'SUPERMEMORY_API_KEY', byterover: 'BYTEROVER_API_KEY', hindsight: 'HINDSIGHT_API_KEY', openviking: 'OPENVIKING_API_KEY', retaindb: 'RETAINDB_API_KEY' }
-export function listProviders() { return listMemoryProviders() }
+
+// gm rs-learn is freddie's canonical, default learning store — no configuration required.
+// The third-party providers below are LEGACY: opt-in only, kept behind explicit configure.
+export const DEFAULT_PROVIDER = 'gm'
+export const LEGACY_PROVIDER_ENV = { honcho: 'HONCHO_API_KEY', mem0: 'MEM0_API_KEY', supermemory: 'SUPERMEMORY_API_KEY', byterover: 'BYTEROVER_API_KEY', hindsight: 'HINDSIGHT_API_KEY', openviking: 'OPENVIKING_API_KEY', retaindb: 'RETAINDB_API_KEY' }
+// Back-compat alias.
+export const PROVIDER_ENV = LEGACY_PROVIDER_ENV
+
+export function listProviders() { return [DEFAULT_PROVIDER, ...listMemoryProviders().filter(n => n !== DEFAULT_PROVIDER)] }
+
 export async function configureProvider(name, apiKey, options = {}) {
+    // gm needs no key/config; selecting it just clears any legacy provider override.
+    if (name === DEFAULT_PROVIDER || name === 'rs-learn') {
+        saveConfigValue('memory.provider', DEFAULT_PROVIDER)
+        saveConfigValue('memory.options', options)
+        return { configured: DEFAULT_PROVIDER, hasKey: false, default: true }
+    }
     if (!listMemoryProviders().includes(name)) throw new Error('unknown memory provider: ' + name)
     saveConfigValue('memory.provider', name)
     saveConfigValue('memory.options', options)
-    if (apiKey && PROVIDER_ENV[name]) await getAuthStore().setCredential(PROVIDER_ENV[name], apiKey)
-    return { configured: name, hasKey: Boolean(apiKey) }
+    if (apiKey && LEGACY_PROVIDER_ENV[name]) await getAuthStore().setCredential(LEGACY_PROVIDER_ENV[name], apiKey)
+    return { configured: name, hasKey: Boolean(apiKey), legacy: true }
 }

package/src/cli/relaunch.js

@@ -1,5 +1,5 @@
-export function relaunch({ argv = process.argv } = {}) {
-    const { spawn } = require('node:child_process')
+export async function relaunch({ argv = process.argv } = {}) {
+    const { spawn } = await import('node:child_process')
     const child = spawn(argv[0], argv.slice(1), { detached: true, stdio: 'ignore', env: process.env })
     child.unref()
     setTimeout(() => process.exit(0), 100)

package/src/cli/stdin_secret.js

@@ -0,0 +1,31 @@
+import readline from 'node:readline'
+
+// Read a secret (API key) without it landing in shell history or `ps` output.
+// - When stdin is a pipe (not a TTY), read the first line of stdin verbatim:
+//   `echo $KEY | freddie auth set anthropic`.
+// - When stdin is a TTY, prompt and read with the terminal echo masked so the
+//   key is not shown on screen.
+// Never accept the secret as an argv argument — argv leaks to history and ps.
+export async function readStdinSecret(promptText = 'secret: ', { input = process.stdin, output = process.stdout } = {}) {
+    if (!input.isTTY) {
+        // Piped input: take the first non-empty line.
+        const rl = readline.createInterface({ input, terminal: false })
+        for await (const line of rl) { rl.close(); return line.trim() }
+        return ''
+    }
+    // Interactive TTY: prompt and mask the echo.
+    return await new Promise((resolve) => {
+        const rl = readline.createInterface({ input, output, terminal: true })
+        let masked = false
+        const onData = () => { if (masked) output.write('\x1b[2K\r' + promptText + '*'.repeat(rl.line.length)) }
+        output.write(promptText)
+        masked = true
+        input.on('data', onData)
+        rl.question('', (answer) => {
+            input.off('data', onData)
+            output.write('\n')
+            rl.close()
+            resolve(answer.trim())
+        })
+    })
+}

package/src/context/engine.js

@@ -15,11 +15,14 @@ export const ContextPlugins = {
     skills: async () => {
         return listSkills().map(s => ({ name: 'skill:' + s.name, body: s.description }))
     },
-    memory: async ({ provider } = {}) => {
-        if (!provider) return []
+    memory: async ({ message = '', namespace = null } = {}) => {
+        // Query-aware semantic recall from gm rs-learn — freddie's primary learning store.
         try {
-            const out = await provider.prefetch('')
-            return (out.items || []).slice(0, 5).map((it, i) => ({ name: 'memory:' + i, body: typeof it === 'string' ? it : JSON.stringify(it) }))
+            const { recall, projectNamespace } = await import('../learn/gm-learn.js')
+            const ns = namespace || await projectNamespace()
+            const q = (message || '').toString().trim() || 'project notes facts decisions'
+            const hits = await recall(q, { limit: 5, namespace: ns })
+            return hits.map((h, i) => ({ name: 'memory:' + i, body: h.text }))
         } catch { return [] }
     },
 }

package/src/gateway/run.js

@@ -36,13 +36,13 @@ export class Gateway {
         this.actor = createActor(this.machine, { input: { platformNames: [...this.platforms.keys()] } })
         // Persist lifecycle transitions so the gateway's state is observable +
         // resumable; an active snapshot on boot means the gateway was running.
-        this.actor.subscribe((snap) => { persist('gateway', 'lifecycle', this.actor.getPersistedSnapshot()).catch(() => {}) })
+        this.actor.subscribe((snap) => { persist('gateway', 'lifecycle', this.actor.getPersistedSnapshot()).catch(e => log.error('gateway lifecycle persist failed', { err: String(e) })) })
         this.actor.start()
     }
     get state() { return this.actor.getSnapshot().value }
     register(name, adapter) {
         this.platforms.set(name, adapter)
-        adapter.on?.('message', (m) => this.handleInbound(name, m))
+        adapter.on?.('message', (m) => { this.handleInbound(name, m).catch(e => log.error('message listener error', { platform: name, from: m.from, error: String(e) })) })
     }
     addHook(stage, fn) { this.hooks[stage].push(fn) }
     async start() {
@@ -63,16 +63,28 @@ export class Gateway {
         // sender + content so a refresh mid-processing re-drives it instead of
         // dropping it. The snapshot is cleared once the reply is sent.
         const msgKey = msg.id || `${platform}:${msg.from}:${randomUUID()}`
-        await persist('gateway-msg', msgKey, { status: 'active', value: 'processing', context: { platform, from: msg.from, text: msg.text } })
+        // A persist failure must not drop the message: degrade to non-resumable
+        // processing (the reply still goes out) rather than throwing it away.
+        try {
+            await persist('gateway-msg', msgKey, { status: 'active', value: 'processing', context: { platform, from: msg.from, text: msg.text } })
+        } catch (e) {
+            log.warn('cannot persist gateway-msg, continuing without resumability', { msgKey, err: String(e) })
+        }
         let cur = { ...msg, platform }
         for (const h of this.hooks.inbound) cur = (await h(cur)) || cur
         const result = await runStep(msgKey, 'run', () => runTurn({ prompt: cur.text || '', callLLM: this.callLLM }))
         let reply = { to: msg.from, text: result.result || result.error || '', platform, result }
         for (const h of this.hooks.outbound) reply = (await h(reply)) || reply
         const adapter = this.platforms.get(platform)
-        await adapter.send?.(reply)
-        await clear('gateway-msg', msgKey)
-        await clearSteps(msgKey)
+        // Clear the in-flight snapshot whether or not the send throws: a send
+        // failure must not leave the message to be re-driven (and re-replied) on
+        // the next boot. The contract is "cleared once processing completes".
+        try {
+            await adapter.send?.(reply)
+        } finally {
+            await clear('gateway-msg', msgKey)
+            await clearSteps(msgKey)
+        }
         return reply
     }
 }

package/src/index.js

@@ -21,6 +21,7 @@ export { createEnvironment, defaultEnvironment, LocalEnvironment, DockerEnvironm
 export { getAuthStore } from './auth.js'
 export { buildContext, blocksToSystemMessage, ContextPlugins } from './context/engine.js'
 export { callLLM as piCallLLM } from './agent/pi-bridge.js'
+export { callLLM as acptoapiCallLLM, isReachable as acptoapiReachable, getAcptoapiUrl, getAcptoapiModel } from './agent/acptoapi-bridge.js'
 export { interactive } from './cli/interactive.js'
 export { listMemoryProviders, createMemoryProvider, registerMemoryProvider } from './plugins/memory/provider.js'
 export { compress, shouldCompress, computeCompressionPlan, SUMMARY_PREFIX, estimateMessagesTokens, pruneOldToolResults, markFailure as compressMarkFailure, shouldRetry as compressShouldRetry, clearFailure as compressClearFailure } from './agent/compress/index.js'

package/src/learn/gm-learn.js

@@ -0,0 +1,179 @@
+// gm rs-learn — freddie's primary learning mechanism.
+//
+// Routes all of freddie's learning (memory tool, turn-context recall, auto-recall on turn
+// entry, auto-learn on turn completion) through gm-plugkit's rs-learn store. One backend is
+// chosen lazily on first use and cached process-wide:
+//
+//   - Node:    gm-plugkit's wasm wrapper is imported in-process (createPlugkit), resolving
+//              .gm/rs-learn.db from CLAUDE_PROJECT_DIR||cwd of this process.
+//   - Browser: a host-provided bridge (globalThis.__GM_DISPATCH__) routes verbs to the
+//              gm wasm instance the host already loaded in-page (e.g. thebird's
+//              window.__debug.gm.dispatch). This is what makes freddie LEARN on gh-pages,
+//              where node:module is unavailable and an in-process import would throw.
+//
+// Every call degrades to a no-op (never throws into the agent loop) when no backend is
+// available, so a freddie process/page without gm installed still runs.
+
+let _initPromise = null // shared in-flight backend selection (no double cold-load)
+let _failed = false // sticky failure flag — stop retrying a missing/broken install
+let _pk = null // cached backend: { dispatch(verb, body) -> json|Promise<json>, version() }
+
+const _isBrowser = typeof window !== 'undefined' || typeof importScripts === 'function'
+
+// The host-provided in-page bridge contract. A host (thebird) sets one of:
+//   globalThis.__GM_DISPATCH__(verb, body) -> json | Promise<json>      (preferred)
+//   globalThis.__gm.dispatch(verb, body)   -> json | Promise<json>      (fallback shape)
+// We probe lazily on every ensure() so a late-loading wasm (149MB cold-load) is picked up
+// once it becomes available rather than being cached as "failed" forever.
+function findBrowserBridge() {
+    const g = (typeof globalThis !== 'undefined') ? globalThis : null
+    if (!g) return null
+    if (typeof g.__GM_DISPATCH__ === 'function') return { dispatch: g.__GM_DISPATCH__ }
+    const gm = g.__gm || (g.__debug && g.__debug.gm)
+    if (gm && typeof gm.dispatch === 'function') return { dispatch: (v, b) => gm.dispatch(v, b) }
+    return null
+}
+
+async function ensureNodePlugkit() {
+    const { createRequire } = await import('node:module')
+    const path = (await import('node:path')).default
+    const _require = createRequire(import.meta.url)
+    // index.js is CommonJS; the createPlugkit export lives on the ESM wrapper file, so resolve
+    // the wrapper path off the package and import it directly.
+    const pkgJson = _require.resolve('gm-plugkit/package.json')
+    const wrapper = path.join(path.dirname(pkgJson), 'plugkit-wasm-wrapper.js')
+    const url = 'file://' + wrapper.replace(/\\/g, '/')
+    const mod = await import(url)
+    if (typeof mod.createPlugkit !== 'function') throw new Error('gm-plugkit createPlugkit export missing (update gm-plugkit)')
+    return mod.createPlugkit()
+}
+
+async function ensurePlugkit() {
+    if (_pk) return _pk
+    // In the browser the bridge can appear AFTER first probe (wasm cold-load). Never set the
+    // sticky _failed flag there — just re-probe each call until the host wires the global.
+    if (_isBrowser) {
+        const bridge = findBrowserBridge()
+        if (!bridge) return null
+        _pk = { dispatch: bridge.dispatch, version: () => 'browser-bridge' }
+        return _pk
+    }
+    if (_failed) return null
+    if (_initPromise) return _initPromise
+    _initPromise = (async () => {
+        try {
+            _pk = await ensureNodePlugkit()
+            return _pk
+        } catch (e) {
+            _failed = true
+            try { console.error('[gm-learn] disabled (gm rs-learn unavailable):', e && e.message) } catch (_) {}
+            return null
+        } finally {
+            _initPromise = null
+        }
+    })()
+    return _initPromise
+}
+
+export function learnAvailable() { return Boolean(_pk) || Boolean(_isBrowser && findBrowserBridge()) }
+
+// Per-project namespace isolation, matching gm's namespace model.
+//   - Browser: the host sets globalThis.__GM_NAMESPACE__ (a string, or a fn returning one)
+//              to the active workspace/instance so memories isolate per thebird instance.
+//   - Node:    derive from the freddie project registry (src/projects.js).
+// Falls back to 'default' if neither is resolvable (e.g. early boot).
+export async function projectNamespace() {
+    if (_isBrowser) {
+        try {
+            const g = globalThis
+            const ns = typeof g.__GM_NAMESPACE__ === 'function' ? g.__GM_NAMESPACE__() : g.__GM_NAMESPACE__
+            const s = (ns == null ? '' : String(ns)).trim()
+            return s || 'default'
+        } catch (_) { return 'default' }
+    }
+    try {
+        const mod = await import('../projects.js')
+        const p = mod.getActiveProject && mod.getActiveProject()
+        return (p && p.name) || 'default'
+    } catch (_) { return 'default' }
+}
+
+// Normalize a recall response into a flat hit list: [{ text, score, key, namespace }].
+function normalizeHits(resp) {
+    const hits = (resp && resp.data && Array.isArray(resp.data.hits)) ? resp.data.hits
+        : (resp && Array.isArray(resp.hits)) ? resp.hits
+            : []
+    return hits.map(h => ({
+        text: h.text != null ? String(h.text) : '',
+        score: typeof h.score === 'number' ? h.score : (typeof h.cos === 'number' ? h.cos : 0),
+        key: h.key || null,
+        namespace: h.namespace || 'default',
+    })).filter(h => h.text)
+}
+
+// Persist a fact into rs-learn. Returns the stored key, or null on no-op/degrade.
+export async function memorize(text, { namespace = 'default', key = null } = {}) {
+    const t = (text || '').toString().trim()
+    if (!t) return null
+    const pk = await ensurePlugkit()
+    if (!pk) return null
+    try {
+        const body = { text: t, namespace }
+        if (key) body.key = key
+        const r = await pk.dispatch('memorize-fire', body)
+        if (r && r.ok === false) return null
+        return (r && r.data && r.data.key) || (r && r.key) || null
+    } catch (e) {
+        try { console.error('[gm-learn] memorize failed:', e && e.message) } catch (_) {}
+        return null
+    }
+}
+
+// Semantic recall against rs-learn. Returns [{ text, score, key, namespace }] (possibly []).
+export async function recall(query, { limit = 5, namespace = 'default' } = {}) {
+    const q = (query || '').toString().trim()
+    if (!q) return []
+    const pk = await ensurePlugkit()
+    if (!pk) return []
+    try {
+        const r = await pk.dispatch('recall', { query: q, limit, namespace })
+        if (r && r.ok === false) return []
+        return normalizeHits(r).slice(0, limit)
+    } catch (e) {
+        try { console.error('[gm-learn] recall failed:', e && e.message) } catch (_) {}
+        return []
+    }
+}
+
+// Turn-entry auto-recall for a raw user prompt. Same store as recall(); kept distinct so the
+// turn-entry pack can use the auto-recall verb's query derivation when present.
+export async function autoRecall(prompt, { limit = 5, namespace = 'default' } = {}) {
+    const p = (prompt || '').toString().trim()
+    if (!p) return []
+    const pk = await ensurePlugkit()
+    if (!pk) return []
+    try {
+        const r = await pk.dispatch('auto-recall', p)
+        // auto-recall may return {hits} directly or under data; fall back to plain recall.
+        let hits = normalizeHits(r)
+        if (!hits.length) hits = await recall(p, { limit, namespace })
+        return hits.slice(0, limit)
+    } catch (_) {
+        return recall(p, { limit, namespace })
+    }
+}
+
+// Remove a memory by explicit key (never blind similarity-delete).
+export async function prune(keys) {
+    const list = Array.isArray(keys) ? keys.filter(Boolean) : (keys ? [keys] : [])
+    if (!list.length) return { pruned: 0 }
+    const pk = await ensurePlugkit()
+    if (!pk) return { pruned: 0 }
+    try {
+        const r = await pk.dispatch('memorize-prune', { keys: list })
+        return (r && r.data) || r || { pruned: list.length }
+    } catch (e) {
+        try { console.error('[gm-learn] prune failed:', e && e.message) } catch (_) {}
+        return { pruned: 0 }
+    }
+}

package/src/plugins/case/index.js

@@ -0,0 +1,28 @@
+// freddie "case" plugin -- registers the case/enquiry toolset into the host so any
+// runTurn can use it. Agentic code per the layering mandate; the data store and the
+// field/enum/role config are injected by the host application (via toolCtx on each
+// turn and plugins.case config), so this plugin is application-agnostic.
+//
+// The store is resolved PER TURN from toolCtx (ctx.store), never a global, so the
+// agent answers for the asking worker. A configured fallback store
+// (plugins.case.resolveStore, a function) is used only when a turn carries none
+// (e.g. tests). Config is read via ctx.config (scopedCfg 'case').
+
+import { buildCaseToolset } from './toolset.js'
+
+export default {
+  name: 'case',
+  surfaces: 'pi',
+  register({ pi, config }) {
+    const resolveStore = config?.get('resolveStore', null)
+    const slimCase = config?.get('slimCase', (c) => c)
+    const slimEvent = config?.get('slimEvent', (e) => e)
+    const tools = buildCaseToolset({
+      resolveStore: typeof resolveStore === 'function' ? resolveStore : null,
+      config,
+      slimCase: typeof slimCase === 'function' ? slimCase : (c) => c,
+      slimEvent: typeof slimEvent === 'function' ? slimEvent : (e) => e,
+    })
+    for (const tool of tools) pi.tools.register(tool)
+  },
+}