groove-dev 0.27.139 → 0.27.141

package/node_modules/@groove-dev/daemon/src/keeper.js

@@ -0,0 +1,277 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+// Keeper — lightweight tagged memory system.
+// Flat file-backed storage: one tag = one markdown file.
+// Hierarchical namespacing via "/" in tag names (groove/memory-system → groove/memory-system.md).
+
+import { resolve, dirname } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+
+export const KEEPER_COMMANDS = {
+  save:     { syntax: '[save] #tag',             description: 'Save the current message as a tagged memory' },
+  append:   { syntax: '[append] #tag',           description: 'Add content to an existing memory without overwriting' },
+  update:   { syntax: '[update] #tag',           description: 'Open the memory editor to edit in place' },
+  delete:   { syntax: '[delete] #tag',           description: 'Delete a tagged memory' },
+  read:     { syntax: '[read] #tag1 #tag2 ...',  description: 'Send memory content to the agent — agent reads it, chat stays clean' },
+  view:     { syntax: '[view] #tag',             description: 'Open a memory in the viewer' },
+  doc:      { syntax: '[doc] #tag',              description: 'AI reads the full conversation and generates a robust document' },
+  link:     { syntax: '[link] #tag path/to/doc', description: 'Link a memory tag to a NORTHSTAR or external document' },
+  instruct: { syntax: '[instruct]',              description: 'Show all Keeper commands and usage instructions' },
+};
+
+export class Keeper {
+  constructor(grooveDir) {
+    this.dir = resolve(grooveDir, 'keeper');
+    this.indexPath = resolve(this.dir, 'index.json');
+    mkdirSync(this.dir, { recursive: true });
+    this._index = this._loadIndex();
+  }
+
+  _loadIndex() {
+    try {
+      if (existsSync(this.indexPath)) {
+        return JSON.parse(readFileSync(this.indexPath, 'utf8'));
+      }
+    } catch { /* corrupted — rebuild */ }
+    return {};
+  }
+
+  _saveIndex() {
+    writeFileSync(this.indexPath, JSON.stringify(this._index, null, 2));
+  }
+
+  _tagToPath(tag) {
+    const safe = tag.replace(/[^a-zA-Z0-9/_-]/g, '');
+    if (!safe) throw new Error('Invalid tag name');
+    return resolve(this.dir, `${safe}.md`);
+  }
+
+  _ensureParentDir(filePath) {
+    const dir = dirname(filePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+
+  _normalize(tag) {
+    return tag.replace(/^#/, '').trim().toLowerCase();
+  }
+
+  // ── CRUD ──────────────────────────────────────────────────
+
+  save(tag, content) {
+    if (!tag || typeof tag !== 'string') throw new Error('Tag is required');
+    if (content === undefined || content === null) throw new Error('Content is required');
+    const normalized = this._normalize(tag);
+    if (!normalized) throw new Error('Tag is required');
+    const filePath = this._tagToPath(normalized);
+    this._ensureParentDir(filePath);
+    writeFileSync(filePath, String(content));
+    this._index[normalized] = {
+      tag: normalized,
+      type: this._index[normalized]?.type || 'manual',
+      links: this._index[normalized]?.links || [],
+      createdAt: this._index[normalized]?.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      size: String(content).length,
+    };
+    this._saveIndex();
+    return { tag: normalized, ...this._index[normalized] };
+  }
+
+  append(tag, content) {
+    if (!tag || typeof tag !== 'string') throw new Error('Tag is required');
+    if (!content) throw new Error('Content is required');
+    const normalized = this._normalize(tag);
+    if (!normalized) throw new Error('Tag is required');
+    const filePath = this._tagToPath(normalized);
+    if (!existsSync(filePath)) {
+      return this.save(normalized, content);
+    }
+    const existing = readFileSync(filePath, 'utf8');
+    const updated = existing + '\n\n---\n\n' + String(content);
+    writeFileSync(filePath, updated);
+    this._index[normalized] = {
+      ...this._index[normalized],
+      updatedAt: new Date().toISOString(),
+      size: updated.length,
+    };
+    this._saveIndex();
+    return { tag: normalized, ...this._index[normalized] };
+  }
+
+  get(tag) {
+    const normalized = this._normalize(tag);
+    if (!normalized) throw new Error('Tag is required');
+    const filePath = this._tagToPath(normalized);
+    if (!existsSync(filePath)) return null;
+    const content = readFileSync(filePath, 'utf8');
+    const meta = this._index[normalized] || {};
+    return { tag: normalized, content, ...meta };
+  }
+
+  pull(tags) {
+    const items = [];
+    for (const tag of tags) {
+      const normalized = this._normalize(tag);
+      if (!normalized) continue;
+      const item = this.get(normalized);
+      if (item) items.push(item);
+      const children = this.children(normalized);
+      for (const child of children) {
+        const childItem = this.get(child.tag);
+        if (childItem && !items.some(i => i.tag === childItem.tag)) {
+          items.push(childItem);
+        }
+      }
+    }
+    if (items.length === 0) return null;
+    return items.map(i => `## #${i.tag}\n\n${i.content}`).join('\n\n---\n\n');
+  }
+
+  update(tag, content) {
+    const normalized = this._normalize(tag);
+    if (!normalized) throw new Error('Tag is required');
+    if (content === undefined || content === null) throw new Error('Content is required');
+    const filePath = this._tagToPath(normalized);
+    if (!existsSync(filePath)) throw new Error(`Memory #${normalized} does not exist`);
+    writeFileSync(filePath, String(content));
+    this._index[normalized] = {
+      ...this._index[normalized],
+      updatedAt: new Date().toISOString(),
+      size: String(content).length,
+    };
+    this._saveIndex();
+    return { tag: normalized, ...this._index[normalized] };
+  }
+
+  delete(tag) {
+    const normalized = this._normalize(tag);
+    if (!normalized) throw new Error('Tag is required');
+    const filePath = this._tagToPath(normalized);
+    if (!existsSync(filePath)) return false;
+    unlinkSync(filePath);
+    delete this._index[normalized];
+    this._saveIndex();
+    return true;
+  }
+
+  // ── Doc (AI-generated) ───────────────────────────────────
+
+  saveDoc(tag, content) {
+    const normalized = this._normalize(tag);
+    if (!normalized) throw new Error('Tag is required');
+    const result = this.save(normalized, content);
+    this._index[normalized].type = 'doc';
+    this._saveIndex();
+    return { tag: normalized, ...this._index[normalized] };
+  }
+
+  // ── Links ─────────────────────────────────────────────────
+
+  link(tag, docPath) {
+    const normalized = this._normalize(tag);
+    if (!normalized) throw new Error('Tag is required');
+    if (!docPath) throw new Error('Document path is required');
+    if (!this._index[normalized]) {
+      this.save(normalized, `Linked to: ${docPath}`);
+    }
+    const links = this._index[normalized].links || [];
+    if (!links.includes(docPath)) {
+      links.push(docPath);
+    }
+    this._index[normalized].links = links;
+    this._saveIndex();
+    return { tag: normalized, ...this._index[normalized] };
+  }
+
+  unlink(tag, docPath) {
+    const normalized = this._normalize(tag);
+    if (!normalized) throw new Error('Tag is required');
+    if (!this._index[normalized]) return false;
+    this._index[normalized].links = (this._index[normalized].links || []).filter(l => l !== docPath);
+    this._saveIndex();
+    return true;
+  }
+
+  // ── Query ─────────────────────────────────────────────────
+
+  list() {
+    return Object.values(this._index).sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+  }
+
+  children(parentTag) {
+    const normalized = this._normalize(parentTag);
+    const prefix = normalized + '/';
+    return Object.values(this._index)
+      .filter(entry => entry.tag.startsWith(prefix))
+      .sort((a, b) => a.tag.localeCompare(b.tag));
+  }
+
+  tree() {
+    const entries = this.list();
+    const roots = [];
+    const childMap = {};
+
+    for (const entry of entries) {
+      const parts = entry.tag.split('/');
+      if (parts.length === 1) {
+        roots.push({ ...entry, children: [] });
+      } else {
+        const parent = parts.slice(0, -1).join('/');
+        if (!childMap[parent]) childMap[parent] = [];
+        childMap[parent].push(entry);
+      }
+    }
+
+    for (const root of roots) {
+      root.children = childMap[root.tag] || [];
+    }
+
+    for (const [parent, children] of Object.entries(childMap)) {
+      if (!roots.some(r => r.tag === parent) && !parent.includes('/')) {
+        roots.push({ tag: parent, virtual: true, children });
+      }
+    }
+
+    return roots.sort((a, b) => a.tag.localeCompare(b.tag));
+  }
+
+  search(query) {
+    if (!query) return this.list();
+    const q = query.toLowerCase();
+    const results = [];
+    for (const entry of Object.values(this._index)) {
+      if (entry.tag.includes(q)) {
+        results.push({ ...entry, matchType: 'tag' });
+        continue;
+      }
+      const item = this.get(entry.tag);
+      if (item && item.content.toLowerCase().includes(q)) {
+        results.push({ ...entry, matchType: 'content' });
+      }
+    }
+    return results.sort((a, b) => (b.updatedAt || '').localeCompare(a.updatedAt || ''));
+  }
+
+  // ── Command parser ────────────────────────────────────────
+
+  static parseCommand(text) {
+    const cmdMatch = text.match(/\[(save|append|update|delete|view|doc|link|read|instruct)\]|\b(save|append|update|delete|view|doc|link|read)\b(?=\s+#[\w/.-])/i);
+    if (!cmdMatch) return null;
+    const command = (cmdMatch[1] || cmdMatch[2]).toLowerCase();
+    const rest = text.slice(cmdMatch.index + cmdMatch[0].length).trim();
+
+    if (command === 'instruct') {
+      return { command, tags: [], extra: null };
+    }
+
+    if (command === 'link') {
+      const linkMatch = rest.match(/^((?:#[\w/.-]+\s*)+)\s+(.+)$/);
+      if (!linkMatch) return null;
+      const tags = linkMatch[1].match(/#[\w/.-]+/g).map(t => t.replace(/^#/, ''));
+      return { command, tags, extra: linkMatch[2].trim() };
+    }
+
+    const tags = (rest.match(/#[\w/.-]+/g) || []).map(t => t.replace(/^#/, ''));
+    if (tags.length === 0 && command !== 'instruct') return null;
+    return { command, tags, extra: null };
+  }
+}

package/node_modules/@groove-dev/daemon/src/model-lab.js

@@ -95,6 +95,17 @@ export class ModelLab {
   removeRuntime(id) {
     const rt = this.runtimes.get(id);
     if (!rt) return null;
+
+    // Stop the llama-server process if this is a local model runtime
+    if (rt._localModelId) {
+      const mm = this.daemon.modelManager;
+      const ls = this.daemon.llamaServer;
+      if (mm && ls) {
+        const modelPath = mm.getModelPath(rt._localModelId);
+        if (modelPath) ls.stopServer(modelPath).catch(() => {});
+      }
+    }
+
     this.runtimes.delete(id);
     this._saveRuntimes();
     this.daemon.broadcast({ type: 'lab:runtime:removed', data: { id } });

package/node_modules/@groove-dev/daemon/src/process.js

@@ -1976,6 +1976,10 @@ For normal file edits within your scope, proceed without review.
    * Resume a completed agent's session with a new message.
    * Uses --resume SESSION_ID for zero cold-start continuation.
    * Falls back to full spawn if no session ID available.
+   *
+   * If the agent has been idle for longer than IDLE_CONTEXT_THRESHOLD,
+   * spawns fresh with the full conversation thread instead of --resume.
+   * This avoids degraded context from internal compaction.
    */
   async resume(agentId, message) {
     const { registry, locks } = this.daemon;
@@ -1996,6 +2000,23 @@ For normal file edits within your scope, proceed without review.
       return this.daemon.rotator.rotate(agentId, { additionalPrompt: message });
     }
 
+    // Context-aware idle resume: if the agent has been idle long enough for
+    // internal compaction to degrade context, spawn fresh with the full
+    // conversation thread instead of resuming the compacted session.
+    const IDLE_CONTEXT_THRESHOLD_MS = 5 * 60_000; // 5 minutes (matches prompt cache TTL)
+    const idleMs = agent.lastActivity
+      ? Date.now() - new Date(agent.lastActivity).getTime()
+      : Infinity;
+
+    if (idleMs > IDLE_CONTEXT_THRESHOLD_MS && this.daemon.journalist) {
+      const resumePrompt = this.daemon.journalist.buildConversationResumePrompt(agent, message);
+      if (resumePrompt) {
+        console.log(`[Groove] Agent ${agent.name} idle ${Math.round(idleMs / 60000)}min — using conversation-thread resume`);
+        // Use rotation machinery but with our richer prompt instead of handoff brief
+        return this._conversationResume(agentId, agent, resumePrompt);
+      }
+    }
+
     const provider = getProvider(agent.provider || 'claude-code');
     if (!provider?.buildResumeCommand) {
       return this.daemon.rotator.rotate(agentId, { additionalPrompt: message });
@@ -2125,6 +2146,61 @@ For normal file edits within your scope, proceed without review.
     return newAgent;
   }
 
+  /**
+   * Conversation-thread resume: spawns a fresh agent with the full
+   * user↔assistant conversation as context instead of using --resume
+   * on a potentially compacted session. Used when idle > threshold.
+   */
+  async _conversationResume(agentId, agent, resumePrompt) {
+    const { registry, locks } = this.daemon;
+    const config = { ...agent };
+
+    if (this.handles.has(agentId)) {
+      await this.kill(agentId);
+    }
+    registry.remove(agentId);
+    locks.release(agentId);
+
+    const newAgent = await this.spawn({
+      role: config.role,
+      scope: config.scope,
+      provider: config.provider,
+      model: config.model,
+      prompt: resumePrompt,
+      permission: config.permission || 'full',
+      workingDir: config.workingDir,
+      name: config.name,
+      teamId: config.teamId,
+      isRotation: true,
+    });
+
+    // Carry cumulative token count for tracking
+    if (config.tokensUsed > 0) {
+      registry.update(newAgent.id, { tokensUsed: config.tokensUsed });
+    }
+
+    if (this.daemon.timeline) {
+      this.daemon.timeline.recordEvent('conversation_resume', {
+        agentId: newAgent.id,
+        oldAgentId: agentId,
+        agentName: newAgent.name,
+        role: config.role,
+        idleMinutes: Math.round((Date.now() - new Date(config.lastActivity).getTime()) / 60000),
+      });
+    }
+
+    this.daemon.broadcast({
+      type: 'rotation:complete',
+      agentId: newAgent.id,
+      agentName: newAgent.name,
+      oldAgentId: agentId,
+      reason: 'conversation_resume',
+      tokensSaved: 0,
+    });
+
+    return newAgent;
+  }
+
   async _resumeAgentLoop(agentId, agent, message, provider) {
     const { registry, locks } = this.daemon;
     const config = { ...agent };

package/node_modules/@groove-dev/daemon/src/validate.js

@@ -112,6 +112,12 @@ export function validateAgentConfig(config) {
     if (!isNaN(v) && v >= 0 && v <= 100) verbosity = Math.round(v);
   }
 
+  const validEffort = ['min', 'low', 'default', 'high', 'max'];
+  const effort = validEffort.includes(config.effort) ? config.effort : undefined;
+
+  const validRouting = ['fixed', 'auto', 'auto-floor'];
+  const routingMode = validRouting.includes(config.routingMode) ? config.routingMode : undefined;
+
   // Return sanitized config (only known fields)
   return {
     role: config.role,
@@ -131,7 +137,10 @@ export function validateAgentConfig(config) {
     reasoningEffort: numericReasoningEffort ?? reasoningEffort,
     temperature,
     verbosity,
+    effort,
+    routingMode,
     labPresetId: (typeof config.labPresetId === 'string' && config.labPresetId.length <= 64) ? config.labPresetId : undefined,
+    keeperTags: Array.isArray(config.keeperTags) ? config.keeperTags.filter(t => typeof t === 'string').slice(0, 20) : undefined,
   };
 }