freddie 0.0.76 → 0.0.78

package/AGENTS.md

@@ -242,7 +242,10 @@ All 21 named integration tests in `test.js` pass (exit 0). Subsystem coverage:
 ## LLM backends and acptoapi
 
 - **acptoapi bridge** — Integrated at `src/agent/acptoapi-bridge.js` + `src/agent/llm_resolver.js` (commit 5f55f1e). Localhost API (default port 4800) converting OpenAI/Anthropic SDK calls to multiple backends: Kilo Code, opencode, Claude CLI, Anthropic API, Gemini, Ollama, Bedrock. Endpoint `/v1/chat/completions`, OpenAI-compatible, accepts `Bearer none` auth.
-- **LLM resolver priority** — (1) explicit `callLLM` arg, (2) pi-bridge if `ANTHROPIC_API_KEY` / `OPENAI_API_KEY` / `GROQ_API_KEY` / `OPENROUTER_API_KEY` env set, (3) acptoapi if `/v1/models` returns 200, (4) throw with actionable error. Configurable via `FREDDIE_LLM_URL` and `FREDDIE_LLM_MODEL` env vars.
+- **acptoapi dep pattern** (2026-05-10) — `package.json` pins `"acptoapi": "file:../acptoapi"` (same pattern as `anentrypoint-design`). Always tracks local SDK without publish cycles. CJS/ESM boundary bridged via `createRequire(import.meta.url)` in freddie ESM files that import acptoapi CJS exports.
+- **LLM resolver priority** (2026-05-10) — (1) explicit provider+key, (2) acptoapi if `/v1/models` returns 200, (3) `agent.model_preference` config array (ordered failover, sampler-gated), (4) `sdk.buildAutoChain()` env-key scan, (5) throw. `PROVIDER_KEYS` and `PROVIDER_DEFAULTS` imported from `acptoapi` — not maintained in freddie. `sdk.chat()` returns OpenAI `{choices:[{message}]}` format; `sdkChat()` adapter in llm_resolver converts to freddie's `{content, tool_calls, raw}`.
+- **Model sampler — re-export shim** (2026-05-10) — `src/agent/model-sampler.js` is a 13-line re-export shim over acptoapi sampler. Sampler logic (5-step backoff 30s→480s, createSampler factory, singleton) lives in `c:\dev\acptoapi\lib\sampler.js`. Exports: `isAvailable`, `markFailed`, `markOk`, `resetAvailability`, `getStatus`, `probe`, `startSampler`, `stopSampler`, `createSampler`.
+- **model_preference config key** (2026-05-10) — `agent.model_preference: []` in `~/.freddie/config.yaml`. Array of `{ provider, model? }` objects; `resolveCallLLM` tries each in order, skipping unavailable (sampler-gated) and marking failures with backoff. Config v2 migration adds the key on upgrade from v1.
 - **acptoapi Claude backend verified** (2026-05-03) — Live agent loop working: start acptoapi server `node bin/agentapi.js --port 4800` (c:\dev\acptoapi), then set `FREDDIE_LLM_URL=http://localhost:4800/v1 + FREDDIE_LLM_MODEL=claude/haiku`. Model prefix `claude/` routes to Claude CLI subprocess. freddie test.js 12/12 green confirming integration production-ready. Dashboard `/api/chat` and `/api/batch` are POST-only; GET returns 404 (correct).
 
 ## Pre-rename validation snapshot (2026-05-03)
@@ -261,10 +264,12 @@ All 12 test.js named groups passing: home+config+skin, sessions+FTS5, tools+tool
 - 2026-05-03 (session 3): Ingested libsql-async-debt-class into AGENTS.md Substrate gotchas (sessions.js + cron/scheduler.js async callsites; silent TypeError class; test.js passes while CLI broken). rs-learn store still unavailable (exec:memorize/exec:recall not on PATH). 0 migration audit items queried. 1 new fact added.
 - 2026-05-03 (session 4): Plugin-architecture decomposition recorded — added "Plugin architecture" section before Layout, rewrote "Adding a tool" + "Adding a gateway platform" for plugins/<name>/{plugin,handler}.js shape. Ingested 6 facts to rs-learn (project/freddie-plugin-architecture, reference/freddie-host-contract, reference/freddie-plugin-ctx, project/freddie-migrated-subsystems, reference/freddie-thin-shims, project/freddie-plugin-witness). Audit: 5 queries fired (pi-ai env keys, profile safe paths, libsql async debt, browser inline module errors, yaml colon space trap, plus self-test on freddie-plugin-architecture) — all returned "No recall results". rs-learn ingest path live but retrieval side empty for this session (likely needs learn-build propagation). 0 items migrated; AGENTS.md items retained.
 - 2026-05-04: Recorded freddie publish workflow root fix — `.github/workflows/restore-package.cjs` now pins anentrypoint-design via `npm view` + version (`^<latest>`) instead of file: dep; `publish.yml` runs `npm install --package-lock-only` to sync lockfile. Updated "Rebase regression trap" entry with detailed causation + recurrence tell. Added new "GitHub Actions deploy-pages@v5 duplicate artifact rejection" caveat (rerun --failed silently re-uploads; trigger fresh run instead). rs-learn store still unavailable. 0 items migrated; 2 facts added/refined in AGENTS.md.
