auxilo-mcp 0.8.2 → 0.9.1

package/scripts/runner.js

@@ -39,6 +39,9 @@ const crypto = require('crypto');
 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 { GenericJsonlSource } = require('./sources/generic-jsonl.js');
 
 // ─── Constants ──────────────────────────────────────────────────────────────
 
@@ -89,6 +92,8 @@ const LOG_PATH = path.join(AUXILO_DIR, 'extract.log');
 const SOURCES = [
   ClaudeCodeSource,
   OpenClawSource,
+  GeminiCliSource,
+  AntigravitySource,
 ];
 
 async function enumerateActiveSources(filter) {
@@ -228,30 +233,52 @@ function listPendingFiles() {
 
 // ─── Upload ─────────────────────────────────────────────────────────────────
 
-async function postExtract(transcript, sessionId, sourceType, scrubReport) {
-  const transcriptSha256 = crypto.createHash('sha256').update(transcript).digest('hex');
-  const idempotencyKey = crypto.randomUUID();
-
-  const res = await fetch(`${BASE_URL}/extract`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'X-API-Key': API_KEY,
-      'Idempotency-Key': idempotencyKey,
-    },
-    body: JSON.stringify({
-      source: { type: sourceType, session_id: sessionId },
-      transcript,
-      transcript_sha256: transcriptSha256,
-      client_scrub_report: scrubReport,
-    }),
-  });
+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' };
+  }
 
-  const data = await res.json();
-  if (!res.ok) {
-    throw new Error(`Upload failed (${res.status}): ${data.error || JSON.stringify(data)}`);
+  let published = 0;
+  let rejected = 0;
+  for (const l of learnings) {
+    try {
+      const res = await fetch(`${BASE_URL}/learn`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': API_KEY,
+          'Idempotency-Key': crypto.randomUUID(),
+        },
+        body: JSON.stringify({
+          title: l.title,
+          body: l.body,
+          category: l.category,
+          tags: l.tags,
+          task_context: l.task_context,
+          outcome: l.outcome,
+          contributor_agent: `auxilo-hook/${sourceType}`,
+        }),
+      });
+      if (res.ok) published += 1;
+      else rejected += 1;
+    } catch (_) {
+      rejected += 1;
+    }
   }
-  return { ...data, transcript_sha256: transcriptSha256 };
+  log(`[runner] client-side extraction: ${learnings.length} candidate(s), published=${published} rejected=${rejected}`);
+  return { learnings_published: published, learnings_rejected: rejected, extraction_id: `client-${sessionId}` };
 }
 
 // ─── Install Hooks (B15) ────────────────────────────────────────────────────
@@ -615,16 +642,21 @@ async function main() {
       process.exit(1);
     }
 
-    // Pick the right source adapter based on file location — default to
-    // claude-code since it can parse either JSONL or plain text, and
-    // works for most hook-fired single-file invocations.
+    // Pick the right source adapter — capture-core forwards the client id
+    // via --source (UC-1). Default to claude-code since it can parse either
+    // JSONL or plain text. Unknown ids (cursor, windsurf, codex, copilot,
+    // factory, ...) fall back to the generic Claude-style JSONL normalizer,
+    // which tags uploads with the actual client id and refuses (fail-silent)
+    // anything that doesn't probe as JSONL.
     const sourceType = args.source || 'claude-code';
     const SourceClass = SOURCES.find(S => S.id === sourceType);
