dsh-memory-recall 0.1.0

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "dsh-memory-recall",
+  "version": "0.1.0",
+  "description": "Persistent memory for dsh in the style of Hermes Agent: a memory tool that keeps a user profile and the model's own notes in every new chat's prompt, and a session_search tool that reads earlier chats only after the user approves, with a Memory panel to see and edit what is kept.",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "lib",
+    "cordis.patch.yml",
+    "package.json",
+    "README.md",
+    "LICENSE",
+    "dsh.plugin.json",
+    "screenshots.json"
+  ],
+  "scripts": {
+    "test": "node --test \"test/*.test.js\""
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-sidebar"
+      ]
+    }
+  },
+  "keywords": [
+    "dsh-plugin",
+    "dsh",
+    "deepseek-harness",
+    "memory",
+    "recall",
+    "session-search",
+    "hermes"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/adithyanraj03/dsh-memory-recall.git"
+  },
+  "homepage": "https://adithyanraj03.github.io/dsh-memory-recall/",
+  "bugs": {
+    "url": "https://github.com/adithyanraj03/dsh-memory-recall/issues"
+  },
+  "author": "Adithya N Raj (adithyanraj03)",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  }
+}

package/screenshots.json

@@ -0,0 +1,6 @@
+[
+  "assets/memory-panel.png",
+  "assets/saved-chip.png",
+  "assets/recall-card.png",
+  "assets/memory-panel-light.png"
+]

package/src/chats.js