+- 2026-05-10: 15-provider LLM resolver expansion. Added model-sampler.js (backoff), PROVIDER_KEYS/DEFAULTS expansion, model_preference config key, config v2 migration. Updated "LLM resolver priority" + "15-provider support" + "Model sampler" + "model_preference" entries in AGENTS.md. test.js 12/12 green at exactly 200 lines. rs-learn store still unavailable. 4 new facts added to AGENTS.md.
+- 2026-05-10 (session 2): Deep integration audit between freddie and acptoapi SDK. Moved sampler logic into acptoapi lib/sampler.js (createSampler factory + singleton, 5-step backoff). Added lib/provider-maps.js (PROVIDER_KEYS + PROVIDER_DEFAULTS, 17 providers, derived from BRANDS+auto-chain). freddie: switched to file:../acptoapi dep, model-sampler.js replaced with 13-line re-export shim, llm_resolver.js simplified 131→95L (OPENAI_COMPAT removed, PROVIDER_KEYS/DEFAULTS from SDK, buildAutoChain() for auto-scan, sdkChat() adapter for OpenAI→freddie format). test.js 12/12 green. Both repos pushed. AGENTS.md updated with acptoapi dep pattern, re-export shim pattern, CJS/ESM bridge via createRequire.
 
 ## Dashboard web UI caveats
 
-- **anentrypoint-design v0.0.27 source/dist skew** — Published npm package lags behind source in C:/dev/anentrypoint-design. New components (EmptyState, etc.) present in source but missing from dist/247420.js until rebuild. Run `node scripts/build.mjs` in the design repo (emits dist/247420.js ~441KB + 247420.css; build ~150ms); warning "[247420] missing css: vendor/rippleui-1.12.1.css" is benign. Skip rebuild and browser-witness new component usage: silent pageerror "component is not a function" kills app mount with no output in #app. freddie/package.json uses `file:../anentrypoint-design` so npm install always mirrors rebuilt dist without publish cycles.
+- **anentrypoint-design source/dist pattern** (2026-05-10) — No vendor dir in freddie (`src/web/vendor/` removed, commit 52d0732). `server.js` always serves SDK from `node_modules/anentrypoint-design/dist/`. freddie's `package.json` pins `"anentrypoint-design": "file:../anentrypoint-design"` so `npm install` symlinks directly to the live source — no publish cycle needed. Dist is rebuilt by CI on push to the SDK repo; rebuild locally after SDK edits via `node scripts/build.mjs` in `C:/dev/anentrypoint-design` (emits dist/247420.js ~441KB + 247420.css; build ~150ms; warning "[247420] missing css: vendor/rippleui-1.12.1.css" is benign). Skip rebuild before using a new component and the pageerror "component is not a function" kills app mount silently.
 - **Live page rerender caveat** — AppState.body caching (page computed once at navigation, body saved) breaks for live routes like #/chat where AppState is mutated mid-flight (SSE pushes new messages). Fix: detect live routes in rerender(), recompute body: `if (AppState.hash === '#/chat') { Promise.resolve(PAGES['#/chat']()).then(b => { AppState.body = b; _mount() }); return }`. Any future live-streaming pages (cron output, traces) need the same treatment.
 - **libuv spawn caveat** — Spawning createDashboard() from exec:nodejs and keeping process alive triggers libuv UV_HANDLE_CLOSING crash on shutdown. Reliable alternative: boot via `node bin/freddie.js dashboard --port <port>`. Liveness checks: exec:browser → page.goto → window.__debug.dashboard() returns {booted, ts, framework, route}; window.__debug.chat() exposes {messages, streaming, draft}; window.__debug.sendChat(text) drives round-trips.
 - **anentrypoint-design theme token descendant selector fix** (2026-05-04) — SDK CSS scopes light/dark theme variables under descendant selectors `.ds-247420 [data-theme="dark"]` and `.ds-247420 [data-theme="light"]`. Placing both `class="ds-247420"` and `data-theme="dark"` on the same node (e.g. `<html>`) breaks theming: the descendant selector does NOT match when both attributes are on the same element. Fix: scope `class="ds-247420"` on `<html>` and `data-theme="dark"` on `<body>`. Theme toggle must write to `document.body`, not `document.documentElement`. Browser-witnessed commit 17dfce0: pre-fix dark/light backgrounds identical (rgb 26,27,30); post-fix dark=rgb(26,27,30), light=rgb(245,240,228). Symptom: toggle theme in dashboard, page background does not change.
@@ -273,7 +278,7 @@ All 12 test.js named groups passing: home+config+skin, sessions+FTS5, tools+tool
 
 - **Structured-YAML rendering** — `website/theme.mjs` (164L) renders structured YAML via 247420 design vocabulary, not raw markdown. Consumes `page.hero` (heading/subheading/accent/body/badges/ctas), `page.sections[]` (rotating rail color green→purple→mascot→sun→flame→sky by section index, optional `lede` + per-item `benefit` italic), `page.examples[]` (railed link list with mono numeric ranks + ↗ glyph). Falls back to `page.body` markdown for prose. Style block inlined so rail/dot/chip/btn classes work without ds-247420 SDK CSS loading first. To get a specific rail color, reorder sections. Prefer enriching hero+sections+examples over expanding body markdown; copy existing YAML structure as template for new pages.
 - **YAML colon-space trap** — In `website/content/pages/*.yaml`, any value containing `: ` outside backticks (e.g. `[linux, macos, windows]`, `requiresEnv: ['MY_KEY']` code snippets) MUST be double-quoted. The parser otherwise interprets the embedded colon as a mapping and the file fails to load. Hit twice: tools.yaml line 72, skills.yaml line 40. Fix is wrapping the whole value in `"..."`.