-    if (!SourceClass) {
-      log(`[runner] Unknown source type: ${sourceType}`);
-      process.exit(1);
+    let source;
+    if (SourceClass) {
+      source = new SourceClass();
+    } else {
+      log(`[runner] No dedicated adapter for source "${sourceType}" — using generic-jsonl fallback`);
+      source = new GenericJsonlSource({ id: sourceType });
     }
-    const source = new SourceClass();
     const sessionId = path.basename(transcriptPath, path.extname(transcriptPath));
     const stat = fs.statSync(transcriptPath);
     const sessionRef = {
@@ -649,6 +681,14 @@ async function main() {
       }
     }
 
+    // UC-1 format-probe refusal: adapters return null (never throw) when a
+    // file doesn't match their expected shape. Skip — do NOT fall back to
+    // raw text, that would mis-parse garbage into a transcript (UC §5).
+    if (!transcriptData || typeof transcriptData.transcript !== 'string') {
+      log(`[runner] Format probe refused ${transcriptPath} (source=${source.type}). Exiting.`);
+      process.exit(0);
+    }
+
     let transcript = transcriptData.transcript;
     if (transcript.length < MIN_CHARS) {
       log(`[runner] Too short (${transcript.length} chars, min ${MIN_CHARS}). Exiting.`);
@@ -668,6 +708,23 @@ async function main() {
       log(`[runner] Scrubbed ${report.patterns_matched.length} sensitive pattern(s): ${[...new Set(report.patterns_matched)].join(', ')} ${DIGEST_ACCOUNT}`);
     }
 
+    // GOV-3 M2: content-sha ledger dedup for single-file mode. Some clients
+    // fire their capture hook PER RESPONSE / PER TURN, not at session end
+    // (Windsurf post_cascade_response_with_transcript; Codex/Antigravity
+    // Stop). Without this, each firing re-uploads the whole transcript-so-far
+    // as a fresh extraction (new idempotency key per call), burning rate
+    // limit and re-running the LLM on growing partials. Keyed on the cleaned
+    // content sha so identical/already-seen content is skipped. --force
+    // bypasses (targeted re-test).
+    const contentSha = crypto.createHash('sha256').update(cleaned).digest('hex');
+    if (!args.force) {
+      const ledger = loadLedger();
+      if (ledgerHas(ledger, sourceType, sessionId, contentSha)) {
+        log(`[runner] Already uploaded this content (source=${sourceType} session=${sessionId}). Skipping.`);
+        process.exit(0);
+      }
+    }
+
     if (args.dryRun) {
       log(`[runner] [DRY RUN] Would upload ${cleaned.length} chars to ${BASE_URL}/extract`);
       process.exit(0);
@@ -676,6 +733,10 @@ 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})`);
+      // Mark only after a successful upload so a failed POST can be retried.
+      const ledger = loadLedger();
+      ledgerMark(ledger, sourceType, sessionId, contentSha, sessionRef.mtime);
+      saveLedger(ledger);
       process.exit(0);
     } catch (err) {
       log(`[runner] ✗ Upload failed: ${err.message}`);
@@ -751,6 +812,14 @@ async function main() {
         continue;
       }
 
+      // UC-1 format-probe refusal: null = skip silently (not a failure).
+      if (!transcriptData || typeof transcriptData.transcript !== 'string') {
+        log(`[runner]   Skipped — format probe refused (source=${source.type})`);
+        totalSkipped++;
+        ledgerMark(ledger, source.type, sessionRef.sessionId, 'probe-refused', sessionRef.mtime);
+        continue;
+      }
+
       let transcript = transcriptData.transcript;
 
       // Size check

package/scripts/sources/antigravity.js

@@ -0,0 +1,131 @@
+/**
+ * scripts/sources/antigravity.js — Antigravity Transcript Source (UC-1)
+ *
+ * Discovers and reads Antigravity per-conversation JSONL transcript logs.
+ * Default location:
+ *   ~/.gemini/antigravity/brain/<conversation-id>/.system_generated/logs/*.jsonl
+ *
+ * Expected line shape: Claude-style JSONL dialect — one JSON object per line
+ * carrying `role`/`content`, `message.role`/`message.content`, or
+ * `sender`/`content`. Tool/function-call internals are skipped.
+ *
+ * GROUND-TRUTH NOTE (verified on this machine, 2026-06-12): the local
+ * Antigravity install stores conversations as binary protobuf
+ * (~/.gemini/antigravity/conversations/*.pb) and its brain dirs contained NO
+ * .system_generated/logs/*.jsonl — only click_feedback PNGs and inter-agent
+ * messages/*.json ({id, recipient, sender, priority, timestamp, hideFromUser,
+ * content}). The logs/*.jsonl path comes from the UC research pass (hook
+ * payloads hand a `transcriptPath` pointing there on hook-enabled builds).
+ * The strict JSONL probe + fail-silent contract means that if the real format
+ * differs, this adapter degrades to "skipped with one log line" — it never
+ * mis-parses (UC §5 risk rule).
+ *
+ * @module sources/antigravity
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { TranscriptSource } = require('./source.interface');
+const { normalizeJsonlLines, probeJsonl } = require('./generic-jsonl');
+
+class AntigravitySource extends TranscriptSource {
+  static id = 'antigravity';
+  static displayName = 'Antigravity (Google)';
+  static version = '1.0.0';
+
+  constructor(config = {}) {
+    super(config);
+    /** @type {string} Root brain dir holding per-conversation artifacts */
+    this.dataDir = config.dataDir || path.join(os.homedir(), '.gemini', 'antigravity', 'brain');
+  }
+
+  /** Detect: the brain directory exists and is readable. */
+  async detect() {
+    try {
+      return fs.statSync(this.dataDir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Discover transcript logs under
+   * <dataDir>/<conversation-id>/.system_generated/logs/*.jsonl
+   * modified after `since`.
+   */
+  async discoverSessions({ since } = {}) {
+    const results = [];
+    const sinceMs = since ? new Date(since).getTime() : 0;
+
+    let conversations;
+    try {
+      conversations = fs.readdirSync(this.dataDir).filter(c => {
+        try { return fs.statSync(path.join(this.dataDir, c)).isDirectory(); }
+        catch { return false; }
+      });
+    } catch {
+      return results;
+    }
+
+    for (const conv of conversations) {
+      const logsDir = path.join(this.dataDir, conv, '.system_generated', 'logs');
+      let files;
+      try { files = fs.readdirSync(logsDir).filter(f => f.endsWith('.jsonl')); }
+      catch { continue; } // most brain dirs have no logs — fine
+
+      for (const file of files) {
+        const filePath = path.join(logsDir, file);
+        try {
+          const stat = fs.statSync(filePath);
+          if (!stat.isFile()) continue;
+          if (stat.mtimeMs <= sinceMs) continue;
+          results.push({
+            sessionId: `${conv}-${path.basename(file, '.jsonl')}`,
+            path: filePath,
+            mtime: stat.mtime.toISOString(),
+            bytes: stat.size,
+          });
+        } catch { /* skip unreadable files */ }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Read + normalize one JSONL transcript. 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}`);
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim());
+
+    if (!probeJsonl(lines)) {
+      process.stderr.write(`[antigravity] format probe refused ${filePath} — skipping\n`);
+      return null;
+    }
+
+    return {
+      transcript: normalizeJsonlLines(lines),
+      metadata: {
+        sessionId: sessionRef.sessionId,
+        source: 'antigravity',
+        mtime: sessionRef.mtime,
+        bytes: sessionRef.bytes,
+      },
+    };
+  }
+
+  /** Hook wiring (Antigravity hooks.json, Stop event) is the installer's job. */
+  async registerSessionEndHook(cb) { return null; }
+}
+
+module.exports = { AntigravitySource };

