codemini-cli 0.4.0 → 0.4.2

package/src/core/command-loader.js

@@ -58,6 +58,12 @@ function isSafeEntry(entry) {
   return entry !== '.' && entry !== '..' && !entry.includes('/') && !entry.includes('\\');
 }
 
+function setCommand(out, name, command) {
+  const existing = out.get(name);
+  if (existing?.source === 'bundled-skill') return;
+  out.set(name, command);
+}
+
 function loadMarkdownCommandsFromDir(baseDir, source, out) {
   if (!fs.existsSync(baseDir)) return;
   for (const entry of safeEntries(baseDir)) {
@@ -70,7 +76,7 @@ function loadMarkdownCommandsFromDir(baseDir, source, out) {
       if (fs.existsSync(commandFile)) {
         const raw = fs.readFileSync(commandFile, 'utf8');
         const parsed = parseFrontmatter(raw);
-        out.set(entry, {
+        setCommand(out, entry, {
           name: entry,
           source,
           path: commandFile,
@@ -85,7 +91,7 @@ function loadMarkdownCommandsFromDir(baseDir, source, out) {
       const name = entry.replace(/\.md$/, '');
       const raw = fs.readFileSync(full, 'utf8');
       const parsed = parseFrontmatter(raw);
-      out.set(name, {
+      setCommand(out, name, {
         name,
         source,
         path: full,
@@ -107,7 +113,7 @@ function loadLegacySkillsFromDir(baseDir, source, out) {
     if (!fs.existsSync(skillFile)) continue;
     const raw = fs.readFileSync(skillFile, 'utf8');
     const parsed = parseFrontmatter(raw);
-    out.set(entry, {
+    setCommand(out, entry, {
       name: entry,
       source: `${source}-skill`,
       path: skillFile,
@@ -131,7 +137,7 @@ function loadBundledSkillsFromDir(baseDir, out) {
     if (!fs.existsSync(skillFile)) continue;
     const raw = fs.readFileSync(skillFile, 'utf8');
     const parsed = parseFrontmatter(raw);
-    out.set(entry, {
+    setCommand(out, entry, {
       name: entry,
       source: 'bundled-skill',
       path: skillFile,
@@ -151,12 +157,13 @@ function loadInstalledSkillsFromRegistry(baseDir, registry, out) {
   for (const skill of registry.skills) {
     if (skill.enabled === false) continue;
     const name = skill.name;
+    if (out.has(name)) continue;
     const entry = skill.entryFile || 'SKILL.md';
     const full = path.join(baseDir, name, entry);
     if (!fs.existsSync(full)) continue;
     const raw = fs.readFileSync(full, 'utf8');
     const parsed = parseFrontmatter(raw);
-    out.set(name, {
+    setCommand(out, name, {
       name,
       source: 'registry-skill',
       path: full,

package/src/core/config-store.js

@@ -65,6 +65,7 @@ const DEFAULT_CONFIG = {
   memory: {
     enabled: true,
     auto_write: true,
+    auto_capture: true,
     inject_on_session_start: true,
     auto_dream_threshold: 10,
     max_items_per_scope: 12,
@@ -165,6 +166,7 @@ function normalizePolicyLists(config) {
   next.memory = next.memory || {};
   next.memory.enabled = next.memory.enabled !== false;
   next.memory.auto_write = next.memory.auto_write !== false;
+  next.memory.auto_capture = next.memory.auto_capture !== false;
   next.memory.inject_on_session_start = next.memory.inject_on_session_start !== false;
   next.memory.max_items_per_scope = Math.max(1, Number(next.memory.max_items_per_scope || 12));
   next.memory.auto_dream_threshold = Number(next.memory.auto_dream_threshold ?? 10);

package/src/core/context-compact.js

@@ -1,4 +1,5 @@
-import { summarizeToolResult, trimInline } from './agent-loop.js';
+import { trimInline } from './string-utils.js';
+import { summarizeToolResult } from './tool-result-store.js';
 
 function textFromContent(content) {
   if (typeof content === 'string') return content;
@@ -37,20 +38,30 @@ function modeToKeepRecent(mode) {
 }
 
 function buildLocalSummary(messages) {
-  const lines = [];
+  const goal = [];
+  const constraints = [];
+  const changedFiles = new Set();
+  const verification = [];
+  const openThreads = [];
   const limit = 16;
   for (const msg of messages.slice(-limit)) {
     if (msg.role === 'tool') {
-      // Try to parse tool result as JSON for semantic summary
       const text = textFromContent(msg.content);
       let parsed;
       try { parsed = JSON.parse(text); } catch { parsed = null; }
       if (parsed && typeof parsed === 'object') {
         const summary = summarizeToolResult(parsed);
-        lines.push(`- tool_result: ${summary}`);
+        if (parsed.path) changedFiles.add(String(parsed.path));
+        if (parsed.command || parsed.code != null || parsed.stderr || parsed.stdout) {
+          verification.push(summary);
+        } else {
+          openThreads.push(`tool_result: ${summary}`);
+        }
       } else {
         const clipped = text.length > 120 ? `${text.slice(0, 117)}...` : text;
-        lines.push(`- tool_result: ${clipped}`);
+        const match = clipped.match(/([A-Za-z0-9_./-]+\.[A-Za-z0-9]+):\d+/);
+        if (match) changedFiles.add(match[1]);
+        openThreads.push(`tool_result: ${clipped}`);
       }
       continue;
     }
@@ -59,21 +70,35 @@ function buildLocalSummary(messages) {
       const toolCallCount = Array.isArray(msg.tool_calls) ? msg.tool_calls.length : 0;
       const toolInfo = toolCallCount > 0 ? ` [called ${toolCallCount} tool(s)]` : '';
       const clipped = text.length > 300 ? `${text.slice(0, 297)}...` : text;
-      lines.push(`- assistant: ${clipped}${toolInfo}`);
+      if (clipped) openThreads.push(`assistant: ${clipped}${toolInfo}`);
       continue;
     }
     if (msg.role === 'user') {
       const text = textFromContent(msg.content).replace(/\s+/g, ' ').trim();
       const clipped = text.length > 200 ? `${text.slice(0, 197)}...` : text;
-      lines.push(`- user: ${clipped}`);
+      if (goal.length === 0) goal.push(clipped);
+      else constraints.push(clipped);
       continue;
     }
     const text = textFromContent(msg.content).replace(/\s+/g, ' ').trim();
     if (!text) continue;
     const clipped = text.length > 160 ? `${text.slice(0, 157)}...` : text;
-    lines.push(`- ${msg.role}: ${clipped}`);
+    openThreads.push(`${msg.role}: ${clipped}`);
   }
-  return `Context Summary\n${lines.join('\n')}`.trim();
+  const lines = [
+    'Context Summary',
+    'Goal:',
+    goal.length > 0 ? `- ${goal[0]}` : '- Unknown from compacted context',
+    'Key Constraints:',
+    ...(constraints.length > 0 ? constraints.slice(-4).map((item) => `- ${item}`) : ['- None recorded']),
+    'Changed Files:',
+    ...(changedFiles.size > 0 ? [...changedFiles].slice(0, 8).map((item) => `- ${item}`) : ['- None recorded']),
+    'Verification:',
+    ...(verification.length > 0 ? verification.slice(-4).map((item) => `- ${item}`) : ['- None recorded']),
+    'Open Threads:',
+    ...(openThreads.length > 0 ? openThreads.slice(-8).map((item) => `- ${item}`) : ['- None recorded'])
+  ];
+  return lines.join('\n').trim();
 }
 
 export function compactMessagesLocally(messages, { mode = 'default' } = {}) {

package/src/core/default-system-prompt.js

@@ -9,14 +9,14 @@ function getToolFewShotBlock() {
 Use these as style examples for tool calls:
 
 Current working directory: ${cwd}
-When a tool takes file_path, build it from the current working directory and prefer absolute paths.
+When a tool takes path, build it from the current working directory and prefer absolute paths.
 If the user mentions a project-relative path like src/app.ts, resolve it from ${cwd} instead of guessing parent directories.
 
 1. File discovery then read
 User: compare the auth flow
 Assistant: first narrow the search with the project index
 Tool: query_project_index({"query":"auth flow","path":"src","max_results":3})
-Tool: read({"file_path":"${cwd}/src/auth/service.ts"})
+Tool: read({"path":"${cwd}/src/auth/service.ts"})
 
 If the visible tool list does not include a needed capability, load it with tool_search instead of assuming it does not exist.
 Example:
@@ -27,7 +27,7 @@ Tool: glob({"pattern":"src/**/*.ts"})
 User: rename loginUser to signInUser
 Assistant: first find the exact occurrences
 Tool: grep({"pattern":"loginUser","path":"src"})
-Tool: edit({"file_path":"${cwd}/src/auth/service.ts","old_string":"loginUser","new_string":"signInUser"})
+Tool: edit({"path":"${cwd}/src/auth/service.ts","old_text":"loginUser","new_text":"signInUser"})
 
 3. Read a specific range
 User: inspect the reducer around line 120
@@ -43,7 +43,7 @@ Assistant: keep the checklist updated as each phase finishes, and do not give a
 5. Create a new file
 User: add a notes file
 Assistant: create the file directly
-Tool: write({"file":"${cwd}/notes.txt","text":"todo\\n"})
+Tool: write({"path":"${cwd}/notes.txt","content":"todo\\n"})
 
 6. Save a high-signal observation to memory
 When you notice a reusable pattern, a user correction, a repeated failure, or a stable preference — save it to persistent memory. Choose scope carefully:
@@ -73,7 +73,7 @@ Tool: tool_search({"query":"web_search"})
 Tool: web_search({"query":"latest pnpm release","max_results":5})
 
 Prefer these direct tool shapes over multi-step metadata reads or shell fallbacks.
-Prefer explicit absolute file_path values when the current working directory is known.`;
+Prefer explicit absolute path values when the current working directory is known.`;
 }
 
 function getEnvBlock() {

package/src/core/dream-audit.js

@@ -56,6 +56,18 @@ function renderReport(report) {
     lines.push('');
   }
 
+  if (report.maintenance?.length) {
+    lines.push('## Memory Maintenance');
+    for (const item of report.maintenance) {
+      if (item.skipped) {
+        lines.push(`- [${item.scope}] skipped: ${item.reason}`);
+      } else {
+        lines.push(`- [${item.scope}] ${item.before} -> ${item.after} item(s)${item.changed ? ' changed' : ' marked clean'}`);
+      }
+    }
+    lines.push('');
+  }
+
   if (report.disagreements?.length) {
     lines.push('## Reviewer Disagreements');
     for (const d of report.disagreements) {

package/src/core/dream-consolidate.js

@@ -1,6 +1,13 @@
-import { listMemories, listInbox, archiveEntry, promoteMemory } from './memory-store.js';
+import {
+  getMemoryBucketMaintenance,
+  listMemories,
+  listInbox,
+  archiveEntry,
+  promoteMemory,
+  replaceMemoryBucket
+} from './memory-store.js';
 import { writeDreamAuditReport } from './dream-audit.js';
-import { evaluateInboxBatch } from './dream-evaluator.js';
+import { evaluateInboxBatch, evaluateMemoryMaintenance } from './dream-evaluator.js';
 
 const LONGTERM_TYPES = new Set(['preference', 'pattern', 'win', 'decision']);
 const OPERATIONAL_TYPES = new Set(['correction', 'failure', 'gap', 'observation']);
@@ -22,6 +29,76 @@ function memoryContainsSummary(memory, summaryKey) {
   return content.includes(summaryKey) || summary.includes(summaryKey);
 }
 
+function maintenanceScopes(scopeFilter) {
+  const scope = normalizeText(scopeFilter);
+  if (!scope) return ['user', 'global', 'project'];
+  if (scope === 'repo') return ['project'];
+  if (['user', 'global', 'project'].includes(scope)) return [scope];
+  return ['user', 'global', 'project'];
+}
+
+async function runMemoryMaintenance({
+  dryRun = false,
+  scope = null,
+  workspaceRoot = process.cwd(),
+  config = {}
+} = {}) {
+  const reports = [];
+  const filesChanged = [];
+
+  for (const memoryScope of maintenanceScopes(scope)) {
+    const maintenance = await getMemoryBucketMaintenance({ scope: memoryScope, workspaceRoot });
+    const items = await listMemories({ scope: memoryScope, workspaceRoot });
+    if (items.length === 0) {
+      reports.push({ scope: memoryScope, skipped: true, reason: 'empty' });
+      continue;
+    }
+    if (maintenance.fresh) {
+      reports.push({ scope: memoryScope, skipped: true, reason: 'already-maintained', itemCount: items.length });
+      continue;
+    }
+
+    const evaluated = dryRun
+      ? { items, archives: [] }
+      : await evaluateMemoryMaintenance({ scope: memoryScope, items, config, workspaceRoot });
+    if (evaluated.error) {
+      reports.push({ scope: memoryScope, skipped: true, reason: `maintenance-error: ${evaluated.error}`, itemCount: items.length });
+      continue;
+    }
+    const nextItems = Array.isArray(evaluated.items) && evaluated.items.length > 0 ? evaluated.items : items;
+    const changed =
+      JSON.stringify(nextItems.map((item) => [item.kind, item.content, item.summary, item.lifecycle || ''])) !==
+      JSON.stringify(items.map((item) => [item.kind, item.content, item.summary, item.lifecycle || '']));
+
+    if (!dryRun) {
+      await replaceMemoryBucket({
+        scope: memoryScope,
+        items: nextItems,
+        workspaceRoot,
+        markMaintained: true
+      });
+      filesChanged.push({
+        file: memoryScope === 'project' ? 'memory/project/*.json' : `memory/${memoryScope}.json`,
+        why: changed
+          ? `LLM-maintained ${items.length} item(s) into ${nextItems.length} item(s)`
+          : `Marked ${items.length} item(s) as maintained`
+      });
+    }
+
+    reports.push({
+      scope: memoryScope,
+      skipped: false,
+      before: items.length,
+      after: nextItems.length,
+      changed,
+      archives: evaluated.archives || [],
+      dryRun
+    });
+  }
+
+  return { reports, filesChanged };
+}
+
 export async function runDreamConsolidation({
   dryRun = false,
   scope = null,
@@ -31,9 +108,6 @@ export async function runDreamConsolidation({
 } = {}) {
   const scopeFilter = scope || null;
   const inbox = await listInbox({ scope: scopeFilter });
-  if (inbox.length === 0) {
-    return { ok: true, dryRun, message: 'No inbox entries to consolidate.', promotions: [], rejections: [], archives: [] };
-  }
 
   const [globalMemories, userMemories, projectMemories] = await Promise.all([
     listMemories({ scope: 'global', workspaceRoot }),
@@ -77,67 +151,63 @@ export async function runDreamConsolidation({
     candidates.push(entry);
   }
 
-  if (candidates.length === 0) {
-    const report = { timestamp: new Date().toISOString(), filesRead, filesChanged: [], candidatesGenerated: inbox.length, promotions, rejections, archives };
-    if (!dryRun && writeAudit) {
-      const reportPath = await writeDreamAuditReport(report);
-      report.auditReport = reportPath;
-    }
-    return { ok: true, dryRun, ...report };
-  }
-
-  /* ── Phase 2: LLM 批量评估（质量门控 + scope 分类 + 内容提炼） ── */
-  const llmResults = dryRun
-    ? candidates.map((e) => ({ id: e.id, action: 'keep', scope: 'global', kind: e.type || 'observation', content: e.details || e.summary, summary: e.summary, confidence: 0.9 }))
-    : await evaluateInboxBatch({ entries: candidates, config, workspaceRoot });
+  if (candidates.length > 0) {
+    /* ── Phase 2: LLM 批量评估（质量门控 + scope 分类 + 内容提炼） ── */
+    const llmResults = dryRun
+      ? candidates.map((e) => ({ id: e.id, action: 'keep', scope: 'global', kind: e.type || 'observation', content: e.details || e.summary, summary: e.summary, confidence: 0.9 }))
+      : await evaluateInboxBatch({ entries: candidates, config, workspaceRoot });
 
-  const resultMap = new Map(llmResults.map((r) => [r.id, r]));
+    const resultMap = new Map(llmResults.map((r) => [r.id, r]));
 
-  /* ── Phase 3: 按评估结果 promote 或 archive ─────────────────── */
-  for (const entry of candidates) {
-    const evaluation = resultMap.get(entry.id);
+    /* ── Phase 3: 按评估结果 promote 或 archive ─────────────────── */
+    for (const entry of candidates) {
+      const evaluation = resultMap.get(entry.id);
 
-    if (!evaluation || evaluation.action === 'discard') {
-      const reason = evaluation?.reason || 'LLM discarded';
-      if (!dryRun) await archiveEntry(entry, 'discarded-by-evaluator', reason);
-      rejections.push({ summary: entry.summary, reason: `evaluator-discard: ${reason}` });
-      continue;
-    }
-
-    const promoteScope = evaluation.scope || 'global';
-    const lifecycle = chooseLifecycle(evaluation.kind);
-    const enrichedEntry = {
-      ...entry,
-      /* 用 LLM 提炼后的内容覆盖原始报错 */
-      summary: evaluation.summary || entry.summary,
-      details: evaluation.content || entry.details || entry.summary,
-      type: evaluation.kind || entry.type || 'observation'
-    };
+      if (!evaluation || evaluation.action === 'discard') {
+        const reason = evaluation?.reason || 'LLM discarded';
+        if (!dryRun) await archiveEntry(entry, 'discarded-by-evaluator', reason);
+        rejections.push({ summary: entry.summary, reason: `evaluator-discard: ${reason}` });
+        continue;
+      }
 
-    if (!dryRun) {
-      try {
-        await promoteMemory({
-          entry: enrichedEntry,
-          scope: promoteScope,
-          lifecycle,
-          workspaceRoot,
-          config,
-          confidence: evaluation.confidence || 0.8
-        });
-        filesChanged.push({ file: `memory/${promoteScope}.json`, why: `Promoted "${enrichedEntry.summary}" as ${lifecycle} (${promoteScope})` });
-        promotions.push({ summary: enrichedEntry.summary, scope: promoteScope, lifecycle, rationale: evaluation.kind, confidence: evaluation.confidence });
-      } catch (error) {
-        const reason = String(error?.message || error || 'promotion failed').slice(0, 180);
-        await archiveEntry(entry, 'promotion-failed', reason);
-        rejections.push({ summary: entry.summary, reason: `promotion-failed: ${reason}` });
-        archives.push({ summary: entry.summary, reason: 'promotion-failed' });
+      const promoteScope = evaluation.scope || 'global';
+      const lifecycle = chooseLifecycle(evaluation.kind);
+      const enrichedEntry = {
+        ...entry,
+        /* 用 LLM 提炼后的内容覆盖原始报错 */
+        summary: evaluation.summary || entry.summary,
+        details: evaluation.content || entry.details || entry.summary,
+        type: evaluation.kind || entry.type || 'observation'
+      };
+
+      if (!dryRun) {
+        try {
+          await promoteMemory({
+            entry: enrichedEntry,
+            scope: promoteScope,
+            lifecycle,
+            workspaceRoot,
+            config,
+            confidence: evaluation.confidence || 0.8
+          });
+          filesChanged.push({ file: `memory/${promoteScope}.json`, why: `Promoted "${enrichedEntry.summary}" as ${lifecycle} (${promoteScope})` });
+          promotions.push({ summary: enrichedEntry.summary, scope: promoteScope, lifecycle, rationale: evaluation.kind, confidence: evaluation.confidence });
+        } catch (error) {
+          const reason = String(error?.message || error || 'promotion failed').slice(0, 180);
+          await archiveEntry(entry, 'promotion-failed', reason);
+          rejections.push({ summary: entry.summary, reason: `promotion-failed: ${reason}` });
+          archives.push({ summary: entry.summary, reason: 'promotion-failed' });
+        }
+        continue;
       }
-      continue;
-    }
 
-    promotions.push({ summary: enrichedEntry.summary, scope: promoteScope, lifecycle, rationale: evaluation.kind, confidence: evaluation.confidence, dryRun: true });
+      promotions.push({ summary: enrichedEntry.summary, scope: promoteScope, lifecycle, rationale: evaluation.kind, confidence: evaluation.confidence, dryRun: true });
+    }
   }
 
+  const maintenance = await runMemoryMaintenance({ dryRun, scope: scopeFilter, workspaceRoot, config });
+  filesChanged.push(...maintenance.filesChanged);
+
   const report = {
     timestamp: new Date().toISOString(),
     filesRead,
@@ -145,7 +215,9 @@ export async function runDreamConsolidation({
     candidatesGenerated: inbox.length,
     promotions,
     rejections,
-    archives
+    archives,
+    maintenance: maintenance.reports,
+    ...(inbox.length === 0 ? { message: 'No inbox entries to consolidate; maintained existing memory buckets.' } : {})
   };
 
   if (!dryRun && writeAudit) {

package/src/core/dream-evaluator.js

@@ -22,6 +22,26 @@ Rules:
 - General coding/environment knowledge → scope "global"
 - If in doubt, discard. Memory is expensive; only promote what future sessions will genuinely benefit from.`;
 
+const MAINTENANCE_SYSTEM_PROMPT = `You are maintaining an existing persistent memory bucket for a coding assistant.
+
+Your job:
+1. Merge duplicates and near-duplicates.
+2. Summarize clusters into fewer, higher-signal memories.
+3. Remove stale, contradictory, trivial, or overly specific noise.
+4. Preserve important exact commands, file paths, preferences, and constraints.
+5. Keep memories scoped exactly to the bucket you receive.
+
+Respond with valid JSON only, no markdown fences:
+{"items":[{"kind":"preference|workflow|pattern|observation|correction|decision|failure|architecture|module|note","content":"durable memory text","summary":"under 80 chars","confidence":0.5,"pinned":false,"lifecycle":"longterm|operational"}],"archives":[{"source_ids":["mem_..."],"reason":"merged|stale|duplicate|noise|contradiction"}]}
+
+Rules:
+- Prefer fewer, clearer items, but do not collapse unrelated facts.
+- User preferences belong in user memory and should not become project rules.
+- Project conventions belong in project memory and should not become user preferences.
+- Global memory is only for reusable cross-project/tool/environment knowledge.
+- If a pinned item is still valid, keep it.
+- Return at least one item if the input has useful durable content.`;
+
 function parseResults(text) {
   try {
     const json = JSON.parse(text);
@@ -97,3 +117,69 @@ export async function evaluateInboxBatch({ entries, config, workspaceRoot }) {
     }));
   }
 }
+
+function parseMaintenanceResult(text) {
+  try {
+    const json = JSON.parse(text);
+    const items = Array.isArray(json?.items) ? json.items : [];
+    const archives = Array.isArray(json?.archives) ? json.archives : [];
+    return {
+      items: items
+        .map((item) => ({
+          kind: String(item.kind || 'note').slice(0, 40),
+          content: String(item.content || '').slice(0, 600),
+          summary: String(item.summary || item.content || '').slice(0, 120),
+          confidence: Math.min(1, Math.max(0.5, Number(item.confidence) || 0.8)),
+          pinned: item.pinned === true,
+          lifecycle: ['longterm', 'operational'].includes(String(item.lifecycle || '')) ? String(item.lifecycle) : undefined
+        }))
+        .filter((item) => item.content.trim()),
+      archives: archives.map((archive) => ({
+        source_ids: Array.isArray(archive.source_ids) ? archive.source_ids.map((id) => String(id)).filter(Boolean) : [],
+        reason: String(archive.reason || '').slice(0, 160)
+      }))
+    };
+  } catch {
+    return { items: [], archives: [] };
+  }
+}
+
+export async function evaluateMemoryMaintenance({ scope, items, config, workspaceRoot }) {
+  const sourceItems = Array.isArray(items) ? items : [];
+  if (sourceItems.length === 0) return { items: [], archives: [] };
+
+  const compactItems = sourceItems.map((item) => ({
+    id: item.id,
+    kind: item.kind,
+    content: String(item.content || '').slice(0, 600),
+    summary: String(item.summary || '').slice(0, 160),
+    confidence: item.confidence,
+    pinned: item.pinned === true,
+    lifecycle: item.lifecycle || ''
+  }));
+
+  try {
+    const result = await createChatCompletion({
+      sdkProvider: config?.sdk?.provider,
+      baseUrl: config?.gateway?.base_url,
+      apiKey: config?.gateway?.api_key,
+      model: config?.model?.name,
+      messages: [
+        { role: 'system', content: MAINTENANCE_SYSTEM_PROMPT },
+        {
+          role: 'user',
+          content: `Maintain this ${scope} memory bucket. Workspace: ${workspaceRoot || process.cwd()}\n\n${JSON.stringify(compactItems, null, 2)}`
+        }
+      ],
+      temperature: 0,
+      timeoutMs: EVAL_TIMEOUT_MS
+    });
+    return parseMaintenanceResult(result?.text || '');
+  } catch (error) {
+    return {
+      items: sourceItems,
+      archives: [],
+      error: String(error?.message || error || 'memory maintenance failed')
+    };
+  }
+}

package/src/core/fff-adapter.js

@@ -111,7 +111,7 @@ class FffMcpClient {
       capabilities: {},
       clientInfo: {
         name: 'codemini-cli',
-        version: '0.4.0'
+        version: '0.4.2'
       }
     });
     this.sendNotification('notifications/initialized', {});