auxilo-mcp 0.9.18 → 0.9.19

package/README.md

@@ -87,9 +87,9 @@ Add to `claude_desktop_config.json` (macOS: `~/Library/Application Support/Claud
 
 The same `mcpServers` block in `~/.cursor/mcp.json`.
 
-**Windsurf**
+**Devin Desktop** (formerly Windsurf)
 
-The same `mcpServers` block in `~/.codeium/windsurf/mcp_config.json`.
+The same `mcpServers` block in `~/.config/devin/mcp_config.json` (legacy path: `~/.codeium/windsurf/mcp_config.json`).
 
 **Any other MCP client**
 

package/bin/auxilo-cli.js

@@ -215,8 +215,17 @@ async function cmdSetup(flags) {
 
   console.log('Detected clients:');
   detected.forEach((c, i) => {
-    const extras = [c.mcp ? 'MCP' : 'poll-based source', c.hooks ? 'background extraction' : null]
-      .filter(Boolean).join(', ');
+    // CLI-CAPTURE-MODE-DISAGREE: was `c.hooks ? 'background extraction' : null`
+    // — true only for Claude Code, so the seven captureHook clients (cursor,
+    // windsurf, codex, gemini-cli, antigravity, factory, copilot-cli) printed
+    // "(MCP)" here even though setup wires their capture hook a few steps
+    // later. `installer.clientHasCaptureHookMode` is the same predicate
+    // `auxilo status` already uses (`c.captureHook`, cmdStatus below), so the
+    // two screens can no longer disagree about a client's capture mode.
+    const extras = [
+      c.mcp ? 'MCP' : 'poll-based source',
+      installer.clientHasCaptureHookMode(c) ? 'background extraction' : null,
+    ].filter(Boolean).join(', ');
     console.log(`  ${i + 1}. ${c.name} (${extras})`);
   });
 

package/lib/installer.js

@@ -181,7 +181,11 @@ const RUNNER_STACK = Object.freeze([
  * `captureEvent` (the client's event name), `captureConfigPath` (the hook
  * config file registerCaptureHook patches), plus `sourceId` when the
  * runner-side source id differs from the registry id (codex → codex-cli,
- * copilot-cli → copilot; must match model_config.json source_allowlist).
+ * copilot-cli → copilot, windsurf → devin — the id kept for ledger
+ * continuity vs. the scripts/sources/*.js poll adapter's own static id;
+ * model_config.json's source_allowlist is the separate, deprecated
+ * server-side-extraction gate and is NOT where this must match — see its
+ * own `_deprecated` note).
  *
  * @param {string} homeDir   Explicit home directory (fixture dir in tests).
  * @param {object} [opts]
@@ -240,9 +244,17 @@ function clientRegistry(homeDir, opts = {}) {
       format: 'json-mcpServers',
       mcp: true,
       hooks: false,
-      // UC-1 capture hook (session-end → capture-core shim)
+      // UC-1 capture hook (session-end → capture-core shim).
+      // CURSOR-STOP-HOOK (0.9.19): was 'sessionEnd' — that event fires only
+      // on IDE quit, and by then Cursor's shell-exec service is already
+      // torn down ("MainThreadShellExec not initialized"), so the hook
+      // never ran; it also named the WRONG (previous) conversation. Cursor's
+      // 'stop' hook fires at agent-turn completion with shell-exec alive and
+      // carries transcript_path for the CURRENT conversation (verified real
+      // payload: {"hook_event_name":"stop","transcript_path":"...",
+      // "model_id":"grok-4.6",...}).
       captureHook: true,
-      captureEvent: 'sessionEnd',
+      captureEvent: 'stop',
       captureConfigPath: path.join(homeDir, '.cursor', 'hooks.json'),
     },
     {
@@ -272,17 +284,38 @@ function clientRegistry(homeDir, opts = {}) {
       hooks: false,
     },
     // ── UC-0 additions (config paths web-verified June 2026, BUILD-SPEC-UNIVERSAL-CLIENTS §5) ──
+    // DEVIN-RENAME (0.9.19): Windsurf → Devin Desktop (vendor rename; Devin
+    // 1.126 migrates mcp_config.json to ~/.config/devin/ but still writes the
+    // legacy ~/.codeium/windsurf/ directory too — detect EITHER). `id` stays
+    // 'windsurf' for ledger continuity (unverified whether any stored state
+    // keys off it; keeping the id is the safe default per BUILD-SPEC-0919).
+    // The capture HOOK is DROPPED here on purpose: the legacy
+    // `post_cascade_response_with_transcript` hook delivered `tool_info:null`
+    // (verified useless) — scripts/sources/devin.js's poll adapter (source
+    // id 'devin', session-store capture from Devin's own SQLite acp-messages
+    // store) replaces it. No captureHook/captureEvent/captureConfigPath
+    // fields, matching the shape of every other pure-MCP, no-hook client
+    // (e.g. claude-desktop).
     {
       id: 'windsurf',
-      name: 'Windsurf',
-      detectDir: path.join(homeDir, '.codeium', 'windsurf'),
-      configPath: path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json'),
+      name: 'Devin Desktop',
+      detectDir: path.join(homeDir, '.config', 'devin'),
+      detectDirs: [
+        path.join(homeDir, '.config', 'devin'),
+        path.join(homeDir, '.codeium', 'windsurf'),
+      ],
+      configPath: path.join(homeDir, '.config', 'devin', 'mcp_config.json'),
       format: 'json-mcpServers',
       mcp: true,
       hooks: false,
-      captureHook: true,
-      captureEvent: 'post_cascade_response_with_transcript',
-      captureConfigPath: path.join(homeDir, '.codeium', 'windsurf', 'hooks.json'),
+      // Runner-side captured-source id differs from the registry id (this
+      // entry keeps id:'windsurf' for ledger continuity) — the poll adapter
+      // scripts/sources/devin.js is source id 'devin'. Documentary only:
+      // no captureHook on this entry means nothing currently reads sourceId
+      // for it (the poll sweep pairs by each adapter's own detect(), not by
+      // this registry), but it keeps the mapping visible for a future
+      // reader, same convention as codex ('codex' → sourceId 'codex-cli').
+      sourceId: 'devin',
     },
     {
       id: 'codex',
@@ -444,6 +477,28 @@ function detectClients(homeDir, opts = {}) {
     (c.detectFiles || []).some((p) => fs.existsSync(p)));
 }
 
+/**
+ * CLI-CAPTURE-MODE-DISAGREE: single source of truth for "does this client
+ * get an automatic session-capture hook wired" — Claude Code's SessionEnd
+ * hook (`hooks:true`) or a UC-1 capture hook (`captureHook:true`) for the
+ * seven other hook clients (cursor, windsurf, codex, gemini-cli, antigravity,
+ * factory, copilot-cli). Before this helper existed, `auxilo setup`'s
+ * detected-clients screen checked `c.hooks` alone (bin/auxilo-cli.js's
+ * `cmdSetup`), so it printed "(MCP)" for all seven captureHook clients even
+ * though setup wires their capture hook a few steps later — while
+ * `auxilo status` (`cmdStatus`) already filtered on `c.captureHook` and got
+ * it right. Both screens must call this one function (see
+ * test/cli-capture-mode-parity.test.js) so they can never disagree again.
+ * Same predicate `test/ext-gate-closure.test.js` already uses independently
+ * (`c.captureHook || c.hooks`) to enumerate hook clients.
+ *
+ * @param {object} client  A clientRegistry() / detectClients() entry.
+ * @returns {boolean}
+ */
+function clientHasCaptureHookMode(client) {
+  return Boolean(client && (client.hooks || client.captureHook));
+}
+
 // ─── MCP registration (spec §LW-12 step 1) ──────────────────────────────────
 
 /**
@@ -1674,13 +1729,17 @@ function patchJsonHookConfig(configPath, mutate) {
  * shim is handled by registerCaptureHook). Keyed by registry id.
  */
 const CAPTURE_WRITERS = Object.freeze({
-  // ~/.cursor/hooks.json — {"version":1,"hooks":{"sessionEnd":[{"command":...}]}}
+  // ~/.cursor/hooks.json — {"version":1,"hooks":{"stop":[{"command":...}]}}
   // version:1 is REQUIRED by Cursor; other events/entries preserved.
+  // CURSOR-STOP-HOOK (0.9.19): was hooks.sessionEnd — that event never
+  // actually fires while shell-exec is alive (see the captureEvent comment
+  // on the cursor registry entry above); the working event is 'stop', so
+  // the key written here must match.
   'cursor': (client, homeDir, shimPath) => {
     const changed = patchJsonHookConfig(client.captureConfigPath, (config) => {
       if (config.version === undefined) config.version = 1;
       if (!config.hooks || typeof config.hooks !== 'object') config.hooks = {};
-      config.hooks.sessionEnd = patchFlatHookArray(config.hooks.sessionEnd, shimPath);
+      config.hooks.stop = patchFlatHookArray(config.hooks.stop, shimPath);
     });
     return { changed };
   },
@@ -2318,6 +2377,7 @@ module.exports = {
   RUNNER_STACK,
   clientRegistry,
   detectClients,
+  clientHasCaptureHookMode,
   registerMcp,
   mcpRegistrationPresent,
   mcpPinnedVersion,

package/mcp-server.js

@@ -198,7 +198,7 @@ async function postBulkChunks(headers, decisions) {
 }
 
 const server = new Server(
-  { name: 'auxilo', version: '0.9.18' },
+  { name: 'auxilo', version: '0.9.19' },
   {
     capabilities: { tools: {} },
     instructions: `You are connected to Auxilo, a knowledge marketplace where AI agents buy and sell operational learnings.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auxilo-mcp",
-  "version": "0.9.18",
+  "version": "0.9.19",
   "mcpName": "io.github.silent-architects/auxilo",
   "description": "MCP server for Auxilo. Your agent stops solving the same problem twice: auto-extracted learnings, free self-unlocks, and earnings when other agents unlock yours.",
   "main": "mcp-server.js",

package/scripts/extract-local.js

@@ -648,11 +648,18 @@ const EXTRACTABLE_SOURCE_IDS = Object.freeze([
   'continue',
   'copilot',
   'cursor',
+  // DEVIN-RENAME (0.9.19): 'windsurf' → 'devin' — the windsurf registry
+  // client (id kept for ledger continuity) dropped its capture hook in
+  // favor of scripts/sources/devin.js's poll adapter, whose static id is
+  // 'devin'. This list is the union of adapter ids (scripts/sources/*.js)
+  // and installer hook-client source ids (test/ext-gate-closure.test.js is
+  // the authority) — devin.js contributes 'devin' via the adapter side now
+  // that windsurf no longer contributes 'windsurf' via the hook side.
+  'devin',
   'factory',
   'gemini-cli',
   'openclaw',
   'roo-code',
-  'windsurf',
 ]);
 
 // Gate-A 2026-09-05: the exported set is IMMUTABLE. It stays a real Set (same

package/scripts/sources/devin.js

@@ -0,0 +1,303 @@
+/**
+ * scripts/sources/devin.js — Devin Desktop Transcript Source (BUILD-SPEC-0919)
+ *
+ * Best-effort UC-3 poll adapter, modeled on scripts/sources/codex-cli.js.
+ * Replaces the pre-0.9.19 `windsurf` capture HOOK (the legacy
+ * `post_cascade_response_with_transcript` event, VERIFIED to deliver
+ * `tool_info:null` — useless) — Devin Desktop drops the hook entirely
+ * (lib/installer.js clientRegistry `windsurf` entry) and this poll adapter
+ * covers it instead.
+ *
+ * STORE (verified against a live install 2026-09-09):
+ *   ~/Library/Application Support/Devin/User/acp-messages/<session-uuid>.db
+ *   SQLite, schema: messages(position INTEGER PRIMARY KEY, kind TEXT NOT NULL,
+ *   payload TEXT NOT NULL) + meta(key TEXT PRIMARY KEY, value TEXT NOT NULL).
+ *   `.db-wal` / `.db-shm` siblings exist alongside an actively-open session —
+ *   we only ever glob `*.db` and open read-only, which is safe to do
+ *   concurrently with Devin's own WAL-mode writer.
+ *
+ * CRITICAL FILTER: many DBs in this directory are SUB-AGENT sessions —
+ * agent_message/agent_thought/tool_call rows only, never a user_message. An
+ * agent-only DB would yield an assistant-only transcript, so discoverSessions
+ * opens each candidate and skips any DB with zero `user_message` rows.
+ *
+ * PAYLOAD SHAPE (verified): each `messages.payload` is JSON
+ *   {"kind":"user_message"|"agent_message","content":[{"sessionUpdate":
+ *   "user_message_chunk"|"agent_message_chunk","content":{"type":"text",
+ *   "text":"..."}}, ...]}
+ *   A short message is one chunk; a long agent_message can be split into
+ *   dozens of small streaming deltas that must be concatenated IN ORDER
+ *   (join, not newline-join) to reconstruct the full text.
+ *
+ * SQLITE READ STRATEGY: PRIMARY `node:sqlite` (DatabaseSync, readOnly) —
+ * experimental, present on Node >=22.5, guarded in try/catch since it is
+ * absent on older runtimes. FALLBACK: the system `sqlite3` binary via
+ * `spawnSync(...,'-readonly','-json',...)`. When NEITHER is available,
+ * discoverSessions returns [] and logs one best-effort line — never throws.
+ * No new package.json dependency (no better-sqlite3).
+ *
+ * MODEL PROVENANCE: the store does not record which model produced the
+ * conversation — neither `meta` (schema_version/info/message_count) nor any
+ * per-message `payload` carries it. `meta.info` DOES carry a config-options
+ * UI schema that happens to include a "model" *setting* (e.g. the currently
+ * selected model in Devin's own settings panel at snapshot time) — that is
+ * an app-preference snapshot, not a per-message attribution, and using it
+ * would be exactly the kind of guess this field exists to forbid. Every
+ * emitted session is stamped `model_provider: 'unknown'`, never inferred.
+ *
+ * @module sources/devin
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+const { TranscriptSource } = require('./source.interface');
+
+// Guarded require: node:sqlite is experimental and absent on Node <22.5.
+let NODE_SQLITE = null;
+try {
+  // eslint-disable-next-line global-require
+  NODE_SQLITE = require('node:sqlite');
+} catch {
+  NODE_SQLITE = null;
+}
+
+// Cached presence probe for the system `sqlite3` binary (one spawnSync per
+// process, not per file/session).
+let _cliProbed = false;
+let _cliAvailable = false;
+function sqliteCliAvailable() {
+  if (_cliProbed) return _cliAvailable;
+  _cliProbed = true;
+  try {
+    const res = spawnSync('sqlite3', ['-version'], { encoding: 'utf8', timeout: 5000 });
+    _cliAvailable = !res.error && res.status === 0;
+  } catch {
+    _cliAvailable = false;
+  }
+  return _cliAvailable;
+}
+
+/** True when either read path could plausibly open a database. */
+function hasSqliteAccess() {
+  return Boolean(NODE_SQLITE) || sqliteCliAvailable();
+}
+
+/**
+ * Query `sql` (no params — every caller here uses a fixed literal, no user
+ * input) against a readonly-opened sqlite db. Tries node:sqlite first, then
+ * the `sqlite3 -json` CLI. Returns an array of row objects, or `null` when
+ * the file could not be queried at all (missing, corrupt, locked mid-write
+ * in a way that defeats even WAL-mode readers, or neither read method
+ * available). Callers treat `null` as "skip this file" — this function
+ * itself never throws.
+ *
+ * @param {string} dbPath
+ * @param {string} sql
+ * @returns {Array<object>|null}
+ */
+function queryRows(dbPath, sql) {
+  if (NODE_SQLITE) {
+    let db = null;
+    try {
+      db = new NODE_SQLITE.DatabaseSync(dbPath, { readOnly: true });
+      return db.prepare(sql).all();
+    } catch {
+      // Fall through to the CLI fallback below.
+    } finally {
+      if (db) {
+        try { db.close(); } catch { /* best-effort */ }
+      }
+    }
+  }
+  if (sqliteCliAvailable()) {
+    try {
+      const res = spawnSync('sqlite3', ['-readonly', '-json', dbPath, sql], {
+        encoding: 'utf8',
+        timeout: 15000,
+      });
+      if (res.error || res.status !== 0) return null;
+      const trimmed = (res.stdout || '').trim();
+      if (!trimmed) return [];
+      const parsed = JSON.parse(trimmed);
+      return Array.isArray(parsed) ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+/** True when the db at `dbPath` contains at least one user_message row. */
+function hasUserMessage(dbPath, queryRowsFn) {
+  const rows = queryRowsFn(dbPath, "SELECT 1 AS x FROM messages WHERE kind = 'user_message' LIMIT 1");
+  return Array.isArray(rows) && rows.length > 0;
+}
+
+/**
+ * Reassemble a message's full text by concatenating (NOT newline-joining)
+ * `chunk.content.text` across the payload's `content[]` streaming-chunk
+ * array, in order. A chunk missing a string `.content.text` contributes
+ * nothing (never throws on shape drift).
+ */
+function textFromChunks(content) {
+  if (!Array.isArray(content)) return '';
+  let text = '';
+  for (const chunk of content) {
+    if (chunk && chunk.content && typeof chunk.content.text === 'string') {
+      text += chunk.content.text;
+    }
+  }
+  return text;
+}
+
+class DevinSource extends TranscriptSource {
+  static id = 'devin';
+  static displayName = 'Devin Desktop';
+  static version = '1.0.0';
+
+  constructor(config = {}) {
+    super(config);
+    const homeDir = config.homeDir || os.homedir();
+    this.acpDir = config.acpDir ||
+      path.join(homeDir, 'Library', 'Application Support', 'Devin', 'User', 'acp-messages');
+    // Test seams (spec: "(can stub)") — default to the real implementations
+    // above. Injecting these lets tests exercise the discovery filter and
+    // the streaming-chunk reassembly against fixture data, and simulate the
+    // "neither sqlite method available" best-effort path, all without
+    // touching the module-level require/spawnSync probes.
+    this._queryRows = config.queryRows || queryRows;
+    this._hasSqliteAccess = config.hasSqliteAccess || hasSqliteAccess;
+  }
+
+  async detect() {
+    try {
+      return fs.statSync(this.acpDir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  async discoverSessions({ since } = {}) {
+    let entries;
+    try {
+      entries = fs.readdirSync(this.acpDir);
+    } catch {
+      return [];
+    }
+    // Glob *.db only — NOT the -wal/-shm siblings of an actively-open session.
+    const dbFiles = entries.filter((f) => f.endsWith('.db'));
+    if (dbFiles.length === 0) return [];
+
+    if (!this._hasSqliteAccess()) {
+      this._logNoSqliteAccess();
+      return [];
+    }
+
+    const parsedSince = since ? Date.parse(since) : 0;
+    const sinceMs = Number.isFinite(parsedSince) ? parsedSince : 0;
+    const sessions = [];
+
+    for (const file of dbFiles) {
+      const filePath = path.join(this.acpDir, file);
+      let stat;
+      try {
+        stat = fs.statSync(filePath);
+        if (!stat.isFile()) continue;
+      } catch {
+        continue; // a session db can disappear while the sweep walks
+      }
+      if (stat.mtimeMs <= sinceMs) continue;
+      // CRITICAL FILTER: agent-only (sub-agent) DBs carry zero user_message
+      // rows and would yield an assistant-only transcript — skip them.
+      if (!hasUserMessage(filePath, this._queryRows)) continue;
+      sessions.push({
+        sessionId: path.basename(file, '.db'),
+        path: filePath,
+        mtime: stat.mtime.toISOString(),
+        bytes: stat.size,
+      });
+    }
+
+    return sessions.sort((a, b) =>
+      Date.parse(a.mtime) - Date.parse(b.mtime) || a.path.localeCompare(b.path)
+    );
+  }
+
+  async readSession(sessionRef) {
+    try {
+      return this._readSession(sessionRef);
+    } catch {
+      // Adapter contract is never-throw (matches codex-cli.js Gate-A F-A):
+      // an unexpected shape refuses the whole session rather than escaping
+      // into the runner as a failed read.
+      return null;
+    }
+  }
+
+  _readSession(sessionRef) {
+    const filePath = sessionRef && sessionRef.path;
+    if (!filePath) return null;
+
+    const rows = this._queryRows(
+      filePath,
+      "SELECT position, kind, payload FROM messages WHERE kind IN ('user_message','agent_message') ORDER BY position"
+    );
+    if (!Array.isArray(rows)) return null; // unreadable/unqueryable — best-effort skip, not a failure
+
+    const turns = [];
+    for (const row of rows) {
+      let payload;
+      try {
+        payload = JSON.parse(row.payload);
+      } catch {
+        continue; // one malformed row is ignored, not fatal to the session
+      }
+      const text = textFromChunks(payload && payload.content);
+      if (!text) continue;
+      const label = row.kind === 'user_message' ? '[user]' : '[assistant]';
+      turns.push(`${label}: ${text}`);
+    }
+
+    if (turns.length === 0) return null;
+
+    return {
+      transcript: turns.join('\n\n'),
+      metadata: {
+        sessionId: sessionRef.sessionId,
+        source: 'devin',
+        mtime: sessionRef.mtime,
+        bytes: sessionRef.bytes,
+        // MODEL PROVENANCE: never inferred — see module header. Stamped
+        // explicitly rather than omitted so the field's absence is never
+        // mistaken for an oversight.
+        model_provider: 'unknown',
+      },
+    };
+  }
+
+  /** Best-effort, never-throw single log line (spec: "logs one best-effort line"). */
+  _logNoSqliteAccess() {
+    try {
+      process.stderr.write(
+        '[devin] no SQLite access available (node:sqlite absent and sqlite3 CLI not found) — Devin capture skipped this sweep\n'
+      );
+    } catch {
+      /* best-effort */
+    }
+  }
+
+  async registerSessionEndHook(cb) {
+    return null; // poll-only source — no live hook (see module header)
+  }
+}
+
+module.exports = {
+  DevinSource,
+  hasSqliteAccess,
+  queryRows,
+  textFromChunks,
+};