package/scripts/sources/gemini-cli.js

@@ -0,0 +1,178 @@
+/**
+ * scripts/sources/gemini-cli.js — Gemini CLI Transcript Source (UC-1)
+ *
+ * Discovers and reads auto-saved Gemini CLI session JSON files.
+ * Default location: ~/.gemini/tmp/<project_hash>/chats/*.json
+ *
+ * KNOWN SHAPES (format probe accepts exactly these, refuses everything else):
+ *
+ *   A. Session auto-save object:
+ *        { sessionId?, startTime?, lastUpdated?,
+ *          messages: [ { id?, type: "user"|"gemini", content: string, ... } ] }
+ *
+ *   B. Checkpoint (`/chat save`) — Gemini API Content list, either bare or
+ *      wrapped:
+ *        [ { role: "user"|"model", parts: [ {text} | {functionCall} | {functionResponse} ] } ]
+ *        { history: [ ...same... ] }
+ *
+ *   NOTE (2026-06-12): built from the documented Gemini CLI session formats.
+ *   No ~/.gemini/tmp data existed on the build machine to verify against —
+ *   only Antigravity uses ~/.gemini here. 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).
+ *
+ * Normalization: user/model turns concatenated as `[user]:` / `[assistant]:`
+ * blocks (same convention as the claude-code adapter). Tool/function-call
+ * internals and thinking parts are skipped.
+ *
+ * @module sources/gemini-cli
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { TranscriptSource } = require('./source.interface');
+const { normalizeRole } = require('./generic-jsonl');
+
+/** Extract user-visible text from a Gemini Content `parts` array. */
+function textFromParts(parts) {
+  if (!Array.isArray(parts)) return '';
+  return parts
+    .filter(p => p && typeof p.text === 'string' && !p.thought) // skip functionCall/functionResponse/thought parts
+    .map(p => p.text)
+    .filter(Boolean)
+    .join('\n');
+}
+
+class GeminiCliSource extends TranscriptSource {
+  static id = 'gemini-cli';
+  static displayName = 'Gemini CLI (Google)';
+  static version = '1.0.0';
+
+  constructor(config = {}) {
+    super(config);
+    /** @type {string} Root dir for Gemini CLI per-project temp data */
+    this.dataDir = config.dataDir || path.join(os.homedir(), '.gemini', 'tmp');
+  }
+
+  /** Detect: ~/.gemini/tmp exists and is a readable directory. */
+  async detect() {
+    try {
+      return fs.statSync(this.dataDir).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Discover session JSON files under <dataDir>/<project_hash>/chats/*.json
+   * modified after `since`.
+   */
+  async discoverSessions({ since } = {}) {
+    const results = [];
+    const sinceMs = since ? new Date(since).getTime() : 0;
+
+    let hashes;
+    try {
+      hashes = fs.readdirSync(this.dataDir).filter(h => {
+        try { return fs.statSync(path.join(this.dataDir, h)).isDirectory(); }
+        catch { return false; }
+      });
+    } catch {
+      return results;
+    }
+
+    for (const hash of hashes) {
+      const chatsDir = path.join(this.dataDir, hash, 'chats');
+      let files;
+      try { files = fs.readdirSync(chatsDir).filter(f => f.endsWith('.json')); }
+      catch { continue; } // no chats dir for this project — fine
+
+      for (const file of files) {
+        const filePath = path.join(chatsDir, file);
+        try {
+          const stat = fs.statSync(filePath);
+          if (!stat.isFile()) continue;
+          if (stat.mtimeMs <= sinceMs) continue;
+          results.push({
+            sessionId: `${hash}-${path.basename(file, '.json')}`,
+            path: filePath,
+            mtime: stat.mtime.toISOString(),
+            bytes: stat.size,
+          });
+        } catch { /* skip unreadable files */ }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Read + normalize one session file. Returns null (single stderr log line)
+   * when the format probe refuses — never throws on bad format, never
+   * mis-parses garbage into a transcript.
+   */
+  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');
+    }
+
+    const turns = [];
+
+    if (parsed && !Array.isArray(parsed) && Array.isArray(parsed.messages)) {
+      // Shape A: session auto-save { messages: [{ type, content }] }
+      for (const m of parsed.messages) {
+        if (!m || typeof m !== 'object') continue;
+        const role = normalizeRole(m.type ?? m.role);
+        if (!role) continue; // tool/info/error entries — skip
+        const text = typeof m.content === 'string' ? m.content : textFromParts(m.content);
+        if (text && text.trim().length > 0) turns.push(`[${role}]: ${text}`);
+      }
+    } else {
+      // Shape B: checkpoint Content list — bare array or { history: [...] }
+      const history = Array.isArray(parsed) ? parsed
+        : (parsed && Array.isArray(parsed.history)) ? parsed.history
+        : null;
+      if (!history) return this._refuse(filePath, 'no messages/history array');
+
+      for (const c of history) {
+        if (!c || typeof c !== 'object') continue;
+        const role = normalizeRole(c.role);
+        if (!role) continue;
+        const text = textFromParts(c.parts);
+        if (text && text.trim().length > 0) turns.push(`[${role}]: ${text}`);
+      }
+    }
+
+    return {
+      transcript: turns.join('\n\n'),
+      metadata: {
+        sessionId: sessionRef.sessionId,
+        source: 'gemini-cli',
+        mtime: sessionRef.mtime,
+        bytes: sessionRef.bytes,
+      },
+    };
+  }
+
+  /** Single log line + null per the UC §5 fail-silent rule. */
+  _refuse(filePath, reason) {
+    process.stderr.write(`[gemini-cli] format probe refused ${filePath} (${reason}) — skipping\n`);
+    return null;
+  }
+
+  /** Hook wiring (Gemini settings.json hooks) is the installer's job. */
+  async registerSessionEndHook(cb) { return null; }
+}
+
+module.exports = { GeminiCliSource };

package/scripts/sources/generic-jsonl.js

@@ -0,0 +1,157 @@
+/**
+ * scripts/sources/generic-jsonl.js — Generic Claude-style JSONL Source (UC-1)
+ *
+ * Best-effort normalizer for clients that speak a Claude-style JSONL dialect
+ * (one JSON object per line carrying `role`/`content` or
+ * `message.role`/`message.content`) but don't have a dedicated adapter yet
+ * (cursor, windsurf, codex, copilot, factory). capture-core forwards the
+ * client id via `--source <id>`; runner.js falls back to this adapter for
+ * unknown ids in single-file mode and tags uploads with that id.
+ *
+ * FORMAT PROBE (UC §5 risk rule): at least 80% of non-empty lines must parse
+ * as JSON objects, or readSession() refuses (returns null with a single
+ * stderr line). Never throws on bad format, never mis-parses garbage into a
+ * transcript.
+ *
+ * Poll-mode methods are inert: there is no canonical on-disk location for a
+ * "generic" client, so detect() → false and discoverSessions() → [].
+ *
+ * @module sources/generic-jsonl
+ */
+
+'use strict';
+
+const fs = require('fs');
+const { TranscriptSource } = require('./source.interface');
+
+/** Minimum fraction of non-empty lines that must parse as JSON objects. */
+const PROBE_MIN_JSON_RATIO = 0.8;
+
+/** Map dialect role names to our normalized two-role vocabulary. */
+function normalizeRole(role) {
+  const r = String(role || '').toLowerCase();
+  if (r === 'user' || r === 'human') return 'user';
+  if (r === 'assistant' || r === 'model' || r === 'gemini' || r === 'ai') return 'assistant';
+  return null; // system / tool / function / unknown → skip
+}
+
+/** Extract plain text from a string | block-array | {text} content value. */
+function extractText(raw) {
+  if (raw == null) return '';
+  if (typeof raw === 'string') return raw;
+  if (Array.isArray(raw)) {
+    return raw
+      .filter(b => b && (b.type === 'text' || b.type === 'input_text' || typeof b.text === 'string'))
+      .map(b => b.text || '')
+      .filter(Boolean)
+      .join('\n');
+  }
+  if (typeof raw === 'object' && typeof raw.text === 'string') return raw.text;
+  return '';
+}
+
+/**
+ * Normalize an array of raw JSONL lines into `[user]:`/`[assistant]:` turns.
+ * Shared with the antigravity adapter. Skips tool/function internals and any
+ * line whose role doesn't normalize to user/assistant.
+ *
+ * @param {string[]} lines - non-empty JSONL lines
+ * @returns {string} normalized transcript (may be empty)
+ */
+function normalizeJsonlLines(lines) {
+  const turns = [];
+  for (const line of lines) {
+    let entry;
+    try { entry = JSON.parse(line); } catch { continue; }
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) continue;
+
+    // Skip explicit tool/function internals regardless of role fields.
+    const t = String(entry.type || '').toLowerCase();
+    if (['tool_use', 'tool_result', 'function_call', 'function_response', 'tool'].includes(t)) continue;
+
+    const role = normalizeRole(entry.message?.role ?? entry.role ?? entry.sender ?? entry.type);
+    if (!role) continue;
+
+    const text = extractText(entry.message?.content ?? entry.content ?? entry.text);
+    if (text.trim().length > 0) turns.push(`[${role}]: ${text}`);
+  }
+  return turns.join('\n\n');
+}
+
+/**
+ * Format probe: true when the file looks like JSONL (≥80% of non-empty lines
+ * parse as JSON objects).
+ *
+ * @param {string[]} lines - non-empty lines
+ * @returns {boolean}
+ */
+function probeJsonl(lines) {
+  if (lines.length === 0) return false;
+  let objects = 0;
+  for (const line of lines) {
+    try {
+      const v = JSON.parse(line);
+      if (v && typeof v === 'object' && !Array.isArray(v)) objects++;
+    } catch { /* not JSON */ }
+  }
+  return objects / lines.length >= PROBE_MIN_JSON_RATIO;
+}
+
+class GenericJsonlSource extends TranscriptSource {
+  static id = 'generic-jsonl';
+  static displayName = 'Generic Claude-style JSONL';
+  static version = '1.0.0';
+
+  /**
+   * @param {object} [config]
+   * @param {string} [config.id] - actual client id this instance represents
+   *   (e.g. "cursor", "windsurf"); used as the upload source tag.
+   */
+  constructor(config = {}) {
+    super(config);
+    // The marketplace source tag is the CLIENT id, not "generic-jsonl".
+    this.type = config.id || GenericJsonlSource.id;
+    this.label = config.label || `${this.type} (generic JSONL)`;
+  }
+
+  /** No canonical data dir for a generic client — never auto-detected. */
+  async detect() { return false; }
+
+  /** Poll discovery unsupported — hook-fired single-file mode only. */
+  async discoverSessions({ since } = {}) { return []; }
+
+  /**
+   * Read + normalize a JSONL transcript. 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}`);
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n').filter(l => l.trim());
+
+    if (!probeJsonl(lines)) {
+      process.stderr.write(`[generic-jsonl] format probe refused ${filePath} (source=${this.type}) — skipping\n`);
+      return null;
+    }
+
+    const transcript = normalizeJsonlLines(lines);
+    return {
+      transcript,
+      metadata: {
+        sessionId: sessionRef.sessionId,
+        source: this.type,
+        adapter: GenericJsonlSource.id,
+        mtime: sessionRef.mtime,
+        bytes: sessionRef.bytes,
+      },
+    };
+  }
+
+  /** Hook wiring is the installer's job (UC-1). */
+  async registerSessionEndHook(cb) { return null; }
+}
+
+module.exports = { GenericJsonlSource, normalizeJsonlLines, probeJsonl, normalizeRole, extractText };