auxilo-mcp 0.9.10 → 0.9.11

package/bin/auxilo-cli.js

@@ -860,6 +860,198 @@ async function cmdReview(flags) {
   console.log(`\nReview complete: approved ${approved}, kept private ${keptPrivate}, rejected ${rejected}, skipped ${skipped} of ${ordered.length}.`);
 }
 
+// ─── auxilo clean-lane (SPEC3-C1 standing consent; CLEAN-LANE-FLIP Phase A) ──
+//
+// GOV-3 (ratified language, Gate-A 2026-09-05): `grant` runs ONLY on a TTY and
+// requires the human to TYPE the affirmation sentence verbatim — no --yes, no
+// flag. The TTY gate + verbatim affirmation prevent ACCIDENTAL enrollment and
+// create a hash-chained record of a DELIBERATE act by the credential holder.
+// That record is EVIDENTIARY, not preventive: it is not a defense against a
+// holder of the account's contribute-scoped key, who can reach the same routes
+// directly. `status` / `revoke` are non-interactive.
+// While the server flag is off the routes answer the catch-all 404 and every
+// subcommand prints "not yet available" (exit 0).
+//
+// The sentence below MIRRORS lib/clean-lane.js CLEAN_LANE_AFFIRMATION. It is
+// a literal here only because lib/clean-lane.js is server-side and not in the
+// published package's files[]; test/clean-lane-phase-a.test.js pins the two
+// byte-equal. The consent VERSION is never a client literal — it always comes
+// from GET /account/clean-lane (consent_version_current).
+const CLEAN_LANE_AFFIRMATION = 'I understand and choose auto-publish for qualifying extracted learnings.';
+const CLEAN_LANE_UNAVAILABLE = 'Auto-publish for clean learnings is not yet available on this account.';
+const CLEAN_LANE_MIN_QUALITY_MIN = 14;
+const CLEAN_LANE_MIN_QUALITY_MAX = 20;
+const CLEAN_LANE_MIN_QUALITY_DEFAULT = 16;
+
+const CLEAN_LANE_EXPLAINER = `
+Auto-publish clean learnings
+
+When this is on, a learning is published without waiting for your review
+only when all three hold: it was extracted by your own model, every server
+screen came back clean, and its quality score is at or above the threshold
+you set.
+
+What is never auto-published: your first public learning (it waits for
+operator review), anything a screen flags, anything below your threshold,
+and anything after an auto-freeze. Every auto-published learning can be
+retracted for 7 days (\`npx auxilo review\` or your dashboard).
+`;
+
+async function cleanLaneRequest({ apiKey, baseUrl, method, route, body }) {
+  const url = `${String(baseUrl).replace(/\/+$/, '')}${route}`;
+  const headers = { 'X-API-Key': apiKey };
+  if (body !== undefined) headers['Content-Type'] = 'application/json';
+  const res = await fetch(url, {
+    method,
+    headers,
+    ...(body !== undefined && { body: JSON.stringify(body) }),
+  });
+  let data = {};
+  try { data = await res.json(); } catch { /* non-JSON body */ }
+  return { status: res.status, ok: res.ok, data: data || {} };
+}
+
+function printCleanLaneStatus(data) {
+  const active = data.clean_lane_active === true;
+  console.log(`Auto-publish clean learnings: ${active ? 'ON' : 'OFF'}`);
+  if (active) {
+    console.log(`  since:            ${data.last_action_at || 'unknown'}`);
+    console.log(`  quality at least: ${data.min_auto_publish_quality}`);
+    console.log(`  consent version:  ${data.consent_version_recorded || data.consent_version_current}`);
+  } else if (data.last_action === 'freeze') {
+    console.log(`  FROZEN: ${data.freeze_reason || 'unknown reason'} (${data.last_action_at || 'unknown time'})`);
+    console.log('  Nothing auto-publishes until you grant consent again: npx auxilo clean-lane grant');
+  } else if (data.last_action === 'revoke') {
+    console.log(`  revoked at: ${data.last_action_at || 'unknown'}`);
+  } else if (data.last_action === 'grant') {
+    console.log(`  a grant exists under consent version ${data.consent_version_recorded} but the current version is ${data.consent_version_current}; re-grant to re-activate.`);
+  }
+  console.log(`  current consent version: ${data.consent_version_current}`);
+}
+
+async function cmdCleanLane(flags) {
+  const sub = process.argv[3];
+  if (!['status', 'grant', 'revoke'].includes(sub)) {
+    if (sub) console.error(`Unknown clean-lane subcommand: ${sub}`);
+    usage('clean-lane');
+    process.exit(sub ? 1 : 0);
+  }
+
+  // The TTY gate runs BEFORE credentials and BEFORE any network call: a
+  // piped or scripted stdin can never reach the grant.
+  if (sub === 'grant' && !process.stdin.isTTY) {
+    console.error('auxilo clean-lane grant must be run by a person in an interactive terminal. It does not accept piped input, and there is no flag that skips typing the consent sentence.');
+    process.exit(1);
+  }
+
+  const creds = installer.readCredentials(HOME);
+  if (!creds || !creds.api_key) {
+    console.error('Not logged in. Run `npx auxilo setup` first.');
+    process.exit(1);
+  }
+  const baseUrl = resolveBaseUrl(flags);
+  const apiKey = creds.api_key;
+
+  let status;
+  try {
+    status = await cleanLaneRequest({ apiKey, baseUrl, method: 'GET', route: '/account/clean-lane' });
+  } catch (err) {
+    console.error(`Could not reach the server: ${err.message}`);
+    process.exit(1);
+  }
+  if (status.status === 404) {
+    console.log(CLEAN_LANE_UNAVAILABLE);
+    return;
+  }
+  if (!status.ok) {
+    console.error(`Could not read auto-publish status (HTTP ${status.status}): ${status.data.error || 'unknown error'}`);
+    process.exit(1);
+  }
+
+  if (sub === 'status') {
+    printCleanLaneStatus(status.data);
+    return;
+  }
+
+  if (sub === 'revoke') {
+    let res;
+    try {
+      res = await cleanLaneRequest({ apiKey, baseUrl, method: 'POST', route: '/account/clean-lane/revoke', body: {} });
+    } catch (err) {
+      console.error(`Could not reach the server: ${err.message}`);
+      process.exit(1);
+    }
+    if (res.status === 404) { console.log(CLEAN_LANE_UNAVAILABLE); return; }
+    if (!res.ok) {
+      console.error(`Revoke failed (HTTP ${res.status}): ${res.data.error || 'unknown error'}`);
+      process.exit(1);
+    }
+    console.log(res.data.message || 'Auto-publish is now OFF.');
+    return;
+  }
+
+  // ── grant: explainer → threshold → the sentence, typed verbatim ──────────
+  console.log(CLEAN_LANE_EXPLAINER);
+  if (status.data.clean_lane_active === true) {
+    console.log(`Auto-publish is already ON (quality at least ${status.data.min_auto_publish_quality}, since ${status.data.last_action_at}). Granting again records a fresh consent row with the threshold you choose now.\n`);
+  } else if (status.data.last_action === 'freeze') {
+    console.log(`Auto-publish is FROZEN: ${status.data.freeze_reason || 'unknown reason'}. Granting again re-activates it.\n`);
+  }
+
+  let minQuality = CLEAN_LANE_MIN_QUALITY_DEFAULT;
+  for (;;) {
+    const answer = await ask(`Publish only when the quality score is at least [${CLEAN_LANE_MIN_QUALITY_MIN}-${CLEAN_LANE_MIN_QUALITY_MAX}, default ${CLEAN_LANE_MIN_QUALITY_DEFAULT}]: `);
+    if (answer === '') break;
+    const n = parseInt(answer, 10);
+    if (Number.isInteger(n) && String(n) === answer && n >= CLEAN_LANE_MIN_QUALITY_MIN && n <= CLEAN_LANE_MIN_QUALITY_MAX) {
+      minQuality = n;
+      break;
+    }
+    if (readlineEnded) { console.log('Aborted. Nothing changed.'); return; }
+    console.log(`Enter a whole number from ${CLEAN_LANE_MIN_QUALITY_MIN} to ${CLEAN_LANE_MIN_QUALITY_MAX}.`);
+  }
+
+  console.log('\nTo turn on auto-publish, type this sentence exactly as written, then press Enter:');
+  console.log(`\n  ${CLEAN_LANE_AFFIRMATION}\n`);
+  const typed = await ask('> ');
+  if (typed !== CLEAN_LANE_AFFIRMATION) {
+    console.log('The sentence did not match. Aborted. Nothing changed.');
+    return;
+  }
+
+  let res;
+  try {
+    res = await cleanLaneRequest({
+      apiKey,
+      baseUrl,
+      method: 'POST',
+      route: '/account/clean-lane/grant',
+      body: {
+        consent_version: status.data.consent_version_current,
+        agree: true,
+        affirmation: typed, // what the human typed, transmitted verbatim
+        min_auto_publish_quality: minQuality,
+      },
+    });
+  } catch (err) {
+    console.error(`Could not reach the server: ${err.message}`);
+    process.exit(1);
+  }
+  if (res.status === 404) { console.log(CLEAN_LANE_UNAVAILABLE); return; }
+  if (res.status === 409) {
+    console.error('The consent version changed on the server while you were reading. Run `npx auxilo clean-lane grant` again.');
+    process.exit(1);
+  }
+  if (!res.ok) {
+    console.error(`Grant failed (HTTP ${res.status}): ${res.data.error || 'unknown error'}`);
+    process.exit(1);
+  }
+  console.log(`\n${res.data.message || 'Auto-publish is now ON.'}`);
+  console.log(`  quality at least: ${res.data.min_auto_publish_quality}`);
+  console.log(`  consent version:  ${res.data.consent_version}`);
+  console.log('  Turn it off any time: npx auxilo clean-lane revoke');
+}
+
 // ─── Entry point ────────────────────────────────────────────────────────────
 
 function usage(command) {
@@ -903,6 +1095,18 @@ them private or sanitize-promote a corrected replacement.`,
     disable: `Usage: auxilo disable [--base-url <url>]
 
 Disable background extraction locally and optionally revoke server consent.`,
+    'clean-lane': `Usage: auxilo clean-lane <status|grant|revoke> [--base-url <url>]
+
+Auto-publish clean learnings (standing consent). While the feature is not yet
+available on your account every subcommand says so and changes nothing.
+
+  status   Show whether auto-publish is on, the quality threshold, and the
+           consent version.
+  grant    Turn it on. Interactive ONLY: you choose the threshold and then
+           TYPE the consent sentence exactly. No flag or piped input can do
+           this for you.
+  revoke   Turn it off (one step, no confirmation). Already-published
+           learnings keep their 7-day retraction window.`,
   };
   if (command && blocks[command]) {
     console.log(`\n${blocks[command]}\n`);
@@ -951,6 +1155,9 @@ Commands:
             skips that step.
   disable   Turn off background extraction (local kill-switch; optional
             server-side consent revoke).
+  clean-lane <status|grant|revoke>
+            Auto-publish clean learnings (standing consent). grant is
+            interactive only: you type the consent sentence yourself.
 
 Docs: https://auxilo.io · API: ${installer.DEFAULT_BASE_URL}
 `);
