amalgm 0.1.51 → 0.1.52

package/runtime/scripts/amalgm-mcp/events/store.js

@@ -2,17 +2,15 @@
  * Event triggers storage — ~/.amalgm/event-triggers.json
  */
 
+const crypto = require('crypto');
 const { EVENT_TRIGGERS_FILE, STORAGE_DIR } = require('../config');
 const { ensureDir, readJson, writeJsonAtomic } = require('../lib/storage');
 const { openLocalDb } = require('../state/db');
-const {
-  chatInputToLegacyFields,
-  getChatInputText,
-  normalizeChatInput,
-} = require('../../../lib/chatInput');
-const { DEFAULT_SELECTED_MODELS, getSelectedModel } = require('../lib/prefs');
-const credentialAdapter = require('../../credential-adapter');
 const { appendStateEvent, insertStateEvent, publishStateEvent } = require('../state/events');
+const { compileWorkflowText } = require('../workflows/compiler');
+const { syncWorkflowTriggerLinks, upsertWorkflowFromTrigger } = require('../workflows/store');
+const { internalWorkflowSeeds } = require('./internal-workflows');
+const { getWebhookUrl } = require('./webhook-url');
 
 const DEFAULT_RUN_LIMIT = 100;
 
@@ -29,66 +27,111 @@ function parseJson(value, fallback = null) {
   }
 }
 