-- **SSR innerHTML injection beats client dispatch** — anentrypoint-design v0.0.27 exposes Hero/HomeView/Panel/Row/Section/WorksList, but pre-mounted SSR injection via innerHTML is more reliable than dispatching components client-side at build — avoids depending on SDK loading before the static HTML paints. Emitted HTML carries rail/dot/chip/btn classes with inline styles to be self-sufficient.
+- **SSR innerHTML injection beats client dispatch** — anentrypoint-design exposes Hero/HomeView/Panel/Row/Section/WorksList (and more), but pre-mounted SSR injection via innerHTML is more reliable than dispatching components client-side at build — avoids depending on SDK loading before the static HTML paints. Emitted HTML carries rail/dot/chip/btn classes with inline styles to be self-sufficient.
 
 ## Residual complement (NOT ported this session)
 

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+## [Unreleased]
+
+### Fixed
+- `src/agent/llm_resolver.js`: fixed tool-calling for all openai-compat providers (groq, mistral, cerebras, openrouter, nvidia, etc.) — `sdk.chat()` was internally using `from:'openai'` format which stripped `url` and `apiKey` before sending to the provider, causing "Failed to parse URL from undefined"; replaced with direct `fetch()` for openai-compat, bypassing the sdk format pipeline entirely
+- `src/agent/llm_resolver.js`: tool schemas (from `getEnabledToolSchemas`) were never passed to the LLM API — `tools: undefined` was hardcoded; now converts freddie tool schemas to OpenAI `{type:'function', function:{...}}` format and passes them in the request body
+
+### Changed
+- `src/web/vendor/anentrypoint-design/` removed; `server.js` now always serves SDK from `node_modules`; `file:../anentrypoint-design` dep keeps node_modules in sync with live SDK source
+- `src/web/app.js` refactored from 548L monolith to 59L shim; state/host helpers extracted to `src/web/state.js` (131L); all page components extracted to `src/web/routes.js` (289L)
+- `acptoapi` dep switched to `file:../acptoapi` — always tracks local SDK, same pattern as `anentrypoint-design`
+- `src/agent/model-sampler.js` is now a thin re-export shim; sampler logic lives in acptoapi `lib/sampler.js`
+- `src/agent/llm_resolver.js` simplified to 95 lines: `PROVIDER_KEYS`/`DEFAULTS` imported from acptoapi, `OPENAI_COMPAT` block removed, auto-scan uses acptoapi `buildAutoChain()`, preference failover calls acptoapi `chat()`
+- `resolveCallLLM`: acptoapi is now priority 1 (before direct API keys and preference list); direct-key providers remain as fallback when acptoapi is unreachable
+
+### Added
+- Per-provider model list probing: `POST /api/providers/:name/probe` fetches live model list; `/api/providers` includes cached `models`/`modelsError`; models page shows model list per provider with probe-all button
+- `hasKey()` fixed to use `resolveKey()` 4-source chain (env → auth-store → freddie.env → acptoapi.env); previously only checked `process.env`, causing keys stored via auth-store to be invisible to the LLM resolver
+- Expanded LLM provider support: cerebras, google, mistral, codestral, cloudflare-workers-ai, xai, zai, opencode, nvidia, sambanova, qwen (15 providers total)
+- `src/agent/model-sampler.js`: background availability sampler with exponential backoff (30s→60s→120s→240s→480s cap)
+- `agent.model_preference` config key (ordered list of {provider, model} objects) for user-defined failover priority
+- `resolveCallLLM` now walks preference list, skips unavailable providers via sampler, marks failed providers on error
+- Config schema version bumped to 2 with automatic migration
+
 # Changelog
 
 ## [0.0.51] - 2026-05-04

package/README.md

@@ -134,6 +134,8 @@ v0.1.1 complete and witnessed: 12/12 named tests passing, dashboard + website bo
 - **Full context compressor** (`src/agent/compress/*`) with handoff-framed summary prefix, structured summarizer prompt, head/middle/tail policy, tool-output pre-pruning, summary-budget ratio, iterative summary update, and 600s failure cooldown
 - **Documentation site** at `website/` powered by `flatspace` (NOT docusaurus). Build with `cd website && node ../node_modules/flatspace/bin/flatspace.js build` — output to `website/docs/` for GitHub Pages.
 
