auxilo-mcp 0.9.2 → 0.9.4

package/scripts/runner.js

@@ -36,11 +36,9 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
+const { spawn } = require('child_process');
 const { scanText, SENSITIVITY_FILTER_VERSION } = require('../lib/sensitivity-filter.js');
-const { ClaudeCodeSource } = require('./sources/claude-code.js');
-const { OpenClawSource } = require('./sources/openclaw.js');
-const { GeminiCliSource } = require('./sources/gemini-cli.js');
-const { AntigravitySource } = require('./sources/antigravity.js');
+const { TranscriptSource } = require('./sources/source.interface.js');
 const { GenericJsonlSource } = require('./sources/generic-jsonl.js');
 
 // ─── Constants ──────────────────────────────────────────────────────────────
@@ -87,14 +85,42 @@ const PENDING_DIR = path.join(AUXILO_DIR, 'pending-learnings');
 const LEDGER_PATH = path.join(AUXILO_DIR, 'ledger.json');
 const LOG_PATH = path.join(AUXILO_DIR, 'extract.log');
 
-// ─── Source Registry (§4.4) ─────────────────────────────────────────────────
+// ─── Source Registry (§4.4 / UC-3 dynamic) ──────────────────────────────────
+//
+// UC-3: the registry is built by enumerating scripts/sources/*.js — a new
+// adapter self-registers by dropping a file in that exports a TranscriptSource
+// subclass with a static `id`. Excluded by name: the abstract interface, and
+// generic-jsonl (the config-instantiated single-file FALLBACK, not a
+// discoverable source — its detect() is deliberately inert).
+//
+// Per-file try/catch: one broken adapter must never kill the runner
+// (fail-silent degradation, UC §5). Duplicate ids: first file wins
+// (alphabetical), so a rogue copy can't shadow an established adapter.
 
