mixdog 0.9.3 → 0.9.5

package/src/tui/app/extension-pickers.mjs

@@ -0,0 +1,506 @@
+/**
+ * extension-pickers.mjs — MCP / Skills / Plugins / Hooks picker cluster.
+ *
+ * Extracted from App.jsx behavior-preservingly as a dependency-injection
+ * factory. These openers drive setPicker + setSettingsPrompt and read live
+ * store state, so they can't be pure. Every function body is the original App
+ * logic verbatim, with closure identifiers threaded through the factory
+ * argument. `disabledSkills` is read fresh via getDisabledSkills() so toggles
+ * observe the latest state at call time. openMcpPicker is exposed for the
+ * plugin-detail enable-mcp path (also aliased on the App body).
+ */
+export function createExtensionPickers({
+  store,
+  theme,
+  clean,
+  copyToClipboard,
+  setPicker,
+  setProviderPrompt,
+  setChannelPrompt,
+  setHookPrompt,
+  setSettingsPrompt,
+  getDisabledSkills,
+  setDisabledSkills,
+}) {
+  const mcpStatus = () => {
+    let status;
+    try {
+      status = store.mcpStatus?.() || { servers: [] };
+    } catch (e) {
+      store.pushNotice(`mcp status failed: ${e?.message || e}`, 'error');
+      return null;
+    }
+    return { ...status, servers: status.servers || [] };
+  };
+
+  const openMcpServersPicker = (options = {}) => {
+    const status = mcpStatus();
+    if (!status) return;
+    const servers = status.servers || [];
+    const items = [];
+    if (servers.length === 0) {
+      items.push({
+        value: 'empty',
+        label: 'No MCP servers',
+        description: 'no configured MCP servers',
+        _action: 'noop',
+      });
+    }
+    for (const server of servers) {
+      const enabled = server.enabled !== false;
+      items.push({
+        value: `server:${server.name}`,
+        label: server.name,
+        marker: enabled ? '●' : '○',
+        markerColor: enabled ? theme.success : theme.inactive,
+        description: `${server.status || 'unknown'} · ${server.transport || 'unknown'} · ${server.toolCount || 0} tools${server.error ? ` · ${server.error}` : ''}`,
+        _action: 'server',
+        _server: server,
+        _enabled: enabled,
+      });
+    }
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    const toggleServer = (item) => {
+      if (item._action !== 'server' || !item._server?.name) return;
+      void store.setMcpServerEnabled?.(item._server.name, !item._enabled)
+        .then(() => openMcpServersPicker({ highlightValue: `server:${item._server.name}` }))
+        .catch((e) => store.pushNotice(`mcp toggle failed: ${e?.message || e}`, 'error'));
+    };
+    setPicker({
+      title: 'MCP servers',
+      description: 'Enable or disable configured MCP servers.',
+      initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options?.highlightValue)),
+      items,
+      onSelect: (_value, item) => toggleServer(item),
+      onLeft: (item) => toggleServer(item),
+      onRight: (item) => toggleServer(item),
+      onCancel: () => {
+        setPicker(null);
+      },
+    });
+  };
+
+  const openMcpPicker = () => {
+    openMcpServersPicker();
+  };
+
+  const skillsStatus = () => {
+    let status;
+    try {
+      status = store.skillsStatus?.() || { skills: [] };
+    } catch (e) {
+      store.pushNotice(`skills status failed: ${e?.message || e}`, 'error');
+      return null;
+    }
+    return { ...status, skills: status.skills || [] };
+  };
+
+  const openProjectSkillsPicker = () => {
+    const status = skillsStatus();
+    if (!status) return;
+    const skills = status.skills || [];
+    const items = [];
+    if (skills.length === 0) {
+      items.push({
+        value: 'empty',
+        label: 'No project skills',
+        description: 'no project skills available',
+        _action: 'noop',
+      });
+    }
+    for (const skill of skills) {
+      items.push({
+        value: skill.name,
+        label: skill.name,
+        description: `${skill.source || 'skill'} · ${skill.description || skill.filePath || ''}`,
+        _action: 'view',
+        _skill: skill,
+      });
+    }
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setPicker({
+      title: 'Project skills',
+      description: 'Skills bundled with this project.',
+      items,
+      onSelect: (_value, item) => {
+        setPicker(null);
+        if (item._action !== 'view') return;
+        openSkillDetailPicker(item._skill);
+      },
+      onCancel: () => {
+        setPicker(null);
+        void openSkillsPicker();
+      },
+    });
+  };
+
+  const openSkillsPicker = (options = {}) => {
+    const status = skillsStatus();
+    if (!status) return;
+    const skills = status.skills || [];
+    const disabledSet = options.disabledOverride instanceof Set ? options.disabledOverride : getDisabledSkills();
+    const items = [];
+    if (skills.length === 0) {
+      items.push({
+        value: 'empty',
+        label: 'No skills',
+        description: 'no project skills available',
+        _action: 'noop',
+      });
+    }
+    for (const skill of skills) {
+      const enabled = !disabledSet.has(skill.name);
+      items.push({
+        value: skill.name,
+        label: skill.name,
+        marker: enabled ? '●' : '○',
+        markerColor: enabled ? theme.success : theme.inactive,
+        description: `${skill.source || 'skill'} · ${skill.description || skill.filePath || ''}`,
+        _action: 'skill',
+        _skill: skill,
+        _enabled: enabled,
+      });
+    }
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    const toggleSkill = (item) => {
+      if (item._action !== 'skill' || !item._skill?.name) return;
+      const name = item._skill.name;
+      const next = new Set(disabledSet);
+      if (item._enabled) next.add(name); else next.delete(name);
+      setDisabledSkills(next);
+      store.pushNotice(`skill ${item._enabled ? 'disabled' : 'enabled'}: ${name}`, 'info');
+      openSkillsPicker({ highlightValue: name, disabledOverride: next });
+    };
+    setPicker({
+      title: 'Skills',
+      description: 'Enable or disable project skills.',
+      initialIndex: Math.max(0, items.findIndex((entry) => entry.value === options.highlightValue)),
+      items,
+      onSelect: (_value, item) => toggleSkill(item),
+      onLeft: (item) => toggleSkill(item),
+      onRight: (item) => toggleSkill(item),
+      onCancel: () => {
+        setPicker(null);
+      },
+    });
+  };
+
+  const openSkillDetailPicker = (skill) => {
+    const disabled = getDisabledSkills().has(skill.name);
+    setPicker({
+      title: `Skill · ${skill.name}`,
+      description: clean(skill.description) || 'Enable, disable, or run this skill.',
+      items: [
+        {
+          value: 'use',
+          label: 'Use skill',
+          description: disabled ? 'enable this skill first' : 'write a request with this skill',
+          _action: disabled ? 'noop' : 'use',
+        },
+        {
+          value: disabled ? 'enable' : 'disable',
+          label: disabled ? 'Enable skill' : 'Disable skill',
+          description: disabled ? 'show and allow this skill in the TUI' : 'hide use action until re-enabled',
+          _action: disabled ? 'enable' : 'disable',
+        },
+      ],
+      onSelect: (_value, item) => {
+        setPicker(null);
+        if (item._action === 'enable') {
+          setDisabledSkills((current) => {
+            const next = new Set(current);
+            next.delete(skill.name);
+            return next;
+          });
+          store.pushNotice(`skill enabled: ${skill.name}`, 'info');
+          openSkillsPicker();
+          return;
+        }
+        if (item._action === 'disable') {
+          setDisabledSkills((current) => {
+            const next = new Set(current);
+            next.add(skill.name);
+            return next;
+          });
+          store.pushNotice(`skill disabled: ${skill.name}`, 'info');
+          openSkillsPicker();
+          return;
+        }
+        if (item._action === 'use') {
+          setSettingsPrompt({
+            kind: 'skill-use',
+            label: `Skill · ${skill.name}`,
+            hint: 'Write the request to run with this skill.',
+            skillName: skill.name,
+          });
+          return;
+        }
+      },
+      onCancel: () => {
+        setPicker(null);
+        void openSkillsPicker();
+      },
+    });
+  };
+
+  const pluginStatus = () => {
+    let status;
+    try {
+      status = store.pluginsStatus?.() || { plugins: [] };
+    } catch (e) {
+      store.pushNotice(`plugins status failed: ${e?.message || e}`, 'error');
+      return null;
+    }
+    return { ...status, plugins: status.plugins || [] };
+  };
+
+  const beginAddPlugin = () => {
+    setPicker(null);
+    setSettingsPrompt({ kind: 'plugin-add', label: 'Plugin URL', hint: 'Git URL, owner/repo, or local path' });
+  };
+
+  const openPluginDetailPicker = (p) => {
+    setPicker({
+      title: p.title || p.name,
+      description: clean(p.description) || 'Update, MCP, or uninstall this plugin.',
+      items: [
+        {
+          value: 'info',
+          label: 'Plugin info',
+          description: `${p.sourceType || p.source}${p.version ? ` · ${p.version}` : ''} · skills ${p.skillCount || 0}`,
+          _action: 'info',
+        },
+        {
+          value: 'update',
+          label: p.sourceType === 'local' ? 'Refresh metadata' : 'Update plugin',
+          description: p.sourceType === 'local' ? 'rescan local plugin manifest' : 'pull latest from source URL',
+          _action: 'update',
+        },
+        {
+          value: 'enable-mcp',
+          label: p.mcpScript ? (p.mcpEnabled ? 'Refresh MCP server' : 'Enable MCP server') : 'No MCP script',
+          description: p.mcpScript ? `${p.mcpServerName || 'plugin-mcp'} · ${p.mcpEnabled ? 'configured' : p.mcpScript}` : 'plugin does not expose scripts/run-mcp.mjs or mcp/server.mjs',
+          _action: p.mcpScript ? 'enable-mcp' : 'noop',
+        },
+        {
+          value: 'copy-root',
+          label: 'Copy root path',
+          description: p.root,
+          _action: 'copy-root',
+        },
+        {
+          value: 'copy-mcp-name',
+          label: p.mcpScript ? 'Copy MCP server name' : 'No MCP server name',
+          description: p.mcpServerName || '',
+          _action: p.mcpScript ? 'copy-mcp-name' : 'noop',
+        },
+        {
+          value: 'uninstall',
+          label: 'Uninstall plugin',
+          description: p.managed === false ? 'remove from registry only' : 'remove registry entry and installed files',
+          _action: 'uninstall',
+        },
+      ],
+      onSelect: (_detailValue, detail) => {
+        setPicker(null);
+        if (detail._action === 'info') {
+          store.pushNotice([
+            `${p.title || p.name}${p.version ? ` ${p.version}` : ''}`,
+            `source: ${p.sourceType || p.source}${p.sourceUrl ? ` / ${p.sourceUrl}` : ''}`,
+            `skills: ${p.skillCount || 0}`,
+            `mcp: ${p.mcpScript ? `${p.mcpEnabled ? 'enabled' : 'available'} (${p.mcpServerName || 'plugin-mcp'})` : '(none)'}`,
+            `root: ${p.root}`,
+            p.description ? `\n${p.description}` : '',
+          ].filter(Boolean).join('\n'), 'info');
+          return;
+        }
+        if (detail._action === 'update') {
+          void store.updatePlugin?.(p)
+            .then(() => openInstalledPluginsPicker())
+            .catch((e) => store.pushNotice(`plugin update failed: ${e?.message || e}`, 'error'));
+          return;
+        }
+        if (detail._action === 'enable-mcp') {
+          void store.enablePluginMcp?.(p)
+            .then(() => openMcpPicker())
+            .catch((e) => store.pushNotice(`plugin MCP enable failed: ${e?.message || e}`, 'error'));
+          return;
+        }
+        if (detail._action === 'copy-root') {
+          void copyToClipboard(p.root)
+            .then(() => store.pushNotice(`copied plugin root: ${p.name}`, 'plain'))
+            .catch((e) => store.pushNotice(`copy failed: ${e?.message || e}`, 'error'));
+          return;
+        }
+        if (detail._action === 'copy-mcp-name') {
+          void copyToClipboard(p.mcpServerName || '')
+            .then(() => store.pushNotice(`copied plugin MCP server: ${p.mcpServerName}`, 'plain'))
+            .catch((e) => store.pushNotice(`copy failed: ${e?.message || e}`, 'error'));
+          return;
+        }
+        if (detail._action === 'uninstall') {
+          void store.removePlugin?.(p)
+            .then(() => openInstalledPluginsPicker())
+            .catch((e) => store.pushNotice(`plugin uninstall failed: ${e?.message || e}`, 'error'));
+        }
+      },
+      onCancel: () => {
+        setPicker(null);
+        void openInstalledPluginsPicker();
+      },
+    });
+  };
+
+  const openInstalledPluginsPicker = () => {
+    const status = pluginStatus();
+    if (!status) return;
+    const plugins = status.plugins || [];
+    const items = [];
+    if (plugins.length === 0) {
+      items.push({
+        value: 'empty',
+        label: 'No installed plugins',
+        description: 'Esc back · add from Plugins > Add plugin',
+        _action: 'noop',
+      });
+    }
+    for (const plugin of plugins) {
+      items.push({
+        value: `${plugin.id || plugin.name}:${plugin.version || ''}`,
+        label: plugin.title || plugin.name,
+        description: `${plugin.sourceType || plugin.source}${plugin.version ? ` · ${plugin.version}` : ''} · skills ${plugin.skillCount || 0}${plugin.mcpScript ? ` · mcp ${plugin.mcpEnabled ? 'enabled' : plugin.mcpScript}` : ''}`,
+        _action: 'plugin',
+        _plugin: plugin,
+      });
+    }
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setPicker({
+      title: 'Installed plugins',
+      description: 'Open an installed plugin to manage it.',
+      items,
+      onSelect: (_value, item) => {
+        setPicker(null);
+        if (item._action !== 'plugin') return;
+        openPluginDetailPicker(item._plugin);
+      },
+      onCancel: () => {
+        setPicker(null);
+        void openPluginsPicker();
+      },
+    });
+  };
+
+  const openPluginsPicker = () => {
+    const status = pluginStatus();
+    if (!status) return;
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    setPicker({
+      title: 'Plugins',
+      description: 'Add or manage local plugin integrations.',
+      items: [
+        {
+          value: 'installed',
+          label: 'Installed plugins',
+          description: `${status.count || 0} installed`,
+          _action: 'installed',
+        },
+        {
+          value: 'add',
+          label: 'Add plugin',
+          description: 'Git URL, owner/repo, or local path',
+          _action: 'add',
+        },
+      ],
+      onSelect: (_value, item) => {
+        setPicker(null);
+        if (item._action === 'installed') {
+          openInstalledPluginsPicker();
+          return;
+        }
+        if (item._action === 'add') beginAddPlugin();
+      },
+      onCancel: () => {
+        setPicker(null);
+      },
+    });
+  };
+
+  const openHooksPicker = () => {
+    let status;
+    try {
+      status = store.hooksStatus?.() || { events: [], recent: [] };
+    } catch (e) {
+      store.pushNotice(`hooks status failed: ${e?.message || e}`, 'error');
+      return;
+    }
+    const rules = status.rules || [];
+    const items = [
+      ...(rules.length ? rules.map((rule) => ({
+        value: `rule:${rule.index}`,
+        label: `${rule.tool} -> ${rule.action}`,
+        marker: rule.enabled ? '●' : '○',
+        markerColor: rule.enabled ? theme.success : theme.inactive,
+        description: `${rule.match ? `match ${rule.match} · ` : ''}${rule.reason || 'Enter toggle'}`,
+        _action: 'rule',
+        _rule: rule,
+      })) : [{
+        value: 'rules:none',
+        label: 'No rules',
+        description: status.rulesPath || 'hooks.json not configured',
+        _action: 'noop',
+      }]),
+    ];
+    setProviderPrompt(null);
+    setChannelPrompt(null);
+    setHookPrompt(null);
+    setSettingsPrompt(null);
+    const toggleRule = (item) => {
+      if (item._action !== 'rule') return;
+      try {
+        store.setHookRuleEnabled?.(item._rule.index, !item._rule.enabled);
+        void openHooksPicker();
+      } catch (e) {
+        store.pushNotice(`hook toggle failed: ${e?.message || e}`, 'error');
+      }
+    };
+    setPicker({
+      title: 'Hooks',
+      description: 'Before-tool hook rules; Enter toggles a rule.',
+      items,
+      onSelect: (_value, item) => toggleRule(item),
+      onLeft: (item) => toggleRule(item),
+      onRight: (item) => toggleRule(item),
+      onCancel: () => {
+        setPicker(null);
+      },
+    });
+  };
+
+  return {
+    openMcpServersPicker,
+    openMcpPicker,
+    openProjectSkillsPicker,
+    openSkillsPicker,
+    openSkillDetailPicker,
+    beginAddPlugin,
+    openPluginDetailPicker,
+    openInstalledPluginsPicker,
+    openPluginsPicker,
+    openHooksPicker,
+  };
+}