+**LLM providers**: anthropic, openai, groq, openrouter, cerebras, google, mistral, codestral, cloudflare-workers-ai, xai, zai, opencode, nvidia, sambanova, qwen — plus acptoapi localhost bridge. Set `agent.model_preference` in `~/.freddie/config.yaml` for ordered failover with exponential backoff.
+
 What's not in the box yet (residual, see AGENTS.md): real credentials per platform / memory backend; modal / daytona / singularity environments; bedrock / codex provider adapters.
 
 ## Testing

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freddie",
-  "version": "0.0.76",
+  "version": "0.0.78",
   "type": "module",
   "description": "Open JS agent harness built on pi-mono, floosie, xstate, and anentrypoint-design",
   "bin": {
@@ -26,7 +26,8 @@
     "plugsdk": "^1.0.15",
     "xstate": "^5.31.0",
     "zod": "^4.0.0",
-    "anentrypoint-design": "^0.0.63"
+    "anentrypoint-design": "^0.0.67",
+    "acptoapi": "^1.0.48"
   },
   "optionalDependencies": {
     "@libsql/darwin-arm64": "0.3.19",

package/plugins/gui-chat/plugin.js

@@ -1,20 +1,27 @@
 import { runTurn } from '../../src/agent/machine.js'
+import { createSession } from '../../src/sessions.js'
 export default {
     name: 'gui-chat', surfaces: 'gui',
     register({ gui }) {
         gui.route('POST', '/api/chat', async (req, res) => {
-            const { prompt, sessionId = null } = req.body || {}
+            const { prompt, sessionId: incomingSessionId = null, cwd, skill, provider, model } = req.body || {}
             if (!prompt) return res.status(400).json({ error: 'prompt required' })
             res.setHeader('Content-Type', 'text/event-stream')
             res.setHeader('Cache-Control', 'no-cache')
             res.setHeader('Connection', 'keep-alive')
             const send = (event, data) => res.write('event: ' + event + '\ndata: ' + JSON.stringify(data) + '\n\n')
+            let sessionId = incomingSessionId
+            if (!sessionId) {
+                try {
+                    sessionId = await createSession({ platform: 'web', title: prompt.slice(0, 80), cwd: cwd || null, skill: skill || null, model: model || null })
+                } catch (_) { sessionId = null }
+            }
             send('start', { ts: Date.now(), sessionId })
             try {
-                const out = await runTurn({ prompt, timeoutMs: 30000 })
+                const out = await runTurn({ prompt, timeoutMs: 120000, cwd, skill, provider, model })
                 if (out.error) { send('error', { error: out.error }); res.end(); return }
                 for (const m of out.messages) send('message', m)
-                send('done', { result: out.result || '', iterations: out.iterations })
+                send('done', { result: out.result || '', iterations: out.iterations, sessionId })
             } catch (e) { send('error', { error: String(e.message || e) }) }
             res.end()
         })

package/plugins/gui-profiles-commands-health/plugin.js

@@ -1,11 +1,37 @@
+import { createRequire } from 'module'
 import { listAllProfiles } from '../../src/commands/profile.js'
 import { COMMAND_REGISTRY } from '../../src/commands/registry.js'
 import { getFreddieHome } from '../../src/home.js'
+import { PROVIDER_KEYS, DEFAULTS } from '../../src/agent/llm_resolver.js'
+import { getStatus } from '../../src/agent/model-sampler.js'
+import { resolveKey } from '../../src/agent/credential_sources.js'
+const _require = createRequire(import.meta.url)
+const { probeModels, getCachedModels } = _require('acptoapi')
 export default {
     name: 'gui-profiles-commands-health', surfaces: 'gui',
     register({ gui }) {
         gui.route('GET', '/api/profiles', (_, res) => res.json(listAllProfiles()))
         gui.route('GET', '/api/commands', (_, res) => res.json(COMMAND_REGISTRY))
         gui.route('GET', '/api/health', (_, res) => res.json({ ok: true, ts: Date.now(), freddie_home: getFreddieHome() }))
+        gui.route('GET', '/api/providers', async (_, res) => {
+            const status = getStatus()
+            const providers = await Promise.all(Object.keys(PROVIDER_KEYS).map(async name => {
+                const envKey = PROVIDER_KEYS[name]
+                const resolved = await resolveKey(name).catch(() => ({ value: null }))
+                const configured = !!(resolved.value || (envKey && process.env[envKey]))
+                const s = status.find(x => x.provider === name)
+                const available = configured && (s ? s.ok !== false : true)
+                const cached = getCachedModels(name)
+                return { name, configured, available, defaultModel: DEFAULTS[name] || '', models: cached?.models || null, modelsError: cached?.error || null }
+            }))
+            res.json(providers)
+        })
+        gui.route('POST', '/api/providers/:name/probe', async (req, res) => {
+            const { name } = req.params
+            const resolved = await resolveKey(name).catch(() => ({ value: null }))
+            if (!resolved.value) return res.status(400).json({ error: 'no key' })
+            const result = await probeModels(name, resolved.value)
+            res.json(result)
+        })
     },
 }

package/src/agent/credential_sources.js

@@ -1,17 +1,33 @@
 import fs from 'node:fs'
 import path from 'node:path'
+import { createRequire } from 'node:module'
 import { getFreddieHome } from '../home.js'
 import { getAuthStore } from '../auth.js'
 const ENV_MAP = { anthropic: 'ANTHROPIC_API_KEY', openai: 'OPENAI_API_KEY', groq: 'GROQ_API_KEY', xai: 'XAI_API_KEY', openrouter: 'OPENROUTER_API_KEY', mistral: 'MISTRAL_API_KEY', deepseek: 'DEEPSEEK_API_KEY' }
+function parseDotEnv(filePath, envKey) {
+    if (!fs.existsSync(filePath)) return null
+    const m = fs.readFileSync(filePath, 'utf8').match(new RegExp('^' + envKey + '=(.+)$', 'm'))
+    return m ? m[1].replace(/^["']|["']$/g, '') : null
+}
+function acptoApiEnvPath() {
+    try {
+        const req = createRequire(import.meta.url)
+        const pkgMain = req.resolve('acptoapi')
+        return path.join(path.dirname(pkgMain), '.env')
+    } catch { return null }
+}
 export async function resolveKey(provider) {
     const env = ENV_MAP[provider] || (provider.toUpperCase() + '_API_KEY')
     if (process.env[env]) return { source: 'env', value: process.env[env] }
     const stored = await getAuthStore().getCredential(env)
     if (stored?.value) return { source: 'auth-store', value: stored.value }
-    const dotEnv = path.join(getFreddieHome(), '.env')
-    if (fs.existsSync(dotEnv)) {
-        const m = fs.readFileSync(dotEnv, 'utf8').match(new RegExp('^' + env + '=(.+)$', 'm'))
-        if (m) return { source: 'dotenv', value: m[1].replace(/^["']|["']$/g, '') }
+    const frederickDotEnv = path.join(getFreddieHome(), '.env')
+    const fromFreddie = parseDotEnv(frederickDotEnv, env)
+    if (fromFreddie) return { source: 'dotenv', value: fromFreddie }
+    const acpPath = acptoApiEnvPath()
+    if (acpPath) {
+        const fromAcp = parseDotEnv(acpPath, env)
+        if (fromAcp) return { source: 'acptoapi-dotenv', value: fromAcp }
     }
     return { source: 'none', value: null }
 }

package/src/agent/llm_resolver.js

@@ -1,22 +1,124 @@
+import { createRequire } from 'module'
 import { callLLM as acptoapiCall, isReachable as acptoapiReachable } from './acptoapi-bridge.js'
-import { callLLM as piCall } from './pi-bridge.js'
+import { isAvailable, markFailed, getStatus } from './model-sampler.js'
+import { getConfigValue } from '../config.js'
+import { resolveKey } from './credential_sources.js'
 
-const KEYS = { anthropic: 'ANTHROPIC_API_KEY', openai: 'OPENAI_API_KEY', groq: 'GROQ_API_KEY', openrouter: 'OPENROUTER_API_KEY' }
+const _require = createRequire(import.meta.url)
+const sdk = _require('acptoapi')
+
+export const PROVIDER_KEYS = sdk.PROVIDER_KEYS
+export const DEFAULTS = sdk.PROVIDER_DEFAULTS
+
+function toOpenAITools(schemas) {
+    if (!schemas?.length) return undefined
+    return schemas.map(s => ({ type: 'function', function: { name: s.name, description: s.description || '', parameters: s.parameters || { type: 'object', properties: {} } } }))
+}
+
+async function directOpenAICompatChat(url, apiKey, model, messages, tools) {
+    const body = { model, messages, ...(tools?.length ? { tools } : {}) }
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(120000),
+    })
+    if (!res.ok) { const t = await res.text(); throw new Error(`${res.status} ${t.slice(0, 200)}`) }
+    return res.json()
+}
+
+async function sdkChat(provider, model, input) {
+    const { resolveModel } = sdk
+    const r = resolveModel(`${provider}/${model}`)
+    const resolved = await resolveKey(provider).catch(() => ({ value: null }))
+    const apiKey = resolved.value || (r.env ? process.env[r.env] : undefined)
+    const openaiTools = toOpenAITools(input.tools)
+    let result
+    if (r.provider === 'openai-compat') {
+        result = await directOpenAICompatChat(r.url, apiKey, r.model, input.messages, openaiTools)
+    } else {
+        const { buffer: sdkBuffer } = sdk
+        result = await sdkBuffer({ from: null, to: 'openai', provider: r.provider, model: r.model, messages: input.messages, apiKey, ...(openaiTools ? { tools: openaiTools } : {}) })
+    }
+    const choice = result?.choices?.[0]?.message || {}
+    const content = typeof choice.content === 'string' ? choice.content : ''
+    const tool_calls = Array.isArray(choice.tool_calls)
+        ? choice.tool_calls.map(tc => ({ id: tc.id, name: tc.function?.name, arguments: tryParseJson(tc.function?.arguments) }))
+        : []
+    return { content, tool_calls, raw: result }
+}
+
+function tryParseJson(s) { try { return typeof s === 'string' ? JSON.parse(s) : (s || {}) } catch { return {} } }
+
+async function hasKey(provider) {
+    const resolved = await resolveKey(provider).catch(() => ({ value: null }))
+    return !!resolved.value
+}
+
+function defaultModel(provider) {
+    return DEFAULTS[provider] || ''
+}
 
 export function resolveCallLLM({ provider, model } = {}) {
     return async (input) => {
         const explicitProvider = provider || input.provider
-        const explicitKey = explicitProvider && KEYS[explicitProvider] ? process.env[KEYS[explicitProvider]] : null
-        if (explicitProvider && explicitKey) {
-            return await piCall({ ...input, provider: explicitProvider, model: model || input.model })
+
+        if (explicitProvider && await hasKey(explicitProvider)) {
+            const m = model || input.model || defaultModel(explicitProvider)
+            if (!isAvailable(explicitProvider)) {
+                const status = getStatus().map(s => `${s.provider}(ok=${s.ok},fails=${s.failCount})`).join(', ')
+                throw new Error(`provider ${explicitProvider} is in backoff | sampler: ${status}`)
+            }
+            try {
+                return await sdkChat(explicitProvider, m, input)
+            } catch (e) {
+                markFailed(explicitProvider)
+                throw e
+            }
         }
+
         if (await acptoapiReachable()) {
             return await acptoapiCall({ ...input, model: model || input.model })
         }
-        const DEFAULTS = { anthropic: 'claude-3-5-haiku-20241022', openai: 'gpt-4o-mini', groq: 'llama3-8b-8192', openrouter: 'openai/gpt-4o-mini' }
-        for (const [p, k] of Object.entries(KEYS)) {
-            if (process.env[k]) return await piCall({ ...input, provider: p, model: model || input.model || DEFAULTS[p] })
+
+        const preference = getConfigValue('agent.model_preference', [])
+        if (Array.isArray(preference) && preference.length > 0) {
+            const errors = []
+            for (const pref of preference) {
+                const p = pref.provider
+                const m = pref.model || model || input.model || defaultModel(p)
+                if (!await hasKey(p)) continue
+                if (!isAvailable(p)) continue
+                try {
+                    return await sdkChat(p, m, input)
+                } catch (e) {
+                    markFailed(p)
+                    errors.push(`${p}: ${e.message}`)
+                }
+            }
+            if (errors.length) {
+                const status = getStatus().map(s => `${s.provider}(ok=${s.ok},fails=${s.failCount})`).join(', ')
+                throw new Error(`all preference providers failed: ${errors.join('; ')} | sampler: ${status}`)
+            }
         }
-        throw new Error('no LLM backend reachable: start acptoapi (http://127.0.0.1:4800/v1) or set ANTHROPIC_API_KEY/OPENAI_API_KEY/GROQ_API_KEY/OPENROUTER_API_KEY')
+
+        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
+        }))).filter(Boolean)
+
+        for (const link of availableLinks) {
+            const prefix = link.model.split('/')[0]
+            const m = link.model.replace(/^[^/]+\//, '')
+            try {
+                return await sdkChat(prefix, m, input)
+            } catch (e) {
+                markFailed(prefix)
+            }
+        }
+
+        const status = getStatus().map(s => `${s.provider}(ok=${s.ok},fails=${s.failCount})`).join(', ')
+        throw new Error('no LLM backend reachable: set a provider API key or start acptoapi (http://127.0.0.1:4800/v1)' + (status ? ' | sampler: ' + status : ''))
     }
 }

package/src/agent/machine.js

@@ -85,9 +85,18 @@ export function createAgentMachine({ provider, model, maxIterations = 90, callLL
     })
 }
 
-export async function runTurn({ prompt, messages = [], model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations = 90, timeoutMs = 30000 } = {}) {
+export async function runTurn({ prompt, messages = [], model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations = 90, timeoutMs = 30000, cwd, skill } = {}) {
+    const initMessages = [...messages]
+    const systemParts = []
+    if (cwd) systemParts.push(`Working directory: ${cwd}. Always pass cwd="${cwd}" to bash tool calls. When reading or writing files use paths relative to this directory or absolute paths under it.`)
+    if (skill) {
+        const h = await bootHost()
+        const skillDef = h.pi.skills.get(skill)
+        if (skillDef?.content) systemParts.push('Skill context:\n' + skillDef.content)
+    }
+    if (systemParts.length > 0) initMessages.unshift({ role: 'user', content: systemParts.join('\n\n') })
     const machine = createAgentMachine({ model, provider, callLLM, enabledToolsets, disabledToolsets, maxIterations })
-    const actor = createActor(machine, { input: { messages } })
+    const actor = createActor(machine, { input: { messages: initMessages } })
     actor.start()
     actor.send({ type: 'SUBMIT', prompt })
     return await new Promise((resolve, reject) => {

package/src/agent/model-sampler.js

@@ -0,0 +1,13 @@
+import { createRequire } from 'module'
+const _require = createRequire(import.meta.url)
+const _sdk = _require('acptoapi')
+
+export const isAvailable = _sdk.isAvailable
+export const markFailed = _sdk.markFailed
+export const markOk = _sdk.markOk
+export const resetAvailability = _sdk.resetAvailability
+export const getStatus = _sdk.getStatus
+export const probe = _sdk.probe
+export const startSampler = _sdk.startSampler
+export const stopSampler = _sdk.stopSampler
+export const createSampler = _sdk.createSampler

package/src/config.js

@@ -4,9 +4,9 @@ import yaml from 'js-yaml'
 import { getFreddieHome } from './home.js'
 
 export const DEFAULT_CONFIG = {
-    _config_version: 1,
+    _config_version: 2,
     display: { skin: 'default', tool_progress_command: false, background_process_notifications: 'all' },
-    agent: { provider: 'anthropic', model: '', max_iterations: 90, fallback_model: null, save_trajectories: false },
+    agent: { provider: 'anthropic', model: '', max_iterations: 90, fallback_model: null, save_trajectories: false, model_preference: [] },
     memory: { provider: null },
     skills: { config: {} },
     terminal: { cwd: null },
@@ -17,6 +17,7 @@ export const DEFAULT_CONFIG = {
 
 const MIGRATIONS = {
     1: cfg => cfg,
+    2: cfg => { if (!cfg.agent) cfg.agent = {}; if (!Array.isArray(cfg.agent.model_preference)) cfg.agent.model_preference = []; return cfg },
 }
 
 export function configPath() { return path.join(getFreddieHome(), 'config.yaml') }

package/src/sessions.js

@@ -12,7 +12,8 @@ async function initDb() {
         CREATE TABLE IF NOT EXISTS sessions (
             id TEXT PRIMARY KEY,
             platform TEXT, user_id TEXT, chat_id TEXT, thread_id TEXT,
-            title TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, model TEXT
+            title TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, model TEXT,
+            cwd TEXT, skill TEXT
         );
         CREATE TABLE IF NOT EXISTS messages (
             id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -23,6 +24,11 @@ async function initDb() {
         CREATE INDEX IF NOT EXISTS idx_msg_session ON messages(session_id, ts);
     `)
 
+    // migrate: add cwd and skill columns if absent
+    for (const col of ['cwd', 'skill']) {
+        try { await d.exec(`ALTER TABLE sessions ADD COLUMN ${col} TEXT`) } catch {}
+    }
+
     // libsql supports FTS5 natively; create FTS virtual table
     try {
         await d.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(content, session_id UNINDEXED, content='messages', content_rowid='id')`)
@@ -38,12 +44,12 @@ async function db() {
     return await initDb()
 }
 
-export async function createSession({ platform = 'cli', userId = null, chatId = null, threadId = null, title = null, model = null } = {}) {
+export async function createSession({ platform = 'cli', userId = null, chatId = null, threadId = null, title = null, model = null, cwd = null, skill = null } = {}) {
     const d = await db()
     const id = randomUUID()
     const now = Date.now()
-    await d.prepare(`INSERT INTO sessions (id, platform, user_id, chat_id, thread_id, title, created_at, updated_at, model) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-        .run(id, platform, userId, chatId, threadId, title, now, now, model)
+    await d.prepare(`INSERT INTO sessions (id, platform, user_id, chat_id, thread_id, title, created_at, updated_at, model, cwd, skill) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, platform, userId, chatId, threadId, title, now, now, model, cwd, skill)
     return id
 }
 
@@ -64,7 +70,7 @@ export async function getMessages(sessionId) {
 
 export async function listSessions(limit = 50) {
     const d = await db()
-    return await d.prepare(`SELECT id, platform, title, created_at, updated_at, model FROM sessions ORDER BY updated_at DESC LIMIT ?`).all(limit)
+    return await d.prepare(`SELECT id, platform, title, created_at, updated_at, model, cwd, skill FROM sessions ORDER BY updated_at DESC LIMIT ?`).all(limit)
 }
 
 export async function search(query, limit = 20) {

package/src/web/app.js

@@ -1,80 +1,64 @@
-import { createFreddieDashboard } from '/vendor/anentrypoint-design/desktop/freddie-dashboard.js';
-import { installStyles } from 'anentrypoint-design';
+import { h, applyDiff, installStyles, components } from 'anentrypoint-design';
+import { fetchHost, ROUTES } from './state.js';
+import { PAGES } from './routes.js';
+
+const { AppShell, Topbar, Side, Crumb, Status, EmptyState, Chip } = components;
 
 await installStyles();
 
-const link = document.createElement('link');
-link.rel = 'stylesheet';
-link.href = '/vendor/anentrypoint-design/desktop/freddie-dashboard.css';
-document.head.appendChild(link);
+const root = document.getElementById('app');
+root.textContent = 'loading…';
+const host0 = await fetchHost();
+root.innerHTML = '';
 
-const j = async (u, opts) => { const r = await fetch(u, opts); if (!r.ok) throw new Error(r.status + ' ' + r.statusText); return await r.json(); };
-const post = (u, body) => j(u, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) });
+const state = { active: 'home', ts: new Date().toLocaleTimeString(), body: null, error: null };
 
-function regFromArray(arr, keyFn = (x) => x.name) {
-    const m = new Map();
-    for (const it of arr || []) m.set(keyFn(it), it);
-    return { get: (k) => m.get(k), has: (k) => m.has(k), list: () => [...m.values()], values: () => m.values(), get size() { return m.size; } };
+function buildSide() {
+    return Side({ sections: [{ group: 'FREDDIE', items: ROUTES.map(r => ({
+        glyph: r.glyph, label: r.label, href: '#fd-' + r.path,
+        active: state.active === r.path,
+        onClick: ev => { ev.preventDefault(); setActive(r.path); },
+    })) }] });
 }
 
-async function fetchHost() {
-    const [tools, skillsResp, cron, projectsResp, env, gateway, health, commands] = await Promise.all([
-        j('/api/tools/detail').catch(() => []),
-        j('/api/skills').catch(() => ({ home: [], bundled: [] })),
-        j('/api/cron').catch(() => []),
-        j('/api/projects').catch(() => ({ active: null, projects: [] })),
-        j('/api/env').catch(() => []),
-        j('/api/gateway').catch(() => ({ platforms: [] })),
-        j('/api/health').catch(() => ({ ok: false })),
-        j('/api/commands').catch(() => []),
-    ]);
-    const skillList = [...(skillsResp.home || []), ...(skillsResp.bundled || [])];
-    const projList = projectsResp.projects || [];
-    return {
-        kind: 'freddie-web', version: 'web',
-        pi: {
-            tools: regFromArray(tools),
-            skills: regFromArray(skillList, (s) => s.name || s.id),
-            cli: regFromArray(commands),
-            projects: {
-                list: () => projList,
-                active: () => projectsResp.active,
-                create: ({ name, path }) => post('/api/projects', { name, path }).then(() => location.reload()),
-                remove: (name) => fetch('/api/projects/' + encodeURIComponent(name), { method: 'DELETE' }).then(() => location.reload()),
-                setActive: (name) => post('/api/projects/active', { name }).then(() => location.reload()),
-            },
-            sessions: {
-                list: () => j('/api/sessions').catch(() => []),
-                getMessages: (id) => j('/api/sessions/' + encodeURIComponent(id) + '/messages').catch(() => []),
-                search: (q) => j('/api/search?q=' + encodeURIComponent(q)).catch(() => []),
-            },
-            cron: {
-                list: () => Promise.resolve(cron),
-                create: (job) => post('/api/cron', job),
-                delete: (id) => fetch('/api/cron/' + id, { method: 'DELETE' }),
-            },
-            env: { list: () => env, isSet: (k) => (env.find(e => e.key === k) || {}).set || false },
-            gateway: { platforms: () => gateway.platforms || [] },
-            agents: () => j('/api/agents').catch(() => ({ count: 0, turns: 0, active: null })),
-            health: () => health,
-            config: {
-                load: () => j('/api/config').catch(() => ({})),
-                saveValue: (path, value) => post('/api/config', { path, value }),
-            },
-            chat: { send: (text) => post('/api/chat', { text }) },
-            batch: { run: (prompts, conc) => post('/api/batch', { prompts, concurrency: conc }) },
-            hooks: {},
-        },
-    };
+function view() {
+    const route = ROUTES.find(r => r.path === state.active) || ROUTES[0];
+    const body = state.body || EmptyState({ text: 'loading…', glyph: '◌' });
+    const main = h('div', { key: state.active, class: 'fd-page' }, ...(Array.isArray(body) ? body : [body]));
+    return AppShell({
+        topbar: Topbar({ brand: 'freddie', leaf: 'dashboard', items: [], active: '' }),
+        crumb: Crumb({ trail: ['freddie'], leaf: route.path, right: state.error ? Chip({ tone: 'miss', children: 'error' }) : Chip({ tone: 'ok', children: 'live' }) }),
+        side: buildSide(),
+        main,
+        status: Status({ left: ['ds-247420 · webjsx · ' + ROUTES.length + ' routes'], right: [state.ts] }),
+    });
 }
 
-const root = document.getElementById('app');
-root.textContent = 'loading…';
-const host = await fetchHost();
-root.innerHTML = '';
-const inst = { id: 'web', fs: { list: () => Promise.resolve([]) }, host };
-const { node } = createFreddieDashboard({ instance: inst });
-root.appendChild(node);
+function rerender() { applyDiff(root, view()); }
+
+function setActive(p) { state.active = p; state.body = null; rerender(); loadActive(); }
+if (typeof window !== 'undefined') window.__fd_nav = setActive;
+
+async function loadActive() {
+    const active = state.active;
+    try {
+        const page = PAGES[active] || PAGES.home;
+        const body = await page(host0);
+        if (state.active !== active) return;
+        state.body = body;
+        state.error = null;
+    } catch (e) {
+        if (state.active !== active) return;
+        state.error = String(e && e.stack || e);
+        const { Panel } = components;
+        state.body = Panel({ title: 'page error', children: h('pre', { class: 'fd-pre', style: 'max-height:200px;overflow-y:auto' }, state.error) });
+    }
+    state.ts = new Date().toLocaleTimeString();
+    applyDiff(root, view());
+}
+
+applyDiff(root, view());
+loadActive();
 
 if (!window.__debug) window.__debug = {};
-window.__debug.dashboard = () => ({ booted: true, mode: 'fetchHost', tools: host.pi.tools.size, skills: host.pi.skills.size });
+window.__debug.dashboard = () => ({ booted: true, tools: host0.pi.tools.size, skills: host0.pi.skills.size, active: state.active });

package/src/web/index.html

@@ -4,16 +4,16 @@
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>Freddie Dashboard</title>
+<link rel="stylesheet" href="/vendor/anentrypoint-design/247420.css">
 <script type="importmap">
 { "imports": { "anentrypoint-design": "/vendor/anentrypoint-design/247420.js" } }
 </script>
 <style>
-/* Freddie-only overrides — all generic primitives ship via SDK installStyles() */
-html, body { margin: 0; padding: 0; min-height: 100vh; }
-#app { padding: 16px 20px; box-sizing: border-box; }
+html, body { margin: 0; padding: 0; height: 100%; }
+#app { height: 100%; }
 </style>
 </head>
-<body data-theme="dark">
+<body data-theme="light">
 <div id="app"></div>
 <script type="module" src="./app.js"></script>
 </body>

package/src/web/routes.js

@@ -0,0 +1,2 @@
+import { FREDDIE_PAGES } from 'anentrypoint-design';
+export const PAGES = FREDDIE_PAGES;