-const SOURCES = [
-  ClaudeCodeSource,
-  OpenClawSource,
-  GeminiCliSource,
-  AntigravitySource,
-];
+const SOURCE_REGISTRY_EXCLUDE = new Set(['source.interface.js', 'generic-jsonl.js']);
+
+function loadSources() {
+  const dir = path.join(__dirname, 'sources');
+  const classes = [];
+  let files = [];
+  try {
+    files = fs.readdirSync(dir).filter(f => f.endsWith('.js') && !SOURCE_REGISTRY_EXCLUDE.has(f)).sort();
+  } catch { return classes; }
+  for (const f of files) {
+    let mod;
+    try { mod = require(`./sources/${f}`); } catch { continue; } // broken adapter — skip silently
+    for (const exported of Object.values(mod || {})) {
+      if (typeof exported !== 'function') continue;
+      if (!(exported.prototype instanceof TranscriptSource)) continue;
+      if (!exported.id || exported.id === 'abstract') continue;
+      if (classes.some(c => c.id === exported.id)) continue;
+      classes.push(exported);
+    }
+  }
+  return classes;
+}
+
+const SOURCES = loadSources();
 
 async function enumerateActiveSources(filter) {
   const active = [];
@@ -233,32 +259,43 @@ function listPendingFiles() {
 
 // ─── Upload ─────────────────────────────────────────────────────────────────
 
-async function postExtract(transcript, sessionId, sourceType, _scrubReport) {
-  // CLIENT-SIDE extraction (2026-07-02). Server /extract is deprecated (410) — Auxilo
-  // does not pay to extract. The local model (via `claude -p`) extracts + self-screens
-  // the already-client-scrubbed transcript, and we submit finished learnings to /learn.
-  const { extractLocally } = require('./extract-local.js');
-  let learnings;
-  let skipped;
-  try {
-    ({ learnings, skipped } = await extractLocally(transcript, sourceType));
-  } catch (err) {
-    throw new Error(`Local extraction failed: ${err.message}`);
-  }
-  if (skipped) {
-    log(`[runner] ${skipped}`);
-    return { learnings_published: 0, learnings_rejected: 0, extraction_id: 'client-skip' };
-  }
+/**
+ * Submit finished learnings to POST /learn, classifying each response
+ * truthfully (P1-13b / SPEC3 A2):
+ *   2xx + status 'approved'        → published (seamless)
+ *   2xx + status 'pending_review'  → held (the contributor review queue)
+ *   anything else / network error  → rejected
+ *
+ * Every submission carries `submission_channel: 'extraction'` UNCONDITIONALLY.
+ * SPEC3 §3.2 trust analysis: the marker is a BRAKE, never a gas pedal — a
+ * pre-B1 server destructures known fields only and ignores it; a post-B1
+ * server uses it to HOLD extraction-channel items behind standing consent.
+ * Shipping it dark means the brake is in the field before scoring ever arms
+ * (see the AUXILO_SCORE_EXTRACTION sequencing constraint in extract-local.js).
+ *
+ * `quality_self_assessment` passes through spread-if-present — extract-local
+ * only attaches it when the A1 score gate is on.
+ *
+ * @param {Array<object>} learnings
+ * @param {string} sourceType
+ * @param {object} [opts]  { fetchImpl, baseUrl, apiKey } — injectable for tests
+ * @returns {Promise<{published:number, held:number, rejected:number}>}
+ */
+async function submitLearnings(learnings, sourceType, opts = {}) {
+  const fetchImpl = opts.fetchImpl || fetch;
+  const baseUrl = opts.baseUrl || BASE_URL;
+  const apiKey = opts.apiKey !== undefined ? opts.apiKey : API_KEY;
 
   let published = 0;
+  let held = 0;
   let rejected = 0;
   for (const l of learnings) {
     try {
-      const res = await fetch(`${BASE_URL}/learn`, {
+      const res = await fetchImpl(`${baseUrl}/learn`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
-          'X-API-Key': API_KEY,
+          'X-API-Key': apiKey,
           'Idempotency-Key': crypto.randomUUID(),
         },
         body: JSON.stringify({
@@ -269,16 +306,69 @@ async function postExtract(transcript, sessionId, sourceType, _scrubReport) {
           task_context: l.task_context,
           outcome: l.outcome,
           contributor_agent: `auxilo-hook/${sourceType}`,
+          submission_channel: 'extraction',
+          ...(l.quality_self_assessment && { quality_self_assessment: l.quality_self_assessment }),
         }),
       });
-      if (res.ok) published += 1;
-      else rejected += 1;
+      if (!res.ok) { rejected += 1; continue; }
+      let body = {};
+      try { body = await res.json(); } catch { /* tolerate non-JSON 2xx */ }
+      if (body && body.status === 'pending_review') held += 1;
+      else published += 1;
     } catch (_) {
       rejected += 1;
     }
   }
-  log(`[runner] client-side extraction: ${learnings.length} candidate(s), published=${published} rejected=${rejected}`);
-  return { learnings_published: published, learnings_rejected: rejected, extraction_id: `client-${sessionId}` };
+  return { published, held, rejected };
+}
+
+async function postExtract(transcript, sessionId, sourceType, _scrubReport) {
+  // CLIENT-SIDE extraction (2026-07-02). Server /extract is deprecated (410) — Auxilo
+  // does not pay to extract. The local model (via `claude -p`) extracts + self-screens
+  // the already-client-scrubbed transcript, and we submit finished learnings to /learn.
+  const { extractLocally } = require('./extract-local.js');
+  let learnings;
+  let skipped;
+  try {
+    ({ learnings, skipped } = await extractLocally(transcript, sourceType));
+  } catch (err) {
+    throw new Error(`Local extraction failed: ${err.message}`);
+  }
+  if (skipped) {
+    log(`[runner] ${skipped}`);
+    return { learnings_published: 0, learnings_held: 0, learnings_rejected: 0, extraction_id: 'client-skip' };
+  }
+
+  const { published, held, rejected } = await submitLearnings(learnings, sourceType);
+  // NOTE: token-free prose — the digest-parsed `published=`/`held=`/`rejected=`
+  // tokens live ONLY on the per-run caller log lines. This line previously
+  // carried `published=` too and the digest double-counted every extraction
+  // (its dedup only drops byte-identical lines). P1-13b.
+  log(`[runner] client-side extraction: ${learnings.length} candidate(s) → ${published} live, ${held} held for review, ${rejected} rejected`);
+  return { learnings_published: published, learnings_held: held, learnings_rejected: rejected, extraction_id: `client-${sessionId}` };
+}
+
+// ─── Held-items local notification (LW-18 layer 2) ──────────────────────────
+
+/**
+ * macOS notification when a run holds items for review: COUNT ONLY, no titles,
+ * no content (pending bodies are adversarial by assumption — LW-18 threat
+ * model). Fail-silent: darwin-only, detached osascript spawn, every error
+ * swallowed; a broken notifier must never fail the run. AUXILO_NO_NOTIFY=1
+ * disables (tests, headless CI).
+ */
+function notifyHeld(count) {
+  try {
+    if (!count || count <= 0) return;
+    if (process.platform !== 'darwin') return;
+    if (process.env.AUXILO_NO_NOTIFY === '1') return;
+    const msg = `${count} learning(s) held for your review — run npx auxilo review`;
+    const child = spawn('/usr/bin/osascript', [
+      '-e', `display notification ${JSON.stringify(msg)} with title "Auxilo"`,
+    ], { stdio: 'ignore', detached: true });
+    child.unref();
+    child.on('error', () => { /* fail-silent */ });
+  } catch { /* fail-silent */ }
 }
 
 // ─── Install Hooks (B15) ────────────────────────────────────────────────────
@@ -362,19 +452,38 @@ function installHooks() {
 // Renamed 2026-07-15: the original label carried a dead pre-Fly host prefix (legacy-label purge).
 const SWEEPER_LABEL = 'io.auxilo.sweeper';
 
+/**
+ * The sweeper copy manifest. Sources rows are DERIVED by enumerating
+ * scripts/sources/*.js (UC-3): a new adapter file is automatically installed —
+ * the d8c7099 bug class (adapter added, manifest not, installed sweepers crash
+ * with MODULE_NOT_FOUND) is now structurally impossible. Exported for the
+ * manifest-closure test in test/wave3-client-funnel.test.js.
+ */
+function sweeperManifest(repoRoot = path.resolve(__dirname, '..')) {
+  const sourceRows = [];
+  try {
+    for (const f of fs.readdirSync(path.join(repoRoot, 'scripts', 'sources')).filter(f => f.endsWith('.js')).sort()) {
+      sourceRows.push([`scripts/sources/${f}`, `scripts/sources/${f}`, 0o644]);
+    }
+  } catch { /* missing dir surfaces as missing-file errors below */ }
+  return [
+    ['scripts/auxilo-sweeper-wrapper.sh', 'auxilo-sweeper-wrapper.sh', 0o755],
+    ['scripts/runner.js', 'scripts/runner.js', 0o755],
+    ...sourceRows,
+    ['lib/sensitivity-filter.js', 'lib/sensitivity-filter.js', 0o644],
+    // Client-side extraction (2026-07-02) — required by the sweep path since /extract went 410.
+    // Missing from this manifest until 2026-07-19: installed sweepers crashed with
+    // "Cannot find module './extract-local.js'" while queue files were retained.
+    ['scripts/extract-local.js', 'scripts/extract-local.js', 0o644],
+  ];
+}
+
 function installSweeper() {
   const repoRoot = path.resolve(__dirname, '..');
   const binRoot = path.join(AUXILO_DIR, 'bin');
 
   // 1. Copy executable surface, preserving relative layout so requires resolve.
-  const filesToCopy = [
-    ['scripts/auxilo-sweeper-wrapper.sh', 'auxilo-sweeper-wrapper.sh', 0o755],
-    ['scripts/runner.js', 'scripts/runner.js', 0o755],
-    ['scripts/sources/source.interface.js', 'scripts/sources/source.interface.js', 0o644],
-    ['scripts/sources/claude-code.js', 'scripts/sources/claude-code.js', 0o644],
-    ['scripts/sources/openclaw.js', 'scripts/sources/openclaw.js', 0o644],
-    ['lib/sensitivity-filter.js', 'lib/sensitivity-filter.js', 0o644],
-  ];
+  const filesToCopy = sweeperManifest(repoRoot);
   for (const [src, dest, mode] of filesToCopy) {
     const srcPath = path.join(repoRoot, src);
     const destPath = path.join(binRoot, dest);
@@ -672,9 +781,19 @@ async function main() {
 
     let transcriptData;
     try {
-      transcriptData = await source.readSession(sessionRef);
+      // N1: capped read — the base-adapter path enforces AUXILO_MAX_SESSION_BYTES.
+      transcriptData = await source.readSessionCapped(sessionRef);
     } catch (err) {
-      // Fallback: treat the file as a plain pre-formatted transcript
+      if (err && err.code === 'SESSION_TOO_LARGE') {
+        // Oversize is a counted SKIP, and it must short-circuit BEFORE the raw
+        // readFileSync fallback below — that fallback is the exact unbounded
+        // read the cap exists to prevent.
+        console.error(`[runner] SKIPPED oversize session ${sessionRef.sessionId} (${err.bytes} bytes > cap ${err.maxBytes}; oversize_skipped=1)`);
+        log(`[runner] Skipped oversize session ${sessionRef.sessionId} (${err.bytes} bytes > cap ${err.maxBytes})`);
+        process.exit(0);
+      }
+      // Fallback: treat the file as a plain pre-formatted transcript. Safe to
+      // read raw here: the cap check above already passed (under-cap file).
       try {
         transcriptData = { transcript: fs.readFileSync(transcriptPath, 'utf-8') };
       } catch (e2) {
@@ -734,7 +853,8 @@ async function main() {
 
     try {
       const result = await postExtract(cleaned, sessionId, sourceType, report);
-      log(`[runner] ✓ published=${result.learnings_published || 0} rejected=${result.learnings_rejected || 0} ${DIGEST_ACCOUNT} (extraction: ${result.extraction_id})`);
+      log(`[runner] ✓ published=${result.learnings_published || 0} held=${result.learnings_held || 0} rejected=${result.learnings_rejected || 0} ${DIGEST_ACCOUNT} (extraction: ${result.extraction_id})`);
+      notifyHeld(result.learnings_held || 0); // LW-18 layer 2: count-only, fail-silent
       // Mark only after a successful upload so a failed POST can be retried.
       const ledger = loadLedger();
       ledgerMark(ledger, sourceType, sessionId, contentSha, sessionRef.mtime);
@@ -751,13 +871,15 @@ async function main() {
     const pending = listPendingFiles();
     log(`[runner] Flushing ${pending.length} pending queue file(s)...`);
     let flushed = 0;
+    let flushHeld = 0;
     for (const qf of pending) {
       try {
         const payload = JSON.parse(fs.readFileSync(qf, 'utf-8'));
         const result = await postExtract(
           payload.transcript, payload.sessionId, payload.source, payload.scrubReport
         );
-        log(`[runner] ✓ Flushed ${path.basename(qf)}: published=${result.learnings_published || 0} rejected=${result.learnings_rejected || 0} ${DIGEST_ACCOUNT}`);
+        log(`[runner] ✓ Flushed ${path.basename(qf)}: published=${result.learnings_published || 0} held=${result.learnings_held || 0} rejected=${result.learnings_rejected || 0} ${DIGEST_ACCOUNT}`);
+        flushHeld += result.learnings_held || 0;
         deleteQueueFile(qf);
         flushed++;
       } catch (err) {
@@ -765,6 +887,7 @@ async function main() {
       }
     }
     log(`[runner] Flush complete: ${flushed}/${pending.length} succeeded`);
+    notifyHeld(flushHeld); // LW-18 layer 2: count-only, fail-silent
     process.exit(0);
   }
 
@@ -779,7 +902,9 @@ async function main() {
   let totalDiscovered = 0;
   let totalProcessed = 0;
   let totalSkipped = 0;
+  let totalOversize = 0; // N1: oversize-cap skips (subset of totalSkipped)
   let totalFailed = 0;
+  let totalHeld = 0;
 
   for (const source of sources) {
     log(`[runner] Discovering sessions from ${source.label} (${source.type})...`);
@@ -804,11 +929,23 @@ async function main() {
     for (const sessionRef of sessions) {
       log(`[runner]   Processing ${sessionRef.sessionId} (${sessionRef.bytes} bytes)...`);
 
-      // Read transcript
+      // Read transcript (N1: capped — base-adapter path enforces
+      // AUXILO_MAX_SESSION_BYTES before any byte is read)
       let transcriptData;
       try {
-        transcriptData = await source.readSession(sessionRef);
+        transcriptData = await source.readSessionCapped(sessionRef);
       } catch (err) {
+        if (err && err.code === 'SESSION_TOO_LARGE') {
+          // Counted skip, never a failure. stderr so constrained-sweeper logs
+          // surface it; ledger-marked (probe-refused idiom) so an immutable
+          // oversize file is not re-announced every sweep.
+          totalOversize++;
+          totalSkipped++;
+          console.error(`[runner]   SKIPPED oversize session ${sessionRef.sessionId} (${err.bytes} bytes > cap ${err.maxBytes}; oversize_skipped=${totalOversize})`);
+          log(`[runner]   Skipped oversize session ${sessionRef.sessionId} (${err.bytes} bytes > cap ${err.maxBytes})`);
+          ledgerMark(ledger, source.type, sessionRef.sessionId, 'oversize', sessionRef.mtime);
+          continue;
+        }
         log(`[runner]   Read failed: ${err.message}`);
         totalFailed++;
         continue;
@@ -878,7 +1015,8 @@ async function main() {
 
       try {
         const result = await postExtract(cleaned, sessionRef.sessionId, source.type, report);
-        log(`[runner]   ✓ published=${result.learnings_published || 0} rejected=${result.learnings_rejected || 0} ${DIGEST_ACCOUNT} (extraction: ${result.extraction_id})`);
+        log(`[runner]   ✓ published=${result.learnings_published || 0} held=${result.learnings_held || 0} rejected=${result.learnings_rejected || 0} ${DIGEST_ACCOUNT} (extraction: ${result.extraction_id})`);
+        totalHeld += result.learnings_held || 0;
         ledgerMark(ledger, source.type, sessionRef.sessionId, sha, sessionRef.mtime);
         deleteQueueFile(queueFile);
         saveLedger(ledger);
@@ -892,7 +1030,11 @@ async function main() {
   }
 
   saveLedger(ledger);
-  log(`[runner] Summary: ${totalDiscovered} discovered, ${totalProcessed} processed, ${totalSkipped} skipped, ${totalFailed} failed`);
+  log(`[runner] Summary: ${totalDiscovered} discovered, ${totalProcessed} processed, ${totalSkipped} skipped (${totalOversize} oversize), ${totalFailed} failed`);
+  if (totalOversize > 0) {
+    console.error(`[runner] oversize_skipped=${totalOversize} (sessions above AUXILO_MAX_SESSION_BYTES were skipped, not read)`);
+  }
+  notifyHeld(totalHeld); // LW-18 layer 2: one notification per sweep, count-only
   process.exit(totalFailed > 0 ? 1 : 0);
 }
 
@@ -902,6 +1044,7 @@ module.exports = {
   parseArgs, writeQueueFile, deleteQueueFile, listPendingFiles,
   loadLedger, saveLedger, ledgerHighWater, ledgerHas, ledgerMark,
   installHooks, installSweeper, installDigest, printStatus, scrubAndVerify, enumerateActiveSources,
+  loadSources, SOURCES, sweeperManifest, submitLearnings, notifyHeld,
   KILL_SWITCH_PATH, PENDING_DIR, LEDGER_PATH,
 };
 

package/scripts/sources/cline.js

@@ -0,0 +1,160 @@
+/**
+ * scripts/sources/cline.js — Cline (VS Code extension) Transcript Source (UC-3)
+ *
+ * Discovers and reads Cline task conversation histories from VS Code global
+ * storage:
+ *
+ *   <vscode-user-dir>/globalStorage/saoudrizwan.claude-dev/tasks/<taskId>/
+ *     api_conversation_history.json   ← read (Anthropic Messages format)
+ *     ui_messages.json                ← ignored (UI event stream)
+ *
+ * Candidate VS Code roots probed (any-of): Code, Code - Insiders, VSCodium —
+ * per-platform user-data locations (darwin: ~/Library/Application Support,
+ * linux: ~/.config, win32: %APPDATA%).
+ *
+ * KNOWN SHAPE (format probe accepts exactly this, refuses everything else):
+ *   [ { role: "user"|"assistant", content: string | [ {type:"text", text} | ... ] } ]
+ *   (tool_use / tool_result blocks and non-text parts are skipped)
+ *
+ * NOTE (2026-07-19): built from Cline's documented/observed storage layout.
+ * No Cline installation existed on the build machine to verify against
+ * (probed all globalStorage roots — absent). The strict probe + fail-silent
+ * contract means a drifted real-world format degrades to "skipped with one
+ * log line", never a mis-parse (UC §5 risk rule) — the same posture the
+ * gemini-cli adapter shipped with. Publicly labeled best-effort (UC-3).
+ *
+ * @module sources/cline
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { TranscriptSource } = require('./source.interface');
+const { normalizeRole, extractText } = require('./generic-jsonl');
+
+/** Per-platform VS Code-family user-data roots (any-of detection). */
+function vscodeUserDirs(homeDir, platform, env) {
+  const apps = ['Code', 'Code - Insiders', 'VSCodium'];
+  if (platform === 'darwin') {
+    return apps.map(a => path.join(homeDir, 'Library', 'Application Support', a, 'User'));
+  }
+  if (platform === 'win32') {
+    const appData = (env && env.APPDATA) || path.join(homeDir, 'AppData', 'Roaming');
+    return apps.map(a => path.join(appData, a, 'User'));
+  }
+  return apps.map(a => path.join(homeDir, '.config', a, 'User'));
+}
+
+class ClineSource extends TranscriptSource {
+  static id = 'cline';
+  static displayName = 'Cline (VS Code)';
+  static version = '1.0.0';
+
+  /** Extension publisher dir(s) under globalStorage — subclass override point. */
+  static publisherDirs = ['saoudrizwan.claude-dev'];
+
+  constructor(config = {}) {
+    super(config);
+    const homeDir = config.homeDir || os.homedir();
+    const platform = config.platform || process.platform;
+    const env = config.env || process.env;
+    /** @type {string[]} candidate tasks roots (first existing wins per discover) */
+    this.taskRoots = config.taskRoots || vscodeUserDirs(homeDir, platform, env).flatMap(
+      (userDir) => this.constructor.publisherDirs.map(
+        (pub) => path.join(userDir, 'globalStorage', pub, 'tasks')
+      )
+    );
+  }
+
+  /** Detect: any candidate tasks root exists and is a directory. Fail-silent. */
+  async detect() {
+    return this.taskRoots.some((p) => {
+      try { return fs.statSync(p).isDirectory(); } catch { return false; }
+    });
+  }
+
+  /**
+   * Discover task sessions: each task dir containing
+   * api_conversation_history.json modified after `since`.
+   */
+  async discoverSessions({ since } = {}) {
+    const results = [];
+    const sinceMs = since ? new Date(since).getTime() : 0;
+
+    for (const root of this.taskRoots) {
+      let taskIds;
+      try { taskIds = fs.readdirSync(root); } catch { continue; }
+      for (const taskId of taskIds) {
+        const historyPath = path.join(root, taskId, 'api_conversation_history.json');
+        try {
+          const stat = fs.statSync(historyPath);
+          if (!stat.isFile()) continue;
+          if (stat.mtimeMs <= sinceMs) continue;
+          results.push({
+            sessionId: `${this.type}-${taskId}`,
+            path: historyPath,
+            mtime: stat.mtime.toISOString(),
+            bytes: stat.size,
+          });
+        } catch { /* task dir without a history file — skip */ }
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Read + normalize one task history. Returns null (single stderr log line)
+   * when the format probe refuses — never throws on bad format.
+   */
+  async readSession(sessionRef) {
+    const filePath = sessionRef.path;
+    if (!filePath || !fs.existsSync(filePath)) {
+      throw new Error(`Transcript file not found: ${filePath}`);
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch {
+      return this._refuse(filePath, 'not valid JSON');
+    }
+
+    // Probe: an ARRAY of {role, content} message objects (Anthropic format).
+    if (!Array.isArray(parsed)) return this._refuse(filePath, 'not a messages array');
+    const messageLike = parsed.filter((m) => m && typeof m === 'object' && m.role !== undefined && m.content !== undefined);
+    if (parsed.length === 0 || messageLike.length === 0) {
+      return this._refuse(filePath, 'no role/content messages');
+    }
+
+    const turns = [];
+    for (const m of messageLike) {
+      const role = normalizeRole(m.role);
+      if (!role) continue; // system / tool roles — skip
+      const text = extractText(m.content);
+      if (text && text.trim().length > 0) turns.push(`[${role}]: ${text}`);
+    }
+
+    return {
+      transcript: turns.join('\n\n'),
+      metadata: {
+        sessionId: sessionRef.sessionId,
+        source: this.type,
+        mtime: sessionRef.mtime,
+        bytes: sessionRef.bytes,
+      },
+    };
+  }
+
+  /** Single log line + null per the UC §5 fail-silent rule. */
+  _refuse(filePath, reason) {
+    process.stderr.write(`[${this.type}] format probe refused ${filePath} (${reason}) — skipping\n`);
+    return null;
+  }
+
+  /** No hook surface — poll-based via the sweeper (UC-3 P-class). */
+  async registerSessionEndHook(cb) { return null; }
+}
+
+module.exports = { ClineSource, vscodeUserDirs };

package/scripts/sources/continue.js

@@ -0,0 +1,140 @@
+/**
+ * scripts/sources/continue.js — Continue.dev Transcript Source (UC-3)
+ *
+ * Discovers and reads Continue.dev saved sessions:
+ *
+ *   ~/.continue/sessions/<sessionId>.json    ← read (one file per session)
+ *   ~/.continue/sessions/sessions.json       ← index (metadata only; ignored)
+ *
+ * KNOWN SHAPES (format probe accepts exactly these, refuses everything else):
+ *
+ *   { history: [ ...items ] , title?, sessionId?, workspaceDirectory? }
+ *   where each item is either
+ *     { message: { role: "user"|"assistant", content: string|[{...}] }, ... }
+ *   or (older sessions)
+ *     { role: "user"|"assistant", content: string|[{...}] }
+ *
+ * Tool/system roles and non-text content parts are skipped.
+ *
+ * NOTE (2026-07-19): built from Continue's documented session persistence
+ * (~/.continue/sessions). No Continue installation existed on the build
+ * machine to verify against (~/.continue absent). Strict probe + fail-silent
+ * degradation per UC §5 — a drifted format is skipped with one log line,
+ * never mis-parsed. Publicly labeled best-effort (UC-3).
+ *
+ * @module sources/continue
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { TranscriptSource } = require('./source.interface');
+const { normalizeRole, extractText } = require('./generic-jsonl');
+
+class ContinueSource extends TranscriptSource {
+  static id = 'continue';
+  static displayName = 'Continue.dev';
+  static version = '1.0.0';
+
+  constructor(config = {}) {
+    super(config);
+    /** @type {string} Sessions dir */
+    this.sessionsDir = config.sessionsDir ||
+      path.join(config.homeDir || os.homedir(), '.continue', 'sessions');
+  }
+
+  /** Detect: ~/.continue/sessions exists and is a directory. Fail-silent. */
+  async detect() {
+    try {
+      return fs.statSync(this.sessionsDir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /** Discover session JSON files (excluding the sessions.json index). */
+  async discoverSessions({ since } = {}) {
+    const results = [];
+    const sinceMs = since ? new Date(since).getTime() : 0;
+
+    let files;
+    try {
+      files = fs.readdirSync(this.sessionsDir)
+        .filter(f => f.endsWith('.json') && f !== 'sessions.json');
+    } catch {
+      return results;
+    }
+
+    for (const file of files) {
+      const filePath = path.join(this.sessionsDir, file);
+      try {
+        const stat = fs.statSync(filePath);
+        if (!stat.isFile()) continue;
+        if (stat.mtimeMs <= sinceMs) continue;
+        results.push({
+          sessionId: path.basename(file, '.json'),
+          path: filePath,
+          mtime: stat.mtime.toISOString(),
+          bytes: stat.size,
+        });
+      } catch { /* skip unreadable files */ }
+    }
+    return results;
+  }
+
+  /**
+   * Read + normalize one session. Returns null (single stderr log line) when
+   * the format probe refuses — never throws on bad format.
+   */
+  async readSession(sessionRef) {
+    const filePath = sessionRef.path;
+    if (!filePath || !fs.existsSync(filePath)) {
+      throw new Error(`Transcript file not found: ${filePath}`);
+    }
+
+    let parsed;
+    try {
+      parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch {
+      return this._refuse(filePath, 'not valid JSON');
+    }
+
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed) || !Array.isArray(parsed.history)) {
+      return this._refuse(filePath, 'no history array');
+    }
+
+    const turns = [];
+    for (const item of parsed.history) {
+      if (!item || typeof item !== 'object') continue;
+      // New shape nests the message; older items ARE the message.
+      const msg = (item.message && typeof item.message === 'object') ? item.message : item;
+      const role = normalizeRole(msg.role);
+      if (!role) continue;
+      const text = extractText(msg.content);
+      if (text && text.trim().length > 0) turns.push(`[${role}]: ${text}`);
+    }
+
+    return {
+      transcript: turns.join('\n\n'),
+      metadata: {
+        sessionId: sessionRef.sessionId,
+        source: 'continue',
+        mtime: sessionRef.mtime,
+        bytes: sessionRef.bytes,
+      },
+    };
+  }
+
+  /** Single log line + null per the UC §5 fail-silent rule. */
+  _refuse(filePath, reason) {
+    process.stderr.write(`[continue] format probe refused ${filePath} (${reason}) — skipping\n`);
+    return null;
+  }
+
+  /** No hook surface — poll-based via the sweeper (UC-3 P-class). */
+  async registerSessionEndHook(cb) { return null; }
+}
+
+module.exports = { ContinueSource };