package/src/tui/app/input-parsers.mjs

@@ -0,0 +1,193 @@
+/**
+ * input-parsers.mjs — pure text-to-structure parsers for slash-command inputs
+ * (hook rules, MCP servers, skills, memory commands + memory row tables).
+ * Extracted verbatim from App.jsx; no hooks, no App state, no closures.
+ */
+export function parseHookRuleInput(text) {
+  const parts = String(text || '').split('|').map((part) => part.trim());
+  const [tool, actionRaw, match, reason, patchText] = parts;
+  const action = String(actionRaw || '').toLowerCase();
+  if (!tool || !action) return { error: 'usage: tool | allow|deny|modify | match(optional) | reason(optional) | json patch(optional)' };
+  if (!['allow', 'deny', 'block', 'modify', 'rewrite'].includes(action)) {
+    return { error: 'hook action must be allow, deny, block, modify, or rewrite' };
+  }
+  const rule = { tool, action };
+  if (match) rule.match = match;
+  if (reason) rule.reason = reason;
+  if (patchText) {
+    try {
+      const patch = JSON.parse(patchText);
+      if (!patch || typeof patch !== 'object' || Array.isArray(patch)) return { error: 'json patch must be an object' };
+      rule.patch = patch;
+    } catch (e) {
+      return { error: `invalid json patch: ${e?.message || e}` };
+    }
+  }
+  if ((action === 'modify' || action === 'rewrite') && !rule.patch) {
+    return { error: 'modify/rewrite needs a json patch object in the last field' };
+  }
+  return { rule };
+}
+
+export function parseMcpServerInput(text) {
+  const parts = String(text || '').split('|').map((part) => part.trim());
+  const [name, commandOrUrl, argsText = '', cwd = ''] = parts;
+  if (!name || !commandOrUrl) return { error: 'usage: name | command-or-url | args(optional) | cwd(optional)' };
+  if (/^(?:https?|wss?):\/\//i.test(commandOrUrl)) return { server: { name, url: commandOrUrl } };
+  return {
+    server: {
+      name,
+      command: commandOrUrl,
+      args: argsText.split(/\s+/).filter(Boolean),
+      cwd,
+    },
+  };
+}
+
+export function parseSkillInput(text) {
+  const parts = String(text || '').split('|').map((part) => part.trim());
+  const [name, description = 'Project skill.'] = parts;
+  if (!name) return { error: 'usage: name | description(optional)' };
+  return { skill: { name, description } };
+}
+
+export function parseMemoryCommand(text) {
+  const parts = String(text || '').trim().split(/\s+/).filter(Boolean);
+  const action = parts[0] || 'status';
+  const out = { action };
+  for (const part of parts.slice(1)) {
+    const [key, ...rest] = part.split('=');
+    if (!key || rest.length === 0) continue;
+    const raw = rest.join('=');
+    const num = Number(raw);
+    out[key] = Number.isFinite(num) && raw.trim() !== '' ? num : raw;
+  }
+  return out;
+}
+
+export function parseMemoryStatusRows(text) {
+  return String(text || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line, index) => {
+      const sep = line.indexOf(':');
+      const label = sep === -1 ? line : line.slice(0, sep);
+      const description = sep === -1 ? '' : line.slice(sep + 1).trim();
+      return {
+        value: `status-${index}`,
+        label,
+        description,
+        _line: line,
+      };
+    });
+}
+
+export function parseMemoryCoreRows(text) {
+  let currentProjectId = null;
+  return String(text || '')
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line, index) => {
+      const raw = line.trim();
+      if (raw.endsWith(':') && !raw.includes('id=')) {
+        const label = raw.slice(0, -1);
+        currentProjectId = label === 'COMMON' ? null : label;
+        // Group headers (COMMON / project slug) are scope markers, not
+        // selectable rows — drop them and carry the scope on each entry's
+        // meta column instead (blank for common).
+        return null;
+      }
+      const match = raw.match(/^id=(\d+)\s+\[([^\]]*)\]\s+(.+?)(?:\s+—\s+(.+))?$/);
+      if (match) {
+        const [, id, category, element, summary = ''] = match;
+        return {
+          value: `core-${id}`,
+          // Display is summary-first: session injection only ever uses the
+          // summary sentence (buildSessionCoreMemoryPayload), so id/category/
+          // element are UI noise. They stay in the hidden _fields for
+          // edit/delete plumbing.
+          label: `#${id}`,
+          meta: currentProjectId || '',
+          description: summary || element,
+          _line: raw,
+          _action: 'core-entry',
+          _id: Number(id),
+          _category: category,
+          _element: element,
+          _summary: summary || element,
+          _projectId: currentProjectId,
+          // Raw pre-edit values, distinct from the (possibly later-mutated)
+          // _element/_summary above -- beginEditCoreMemory reads these to
+          // decide whether the row's element duplicated its summary (single-
+          // sentence entry) before deciding whether to touch element on edit.
+          _origElement: element,
+          _origSummary: summary,
+        };
+      }
+      return {
+        value: `core-${index}`,
+        label: raw,
+        description: '',
+        _line: raw,
+      };
+    })
+    .filter(Boolean);
+}
+
+export function parseMemoryCandidateRows(text) {
+  const trimmed = String(text || '').trim();
+  // op:'candidates' returns this exact sentinel (index.mjs ~3158) when the
+  // resolved scope has none — treat as an empty list, not an inert text row.
+  if (!trimmed || /^core candidates:\s*none$/i.test(trimmed)) return [];
+  // Backend row shape (index.mjs ~3164), one candidate per line, no group
+  // headers:
+  //   id=<n> project=<COMMON|slug> [<category>] score=<x.xx|-> <element> — <summary> (<reason>)
+  const rowPattern = /^id=(\d+)\s+project=(\S+)\s+\[([^\]]*)\]\s+score=(\S+)\s+(.+?)\s+—\s+(.+?)\s+\(([^)]*)\)$/;
+  return trimmed
+    .split('\n')
+    .filter((line) => line.trim())
+    .map((line, index) => {
+      const raw = line.trim();
+      const match = raw.match(rowPattern);
+      if (match) {
+        const [, id, project, category, score, element, summary, reason] = match;
+        return {
+          value: `candidate-${id}`,
+          label: `#${id} [${category}] ${element}`,
+          meta: project === 'COMMON' ? 'common' : project,
+          description: `${summary}${score !== '-' ? ` (score ${score})` : ''} — ${reason}`,
+          _line: raw,
+          _action: 'candidate-entry',
+          _id: Number(id),
+          _projectId: project === 'COMMON' ? null : project,
+        };
+      }
+      return {
+        value: `candidate-${index}`,
+        label: raw,
+        description: '',
+        _line: raw,
+      };
+    });
+}
+
+// Backend "core" op errors are flattened to plain text by store.memoryControl
+// (isError is dropped -- see engine.mjs memoryControl / toolResponseText in
+// mixdog-session-runtime.mjs). Success text always uses a past-tense verb
+// ("core added/edited/deleted/promoted...", "core candidate dismissed...");
+// every declared failure in index.mjs's core-op handling uses the op word
+// followed by either ":" (validation message) or " failed" (caught
+// exception) -- e.g. "core add: project_id required...", "core edit failed:
+// no entry with id=5". That shape is used here to recover the error signal
+// since store.memoryControl resolves instead of rejecting on isError.
+export function memoryCoreResultErrorText(text) {
+  const value = String(text || '').trim();
+  if (/^core (add|edit|delete|promote|dismiss)(:| failed)/i.test(value)) return value;
+  // Broader catch-all for other flattened "core" failures that don't name an
+  // op word right after "core" (e.g. "core: memory data dir is not
+  // initialized", "core requires op: ..."), plus any bare error/failed lead-in.
+  if (/^core:.*(not initialized|failed|error)/i.test(value)) return value;
+  if (/^(error|failed)\b/i.test(value)) return value;
+  return null;
+}