@@ -0,0 +1,160 @@
+// Every chat the user can @-mention, grouped by the workspace it belongs to.
+//
+// dsh's own @ list shows at most 50 sessions and includes sub-agent sessions
+// — the model's workers, which have no titles and show as raw ids — so real
+// chats get pushed out by them. This index lists only the user's own
+// top-level chats, all of them, under the workspace titles the sidebar shows,
+// and gives every chat a readable name: its title, or failing that the start
+// of its first message.
+//
+// Workspaces come from dsh's workspace registry (same titles and order as the
+// sidebar); a chat in no workspace is listed under "No workspace". The whole
+// index is cached briefly — the @ menu asks on every keystroke — and first
+// messages are cached for good, since a chat's first message never changes.
+
+const CACHE_MS = 15_000;
+const LABEL_CHARS = 70;
+
+const isRoot = (header) => header && !header.parentSession && header.origin !== 'subagent';
+
+/** One line of text, cut to fit a menu row. */
+export function labelFrom(text, max = LABEL_CHARS) {
+  const line = String(text ?? '').replace(/\s+/g, ' ').trim();
+  return line.length > max ? `${line.slice(0, max - 1).trimEnd()}…` : line;
+}
+
+/** Case-insensitive path equality on Windows, exact elsewhere; trailing separators ignored. */
+export function samePath(a, b, platform = process.platform) {
+  if (typeof a !== 'string' || typeof b !== 'string') return false;
+  const norm = (p) => p.replace(/[\\/]+$/, '').replace(/\//g, '\\');
+  return platform === 'win32' ? norm(a).toLowerCase() === norm(b).toLowerCase() : a.replace(/\/+$/, '') === b.replace(/\/+$/, '');
+}
+
+/**
+ * @param {object} p
+ * @param {() => object|undefined} p.getQuery       ctx.sessionQuery
+ * @param {() => object|undefined} p.getWorkspaces  ctx.workspaceRegistry
+ * @param {() => number} [p.now]
+ */
+export function createChatIndex({ getQuery, getWorkspaces, now = () => Date.now() }) {
+  const firstMessages = new Map(); // sessionId → label (or '' when there is none)
+  let cached = null;
+
+  async function firstMessageOf(query, id) {
+    if (firstMessages.has(id)) return firstMessages.get(id);
+    let label = '';
+    try {
+      const docs = await query.filterEvents(id, [{ kind: 'type', values: ['user/message'] }, { kind: 'seq', from: 0, to: 200 }]);
+      const first = [...(docs ?? [])].sort((a, b) => a.seq - b.seq).find((d) => String(d.text ?? '').trim());
+      label = first ? labelFrom(first.text) : '';
+    } catch { /* unreadable: stays untitled */ }
+    firstMessages.set(id, label);
+    return label;
+  }
+
+  async function titlesOf(query, ids) {
+    const out = new Map();
+    for (let i = 0; i < ids.length; i += 100) {
+      try {
+        const rows = await query.readTitleSnapshots(ids.slice(i, i + 100));
+        for (const row of rows ?? []) {
+          if (row?.status === 'fulfilled' && row.value?.title?.title) out.set(row.sessionId, row.value.title.title);
+        }
+      } catch { /* a failed batch leaves its chats to the fallback */ }
+    }
+    return out;
+  }
+
+  /** Run `fn` over `items`, at most `limit` at a time. */
+  async function pooled(items, limit, fn) {
+    let next = 0;
+    const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+      while (next < items.length) {
+        const item = items[next++];
+        await fn(item);
+      }
+    });
+    await Promise.all(workers);
+  }
+
+  async function build() {
+    const query = getQuery();
+    if (!query || typeof query.listSessions !== 'function') throw new Error("dsh's session query service is not available");
+    const headers = (await query.listSessions()).map((r) => r.header).filter(isRoot);
+    const byId = new Map(headers.map((h) => [h.id, h]));
+    const titles = await titlesOf(query, headers.map((h) => h.id));
+    const untitled = headers.filter((h) => !titles.has(h.id));
+    const untitledIds = new Set(untitled.map((h) => h.id));
+    await pooled(untitled, 4, async (h) => {
+      const label = await firstMessageOf(query, h.id);
+      if (label) titles.set(h.id, label);
+    });
+
+    const chat = (h) => ({
+      sessionId: h.id,
+      title: titles.get(h.id) ?? null,
+      fromMessage: !!titles.get(h.id) && untitledIds.has(h.id),
+      createdAt: h.createdAt,
+      cwd: h.cwd ?? null,
+    });
+
+    let registry = [];
+    try {
+      registry = getWorkspaces()?.list?.() ?? [];
+    } catch { /* no workspaces: everything is ungrouped */ }
+
+    const placed = new Set();
+    const workspaces = [];
+    for (const ws of registry) {
+      const chats = [];
+      for (const id of ws.sessionIds ?? []) {
+        const h = byId.get(id);
+        if (!h || placed.has(id)) continue;
+        placed.add(id);
+        chats.push(chat(h));
+      }
+      // A chat whose folder matches but that the registry has not recorded yet.
+      for (const h of headers) {
+        if (!placed.has(h.id) && samePath(h.cwd, ws.path)) {
+          placed.add(h.id);
+          chats.push(chat(h));
+        }
+      }
+      if (!chats.length) continue;
+      chats.sort((a, b) => b.createdAt - a.createdAt);
+      workspaces.push({ id: String(ws.id), title: ws.title || ws.path, path: ws.path, chats });
+    }
+    const ungrouped = headers.filter((h) => !placed.has(h.id)).map(chat).sort((a, b) => b.createdAt - a.createdAt);
+    return { builtAt: now(), workspaces, ungrouped };
+  }
+
+  /** The grouped index, rebuilt at most every 15 seconds. */
+  async function list({ fresh = false } = {}) {
+    if (!fresh && cached && now() - cached.builtAt < CACHE_MS) return cached;
+    cached = await build();
+    return cached;
+  }
+
+  /** Which workspace a session belongs to, by membership or folder. */
+  function workspaceOf(index, sessionId, cwd) {
+    return index.workspaces.find((w) => w.chats.some((c) => c.sessionId === sessionId))
+      ?? (cwd ? index.workspaces.find((w) => samePath(w.path, cwd)) : undefined)
+      ?? null;
+  }
+
+  /**
+   * Resolve what the user or model named — a workspace title, its folder, or
+   * its id — to the workspace. Titles may repeat; an exact folder wins.
+   */
+  async function resolveWorkspace(name) {
+    const wanted = String(name ?? '').trim();
+    if (!wanted) return null;
+    const index = await list();
+    return index.workspaces.find((w) => w.id === wanted || samePath(w.path, wanted))
+      ?? index.workspaces.find((w) => w.title.toLowerCase() === wanted.toLowerCase())
+      ?? index.workspaces.find((w) => w.title.toLowerCase().includes(wanted.toLowerCase()))
+      ?? null;
+  }
+
+  return { list, workspaceOf, resolveWorkspace, invalidate: () => { cached = null; } };
+}

