wogiflow 2.26.2 → 2.29.1

package/scripts/flow-worker-question-classifier.js

@@ -142,6 +142,36 @@ Examples:
 - "Task complete. Next: wf-abc12345 — starting now." → {"isUserQuestion": false, "confidence": 95, "reason": "action statement, no question"}`;
 }
 
+/**
+ * Build the main-mode classifier prompt. Used by the task-boundary-reset path
+ * in solo/main-mode sessions to detect when the AI forgot to call `flow ask`
+ * before ending a turn with a user-facing question. A YES classification
+ * auto-writes the pending-question marker and defers the restart.
+ *
+ * Same shape as buildClassifierPrompt — only the contextual framing differs.
+ */
+function buildMainModePrompt(lastMessage) {
+  return `You classify whether an AI assistant's final message to a SOLO (non-workspace) session ends by asking the USER a question that expects a user response.
+
+Context: in solo mode the session has a task-boundary session-restart feature. Before the restart fires, this classifier checks whether the AI is waiting on a user answer. If YES, the restart is deferred so the user's next reply lands in the same session context. The safety net exists because the AI should have called \`flow ask\` manually but sometimes forgets.
+
+Your job: classify YES only when the AI's final message contains an OPEN question the AI is waiting on the user to answer. Classify NO for rhetorical questions the AI answers itself, narrative descriptions, "here are your options" menus with the AI continuing after, or questions that have an accompanying decision.
+
+[MESSAGE_START]
+${String(lastMessage || '').slice(0, MAX_MESSAGE_CHARS)}
+[MESSAGE_END]
+
+Return JSON only, no prose, no markdown fences:
+{"isUserQuestion": true|false, "confidence": 0-100, "reason": "one short sentence"}
+
+Examples:
+- "Confirm this approach, or want a different split?" → {"isUserQuestion": true, "confidence": 95, "reason": "open confirm/alternate awaiting user"}
+- "Option 1 (rule only) or option 2 (classifier)?" → {"isUserQuestion": true, "confidence": 95, "reason": "binary choice awaiting user"}
+- "Did the tests pass? Yes, all 12 passed." → {"isUserQuestion": false, "confidence": 90, "reason": "rhetorical, answered inline"}
+- "Task complete. Moving to next task now." → {"isUserQuestion": false, "confidence": 95, "reason": "action statement, no question"}
+- "Implementation done — committing and pushing." → {"isUserQuestion": false, "confidence": 95, "reason": "action statement, no question"}`;
+}
+
 /**
  * Guard parsed JSON response against prototype pollution. Mirrors
  * flow-conclusion-classifier.hasDangerousKeys.
@@ -157,10 +187,11 @@ function hasDangerousKeys(value) {
 }
 
 /**
- * Classify the worker's last assistant message.
+ * Classify the assistant's last message in either worker or main mode.
  *
  * @param {Object} opts
  * @param {string} opts.transcriptPath - Absolute path to session JSONL transcript
+ * @param {'worker'|'main'} [opts.mode='worker'] - Which prompt framing to use
  * @param {number} [opts.minConfidence] - Confidence threshold (default 70)
  * @param {string} [opts.model] - Model override (default haiku)
  * @returns {Promise<{
@@ -168,10 +199,13 @@ function hasDangerousKeys(value) {
  *   isUserQuestion?: boolean,
  *   confidence?: number,
  *   reason?: string,
- *   lastMessage?: string
+ *   lastMessage?: string,
+ *   blocked?: boolean,
+ *   minConfidence?: number
  * }>}
  */
-async function classifyWorkerQuestion(opts = {}) {
+async function classifyQuestion(opts = {}) {
+  const mode = opts.mode === 'main' ? 'main' : 'worker';
   const minConfidence = Number.isFinite(opts.minConfidence) ? opts.minConfidence : DEFAULT_MIN_CONFIDENCE;
   const model = opts.model || DEFAULT_MODEL;
 
@@ -195,15 +229,19 @@ async function classifyWorkerQuestion(opts = {}) {
     return { classified: false, reason: 'no-model-caller' };
   }
 
+  const prompt = mode === 'main'
+    ? buildMainModePrompt(lastMessage)
+    : buildClassifierPrompt(lastMessage);
+
   let result;
   try {
-    result = await callModel(model, buildClassifierPrompt(lastMessage), {
+    result = await callModel(model, prompt, {
       temperature: TEMPERATURE,
       maxTokens: MAX_TOKENS
     });
   } catch (err) {
     if (process.env.DEBUG) {
-      console.error(`[worker-question-classifier] model call failed: ${err.message}`);
+      console.error(`[question-classifier:${mode}] model call failed: ${err.message}`);
     }
     return { classified: false, reason: 'model-error' };
   }
@@ -245,11 +283,19 @@ async function classifyWorkerQuestion(opts = {}) {
   };
 }
 
+// Preserve the original worker-mode export name for zero signature break.
+// New callers should prefer classifyQuestion({ mode }) directly.
+async function classifyWorkerQuestion(opts = {}) {
+  return classifyQuestion({ ...opts, mode: 'worker' });
+}
+
 module.exports = {
+  classifyQuestion,
   classifyWorkerQuestion,
   extractLastAssistantMessage,
   extractAssistantText,
   buildClassifierPrompt,
+  buildMainModePrompt,
   hasDangerousKeys,
   DEFAULT_MIN_CONFIDENCE,
   DEFAULT_MODEL

package/scripts/flow-workspace-migrate-ipc.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Workspace — IPC Migration / Re-Index (wf-3635574e / G3, AC4)
+ *
+ * One-shot + idempotent script that rebuilds the per-worker SQLite IPC index
+ * (under `.workspace/state/ipc/<repoName>/{inbound,outbound}.db`) from the
+ * authoritative JSON sources:
+ *
+ *   - `.workspace/messages/msg-*.json` (message bus)
+ *   - `.workspace/state/dispatched-tasks.json` (ring buffer — optional)
+ *
+ * Routing per message `from`/`to`:
+ *   from == 'manager'         → <to>/inbound.db
+ *   to   == 'manager'         → <from>/outbound.db
+ *   to   == 'all'             → <from>/outbound.db (broadcast)
+ *   worker → worker           → <to>/inbound.db (manager-brokered semantics)
+ *
+ * Idempotent: UPSERT on message id. Re-running scans all JSON again and
+ * re-writes, which is safe — consumed_at is preserved via COALESCE in the
+ * UPSERT path (see workspace-ipc-sqlite.js).
+ *
+ * Usage:
+ *   node scripts/flow-workspace-migrate-ipc.js <workspaceRoot> [--quiet]
+ *   node scripts/flow-workspace-migrate-ipc.js --help
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const ipc = require('../lib/workspace-ipc-sqlite');
+
+const USAGE = `Usage: flow-workspace-migrate-ipc.js <workspaceRoot> [--quiet]
+
+Rebuilds the SQLite IPC index from existing JSON message bus + dispatch
+tracking files. Safe to run repeatedly; does not delete JSON files.
+
+Options:
+  --quiet    Suppress per-file log output.
+  --help     Show this help.
+`;
+
+function log(quiet, ...args) {
+  if (!quiet) console.log(...args);
+}
+
+function parseArgs(argv) {
+  const args = { workspaceRoot: null, quiet: false, help: false };
+  for (const a of argv.slice(2)) {
+    if (a === '--help' || a === '-h') { args.help = true; continue; }
+    if (a === '--quiet' || a === '-q') { args.quiet = true; continue; }
+    if (!args.workspaceRoot) { args.workspaceRoot = a; continue; }
+  }
+  return args;
+}
+
+function safeReadJson(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch (_err) {
+    return null;
+  }
+}
+
+/**
+ * Decide which repo's DB and which direction an existing JSON message belongs to.
+ */
+function routeMessage(msg) {
+  const from = typeof msg.from === 'string' ? msg.from : '';
+  const to = typeof msg.to === 'string' ? msg.to : '';
+
+  if (from === 'manager' && to && to !== 'all' && to !== 'manager') {
+    return { repoName: to, direction: 'inbound' };
+  }
+  if (to === 'manager' && from) {
+    return { repoName: from, direction: 'outbound' };
+  }
+  if (to === 'all' && from && from !== 'manager') {
+    return { repoName: from, direction: 'outbound' };
+  }
+  if (from && to && from !== to) {
+    return { repoName: to, direction: 'inbound' };
+  }
+  return null;
+}
+
+function inferConsumedAt(msg) {
+  if (typeof msg.consumed_at === 'string') return msg.consumed_at;
+  if (typeof msg.consumedAt === 'string') return msg.consumedAt;
+  if (msg.status && msg.status !== 'pending') {
+    return msg.updatedAt || msg.resolvedAt || null;
+  }
+  return null;
+}
+
+async function migrateMessages(workspaceRoot, quiet) {
+  const messagesDir = path.join(workspaceRoot, '.workspace', 'messages');
+  if (!fs.existsSync(messagesDir)) {
+    log(quiet, `[migrate-ipc] No messages dir at ${messagesDir} — skipping.`);
+    return { scanned: 0, indexed: 0, skipped: 0 };
+  }
+
+  const files = fs.readdirSync(messagesDir).filter(f => f.endsWith('.json'));
+  let indexed = 0;
+  let skipped = 0;
+
+  for (const file of files) {
+    const filePath = path.join(messagesDir, file);
+    const msg = safeReadJson(filePath);
+    if (!msg || !msg.id) { skipped++; continue; }
+
+    const route = routeMessage(msg);
+    if (!route) { skipped++; continue; }
+
+    const kind = typeof msg.type === 'string' ? msg.type : 'unknown';
+    const ok = await ipc.indexMessage(workspaceRoot, route.repoName, route.direction, {
+      id: msg.id,
+      kind,
+      payload: msg,
+      createdAt: msg.timestamp || new Date().toISOString(),
+      consumedAt: inferConsumedAt(msg)
+    });
+
+    if (ok) {
+      indexed++;
+      log(quiet, `[migrate-ipc] indexed ${msg.id} → ${route.repoName}/${route.direction}.db (${kind})`);
+    } else {
+      skipped++;
+    }
+  }
+
+  return { scanned: files.length, indexed, skipped };
+}
+
+async function migrateDispatches(workspaceRoot, quiet) {
+  const dispatchPath = path.join(workspaceRoot, '.workspace', 'state', 'dispatched-tasks.json');
+  if (!fs.existsSync(dispatchPath)) {
+    log(quiet, `[migrate-ipc] No dispatched-tasks.json — skipping dispatch index.`);
+    return { scanned: 0, indexed: 0, skipped: 0 };
+  }
+
+  const state = safeReadJson(dispatchPath);
+  if (!state || !Array.isArray(state.dispatches)) {
+    return { scanned: 0, indexed: 0, skipped: 0 };
+  }
+
+  let indexed = 0;
+  let skipped = 0;
+
+  for (const rec of state.dispatches) {
+    if (!rec || !rec.taskId || !rec.repoName) { skipped++; continue; }
+
+    // Synthesize a stable message id from taskId + dispatchedAt.
+    const id = `disp-${rec.taskId}-${Date.parse(rec.dispatchedAt || '') || 0}`.substring(0, 80);
+
+    const ok = await ipc.indexMessage(workspaceRoot, rec.repoName, 'inbound', {
+      id,
+      kind: 'task-dispatch',
+      payload: rec,
+      createdAt: rec.dispatchedAt || new Date().toISOString(),
+      consumedAt: rec.reconciledAt || (rec.status && rec.status !== 'pending' ? new Date().toISOString() : null)
+    });
+
+    if (ok) indexed++;
+    else skipped++;
+  }
+
+  return { scanned: state.dispatches.length, indexed, skipped };
+}
+
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) { console.log(USAGE); process.exit(0); }
+
+  const workspaceRoot = args.workspaceRoot
+    || process.env.WOGI_WORKSPACE_ROOT
+    || process.cwd();
+
+  if (!fs.existsSync(workspaceRoot)) {
+    console.error(`[migrate-ipc] Workspace root does not exist: ${workspaceRoot}`);
+    process.exit(2);
+  }
+
+  if (!(await ipc.isAvailable())) {
+    console.error(`[migrate-ipc] SQLite (sql.js) unavailable: ${ipc.unavailableReason()}`);
+    console.error(`[migrate-ipc] AC5 fallback active — JSON message bus will continue to serve reads/writes.`);
+    console.error(`[migrate-ipc] No migration performed.`);
+    process.exit(3);
+  }
+
+  log(args.quiet, `[migrate-ipc] workspaceRoot: ${workspaceRoot}`);
+  log(args.quiet, `[migrate-ipc] SQLite ready.`);
+
+  const msgRes = await migrateMessages(workspaceRoot, args.quiet);
+  log(args.quiet, `[migrate-ipc] messages: scanned=${msgRes.scanned} indexed=${msgRes.indexed} skipped=${msgRes.skipped}`);
+
+  const dispRes = await migrateDispatches(workspaceRoot, args.quiet);
+  log(args.quiet, `[migrate-ipc] dispatches: scanned=${dispRes.scanned} indexed=${dispRes.indexed} skipped=${dispRes.skipped}`);
+
+  await ipc.closeAll();
+
+  const repos = ipc.listIndexedRepos(workspaceRoot);
+  log(args.quiet, `[migrate-ipc] indexed repos: ${repos.join(', ') || '(none)'}`);
+  log(args.quiet, `[migrate-ipc] done.`);
+}
+
+if (require.main === module) {
+  main().catch(err => {
+    console.error('[migrate-ipc] FAILED:', err && err.stack ? err.stack : err);
+    process.exit(1);
+  });
+}
+
+module.exports = { routeMessage, migrateMessages, migrateDispatches };

package/scripts/flow-workspace-summary.js

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+
+/**
+ * Wogi Flow — Workspace Autonomous-Run Completion Summary (Story B / wf-ab59f0e4)
+ *
+ * Workers emit completion summaries to the manager via the channel-dispatch
+ * HTTP bus. The wire format is single-line:
+ *
+ *     ## COMPLETION-SUMMARY: <base64-JSON>
+ *
+ * Where <base64-JSON> is the same payload Story C produces locally, with a
+ * `workerId` field added for manager-side aggregation. Base64 was chosen
+ * over plain JSON because the channel-dispatch parser splits on `##`
+ * line-prefixes — multi-line raw JSON would split mid-payload (Blocker 5
+ * from the adversary critique).
+ *
+ * Chunked variant for >64KB payloads:
+ *
+ *     ## COMPLETION-SUMMARY-CHUNK-1/3: <base64-fragment>
+ *     ## COMPLETION-SUMMARY-CHUNK-2/3: <base64-fragment>
+ *     ## COMPLETION-SUMMARY-CHUNK-3/3: <base64-fragment>
+ *
+ * Programmatic:
+ *   const ws = require('./flow-workspace-summary');
+ *   const lines = ws.encodeMessage(payload);  // → ['## COMPLETION-SUMMARY: ...']
+ *   const r = ws.parseMessage(line);          // → { ok, payload?, error? }
+ *   const r = ws.parseChunked(lines);         // re-assemble chunks
+ *   const text = ws.renderMultiWorker(summaries);
+ */
+
+const SINGLE_LINE_PREFIX = '## COMPLETION-SUMMARY: ';
+const CHUNK_PREFIX_REGEX = /^## COMPLETION-SUMMARY-CHUNK-(\d+)\/(\d+):\s+/;
+// Channel-dispatch lines are typically capped well under 64KB; pick a
+// conservative single-line ceiling. Anything larger goes through chunking.
+const SINGLE_LINE_MAX_BYTES = 60 * 1024;
+
+const SEP = '━'.repeat(58);
+
+function encodeBase64(payload) {
+  return Buffer.from(JSON.stringify(payload), 'utf-8').toString('base64');
+}
+
+function decodeBase64(s) {
+  try {
+    const buf = Buffer.from(s, 'base64');
+    const text = buf.toString('utf-8');
+    return JSON.parse(text);
+  } catch (err) {
+    throw new Error(`base64-JSON decode failed: ${err.message}`);
+  }
+}
+
+/**
+ * Encode a completion-summary payload into one or more channel-dispatch
+ * message lines. Always returns at least one line; chunks when the payload
+ * exceeds SINGLE_LINE_MAX_BYTES.
+ */
+function encodeMessage(payload) {
+  if (!payload || typeof payload !== 'object') {
+    throw new Error('encodeMessage: payload must be an object');
+  }
+  const encoded = encodeBase64(payload);
+  if (encoded.length + SINGLE_LINE_PREFIX.length <= SINGLE_LINE_MAX_BYTES) {
+    return [`${SINGLE_LINE_PREFIX}${encoded}`];
+  }
+  const chunkSize = SINGLE_LINE_MAX_BYTES - 64;
+  const total = Math.ceil(encoded.length / chunkSize);
+  const lines = [];
+  for (let i = 0; i < total; i++) {
+    const fragment = encoded.slice(i * chunkSize, (i + 1) * chunkSize);
+    lines.push(`## COMPLETION-SUMMARY-CHUNK-${i + 1}/${total}: ${fragment}`);
+  }
+  return lines;
+}
+
+function isCompletionSummaryLine(line) {
+  if (typeof line !== 'string') return false;
+  if (line.startsWith(SINGLE_LINE_PREFIX)) return true;
+  return CHUNK_PREFIX_REGEX.test(line);
+}
+
+function parseMessage(line) {
+  if (typeof line !== 'string') {
+    return { ok: false, error: 'line must be a string' };
+  }
+  if (!line.startsWith(SINGLE_LINE_PREFIX)) {
+    return { ok: false, error: 'not a single-line COMPLETION-SUMMARY' };
+  }
+  const b64 = line.slice(SINGLE_LINE_PREFIX.length).trim();
+  try {
+    const payload = decodeBase64(b64);
+    return validatePayload(payload);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+function parseChunked(lines) {
+  if (!Array.isArray(lines) || lines.length === 0) {
+    return { ok: false, error: 'lines must be a non-empty array' };
+  }
+  const fragments = [];
+  let total = null;
+  for (const line of lines) {
+    const m = CHUNK_PREFIX_REGEX.exec(line);
+    if (!m) return { ok: false, error: 'non-chunk line in chunked input' };
+    const n = parseInt(m[1], 10);
+    const t = parseInt(m[2], 10);
+    if (total === null) total = t;
+    if (t !== total) return { ok: false, error: 'mismatched chunk totals' };
+    if (!Number.isInteger(n) || n < 1 || n > total) {
+      return { ok: false, error: `invalid chunk index: ${m[1]}` };
+    }
+    fragments[n - 1] = line.replace(CHUNK_PREFIX_REGEX, '');
+  }
+  if (fragments.length !== total || fragments.some(f => f === undefined)) {
+    return { ok: false, error: `missing chunks (have ${fragments.filter(Boolean).length} of ${total})` };
+  }
+  try {
+    const payload = decodeBase64(fragments.join(''));
+    return validatePayload(payload);
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Validate the shape of a completion-summary payload. Returns
+ * { ok: true, payload } or { ok: false, error }.
+ */
+function validatePayload(payload) {
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    return { ok: false, error: 'payload must be a JSON object' };
+  }
+  if (typeof payload.runId !== 'string' || !payload.runId) {
+    return { ok: false, error: 'missing runId' };
+  }
+  for (const key of ['completed', 'queuedQuestions', 'skippedTasks']) {
+    if (!Array.isArray(payload[key])) {
+      return { ok: false, error: `${key} must be an array` };
+    }
+  }
+  return { ok: true, payload };
+}
+
+/**
+ * Render a multi-worker workspace summary block. `summaries` is an array
+ * of validated payloads (each may include `workerId`).
+ *
+ * Empty-collection rule (decisions.md 2026-04-23): all 3 sections always
+ * render per worker. Workers with no work still appear with empty-state
+ * placeholders so the user never wonders if a worker is missing.
+ */
+function renderMultiWorker(summaries) {
+  const list = Array.isArray(summaries) ? summaries : [];
+  const lines = [];
+  lines.push(SEP);
+  lines.push('WORKSPACE AUTONOMOUS RUN COMPLETE');
+  lines.push(SEP);
+  lines.push('');
+
+  if (list.length === 0) {
+    lines.push('[no worker summaries received]');
+    lines.push(SEP);
+    return lines.join('\n');
+  }
+
+  let totalCompleted = 0;
+  let totalQuestions = 0;
+  let totalSkipped = 0;
+  for (const s of list) {
+    const workerId = s.workerId || 'unknown';
+    const dur = formatDuration(s.startedAt, s.endedAt);
+    const completed = Array.isArray(s.completed) ? s.completed : [];
+    const queued = Array.isArray(s.queuedQuestions) ? s.queuedQuestions : [];
+    const skipped = Array.isArray(s.skippedTasks) ? s.skippedTasks : [];
+    totalCompleted += completed.length;
+    totalQuestions += queued.length;
+    totalSkipped += skipped.length;
+
+    lines.push(`Worker: ${workerId} (runId: ${s.runId}, duration: ${dur})`);
+    lines.push(`  ✓ Completed (${completed.length}):`);
+    if (completed.length === 0) {
+      lines.push('    [none]');
+    } else {
+      for (const t of completed) lines.push(`    - ${t.taskId}: ${t.title || '(no title)'}`);
+    }
+    lines.push(`  ? Queued questions (${queued.length}):`);
+    if (queued.length === 0) {
+      lines.push('    [none]');
+    } else {
+      for (const q of queued) {
+        const blockers = Array.isArray(q.dependencies) && q.dependencies.length
+          ? ` (blocks: ${q.dependencies.join(', ')})`
+          : '';
+        lines.push(`    - ${q.id}: ${q.text}${blockers}`);
+      }
+    }
+    lines.push(`  ⊘ Skipped tasks (${skipped.length}):`);
+    if (skipped.length === 0) {
+      lines.push('    [none]');
+    } else {
+      for (const sk of skipped) {
+        const ref = sk.blockingQuestionId ? ` (awaiting ${sk.blockingQuestionId})` : '';
+        lines.push(`    - ${sk.taskId}: ${sk.reason}${ref}`);
+      }
+    }
+    if (s.endReason && s.endReason !== 'queue-drained') {
+      lines.push(`  ⚠ endReason: ${s.endReason}`);
+    }
+    lines.push('');
+  }
+
+  lines.push(`Total: ${totalCompleted} completed, ${totalQuestions} questions queued, ${totalSkipped} skipped across ${list.length} worker${list.length === 1 ? '' : 's'}`);
+  lines.push(SEP);
+  return lines.join('\n');
+}
+
+function formatDuration(startedAt, endedAt) {
+  if (!startedAt || !endedAt) return '0:00';
+  const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+  if (!Number.isFinite(ms) || ms < 0) return '0:00';
+  const sec = Math.floor(ms / 1000);
+  const m = Math.floor(sec / 60);
+  const s = sec % 60;
+  if (m >= 60) {
+    const h = Math.floor(m / 60);
+    return `${h}:${String(m % 60).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
+  }
+  return `${m}:${String(s).padStart(2, '0')}`;
+}
+
+module.exports = {
+  SINGLE_LINE_PREFIX,
+  CHUNK_PREFIX_REGEX,
+  SINGLE_LINE_MAX_BYTES,
+  encodeMessage,
+  parseMessage,
+  parseChunked,
+  isCompletionSummaryLine,
+  validatePayload,
+  renderMultiWorker
+};
+
+if (require.main === module) {
+  const [,, cmd, ...rest] = process.argv;
+  if (cmd === 'encode') {
+    const payload = JSON.parse(rest.join(' '));
+    console.log(encodeMessage(payload).join('\n'));
+  } else if (cmd === 'parse') {
+    const r = parseMessage(rest.join(' '));
+    console.log(JSON.stringify(r, null, 2));
+  } else {
+    console.log('Usage: flow-workspace-summary <encode <json>|parse <line>>');
+  }
+}

package/scripts/hooks/adapters/base-adapter.js

@@ -38,7 +38,7 @@ class BaseAdapter {
    * @param {Object} coreResult - Result from core module
    * @returns {Object} CLI-specific format
    */
-  transformResult(_event, coreResult) {
+  transformResult(_event, _coreResult) {
     throw new Error('transformResult() must be implemented by subclass');
   }
 
@@ -58,7 +58,7 @@ class BaseAdapter {
    * @param {Object} [transportConfig] - Transport config: { transport, url, headers, allowedEnvVars }
    * @returns {Object} CLI-specific hook configuration
    */
-  generateConfig(_rules, projectRoot, transportConfig) {
+  generateConfig(_rules, _projectRoot, _transportConfig) {
     throw new Error('generateConfig() must be implemented by subclass');
   }