auxilo-mcp 0.9.17 → 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})`);
   });
 
@@ -586,7 +595,7 @@ async function cmdStatus() {
     );
     if (autoupdateLine) console.log(autoupdateLine);
   }
-  console.log(extractionProviderLine(await providers.resolveProvider({})));
+  console.log(extractionProviderLine(lastRecordedProviderResolution()));
   // Lazy require: scripts/runner.js is a heavier module (sources, sensitivity
   // filter, ops-alert) than this one status line needs at require-time for
   // every CLI invocation.
@@ -625,18 +634,58 @@ function runnerSkewLine(skew) {
  */
 const CLI_CLEAN_LANE_CALIBRATED_PROVIDERS = ['claude-code'];
 
+/**
+ * EXTRACTION-MODEL-PROVENANCE (PUNCH-LIST P1): `auxilo status` used to feed
+ * extractionProviderLine() a LIVE `providers.resolveProvider({})` call — a
+ * fresh detect() answering "what would run right now" (and, on a full scan,
+ * capable of writing ~/.auxilo/providers.json's `selected` field as a side
+ * effect of a status check), not "what actually ran". This function replaces
+ * that with two read-only, no-detect sources of TRUTH, in priority order:
+ * (1) AUXILO_EXTRACTION_PROVIDER, if set, is a certain fact about the
+ *     current session's config — reading it is not a guess — validated
+ *     against providers.PROVIDER_ORDER exactly as resolveProvider() itself
+ *     validates an override, without calling it.
+ * (2) Otherwise, providers.json's `selected` field — the LAST provider a
+ *     genuine resolveProvider() full-scan actually chose and persisted
+ *     (scripts/providers/index.js's persistSelected(), only ever called
+ *     after a real detect() succeeded) — read here with a plain
+ *     fs.readFileSync, no detect() invoked, no possibility of writing.
+ * Neither source can misrepresent "would run" as "ran": (1) is what WILL
+ * run (an explicit operator override, not a probe), and (2) is what was
+ * last recorded to have been selected, honestly labeled as such below.
+ * `{ok:false}` (shown as "no recorded provider selection yet") when neither
+ * source has an answer — e.g. a fresh install that has never extracted.
+ */
+function lastRecordedProviderResolution() {
+  const override = process.env.AUXILO_EXTRACTION_PROVIDER;
+  if (override) {
+    if (providers.PROVIDER_ORDER.includes(override)) return { ok: true, id: override };
+    return {
+      ok: false,
+      reason: `AUXILO_EXTRACTION_PROVIDER="${override}" is not a known provider (expected one of: ${providers.PROVIDER_ORDER.join(', ')})`,
+    };
+  }
+  try {
+    const raw = fs.readFileSync(providers.PROVIDERS_STATE_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    const id = parsed && typeof parsed === 'object' && typeof parsed.selected === 'string' ? parsed.selected : null;
+    if (id) return { ok: true, id };
+  } catch { /* no recorded selection yet, or the file is unreadable/corrupt */ }
+  return { ok: false, reason: 'no recorded provider selection yet' };
+}
+
 /**
  * EXTRACT-PER-CLIENT W1 PART A/C — one unconditional line naming which
- * extraction model provider resolves, why (env override vs auto-detected),
- * and (PART C) whether that provider's submissions can reach the clean-lane
- * auto-publish path at all (server-side gate: lib/clean-lane.js's
- * CLEAN_LANE_CALIBRATED_PROVIDERS, mirrored above).
+ * extraction model provider resolves, why (env override vs last recorded
+ * selection), and (PART C) whether that provider's submissions can reach
+ * the clean-lane auto-publish path at all (server-side gate:
+ * lib/clean-lane.js's CLEAN_LANE_CALIBRATED_PROVIDERS, mirrored above).
  */
 function extractionProviderLine(resolution) {
   if (resolution && resolution.ok) {
     const via = process.env.AUXILO_EXTRACTION_PROVIDER
       ? 'env override AUXILO_EXTRACTION_PROVIDER'
-      : 'auto-detected';
+      : 'last recorded selection';
     const calibration = CLI_CLEAN_LANE_CALIBRATED_PROVIDERS.includes(resolution.id)
       ? 'clean-lane calibrated'
       : 'review-lane only';
@@ -1639,6 +1688,7 @@ module.exports = {
   parseFlags,
   runnerSkewLine,
   extractionProviderLine,
+  lastRecordedProviderResolution,
   resolveBaseUrl,
   shortFlags,
   groupSummaryRows,

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.17' },
+  { 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.17",
+  "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

@@ -400,37 +400,37 @@ function judgeUsage(usage, prompt, completion) {
 
 /**
  * PART C — resolve the extraction_model identity for a runModel result.
- * Prefers the additive `identity` field a provider's runModel result may
- * carry. Current state (post Gate-A item a): byo-key.js always sets one
- * ({provider:'byo-key', model, version:null, vendor}); codex-cli.js sets one
- * on success ({provider:'codex-cli', model:null, version:<codex --version>,
- * vendor:null} — its result also carries the same object under the
- * deprecated `extraction_model` alias, kept for one release only for
- * test/codex-cli-provider.test.js). claude-code.js is the one provider that
- * still sets no `identity` on its result — that's the case this function's
- * fallback exists for: it re-resolves via providers.resolveProvider() and
- * stamps {provider: resolved.id, model: null, version: null, vendor: null},
- * so every provider gets SOME stamp, never silently none. That re-resolution
- * walks scripts/providers/index.js's PROVIDER_ORDER (claude-code →
- * codex-cli → byo-key); resolveProvider/runModel there fall through from one
- * provider to the next only on a NON_RETRYABLE_FOR_THIS_PROVIDER reasonCode
- * (unauthenticated, not installed, a billing helper configured, an
- * unconfigured BYO key, or an unsafe providers.json mode) — a provider that
- * merely failed once (a timeout, a model error) is not retried under a
- * different one. Best-effort throughout: a resolution failure here must
- * never block extraction itself.
+ *
+ * EXTRACTION-MODEL-PROVENANCE (PUNCH-LIST P1): this function used to fall
+ * back to a FRESH, INDEPENDENT providers.resolveProvider() call whenever the
+ * result carried no `identity` — a re-detect decoupled from which provider
+ * actually produced `runModelResult`, which is what "what would run now"
+ * answers, not "what ran". That re-resolve could also silently rewrite
+ * `~/.auxilo/providers.json` (resolveProvider's full-scan path calls
+ * persistSelected) from what should have been a read-only identity lookup.
+ * Both are gone. `identity` is now ALWAYS attached by
+ * scripts/providers/index.js's runModel() itself — centrally, because that
+ * registry is the only thing that knows which module it actually invoked
+ * for this call (see its withIdentity()/deriveIdentity() — claude-code's own
+ * cliVersion is used there when present, richer than the null/null/null
+ * triple this function used to guess). This function's job shrinks to: use
+ * the identity the result actually carries, or admit the honest
+ * `provider:'unknown'` when none exists (the `no-usable-provider` /
+ * bad-override-name aggregate failures — nothing actually ran to
+ * completion, so there is nothing to attribute). Never re-derives, never
+ * writes, never blocks extraction on failure.
  */
-async function resolveExtractionModelIdentity(runModelResult, opts) {
-  if (runModelResult && runModelResult.identity && typeof runModelResult.identity === 'object') {
+function resolveExtractionModelIdentity(runModelResult) {
+  if (
+    runModelResult
+    && runModelResult.identity
+    && typeof runModelResult.identity === 'object'
+    && typeof runModelResult.identity.provider === 'string'
+    && runModelResult.identity.provider
+  ) {
     return runModelResult.identity;
   }
-  try {
-    const resolved = await providers.resolveProvider(opts);
-    if (resolved && resolved.ok && resolved.id) {
-      return { provider: resolved.id, model: null, version: null, vendor: null };
-    }
-  } catch { /* identity is best-effort; never block extraction on it */ }
-  return null;
+  return { provider: 'unknown', model: null, version: null, vendor: null };
 }
 
 /**
@@ -456,7 +456,7 @@ async function defaultInvokeModel(transcript, invokeOpts, opts) {
     reason: result.reason,
     reasonCode: result.reasonCode,
     authStatus: result.authStatus,
-    extractionModel: await resolveExtractionModelIdentity(result, opts),
+    extractionModel: resolveExtractionModelIdentity(result),
     ...(result.authDiscrepancy !== undefined && { authDiscrepancy: result.authDiscrepancy }),
     // EXTRACTION-RUN-LOG (0.9.15): additive passthrough for the one-line-per-run
     // provider summary logged at the end of extractLocally() below. Only
@@ -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
@@ -704,12 +711,53 @@ function formatArgvForLog(argv) {
  * (spawned) this run, not whether it succeeded — a spawn that ran and then
  * hit a model error still counts as "ran" (it happened; the failure is in
  * `reason`, not in whether isolation applied). `hooks` is `claude-code`-
- * specific: 'isolated' whenever a claude-code spawn this run carried
- * --setting-sources (the only state a spawn can be in per the fail-closed
- * gate in scripts/providers/claude-code.js — it never spawns without the
- * flag), 'unsupported' when the CLI was found not to support the flag at
- * all, 'n/a' for a non-claude-code provider (codex-cli/byo-key isolate by a
- * different mechanism entirely, out of this row's scope).
+ * specific and EVIDENCE-DERIVED (EXTRACT-LOG-HOOKS-EVIDENCE, PUNCH-LIST P2):
+ * it reads the argv this run actually captured rather than inferring
+ * isolation from the provider name plus the absence of a reason code —
+ * 'isolated' ONLY when that argv literally contains --setting-sources (the
+ * flag scripts/providers/claude-code.js's fail-closed gate never spawns
+ * without), 'unsupported' when the CLI was found not to support the flag at
+ * all (existing reason-code path, unchanged), 'unknown' when no argv was
+ * captured this run (finder skipped pre-spawn, or the run that actually
+ * produced this result fell through to a different/no provider — see the
+ * EXTRACT-LOG-HOOKS-EVIDENCE root-cause note below), and 'n/a' for a
+ * non-claude-code provider (codex-cli/byo-key isolate by a different
+ * mechanism entirely, out of this row's scope). Never 'isolated' without an
+ * argv carrying the flag in hand — a safety claim needs evidence, not an
+ * absence of contrary evidence.
+ *
+ * Root cause of the missing-argv runs (EXTRACT-LOG-HOOKS-EVIDENCE
+ * investigation): claude-code.js's own runExtractMode() never omits argv on
+ * a claude-code result that actually reached this line — every return after
+ * `const argv = EXTRACT_MODE_ARGV` carries it, and the two pre-spawn
+ * short-circuits that don't (cached --setting-sources-unsupported,
+ * cli-unauthenticated) both carry reasonCodes already in
+ * PRE_SPAWN_SKIP_REASON_CODES, so they render finder=skipped, not ran. The
+ * observed defect lines (finder=ran, flags=n/a) come from a DIFFERENT case:
+ * scripts/providers/index.js's runModel() falls through from claude-code to
+ * the next configured provider (e.g. codex-cli) whenever claude-code's own
+ * attempt fails with a NON_RETRYABLE_FOR_THIS_PROVIDER reasonCode, and
+ * returns that OTHER provider's result directly when it stops there. That
+ * provider's result carries no `argv` field at all (argv is a
+ * claude-code-only concept), so there is no shipped argv being hidden here —
+ * 'unknown' remains the correct, honest `hooks` value regardless of which
+ * provider is named.
+ *
+ * EXTRACTION-MODEL-PROVENANCE (PUNCH-LIST P1) closed the mismatch this
+ * docblock used to describe as a known, deferred gap: a fallthrough
+ * provider's result used to reach this function carrying no `identity` on
+ * failure (codex-cli/byo-key only self-stamped on success), so
+ * resolveExtractionModelIdentity()'s old fallback re-resolved the label via
+ * a FRESH, INDEPENDENT providers.resolveProvider() call — decoupled from
+ * which provider's runModel() result was actually being logged, and prone to
+ * landing back on 'claude-code' (its detect() only checks the
+ * billing-helper gate + auth status, not whether the earlier attempt
+ * actually spawned). That fallback is gone. `identity` is now attached
+ * centrally by providers/index.js's runModel() to EVERY result it returns —
+ * success or failure, fallthrough or not — because that registry alone
+ * knows which module it actually invoked for a given attempt. The line this
+ * function renders now names the provider that actually ran (or 'unknown'
+ * only when nothing did), not a guess.
  */
 function logProviderRunSummary(opts, runId, modelResult, judged) {
   try {
@@ -725,8 +773,11 @@ function logProviderRunSummary(opts, runId, modelResult, judged) {
     const cliVersion = modelResult.cliVersion || (judged && judged.judgeCliVersion) || null;
     const finderUnsupported = modelResult.reasonCode === 'cli-settings-isolation-unsupported';
     const judgeUnsupported = Boolean(judged && judged.judgeReasonCode === 'cli-settings-isolation-unsupported');
+    const hasSettingSourcesArgv = Array.isArray(argv) && argv.includes('--setting-sources');
     const hooks = provider === 'claude-code'
-      ? ((finderUnsupported || judgeUnsupported) ? 'unsupported' : 'isolated')
+      ? ((finderUnsupported || judgeUnsupported)
+        ? 'unsupported'
+        : (hasSettingSourcesArgv ? 'isolated' : 'unknown'))
       : 'n/a';
     log(
       `[providers] run=${runId || 'unknown'} provider=${provider} cli=${cliVersion || '-'} ` +
@@ -875,4 +926,7 @@ module.exports = {
   resolveClaudeBin: claudeCodeProvider.resolveClaudeBin,
   // EXTRACTION-RUN-LOG (0.9.15) — exported for direct unit coverage.
   formatArgvForLog, logProviderRunSummary, PRE_SPAWN_SKIP_REASON_CODES,
+  // EXTRACTION-MODEL-PROVENANCE (PUNCH-LIST P1) — exported for direct unit
+  // coverage of the "never guess, fail closed to unknown" contract.
+  resolveExtractionModelIdentity,
 };

package/scripts/providers/index.js

@@ -245,6 +245,92 @@ const NON_RETRYABLE_FOR_THIS_PROVIDER = new Set([
   'cli-settings-isolation-unsupported',
 ]);
 
+/**
+ * EXTRACTION-MODEL-PROVENANCE (PUNCH-LIST P1, follow-up to the
+ * EXTRACT-LOG-HOOKS-EVIDENCE row): `identity` on a runModel() result is
+ * provenance — a record of which provider actually produced this text — not
+ * a guess. It must never be re-derived after the fact from a fresh detect(),
+ * because a fresh detect() answers "what would run now", not "what ran".
+ * This registry is the only thing that KNOWS which module's runModel() it
+ * just invoked for a given attempt, so identity is enforced HERE, centrally,
+ * rather than trusted to per-provider convention (the gap this row closes:
+ * before this fix, a provider `ok:true` return that forgot to attach
+ * `identity` would silently fall through to extract-local.js's
+ * resolveExtractionModelIdentity() re-detecting via resolveProvider() —
+ * decoupled from which module actually ran).
+ */
+function hasUsableIdentity(identity) {
+  return Boolean(
+    identity
+    && typeof identity === 'object'
+    && typeof identity.provider === 'string'
+    && identity.provider
+  );
+}
+
+/**
+ * Derive an identity for the module actually invoked as `id`, used only when
+ * that module's own result didn't already carry one. The derivation differs
+ * by outcome, because a SUCCESS identity can reach a published learning and
+ * the clean-lane calibration gate, while a FAILURE identity is purely
+ * diagnostic (extract-local.js returns before stamping anything onto a
+ * candidate on `ok:false` — see its `:824-834`):
+ *
+ * - claude-code: always gets a real, provider-specific identity — it
+ *   already has `cliVersion` in hand on every returned result (success or
+ *   failure), richer than the null/null/null triple this used to guess, and
+ *   claude-code is the one provider documented to never self-stamp
+ *   `identity` at all, so this is filling a KNOWN, structural gap, not
+ *   papering over a violated contract.
+ * - Every other provider on a FAILURE: `{provider:id, model:null,
+ *   version:null, vendor:null}` — naming the module we actually invoked is
+ *   a plain structural fact (we chose to call it), not a guess, and it is
+ *   what lets the per-run `[providers]` log name the provider that actually
+ *   ran even when that provider's own failure return carries no identity
+ *   (codex-cli and byo-key only self-stamp on their SINGLE success return —
+ *   this is the exact fall-through failure case the investigation traced:
+ *   claude-code skipped, codex-cli ran and failed, no identity of its own,
+ *   the label used to be re-guessed as claude-code by the old fallback).
+ * - Every other provider on a SUCCESS: `{provider:'unknown', ...}` —
+ *   byo-key.js and codex-cli.js both self-stamp `identity` on their only
+ *   success return BY CONTRACT; a success with none means that contract was
+ *   violated, so this registry has no provider-reported basis for the
+ *   claim. Confidently naming the module here would look like provenance
+ *   without being backed by anything the provider itself reported — since
+ *   this stamp CAN reach a published learning, the fail-closed, honest
+ *   answer is 'unknown', never a guess dressed up as a fact.
+ */
+function deriveIdentity(id, result) {
+  if (id === 'claude-code') {
+    return {
+      provider: 'claude-code',
+      model: null,
+      version: (result && result.cliVersion) || null,
+      vendor: 'anthropic',
+    };
+  }
+  if (!(result && result.ok)) {
+    return { provider: id, model: null, version: null, vendor: null };
+  }
+  return { provider: 'unknown', model: null, version: null, vendor: null };
+}
+
+/**
+ * Attach a derived identity to `result` IFF it doesn't already carry a
+ * usable one — never overwrites a provider-reported identity (e.g.
+ * byo-key's real model name). Applied to every result this registry
+ * returns, success or failure, so the per-run `[providers]` log
+ * (scripts/extract-local.js's logProviderRunSummary) names the provider
+ * that actually ran even on a failure — that is the fall-through failure
+ * case this row's investigation traced (claude-code skipped, codex-cli ran
+ * and failed with no identity of its own, the stamp used to be re-guessed
+ * as claude-code by the caller).
+ */
+function withIdentity(id, result) {
+  if (hasUsableIdentity(result && result.identity)) return result;
+  return { ...result, identity: deriveIdentity(id, result) };
+}
+
 /**
  * runModel(opts) — resolve a starting provider via resolveProvider(), then
  * walk PROVIDER_ORDER from there, calling each candidate's OWN runModel()
@@ -262,7 +348,9 @@ const NON_RETRYABLE_FOR_THIS_PROVIDER = new Set([
  * as-is. When every provider tried is exhausted, returns reasonCode
  * 'no-usable-provider' with a bounded summary of every provider's reason in
  * `reason` (no secrets — each provider's own reason string is already
- * secret-free by contract). Never throws.
+ * secret-free by contract) and NO identity — nothing actually ran to
+ * completion, so the caller (extract-local.js) stamps `provider:'unknown'`
+ * rather than have this registry guess one. Never throws.
  */
 async function runModel(opts = {}) {
   const mode = opts.mode === 'judge' ? 'judge' : 'extract';
@@ -281,7 +369,8 @@ async function runModel(opts = {}) {
         authStatus: 'unknown',
       };
     }
-    return resolved.module.runModel({ ...opts, mode });
+    const result = await resolved.module.runModel({ ...opts, mode });
+    return withIdentity(resolved.id, result);
   }
 
   const log = typeof opts.log === 'function' ? opts.log : console.error;
@@ -293,7 +382,8 @@ async function runModel(opts = {}) {
   for (const id of order) {
     const mod = PROVIDERS[id];
     // eslint-disable-next-line no-await-in-loop
-    const result = await mod.runModel({ ...opts, mode });
+    const rawResult = await mod.runModel({ ...opts, mode });
+    const result = withIdentity(id, rawResult);
     if (result.ok) return result;
     attempts.push({ id, reasonCode: result.reasonCode, reason: result.reason });
     if (!NON_RETRYABLE_FOR_THIS_PROVIDER.has(result.reasonCode)) {

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,
+};