-function normalizeStoredTrigger(trigger) {
-  const harness =
-    (trigger.chatInput && trigger.chatInput.agent && trigger.chatInput.agent.harness)
-    || trigger.harness
-    || 'claude_code';
-  const model =
-    (trigger.chatInput && trigger.chatInput.agent && trigger.chatInput.agent.model)
-    || trigger.model
-    || getSelectedModel(harness)
-    || DEFAULT_SELECTED_MODELS[harness]
-    || null;
-  const authMethod =
-    (trigger.chatInput && trigger.chatInput.agent && trigger.chatInput.agent.authMethod)
-    || trigger.authMethod
-    || (credentialAdapter.VALID_HARNESS_IDS.includes(harness)
-      ? credentialAdapter.getPersistedAuthMode(harness)
-      : 'amalgm');
-  const chatInput = normalizeChatInput(trigger.chatInput, {
-    prompt: trigger.agent_prompt,
-    harness,
-    modelId: model,
-    authMethod,
-    cwd: trigger.projectPath,
-    projectPath: trigger.projectPath,
-  });
-  const legacy = chatInputToLegacyFields(chatInput, {
-    prompt: trigger.agent_prompt,
-    harness,
-    modelId: model,
-    authMethod,
-    cwd: trigger.projectPath,
-    projectPath: trigger.projectPath,
-  });
+function normalizeStringList(values) {
+  if (!Array.isArray(values)) return [];
+  return [...new Set(values
+    .filter((value) => typeof value === 'string')
+    .map((value) => value.trim())
+    .filter(Boolean))];
+}
+
+function normalizeWorkflowTrigger(trigger) {
+  const workflowText = String(trigger.workflowText || trigger.workflow || '').trim();
+  let workflowIr = trigger.workflowIr && trigger.workflowIr.version === 1 ? trigger.workflowIr : null;
+  let compilerErrors = null;
+
+  if (workflowText) {
+    try {
+      workflowIr = compileWorkflowText(workflowText);
+    } catch (error) {
+      workflowIr = null;
+      compilerErrors = [error.message || String(error)];
+    }
+  }
+
+  const irTrigger = workflowIr?.trigger || {};
+  const allowlist = {
+    ...(workflowIr?.allowlist || {}),
+    ...(trigger.allowlist && typeof trigger.allowlist === 'object' ? trigger.allowlist : {}),
+  };
+  const limits = {
+    ...(workflowIr?.limits || {}),
+    ...(trigger.limits && typeof trigger.limits === 'object' ? trigger.limits : {}),
+  };
 
   return {
-    ...trigger,
-    chatInput,
-    agent_prompt: getChatInputText(chatInput, trigger.agent_prompt) || legacy.prompt,
-    harness: legacy.harness || harness,
-    model: legacy.modelId || model,
-    authMethod: legacy.authMethod || authMethod,
-    projectPath: legacy.cwd || trigger.projectPath || null,
+    id: trigger.id,
+    name: trigger.name || 'Untitled workflow',
+    description: trigger.description || '',
+    source: irTrigger.source || trigger.source || '*',
+    event: irTrigger.event || trigger.event || '*',
+    enabled: trigger.enabled !== false,
+    webhookUrl: trigger.webhookUrl || getWebhookUrl(),
+    secret: trigger.secret || crypto.randomUUID().replace(/-/g, ''),
+    projectPath: trigger.projectPath || null,
+    workflowIds: normalizeStringList(
+      trigger.workflowIds || (trigger.workflowId ? [trigger.workflowId] : []),
+    ),
+    workflowText,
+    workflowIr,
+    compilerErrors,
+    allowlist,
+    limits,
+    internal: trigger.internal === true,
+    createdAt: trigger.createdAt || nowIso(),
+    updatedAt: trigger.updatedAt || null,
+    lastFiredAt: trigger.lastFiredAt || null,
   };
 }
 
 function migrateTriggersData(data) {
   let changed = false;
-  const triggers = Array.isArray(data.triggers)
-    ? data.triggers.map((trigger) => {
-        const normalizedTrigger = normalizeStoredTrigger(trigger);
-        if (JSON.stringify(normalizedTrigger) !== JSON.stringify(trigger)) {
-          changed = true;
-        }
-        return normalizedTrigger;
-      })
-    : [];
+  const rawTriggers = Array.isArray(data.triggers) ? data.triggers : [];
+  const triggers = rawTriggers
+    .filter((trigger) => trigger && (
+      trigger.workflowText
+      || trigger.workflow
+      || trigger.workflowIr
+      || trigger.workflowId
+      || (Array.isArray(trigger.workflowIds) && trigger.workflowIds.length > 0)
+    ))
+    .map((trigger) => {
+      const embeddedWorkflow = upsertWorkflowFromTrigger(trigger);
+      const normalizedTrigger = normalizeWorkflowTrigger({
+        ...trigger,
+        workflowIds: normalizeStringList([
+          ...(Array.isArray(trigger.workflowIds) ? trigger.workflowIds : []),
+          ...(trigger.workflowId ? [trigger.workflowId] : []),
+          ...(embeddedWorkflow?.id ? [embeddedWorkflow.id] : []),
+        ]),
+      });
+      if (JSON.stringify(normalizedTrigger) !== JSON.stringify(trigger)) {
+        changed = true;
+      }
+      return normalizedTrigger;
+    });
+
+  if (triggers.length !== rawTriggers.length) changed = true;
+
+  const existingIds = new Set(triggers.map((trigger) => trigger.id));
+  for (const seed of internalWorkflowSeeds()) {
+    if (existingIds.has(seed.id)) continue;
+    triggers.push(normalizeWorkflowTrigger({
+      ...seed,
+      webhookUrl: seed.webhookUrl || null,
+      secret: seed.secret || null,
+      createdAt: nowIso(),
+      lastFiredAt: null,
+    }));
+    changed = true;
+  }
 
   return {
     changed,
-    data: { triggers },
+    data: {
+      version: 2,
+      triggers,
+    },
   };
 }
 
@@ -124,6 +167,7 @@ function publishEventTriggersChange(data, source = 'event-triggers') {
 
 function saveEventTriggers(data, options = {}) {
   writeJsonAtomic(EVENT_TRIGGERS_FILE, data);
+  syncWorkflowTriggerLinks(data.triggers);
   publishEventTriggersChange(data, options.source || 'event-triggers:save');
 }
 
@@ -240,6 +284,8 @@ function mergeEventRunEntry(existing, triggerId, entry) {
     runId: entry.runId || entry.id || existing?.id || entry.sessionId || null,
     triggerId,
     triggerName: entry.triggerName || existing?.triggerName || null,
+    workflowId: entry.workflowId || existing?.workflowId || null,
+    workflowName: entry.workflowName || existing?.workflowName || null,
     status: entry.status || existing?.status || 'running',
     startedAt,
     finishedAt,
@@ -248,6 +294,8 @@ function mergeEventRunEntry(existing, triggerId, entry) {
     projectPath: entry.projectPath || existing?.projectPath || null,
     error: entry.error || existing?.error || null,
     durationMs: entry.durationMs ?? existing?.durationMs ?? null,
+    workflow: entry.workflow ?? existing?.workflow ?? null,
+    output: entry.output ?? existing?.output ?? null,
     outputLength: entry.outputLength ?? existing?.outputLength ?? null,
     prompt: entry.prompt || existing?.prompt || null,
     events,
@@ -308,6 +356,7 @@ module.exports = {
   ensureTriggersDirs,
   listEventRuns,
   loadEventTriggers,
+  normalizeWorkflowTrigger,
   recordEventRun,
   saveEventTriggers,
 };

package/runtime/scripts/amalgm-mcp/index.js

@@ -11,13 +11,13 @@
  *
  * Modules:
  *   config.js                   env + paths
- *   deps.js                     cron-parser + playwright loaders
+ *   deps.js                     optional runtime dependency loaders
  *   lib/                        generic utilities (storage, chat-runner,
  *                               supabase, prefs, email-md, tool-result)
- *   tasks/                      scheduled tasks (8 MCP tools + poll loop)
- *   events/                     event triggers (5 MCP tools + /events ingress)
+ *   automations/                triggers + workflows (MCP tools + scheduler)
+ *   events/                     webhook ingress runtime for event triggers
  *   agents/                     agents CRUD + talk_to_agent
- *   browser/                    visible Electron browser + Playwright fallback tools
+ *   browser/                    visible Electron browser tools + agent-browser fallback
  *   notify/                     notify_user (email via proxy)
  *   server/                     MCP JSON-RPC dispatch + HTTP route table
  */
@@ -75,23 +75,21 @@ async function ensureProxyToken() {
 async function boot() {
   await ensureProxyToken();
 
-  const { ensureTasksDirs } = require('./tasks/store');
-  const { ensureTriggersDirs } = require('./events/store');
+  const { ensureAutomationsStore } = require('./automations/store');
   const { ensureAgentsDirs } = require('./agents/store');
-  const { ensureArtifactsDirs } = require('./artifacts/store');
-  const { startArtifactRouteSyncLoop } = require('./artifacts/advertise');
-  const { startRegisteredArtifacts } = require('./artifacts/supervisor');
+  const { ensureAppsDirs } = require('./apps/store');
+  const { startAppRouteSyncLoop } = require('./apps/advertise');
+  const { startRegisteredApps } = require('./apps/supervisor');
   const { listen } = require('./server/http');
 
   // Make sure every storage dir/file exists before we accept traffic.
-  ensureTasksDirs();
-  ensureTriggersDirs();
+  ensureAutomationsStore();
   ensureAgentsDirs();
-  ensureArtifactsDirs();
+  ensureAppsDirs();
 
   await listen();
-  await startRegisteredArtifacts();
-  startArtifactRouteSyncLoop();
+  await startRegisteredApps();
+  startAppRouteSyncLoop();
 }
 
 boot().catch((err) => {

package/runtime/scripts/amalgm-mcp/lib/prefs.js

@@ -1,17 +1,17 @@
 /**
  * User model preferences — mirrors the Zustand harnessPreferences store.
  *
- * Hydrates on boot (non-blocking) from Supabase. Used to pick the right model
+ * Hydrates on boot (non-blocking) from local SQLite. Used to pick the right model
  * for task/event/agent runs without requiring the caller to specify it.
  */
 
-const { AMALGM_USER_ID } = require('../config');
-const { hasSupabase, supabaseSelect } = require('./supabase');
+const { openLocalDb } = require('../state/db');
+const { insertStateEvent, publishStateEvent } = require('../state/events');
 
 const DEFAULT_SELECTED_MODELS = {
   claude_code: 'anthropic/claude-opus-4.7',
-  codex: 'openai/gpt-5.4-thinking-xhigh',
-  opencode: 'opencode-moonshotai-kimi-k2.5',
+  codex: 'openai/gpt-5.5',
+  opencode: 'opencode-deepseek-deepseek-v4-pro',
   pi: 'pi-anthropic-claude-sonnet-4.6',
   amp: 'amp-default',
   cursor: 'cursor/composer-2-fast',
@@ -124,10 +124,16 @@ const CURSOR_MODEL_ALIASES = {
   'cursor-moonshotai/kimi-k2.5': 'moonshotai/kimi-k2.5',
 };
 
+const PREFERENCES_META_KEY = 'user_preferences';
+const PREFERENCES_RESOURCE = 'user_preferences';
+const PREFERENCES_RESOURCE_ID = 'current';
+
 const _selectedModels = { ...DEFAULT_SELECTED_MODELS };
-const _authMethods = {};
-let _pinnedHarness = null;
-let _pinnedModel = null;
+const _authMethods = { ...DEFAULT_AUTH_METHODS };
+let _lastUsedHarness = 'claude_code';
+let _lastUsedModel = DEFAULT_SELECTED_MODELS.claude_code;
+let _lastUsedCwd = null;
+let _modelSettings = {};
 let _prefsHydrated = false;
 let _prefsHydratePromise = null;
 
@@ -294,26 +300,212 @@ function normalizeModelSelection(harnessId, modelId) {
   return { modelId, reasoningEffort: null };
 }
 
-function inferHarnessForModel(modelId, fallbackHarnessId) {
-  const cleaned = cleanModelId(modelId);
-  if (cleaned.startsWith('cursor-') || cleaned.startsWith('cursor/')) return 'cursor';
-  if (cleaned.startsWith('amp-')) return 'amp';
-  if (cleaned.startsWith('opencode-')) return 'opencode';
-  if (cleaned.startsWith('pi-')) return 'pi';
-  if (
-    cleaned.startsWith('claude-') ||
-    cleaned.startsWith('anthropic/claude-') ||
-    ['opus', 'opus1m', 'opus[1m]', 'sonnet', 'sonnet[1m]', 'haiku'].includes(cleaned)
-  ) {
-    return 'claude_code';
+function isPlainObject(value) {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function coerceHarnessId(value, fallback = 'claude_code') {
+  return Object.prototype.hasOwnProperty.call(DEFAULT_SELECTED_MODELS, value)
+    ? value
+    : fallback;
+}
+
+function normalizeModelSettings(value) {
+  if (!isPlainObject(value)) return {};
+  const normalized = {};
+  for (const [key, settings] of Object.entries(value)) {
+    if (!key || !isPlainObject(settings)) continue;
+    if (Object.keys(settings).length === 0) continue;
+    normalized[key] = settings;
+  }
+  return normalized;
+}
+
+function normalizeReasoningEffort(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim().toLowerCase().replace(/_/g, '-');
+  if (normalized === 'low') return 'low';
+  if (normalized === 'medium') return 'medium';
+  if (normalized === 'high') return 'high';
+  if (normalized === 'xhigh' || normalized === 'extra-high' || normalized === 'extra high') {
+    return 'xhigh';
+  }
+  return null;
+}
+
+function codexModelSettingsKey(modelId) {
+  return codexGatewayModelId(String(modelId || ''));
+}
+
+function reasoningEffortForSelection(harnessId, modelId, normalizedEffort) {
+  const explicitEffort = normalizeReasoningEffort(normalizedEffort);
+  if (explicitEffort) return explicitEffort;
+  if (harnessId !== 'codex') return null;
+  const settingsKey = codexModelSettingsKey(modelId);
+  const settings = _modelSettings[settingsKey] || _modelSettings[modelId] || {};
+  return normalizeReasoningEffort(settings.effort || settings.reasoningEffort || settings.reasoning) || 'xhigh';
+}
+
+function normalizePreferences(input) {
+  const raw = isPlainObject(input) ? input : {};
+  const rawRecentPrefs = isPlainObject(raw.recent_prefs) ? raw.recent_prefs : {};
+  const recentPrefs = { ...DEFAULT_SELECTED_MODELS };
+  for (const [harnessId, modelId] of Object.entries(rawRecentPrefs)) {
+    if (!modelId) continue;
+    const harness = coerceHarnessId(harnessId, null);
+    if (!harness) continue;
+    recentPrefs[harness] = normalizeModelSelection(harness, modelId).modelId || modelId;
+  }
+
+  const rawUsage = isPlainObject(raw.usage) ? raw.usage : {};
+  const usage = { ...DEFAULT_AUTH_METHODS };
+  for (const harnessId of Object.keys(DEFAULT_AUTH_METHODS)) {
+    usage[harnessId] = coerceAuthMethodForHarness(harnessId, rawUsage[harnessId] || usage[harnessId]);
+  }
+
+  const rawLastUsed = isPlainObject(raw.last_used) ? raw.last_used : {};
+  const lastUsedHarness = coerceHarnessId(rawLastUsed.harness, 'claude_code');
+  const rawLastModel =
+    rawLastUsed.model ||
+    recentPrefs[lastUsedHarness] ||
+    DEFAULT_SELECTED_MODELS[lastUsedHarness];
+  const lastUsedModel =
+    normalizeModelSelection(lastUsedHarness, rawLastModel).modelId ||
+    rawLastModel;
+  recentPrefs[lastUsedHarness] = lastUsedModel;
+
+  return {
+    last_used: {
+      harness: lastUsedHarness,
+      model: lastUsedModel,
+      cwd: cleanString(rawLastUsed.cwd ?? raw.last_cwd ?? raw.selected_cwd),
+    },
+    usage,
+    recent_prefs: recentPrefs,
+    model_settings: normalizeModelSettings(raw.model_settings),
+  };
+}
+
+function applyPreferenceCache(preferences) {
+  const normalized = normalizePreferences(preferences);
+  _lastUsedHarness = normalized.last_used.harness;
+  _lastUsedModel = normalized.last_used.model;
+  _lastUsedCwd = normalized.last_used.cwd;
+  _modelSettings = normalized.model_settings;
+
+  for (const key of Object.keys(_selectedModels)) delete _selectedModels[key];
+  Object.assign(_selectedModels, normalized.recent_prefs);
+
+  for (const key of Object.keys(_authMethods)) delete _authMethods[key];
+  Object.assign(_authMethods, normalized.usage);
+
+  return normalized;
+}
+
+function parseStoredPreferences(value) {
+  if (typeof value !== 'string' || !value) return {};
+  try {
+    return JSON.parse(value);
+  } catch {
+    return {};
   }
-  if (cleaned.startsWith('codex-') || cleaned.startsWith('openai/') || /^(gpt-|gpt\d|o-|o\d)/i.test(cleaned)) {
-    return 'codex';
+}
+
+function readUserPreferences() {
+  const row = openLocalDb()
+    .prepare('SELECT value FROM local_meta WHERE key = ?')
+    .get(PREFERENCES_META_KEY);
+  _prefsHydrated = true;
+  return applyPreferenceCache(normalizePreferences(parseStoredPreferences(row?.value)));
+}
+
+function writeUserPreferences(preferences, options = {}) {
+  const normalized = normalizePreferences(preferences);
+  const db = openLocalDb();
+  const event = db.transaction(() => {
+    db.prepare(`
+      INSERT INTO local_meta (key, value, updated_at)
+      VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      ON CONFLICT(key) DO UPDATE SET
+        value = excluded.value,
+        updated_at = excluded.updated_at
+    `).run(PREFERENCES_META_KEY, JSON.stringify(normalized));
+
+    return insertStateEvent(db, {
+      resource: PREFERENCES_RESOURCE,
+      op: 'replace',
+      id: PREFERENCES_RESOURCE_ID,
+      value: normalized,
+      source: options.source || 'user-preferences',
+    });
+  })();
+
+  _prefsHydrated = true;
+  applyPreferenceCache(normalized);
+  publishStateEvent(event);
+  return normalized;
+}
+
+function mergePreferencesPatch(current, patch) {
+  const body = isPlainObject(patch) ? patch : {};
+  const bodyLastUsed = isPlainObject(body.last_used) ? body.last_used : {};
+  const lastUsedHarness = coerceHarnessId(
+    bodyLastUsed.harness,
+    current.last_used.harness,
+  );
+  const bodyRecentPrefs = isPlainObject(body.recent_prefs) ? body.recent_prefs : {};
+  const recentPrefs = {
+    ...current.recent_prefs,
+    ...bodyRecentPrefs,
+  };
+  const lastUsedModel =
+    bodyLastUsed.model ||
+    recentPrefs[lastUsedHarness] ||
+    current.last_used.model;
+  const cwd = cleanString(
+    bodyLastUsed.cwd ??
+    body.selectedCwd ??
+    body.cwd ??
+    current.last_used.cwd,
+  );
+
+  return normalizePreferences({
+    last_used: {
+      harness: lastUsedHarness,
+      model: lastUsedModel,
+      cwd,
+    },
+    usage: isPlainObject(body.usage)
+      ? { ...current.usage, ...body.usage }
+      : current.usage,
+    recent_prefs: recentPrefs,
+    model_settings: mergeModelSettingsPatch(current.model_settings, body.model_settings),
+  });
+}
+
+function mergeModelSettingsPatch(currentModelSettings, patchModelSettings) {
+  if (!isPlainObject(patchModelSettings)) return currentModelSettings;
+  const next = { ...currentModelSettings };
+  for (const [key, value] of Object.entries(patchModelSettings)) {
+    if (!key || !isPlainObject(value) || Object.keys(value).length === 0) {
+      delete next[key];
+      continue;
+    }
+    next[key] = value;
   }
-  return fallbackHarnessId;
+  return next;
 }
 
-function resolveCliModel(harnessId, modelId) {
+function updateUserPreferences(patch, options = {}) {
+  const current = readUserPreferences();
+  return writeUserPreferences(mergePreferencesPatch(current, patch), options);
+}
+
+function resolveCliModel(harnessId, modelId, reasoningEffort = null) {
   const selection = normalizeModelSelection(harnessId, modelId);
   const selectedModelId = selection.modelId || modelId;
   if (harnessId === 'claude_code') {
@@ -321,7 +513,10 @@ function resolveCliModel(harnessId, modelId) {
       selectedModelId.replace(/^anthropic\//, '').replace(/-(\d+)\.(\d+)(?=$|-)/, '-$1-$2');
   }
   if (harnessId === 'codex') {
-    return codexHarnessModelId(selectedModelId, selection.reasoningEffort);
+    return codexHarnessModelId(
+      selectedModelId,
+      reasoningEffortForSelection(harnessId, selectedModelId, reasoningEffort || selection.reasoningEffort),
+    );
   }
   if (harnessId === 'cursor') {
     return cursorCanonicalModelIdToCliModel(selectedModelId);
@@ -347,50 +542,16 @@ function resolveCliModel(harnessId, modelId) {
 
 async function hydrateModelPreferences() {
   if (_prefsHydratePromise) return _prefsHydratePromise;
-  if (_prefsHydrated || !hasSupabase()) return;
+  if (_prefsHydrated) return;
   _prefsHydratePromise = (async () => {
-    _prefsHydrated = true;
     try {
-      const rows = await supabaseSelect(
-        'user_preferences',
-        `user_id=eq.${AMALGM_USER_ID}&select=preferences`,
-      );
-      if (!rows) return;
-      const preferences = rows?.[0]?.preferences;
-      const recentPrefs = preferences?.recent_prefs;
-      if (recentPrefs && typeof recentPrefs === 'object') {
-        for (const [h, m] of Object.entries(recentPrefs)) {
-          if (m) {
-            const normalized = normalizeModelSelection(h, m).modelId || m;
-            if (_selectedModels[h] !== normalized) _selectedModels[h] = normalized;
-          }
-        }
-      }
-      const usagePrefs = preferences?.usage;
-      if (usagePrefs && typeof usagePrefs === 'object') {
-        for (const [h, method] of Object.entries(usagePrefs)) {
-          if (method) _authMethods[h] = coerceAuthMethodForHarness(h, method);
-        }
-      }
-      _pinnedHarness = preferences?.autopilot?.harness || null;
-      const rawPinnedModel = preferences?.autopilot?.model || null;
-      if (rawPinnedModel) {
-        const harnessForPinned =
-          _pinnedHarness ||
-          inferHarnessForModel(rawPinnedModel, preferences?.last_used?.harness || null);
-        _pinnedModel = harnessForPinned
-          ? normalizeModelSelection(harnessForPinned, rawPinnedModel).modelId || rawPinnedModel
-          : rawPinnedModel;
-      } else {
-        _pinnedModel = null;
-      }
+      const preferences = readUserPreferences();
       console.log(
         '[AmalgmMCP] Hydrated user prefs:',
         JSON.stringify({
           selectedModels: _selectedModels,
           authMethods: _authMethods,
-          pinnedHarness: _pinnedHarness,
-          pinnedModel: _pinnedModel,
+          lastUsed: preferences.last_used,
         }),
       );
     } catch (err) {
@@ -403,7 +564,6 @@ async function hydrateModelPreferences() {
 }
 
 function getSelectedModel(harnessId) {
-  if (_pinnedHarness === harnessId && _pinnedModel) return _pinnedModel;
   return _selectedModels[harnessId] || DEFAULT_SELECTED_MODELS[harnessId] || null;
 }
 
@@ -425,16 +585,20 @@ function resolveModelSelection(harnessId, uiModelId) {
   }
   const normalized = normalizeModelSelection(harnessId, selectedModelId);
   const modelId = normalized.modelId || selectedModelId;
+  const reasoningEffort = reasoningEffortForSelection(harnessId, modelId, normalized.reasoningEffort);
   return {
     modelId,
-    cliModel: resolveCliModel(harnessId, modelId),
-    reasoningEffort: normalized.reasoningEffort || null,
+    cliModel: resolveCliModel(harnessId, modelId, reasoningEffort),
+    reasoningEffort,
   };
 }
 
 module.exports = {
   DEFAULT_SELECTED_MODELS,
   hydrateModelPreferences,
+  readUserPreferences,
+  writeUserPreferences,
+  updateUserPreferences,
   getSelectedModel,
   getPreferredAuthMethod,
   resolveModelSelection,