package/src/dsh-tools.js

@@ -0,0 +1,75 @@
+// Getting dsh's `defineTool`, however this plugin was installed.
+//
+// A plugin installed as a copy inside the profile's node_modules can import
+// `@deepseek-ai/dsh-tools` by name: that is where dsh's loader makes its own
+// packages resolvable. Installed as a LINK (`dsh plugin add /path`, which pnpm
+// records as `link:`), Node resolves imports from the plugin's real folder
+// instead — outside the profile — and the import fails. It failed silently
+// here once: the plugin loaded, told the model about its memory tool, and
+// registered none.
+//
+// So: the ordinary import first; failing that, the copy of dsh-tools inside
+// dsh's own installation, found by walking up from dsh's launcher. That is the
+// very file dsh loaded, so it is the same module instance, not a second copy.
+
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const PACKAGE = ['node_modules', '@deepseek-ai', 'dsh-tools'];
+
+/** The entry file a package.json names for a plain `import`. */
+function entryOf(dir) {
+  const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'));
+  const root = pkg.exports?.['.'] ?? pkg.exports;
+  const entry = typeof root === 'string' ? root : root?.import ?? root?.default ?? pkg.main ?? 'index.js';
+  return join(dir, entry);
+}
+
+/**
+ * The dsh-tools entry file above `start` (a file or folder), or null.
+ * @param {string} start  normally process.argv[1], dsh's bin.js
+ */
+export function findDshTools(start) {
+  if (!start) return null;
+  let dir;
+  try {
+    dir = dirname(realpathSync(start));
+  } catch {
+    return null;
+  }
+  for (;;) {
+    const candidate = join(dir, ...PACKAGE);
+    if (existsSync(join(candidate, 'package.json'))) {
+      try {
+        const entry = entryOf(candidate);
+        if (existsSync(entry)) return entry;
+      } catch { /* unreadable package.json: keep looking */ }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+/**
+ * dsh's defineTool. Throws the ORIGINAL import error when neither way works,
+ * so the reason logged is the real one.
+ * @param {object} [o]
+ * @param {() => Promise<object>} [o.importByName]  the ordinary import (a hook for tests)
+ * @param {string} [o.launcher]  where dsh was started from
+ */
+export async function loadDefineTool({ importByName = () => import('@deepseek-ai/dsh-tools'), launcher = process.argv[1] } = {}) {
+  try {
+    const mod = await importByName();
+    if (typeof mod?.defineTool === 'function') return mod.defineTool;
+    throw new Error('@deepseek-ai/dsh-tools has no defineTool export');
+  } catch (first) {
+    const entry = findDshTools(launcher);
+    if (entry) {
+      const mod = await import(pathToFileURL(entry).href);
+      if (typeof mod?.defineTool === 'function') return mod.defineTool;
+    }
+    throw first;
+  }
+}

package/src/index.js

@@ -0,0 +1,156 @@
+// dsh-memory-recall — Hermes Agent-style memory for dsh.
+//
+//   memory          the model saves, corrects and forgets facts in USER.md and
+//                   MEMORY.md; every new chat starts with them in its prompt
+//   session_search  the model looks things up in earlier chats — after the
+//                   user allows it, through dsh's own approval prompt
+//
+// Data lives in ~/.dsh/dsh-memory-recall/. Nothing leaves the machine.
+//
+// Config (all optional, set on this plugin's row in cordis.patch.yml):
+//   dir                   where USER.md and MEMORY.md live
+//   limits: {memory, user} character budgets (default 2200 / 1375)
+//   recall: false         drop session_search, keep memory
+//   askBeforeRecall: false read earlier chats without asking (default: ask)
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { MemoryStore } from './store.js';
+import { SECTION_NAME, SECTION_ORDER, renderSection } from './snapshot.js';
+import { createMemoryTool } from './memory-tool.js';
+import { createRecall } from './recall.js';
+import { createRecallTool } from './recall-tool.js';
+import { createRecallLog, registerRoutes } from './routes.js';
+import { createChatIndex } from './chats.js';
+import { loadDefineTool } from './dsh-tools.js';
+
+export const name = 'dsh-memory-recall';
+
+/**
+ * Required services only. The session query, approval and system-prompt
+ * services are resolved per use with `get`, so a composition without one
+ * loses that feature rather than failing to load the plugin.
+ */
+export const inject = ['webServer', 'tools'];
+
+/** Look a service up without throwing when it is absent. */
+function service(ctx, id) {
+  try {
+    return ctx?.get?.(id);
+  } catch {
+    return undefined;
+  }
+}
+
+/** A user's own chat — not a sub-agent the model started. */
+function isTopLevel(agent) {
+  const header = agent?.session?.header;
+  return !header || (!header.parentSession && header.origin !== 'subagent');
+}
+
+/**
+ * @param {object} ctx host plugin context
+ * @param {object} [config]
+ * @param {object} [deps] test hooks: defineTool, loadDefineTool
+ */
+export async function apply(ctx, config = {}, deps = {}) {
+  const dir = config.dir || join(homedir(), '.dsh', 'dsh-memory-recall');
+  const store = new MemoryStore({ dir, limits: config.limits });
+  await store.load();
+
+  const log = createRecallLog();
+  const grants = new Map();
+  // Every chat, grouped by workspace: the @ menu's list, and what a
+  // `workspace` given to session_search resolves against.
+  const chatIndex = createChatIndex({
+    getQuery: () => service(ctx, 'sessionQuery'),
+    getWorkspaces: () => service(ctx, 'workspaceRegistry'),
+  });
+  const cwdOf = async (sessionId) => {
+    try {
+      const rows = await service(ctx, 'sessionQuery')?.filterSessions?.([{ kind: 'id', values: [sessionId] }]);
+      return rows?.[0]?.header?.cwd ?? null;
+    } catch {
+      return null;
+    }
+  };
+  const disposers = [];
+  // Whether the model actually got its tools. The prompt and the Memory
+  // panel both read this, so neither can promise a tool that is not there.
+  const tooling = { ok: false, error: null, tools: [] };
+
+  // ---- the model's tools ----------------------------------------------
+  if (ctx.tools?.register) {
+    try {
+      const defineTool = deps.defineTool ?? (await (deps.loadDefineTool ?? loadDefineTool)());
+      const tools = [createMemoryTool({ store, defineTool })];
+      if (config.recall !== false) {
+        const recall = createRecall({ getQuery: () => service(ctx, 'sessionQuery'), options: config.recallOptions });
+        tools.push(createRecallTool({
+          recall,
+          defineTool,
+          getApproval: () => service(ctx, 'approval'),
+          grants,
+          log,
+          askFirst: config.askBeforeRecall !== false,
+          resolveWorkspace: (name) => chatIndex.resolveWorkspace(name),
+          listWorkspaces: async () => (await chatIndex.list()).workspaces,
+        }));
+      }
+      for (const tool of tools) {
+        const dispose = ctx.tools.register(tool);
+        if (typeof dispose === 'function') disposers.push(dispose);
+        tooling.tools.push(tool.name);
+      }
+      tooling.ok = true;
+    } catch (error) {
+      tooling.error = String(error?.message ?? error);
+      ctx.logger?.warn?.(`[dsh-memory-recall] tools not registered: ${tooling.error}`);
+    }
+  } else {
+    tooling.error = 'this dsh has no tool registry';
+  }
+
+  // ---- each new chat: memory in its prompt, frozen for its lifetime ---
+  const briefed = new WeakSet();
+  ctx.on?.('agent/session-start', (payload) => {
+    const agent = payload?.agent;
+    const agentCtx = agent?.ctx;
+    if (!agentCtx || briefed.has(agentCtx) || !isTopLevel(agent)) return;
+    briefed.add(agentCtx);
+    try {
+      const prompt = service(agentCtx, 'systemPrompt');
+      if (typeof prompt?.section !== 'function') return;
+      // Read now, once: this text is what the chat keeps, so a save made later
+      // in it never rewrites its prompt (which would cost the cached prefix).
+      const text = renderSection(store.loadSync(), store.limits, { tools: tooling.ok });
+      const register = () => prompt.section({ name: SECTION_NAME, order: SECTION_ORDER, text });
+      if (typeof agentCtx.effect === 'function') agentCtx.effect(register, 'dsh-memory-recall: memory snapshot');
+      else register();
+    } catch (error) {
+      // Losing the snapshot costs this chat its memory, never the chat.
+      ctx.logger?.warn?.(`[dsh-memory-recall] no memory for this chat: ${error?.message ?? error}`);
+    }
+  });
+
+  // One "allow" lasts until the reply it was given in ends.
+  ctx.on?.('agent/status', (payload) => {
+    if (payload?.status === 'idle' && payload.agent?.id) grants.delete(payload.agent.id);
+  });
+
+  // ---- the browser half ----------------------------------------------
+  if (ctx.webServer?.register) {
+    disposers.push(registerRoutes(ctx.webServer, { store, log, chatIndex, cwdOf, tooling }));
+  } else {
+    ctx.logger?.warn?.('[dsh-memory-recall] webServer unavailable; the Memory panel and cards will be empty');
+  }
+
+  ctx.on?.('dispose', () => {
+    for (const dispose of disposers) {
+      try { dispose(); } catch { /* keep disposing the rest */ }
+    }
+  });
+  // cordis treats a returned value as an effect disposer; return nothing.
+}
+
+export default { apply, inject, name };

package/src/memory-tool.js

@@ -0,0 +1,136 @@
+// The `memory` tool: how the model saves, corrects and forgets.
+//
+// Hermes Agent's tool, kept close to the original because its wording is the
+// result of a lot of tuning: one tool, two targets, add/replace/remove, and a
+// batch form whose budget is checked on the FINAL result — which is what lets
+// a full store make room and add in a single call instead of failing forever.
+//
+// The first words of every result are fixed ("Saved to memory", "Already in
+// memory", "Not saved", "Blocked"): the chat card reads them to label itself.
+
+import { TARGETS } from './store.js';
+
+export const MEMORY_TOOL = 'memory';
+
+export const TEXT_OUTPUT = {
+  schema: { type: 'object', properties: { text: { type: 'string' } }, additionalProperties: false },
+  render: (_args, value) => [{ type: 'text', text: value.text }],
+};
+
+const ACTIONS = ['add', 'replace', 'remove'];
+
+export const MEMORY_DESCRIPTION = [
+  'Save durable facts to persistent memory that carries across chats. Memory is placed in the system prompt of every new chat,',
+  'so keep entries compact and high-signal. Changes are saved at once but show in the prompt from the next new chat.',
+  '',
+  'HOW: for several changes, make them ALL in ONE call with an `operations` list (each item {action, content?, old_text?}).',
+  'The batch is applied all-or-nothing and the character budget is checked only on the FINAL result, so one call can remove',
+  'or shorten stale entries to make room AND add new ones. For a single change, use action/content/old_text instead.',
+  'The result confirms the update is complete; do not repeat it.',
+  '',
+  "TARGETS: 'user' = who the user is (name, role, preferences, working style). 'memory' = your own notes",
+  '(environment facts, conventions, tool quirks, lessons that apply to every task).',
+  '',
+  'WHEN: facts that will matter in future chats regardless of the task. The user sees every save and can edit or delete it.',
+  '',
+  'IF FULL: an add is refused with the current entries listed. Reissue as ONE batch that merges or removes enough stale',
+  'entries and adds the new one together.',
+  '',
+  'SKIP: trivial or easily re-discovered facts, raw data, task progress, logs of finished work, temporary to-dos, and',
+  'anything secret. To look something up from an earlier chat instead of remembering it, use session_search.',
+].join('\n');
+
+const fmt = (n) => Number(n).toLocaleString('en-US');
+
+/** "42% — 578/1,375 chars" */
+export function usageText(usage) {
+  return `${usage.percent}% — ${fmt(usage.chars)}/${fmt(usage.limit)} chars`;
+}
+
+function countChanges(changed = {}) {
+  const parts = [];
+  if (changed.added?.length) parts.push(`added ${changed.added.length}`);
+  if (changed.replaced?.length) parts.push(`replaced ${changed.replaced.length}`);
+  if (changed.removed?.length) parts.push(`removed ${changed.removed.length}`);
+  return parts.join(', ');
+}
+
+/** The model-facing text for a store result. */
+export function describeResult(result) {
+  const label = TARGETS[result.target]?.label ?? result.target;
+  if (result.success) {
+    const what = countChanges(result.changed);
+    if (!what) {
+      return `Already in memory (${label}) — nothing changed. ${usageText(result.usage)}. This update is complete — do not repeat it.`;
+    }
+    return `Saved to memory (${label}): ${what}. Now ${usageText(result.usage)}, ${result.entryCount} entr${result.entryCount === 1 ? 'y' : 'ies'}. `
+      + 'This update is complete — do not repeat it.';
+  }
+  const head = result.blocked ? `Blocked — not saved (${label}): ${result.error}` : `Not saved (${label}): ${result.error}`;
+  if (!Array.isArray(result.currentEntries)) return head;
+  const list = result.currentEntries.length
+    ? result.currentEntries.map((entry, i) => `${i + 1}. ${entry}`).join('\n')
+    : '(empty)';
+  return `${head}\n\nCurrent ${label} entries (${usageText(result.usage)}):\n${list}`;
+}
+
+/**
+ * @param {object} p
+ * @param {import('./store.js').MemoryStore} p.store
+ * @param {Function} p.defineTool  from @deepseek-ai/dsh-tools
+ */
+export function createMemoryTool({ store, defineTool }) {
+  return defineTool({
+    name: MEMORY_TOOL,
+    description: MEMORY_DESCRIPTION,
+    parameters: {
+      target: {
+        type: 'string', enum: ['memory', 'user'], required: true,
+        description: "'user' for the user profile, 'memory' for your own notes.",
+      },
+      action: {
+        type: 'string', enum: ACTIONS,
+        description: 'A single change. Omit when using operations.',
+      },
+      content: {
+        type: 'string',
+        description: 'The entry text, for add and replace.',
+      },
+      old_text: {
+        type: 'string',
+        description: 'For replace and remove: a short piece of the existing entry, unique to it.',
+      },
+      operations: {
+        type: 'array',
+        description: 'Several changes applied all-or-nothing, the budget checked on the final result.',
+        items: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            action: { type: 'string', enum: ACTIONS, required: true },
+            content: { type: 'string', description: 'Entry text for add and replace.' },
+            old_text: { type: 'string', description: 'Piece of the entry to replace or remove.' },
+          },
+        },
+      },
+    },
+    output: TEXT_OUTPUT,
+    execute: async (args) => ({ text: describeResult(await runMemory(store, args)) }),
+  });
+}
+
+/** Dispatch one call to the store. Kept apart from the tool so it can be tested alone. */
+export async function runMemory(store, args = {}) {
+  const target = args.target ?? 'memory';
+  if (!Object.hasOwn(TARGETS, target)) return store.fail(target, `unknown target '${target}' — use 'memory' or 'user'`);
+  // Some providers send JSON null for every omitted optional field.
+  const operations = Array.isArray(args.operations) && args.operations.length ? args.operations : null;
+  if (operations) return store.applyBatch(target, operations);
+  switch (args.action) {
+    case 'add': return store.add(target, args.content);
+    case 'replace': return store.replace(target, args.old_text, args.content);
+    case 'remove': return store.remove(target, args.old_text);
+    default:
+      return store.fail(target, `give either action (add, replace or remove) or an operations list — got action '${args.action ?? ''}'`);
+  }
+}