@@ -959,7 +1166,7 @@ Docs: https://auxilo.io · API: ${installer.DEFAULT_BASE_URL}
 async function main() {
   const cmd = process.argv[2];
   const subcommandHelp = ['help', '--help', '-h'].includes(process.argv[3]);
-  if (['setup', 'init', 'status', 'review', 'disable'].includes(cmd) && subcommandHelp) {
+  if (['setup', 'init', 'status', 'review', 'disable', 'clean-lane'].includes(cmd) && subcommandHelp) {
     return usage(cmd);
   }
   const flags = parseFlags(process.argv);
@@ -969,6 +1176,7 @@ async function main() {
     case 'status': return cmdStatus(flags);
     case 'review': return cmdReview(flags);
     case 'disable': return cmdDisable(flags);
+    case 'clean-lane': return cmdCleanLane(flags);
     case 'help': case '--help': case '-h': case undefined: return usage();
     default:
       console.error(`Unknown command: ${cmd}`);
@@ -1002,4 +1210,6 @@ module.exports = {
   printSummaryTable,
   usage,
   run,
+  CLEAN_LANE_AFFIRMATION,
+  CLEAN_LANE_UNAVAILABLE,
 };

package/lib/extraction-index.js

@@ -140,6 +140,20 @@ function localIndexRow(learning, response = {}, opts = {}) {
     ...(typeof response.status === 'string' && VALID_STATUSES.has(response.status) && {
       status: response.status,
     }),
+    // CLEAN-LANE-FLIP Phase A2: persist the standing-consent publish stamps the
+    // /learn response carries (published_via / standing_consent_version /
+    // retractable_until) so the SessionStart rollup (scripts/review-notice.js)
+    // can count clean-lane publishes from the local index. Spread only when
+    // present as non-empty strings; absent on every non-clean-lane response.
+    ...(typeof response.published_via === 'string' && response.published_via && {
+      published_via: response.published_via,
+    }),
+    ...(typeof response.standing_consent_version === 'string' && response.standing_consent_version && {
+      standing_consent_version: response.standing_consent_version,
+    }),
+    ...(typeof response.retractable_until === 'string' && response.retractable_until && {
+      retractable_until: response.retractable_until,
+    }),
   };
 }
 

package/mcp-server.js

@@ -198,7 +198,7 @@ async function postBulkChunks(headers, decisions) {
 }
 
 const server = new Server(
-  { name: 'auxilo', version: '0.9.10' },
+  { name: 'auxilo', version: '0.9.11' },
   {
     capabilities: { tools: {} },
     instructions: `You are connected to Auxilo, a knowledge marketplace where AI agents buy and sell operational learnings.
@@ -384,7 +384,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'auxilo_contributor',
-      description: 'Check earnings for a contributor wallet. Shows total earned, per-learning breakdown. Free.',
+      description: 'Check aggregate earnings totals for a contributor wallet. Per-learning earnings require the authenticated auxilo_account_earnings tool. Free.',
       inputSchema: {
         type: 'object',
         properties: {
@@ -408,7 +408,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
     },
     {
       name: 'auxilo_account_earnings',
-      description: 'View earnings for your authenticated Auxilo account. Authenticates with your configured API key automatically, or pass a session_token (JWT). Returns total gross, contributor share, pending balance, total withdrawn, whether withdrawal is available (can_withdraw), and held_pending_assent — undisbursable receipts recorded before you accepted the current Terms, released to your withdrawable balance when you accept via auxilo_accept_terms. Earnings from on-chain-settled sales are paid to your wallet at sale time and appear in settlement history, not in pending balance. Free.',
+      description: 'View aggregate and per-learning earnings for your authenticated Auxilo account. Authenticates with your configured API key automatically, or pass a session_token (JWT). Returns total gross, contributor share, pending balance, total withdrawn, whether withdrawal is available (can_withdraw), and held_pending_assent — undisbursable receipts recorded before you accepted the current Terms, released to your withdrawable balance when you accept via auxilo_accept_terms. Earnings from on-chain-settled sales are paid to your wallet at sale time and appear in settlement history, not in pending balance. Free.',
       inputSchema: {
         type: 'object',
         properties: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auxilo-mcp",
-  "version": "0.9.10",
+  "version": "0.9.11",
   "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

@@ -662,11 +662,55 @@ async function runAnchoredJudge(candidates, indexState, opts = {}) {
 
 /**
  * Extract learnings locally. Returns { learnings: [...] } or { learnings: [], skipped }.
- * Claude Code and Codex rollout captures use the existing client-local Claude
- * extractor; other clients rely on the agent's proactive auxilo_contribute
- * (MCP) call.
+ *
+ * EXT-GATE: every capture source id runs the client-local extractor. The
+ * extractor is transcript-text based (buildExtractionPrompt carries no
+ * per-source branch), so nothing here depends on WHICH client captured.
+ * Unknown ids still short-circuit: a `--source` value the registry does not
+ * know is a misconfigured shim, not a client, and the skip message below is
+ * matched by runner.js and test/uc6-codex-capture.test.js — do not change it.
+ *
+ * The list is static on purpose: lib/installer.js is not in RUNNER_STACK, so
+ * this file cannot enumerate the registry at runtime. The closure test
+ * (test/ext-gate-closure.test.js) derives the expected set from the two live
+ * enumerations — scripts/sources/*.js adapter ids ∪ installer hook-client
+ * source ids — and is the authority; a new adapter or hook client that is not
+ * added here turns CI red.
  */
-const EXTRACTABLE_SOURCES = new Set(['claude-code', 'codex-cli']);
+const EXTRACTABLE_SOURCE_IDS = Object.freeze([
+  'antigravity',
+  'claude-code',
+  'cline',
+  'codex-cli',
+  'continue',
+  'copilot',
+  'cursor',
+  'factory',
+  'gemini-cli',
+  'openclaw',
+  'roo-code',
+  'windsurf',
+]);
+
+// Gate-A 2026-09-05: the exported set is IMMUTABLE. It stays a real Set (same
+// name, `.has()` / iteration / `instanceof Set` unchanged) but its own
+// add/delete/clear shadow the prototype's and throw, so no importer can widen
+// or narrow the allowlist at runtime — the frozen id array above is the only
+// source and the closure test is the only authority.
+function immutableSet(ids) {
+  const set = new Set(ids);
+  const refuse = (op) => function () {
+    throw new TypeError(`EXTRACTABLE_SOURCES is immutable (${op} refused)`);
+  };
+  Object.defineProperties(set, {
+    add: { value: refuse('add'), writable: false, configurable: false, enumerable: false },
+    delete: { value: refuse('delete'), writable: false, configurable: false, enumerable: false },
+    clear: { value: refuse('clear'), writable: false, configurable: false, enumerable: false },
+  });
+  return Object.freeze(set);
+}
+
+const EXTRACTABLE_SOURCES = immutableSet(EXTRACTABLE_SOURCE_IDS);
 
 async function extractLocally(transcript, sourceType, opts = {}) {
   if (sourceType && !EXTRACTABLE_SOURCES.has(sourceType)) {
@@ -780,7 +824,7 @@ async function extractLocally(transcript, sourceType, opts = {}) {
 }
 
 module.exports = {
-  extractLocally, extractWithClaudeCode, checkClaudeAuthStatus,
+  extractLocally, extractWithClaudeCode, checkClaudeAuthStatus, EXTRACTABLE_SOURCES, EXTRACTABLE_SOURCE_IDS,
   parseLearnings, parseExtractionOutput, resolveClaudeBin,
   CATEGORIES, PRIVATE_CATEGORIES, RETIRED_CATEGORIES,
   EXTRACTION_PROMPT, buildExtractionPrompt, scoreExtractionEnabled,

package/scripts/review-notice.js

@@ -24,6 +24,13 @@
  *   - Count source: GET /account/pending/summary with the credentials from
  *     ~/.auxilo/credentials.json; 3.5s abort so session start is never held
  *     hostage by a slow network.
+ *   - Standing-consent rollup (CLEAN-LANE-FLIP Phase A, SPEC3-C1 §4.3): ONE
+ *     more count-only line when the LOCAL submitted-learnings log
+ *     (~/.auxilo/extracted-index.jsonl, lib/extraction-index.js) holds rows
+ *     stamped published_via = clean_lane_standing_consent since the last
+ *     notice. Zero platform cost; reaches the human in their own client.
+ *     Suppression and the last-notice stamp are shared with the held-count
+ *     line (one state file, one 4h window).
  *
  * Self-contained (fs/path/os + global fetch) — ships in RUNNER_STACK to
  * ~/.auxilo/bin/scripts/ and must not require anything outside that layout
@@ -86,6 +93,61 @@ function renderNotice(count) {
   return `Auxilo: ${count} learning(s) held for your review — run auxilo_review (MCP) or \`npx auxilo review\`.`;
 }
 
+/**
+ * Stamp lib/clean-lane.js writes on lane publishes (PUBLISHED_VIA_CLEAN_LANE).
+ * A literal here because this script is self-contained (RUNNER_STACK layout);
+ * test/clean-lane-phase-a.test.js pins the two byte-equal.
+ */
+const PUBLISHED_VIA_CLEAN_LANE = 'clean_lane_standing_consent';
+
+/** Local submitted-learnings log (lib/extraction-index.js DEFAULT_INDEX_PATH). */
+function submittedIndexPath(homeDir) {
+  return path.join(auxiloDir(homeDir), 'extracted-index.jsonl');
+}
+
+/** Read the local log; absent/unreadable → []; malformed lines skipped. */
+function readSubmittedRows(homeDir) {
+  let raw;
+  try {
+    raw = fs.readFileSync(submittedIndexPath(homeDir), 'utf-8');
+  } catch {
+    return [];
+  }
+  const rows = [];
+  for (const line of String(raw).split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row && typeof row === 'object') rows.push(row);
+    } catch { /* skip */ }
+  }
+  return rows;
+}
+
+/**
+ * Pure: how many local rows were published under standing consent AFTER
+ * `sinceIso` (the last notice stamp). No stamp → every such row counts.
+ */
+function countStandingConsentPublishes(rows, sinceIso) {
+  const since = sinceIso ? Date.parse(sinceIso) : NaN;
+  let n = 0;
+  for (const row of rows || []) {
+    if (!row || row.published_via !== PUBLISHED_VIA_CLEAN_LANE) continue;
+    if (Number.isFinite(since)) {
+      const t = Date.parse(row.submitted_at);
+      if (!Number.isFinite(t) || t <= since) continue;
+    }
+    n += 1;
+  }
+  return n;
+}
+
+/** The rollup line. Count only — same contract as renderNotice. */
+function renderStandingConsentNotice(count) {
+  return `Auxilo: ${count} learning(s) auto-published under your standing consent (retract within 7 days: npx auxilo review).`;
+}
+
 /** Load credentials; null when absent/malformed/keyless. */
 function readCredentials(homeDir) {
   try {
@@ -125,18 +187,26 @@ async function main() {
   const creds = readCredentials(homeDir);
   if (!creds) return;
 
-  if (!shouldNotify(readState(homeDir))) return;
+  const state = readState(homeDir);
+  if (!shouldNotify(state)) return;
 
   const count = await fetchPendingCount(creds);
-  if (count == null || count <= 0) return;
+  const autoPublished = countStandingConsentPublishes(readSubmittedRows(homeDir), state.last_notice_at);
+
+  const lines = [];
+  if (count != null && count > 0) lines.push(renderNotice(count));
+  if (autoPublished > 0) lines.push(renderStandingConsentNotice(autoPublished));
+  if (lines.length === 0) return;
 
-  process.stdout.write(renderNotice(count) + '\n');
+  process.stdout.write(lines.join('\n') + '\n');
   writeState(homeDir);
 }
 
 module.exports = {
   shouldNotify, renderNotice, readState, writeState, readCredentials,
   fetchPendingCount, NOTICE_SUPPRESSION_MS, FETCH_TIMEOUT_MS,
+  PUBLISHED_VIA_CLEAN_LANE, submittedIndexPath, readSubmittedRows,
+  countStandingConsentPublishes, renderStandingConsentNotice,
 };
 
 if (require.main === module) {