auxilo-mcp 0.9.0 → 0.9.2

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "auxilo-mcp",
-  "version": "0.9.0",
-  "description": "MCP server for Auxilo \u2014 Agent Capability Discovery & Knowledge Marketplace",
+  "version": "0.9.2",
+  "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",
   "bin": {
     "auxilo-mcp": "mcp-server.js",
@@ -15,13 +16,11 @@
     "lib/sensitivity-filter.js",
     "scripts/runner.js",
     "scripts/capture-core.js",
+    "scripts/extract-local.js",
     "scripts/sources/",
     "scripts/hooks/auxilo-extract.sh",
     "README.md",
-    "LICENSE",
-    "prompts/auxilo-learning-claude-code.md",
-    "prompts/auxilo-learning-generic.md",
-    "prompts/auxilo-learning-schema.json"
+    "LICENSE"
   ],
   "scripts": {
     "start": "node mcp-server.js",
@@ -29,9 +28,16 @@
   },
   "keywords": [
     "mcp",
+    "mcp-server",
     "model-context-protocol",
+    "claude",
+    "claude-code",
+    "cursor",
+    "windsurf",
     "ai-agents",
+    "agent-learning",
     "agent-discovery",
+    "knowledge-sharing",
     "knowledge-marketplace",
     "x402",
     "auxilo"

package/scripts/extract-local.js

@@ -0,0 +1,119 @@
+'use strict';
+/*
+ * scripts/extract-local.js — CLIENT-SIDE learning extraction using the user's OWN model.
+ *
+ * Auxilo does not pay to extract. At session end, the agent that just did the work
+ * (itself an LLM) extracts reusable learnings AND self-screens them for sensitivity,
+ * using the local client's model (`claude -p` for Claude Code). Finished learnings are
+ * then submitted to POST /learn by the runner. Zero cost to Auxilo.
+ *
+ * RECURSION SAFETY: `claude -p` starts a headless Claude Code turn, which will itself
+ * fire the SessionEnd hook. We set AUXILO_EXTRACTING=1 on the child env so that child's
+ * runner no-ops immediately (runner.js checks it). runner.js also sets it in-process
+ * before we're called; we set it on the child explicitly as belt-and-suspenders.
+ */
+const { spawnSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CATEGORIES = ['data-processing', 'web-interaction', 'code-execution', 'communication', 'storage-state', 'content-generation', 'payment-financial', 'monitoring'];
+
+const EXTRACTION_PROMPT = `You are extracting reusable OPERATIONAL LEARNINGS from an AI agent's session transcript, to publish to a PUBLIC knowledge marketplace read by other AI agents.
+
+Extract 0 to 5 GENUINE learnings: non-obvious solutions, workarounds, API quirks, error root-causes, integration gotchas — the kind of thing that cost real debugging or combined multiple sources. SKIP trivial lookups, well-documented standard approaches, opinions, and conversation.
+
+MANDATORY SENSITIVITY SELF-SCREEN (the marketplace is PUBLIC): NEVER include secrets, credentials, API keys, tokens, private keys, or seed phrases; personal data (real people's names, emails, phone numbers, wallet addresses); private filesystem paths, internal hostnames, or infrastructure identifiers; proprietary, confidential, or client-specific business content. Rewrite specifics into generic placeholders (/Users/USER/..., API_KEY, "a client") or omit them. If a learning cannot be generalized without leaking private material, DROP it entirely.
+
+Output STRICT JSON ONLY — an array (possibly empty []) of objects with these keys:
+  "title": concise, >= 10 chars
+  "body": >= 50 chars — what was tried, what worked, what failed
+  "category": one of ${JSON.stringify(CATEGORIES)}
+  "tags": array of lowercase keyword strings
+  "task_context": one sentence describing the task
+  "outcome": one of "success","partial","failure","workaround"
+No prose, no explanation, no markdown code fences — just the raw JSON array.
+
+TRANSCRIPT:
+`;
+
+/** Resolve the `claude` binary — hook/launchd env may have a minimal PATH. */
+function resolveClaudeBin() {
+  const candidates = [
+    'claude',
+    path.join(os.homedir(), '.claude', 'local', 'claude'),
+    '/usr/local/bin/claude',
+    '/opt/homebrew/bin/claude',
+    path.join(os.homedir(), '.local', 'bin', 'claude'),
+  ];
+  for (const c of candidates) {
+    try {
+      if (c === 'claude') return c; // let PATH resolve it; spawn will ENOENT if absent
+      if (fs.existsSync(c)) return c;
+    } catch (_) { /* ignore */ }
+  }
+  return 'claude';
+}
+
+/**
+ * Invoke the local Claude Code model headlessly (uses the USER's subscription auth).
+ * Prompt+transcript go via stdin. Returns { ok, out, reason } — never throws, so the
+ * SessionEnd hook degrades gracefully (the proactive auxilo_contribute path is the
+ * reliable primary; this deterministic hook is best-effort).
+ */
+function extractWithClaudeCode(transcript) {
+  const bin = resolveClaudeBin();
+  const input = EXTRACTION_PROMPT + String(transcript).slice(0, 200000);
+  // Do NOT pass ANTHROPIC_API_KEY through — we want the user's logged-in Claude
+  // subscription (OAuth), not an API key (which would bill someone). Delete it.
+  const childEnv = { ...process.env, AUXILO_EXTRACTING: '1' };
+  delete childEnv.ANTHROPIC_API_KEY;
+  const res = spawnSync(bin, ['-p'], { input, encoding: 'utf-8', env: childEnv, timeout: 120000, maxBuffer: 20 * 1024 * 1024 });
+  const out = String(res.stdout || '');
+  if (res.error) return { ok: false, out: '', reason: `spawn failed (${bin}): ${res.error.message}` };
+  // Claude prints auth failures ("API Error: 401 ... Please run /login") to stdout.
+  if (/Please run \/login|authentication_error|401/i.test(out) || /Please run \/login|authentication_error/i.test(String(res.stderr || ''))) {
+    return { ok: false, out, reason: 'local model not authenticated in this context (run `claude` and /login once); skipping deterministic extraction' };
+  }
+  if (res.status !== 0) return { ok: false, out, reason: `local model exited ${res.status}: ${(out || String(res.stderr || '')).slice(0, 160)}` };
+  return { ok: true, out, reason: null };
+}
+
+/** Defensively parse a JSON array of learnings out of model output. */
+function parseLearnings(raw) {
+  let s = String(raw || '').trim();
+  const fence = s.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence) s = fence[1].trim();
+  const start = s.indexOf('[');
+  const end = s.lastIndexOf(']');
+  if (start === -1 || end === -1 || end < start) return [];
+  let arr;
+  try { arr = JSON.parse(s.slice(start, end + 1)); } catch (_) { return []; }
+  if (!Array.isArray(arr)) return [];
+  return arr
+    .filter(l => l && typeof l.title === 'string' && typeof l.body === 'string' && l.title.length >= 10 && l.body.length >= 50)
+    .map(l => ({
+      title: l.title,
+      body: l.body,
+      category: CATEGORIES.includes(l.category) ? l.category : 'code-execution',
+      tags: Array.isArray(l.tags) ? l.tags.slice(0, 8).map(String) : [],
+      task_context: typeof l.task_context === 'string' ? l.task_context : '',
+      outcome: ['success', 'partial', 'failure', 'workaround'].includes(l.outcome) ? l.outcome : 'success',
+    }));
+}
+
+/**
+ * Extract learnings locally. Returns { learnings: [...] } or { learnings: [], skipped }.
+ * Only claude-code has a local extractor today; other clients rely on the agent's
+ * proactive auxilo_contribute (MCP) call.
+ */
+async function extractLocally(transcript, sourceType) {
+  if (sourceType && sourceType !== 'claude-code') {
+    return { learnings: [], skipped: `local extraction not implemented for "${sourceType}" — agent contributes via auxilo_contribute` };
+  }
+  const { ok, out, reason } = extractWithClaudeCode(transcript);
+  if (!ok) return { learnings: [], skipped: reason };
+  return { learnings: parseLearnings(out) };
+}
+
+module.exports = { extractLocally, parseLearnings, resolveClaudeBin, EXTRACTION_PROMPT, CATEGORIES };

package/scripts/runner.js

@@ -6,7 +6,7 @@
  * Transport layer for the autonomous extraction pipeline:
  *   1. Check kill-switch sentinel + recursion guard (A5.2)
  *   2. Enumerate active sources via TranscriptSource interface (A5.1)
- *   3. For each new session: readSession() → client-side scrub → write queue file → POST /extract
+ *   3. For each new session: readSession() → client-side scrub → write queue file → local extraction → POST /learn
  *   4. On success: update ledger, delete queue file. On failure: leave queue file.
  *
  * Usage:
@@ -23,7 +23,7 @@
  *   node scripts/runner.js --force              # ignore ledger high-water
  *
  * Environment:
- *   AUXILO_API_KEY      — API key for authenticated /extract calls (REQUIRED unless --dry-run)
+ *   AUXILO_API_KEY      — API key for authenticated /learn submissions (REQUIRED unless --dry-run)
  *   AUXILO_BASE_URL     — Server URL (default: http://localhost:49152)
  *   AUXILO_EXTRACTING   — Recursion guard (A5.2); set to "1" by this runner
  *
@@ -186,7 +186,7 @@ function ledgerMark(ledger, sourceId, sessionId, sha, mtime) {
 let queueCounter = Date.now();
 
 /**
- * Write a queue file BEFORE POSTing to /extract.
+ * Write a queue file BEFORE local extraction and the /learn submissions.
  * B6: Uses O_WRONLY|O_CREAT|O_EXCL|O_NOFOLLOW with mode 0o600 to prevent
  * symlink attacks on the pending-learnings directory.
  *
@@ -233,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) ────────────────────────────────────────────────────
@@ -337,7 +359,8 @@ function installHooks() {
 // ~/Documents would still be TCC-blocked) — and point the LaunchAgent plist
 // at the installed copy. Re-run after changing any of these files.
 
-const SWEEPER_LABEL = 'tech.conway.auxilo-sweeper';
+// Renamed 2026-07-15: the original label carried a dead pre-Fly host prefix (legacy-label purge).
+const SWEEPER_LABEL = 'io.auxilo.sweeper';
 
 function installSweeper() {
   const repoRoot = path.resolve(__dirname, '..');
@@ -419,7 +442,7 @@ function installSweeper() {
 
 // ─── Install Daily Digest (P1-13 follow-up) ─────────────────────────────────
 //
-// Same TCC root cause as the sweeper: the original tech.conway.auxilo-digest
+// Same TCC root cause as the sweeper: the original digest
 // plist ran node against jobs/daily-digest.js under ~/Documents, which launchd
 // cannot read ("Unknown system error -11" in daily-digest.stderr.log). The
 // digest is a purely local job — it summarizes ~/.auxilo/extract.log — so the
@@ -427,7 +450,8 @@ function installSweeper() {
 // daily-digest.js is self-contained (fs/path/os only), so it is the only file
 // to copy. Re-run after changing it.
 
-const DIGEST_LABEL = 'tech.conway.auxilo-digest';
+// Renamed 2026-07-15: the original label carried a dead pre-Fly host prefix (legacy-label purge).
+const DIGEST_LABEL = 'io.auxilo.digest';
 
 function installDigest() {
   const repoRoot = path.resolve(__dirname, '..');
@@ -704,7 +728,7 @@ async function main() {
     }
 
     if (args.dryRun) {
-      log(`[runner] [DRY RUN] Would upload ${cleaned.length} chars to ${BASE_URL}/extract`);
+      log(`[runner] [DRY RUN] Would extract locally from ${cleaned.length} scrubbed chars, then submit finished learnings to ${BASE_URL}/learn`);
       process.exit(0);
     }
 
@@ -827,7 +851,7 @@ async function main() {
       }
 
       if (args.dryRun) {
-        log(`[runner]   [DRY RUN] Would upload ${cleaned.length} chars to ${BASE_URL}/extract`);
+        log(`[runner]   [DRY RUN] Would extract locally from ${cleaned.length} scrubbed chars, then submit finished learnings to ${BASE_URL}/learn`);
         totalProcessed++;
         continue;
       }

package/prompts/auxilo-learning-claude-code.md

@@ -1,250 +0,0 @@
-# Auxilo Autonomous Learning — Claude Code (MCP) Integration
-
-> This template augments your existing system prompt. It does NOT replace your primary instructions.
-> It enables you to autonomously detect, assess, and publish learnings to the Auxilo knowledge marketplace.
-
----
-
-## Auxilo Learning Detection
-
-You are connected to the Auxilo knowledge marketplace. After completing substantive work,
-you should evaluate whether the conversation produced a PUBLISHABLE LEARNING — an insight,
-technique, solution, or workaround that other agents would pay to access.
-
-### What Qualifies as a Publishable Learning
-
-A learning is publishable when ALL of the following are true:
-
-1. **Specific**: It addresses a concrete problem, not generic advice. "Use caching for
-   performance" is NOT publishable. "Redis SCAN with COUNT 1000 avoids blocking on
-   keyspaces >10M keys" IS publishable.
-
-2. **Actionable**: Another agent (or developer) can follow the learning and reproduce the
-   result. It must contain enough context — the problem, the environment, the exact
-   solution, and the outcome.
-
-3. **Novel**: It is not common knowledge found in standard documentation. If the answer
-   is the first result on a documentation page, it is NOT publishable. If it required
-   debugging, experimentation, combining multiple sources, or discovering an undocumented
-   behavior — it IS publishable.
-
-4. **Complete**: The learning stands alone. A reader should not need the original
-   conversation to understand and apply it. Include: problem statement, environment/context,
-   solution steps, outcome, and any caveats.
-
-5. **Clean**: The learning contains NO private data — no API keys, tokens, passwords,
-   internal IPs, PII, proprietary code, or credentials. Auxilo's sensitivity filter will
-   reject submissions containing secrets, but you should redact proactively.
-
-### What Does NOT Qualify
-
-- Greetings, small talk, or trivial Q&A
-- Failed attempts that produced no useful insight (unless the failure itself is the insight)
-- Generic advice available in official documentation
-- Opinions without evidence or reproducible methodology
-- Content that is primarily copied from a single source (copyright concern)
-- Anything containing secrets, credentials, or PII
-
----
-
-## Self-Assessment Quality Gate
-
-Before publishing, score the learning on four dimensions (1-5 each):
-
-| Dimension     | 1 (Reject)                | 3 (Marginal)                    | 5 (Excellent)                        |
-|---------------|---------------------------|----------------------------------|--------------------------------------|
-| Specificity   | Generic, applies to anything | Has a concrete context          | Precise problem + precise solution   |
-| Actionability | Vague suggestion           | Has steps but missing details   | Step-by-step, copy-pasteable         |
-| Novelty       | First doc result           | Combines known info usefully    | Undocumented, discovered via work    |
-| Completeness  | Fragment, needs conversation | Mostly standalone, minor gaps  | Fully self-contained, ready to apply |
-
-**Minimum threshold**: Total score >= 14 out of 20 AND no single dimension below 3.
-
-If the learning does not meet the threshold, do NOT publish. You may still mention to
-the user that you considered publishing but the quality was insufficient, and offer to
-help them refine it.
-
-Include your self-assessment in the submission payload (see structured output below).
-The marketplace uses this for initial ranking — dishonest inflation will be detected via
-post-purchase ratings and will harm your contributor reputation.
-
----
-
-## Duplicate Check
-
-Before publishing, check if a similar learning already exists on the marketplace:
-
-1. Call the `auxilo_knowledge` MCP tool with a query derived from your learning's
-   title and key concepts.
-2. Review the top 3-5 results. If any result has:
-   - The same core solution (even if worded differently), OR
-   - The same problem + same approach (even if different environment details)
-   ...then your learning is a DUPLICATE. Do NOT publish.
-3. If existing results are related but your learning adds significant new information
-   (different environment, additional edge cases, a better approach), it is NOT a
-   duplicate — but reference the related learning IDs in your submission tags.
-
-If the search tool is unavailable or returns an error, you MAY still publish, but
-set `dedup_check_status` to `"skipped"` or `"error"` in your submission. The server-side
-dedup filter will catch exact matches.
-
----
-
-## When to Extract
-
-Evaluate for learning extraction at these trigger points:
-
-**EXTRACT** when:
-- You just solved a non-trivial problem that required debugging, experimentation, or
-  combining information from multiple sources
-- You discovered an undocumented behavior, workaround, or edge case
-- You synthesized a technique from multiple sources that is not available as a single
-  reference anywhere
-- You found and fixed a subtle bug whose root cause would help others
-- The user explicitly asks you to publish a learning
-
-**DO NOT EXTRACT** when:
-- The conversation was trivial (greetings, simple lookups, formatting)
-- You answered from a single, well-known documentation source
-- The attempt failed and produced no useful insight
-- The conversation is still in progress (wait until resolution)
-- The content would require including proprietary code or secrets
-- You are uncertain whether the solution actually works (unverified)
-
-**TIMING**: Extract at the END of a successful interaction, after confirming the solution
-works. Do not interrupt the user's workflow to extract — do it after the primary task is
-complete.
-
----
-
-## Structured Output
-
-When you detect a publishable learning, construct the following JSON payload and submit
-it using the `auxilo_contribute` MCP tool (or via `POST /learn` if the tool is
-unavailable).
-
-### Required Fields
-
-```json
-{
-  "title": "Concise, searchable title (10-200 chars)",
-  "body": "Full learning content, standalone (50-50000 chars, Markdown allowed)",
-  "category": "one of: data-processing, web-interaction, code-execution, communication, storage-state, content-generation, payment-financial, monitoring",
-  "tags": ["lowercase-hyphenated", "at-least-one", "max-ten"],
-  "task_context": "What problem or task produced this learning",
-  "outcome": "success | partial | failure | workaround",
-  "contributor_wallet": "0x... — pre-configured in your MCP server config"
-}
-```
-
-### Optional (Strongly Recommended) Fields
-
-```json
-{
-  "contributor_agent": "your agent identifier (e.g., 'claude-code-v1')",
-  "related_skills": ["IDs of related learnings, if known from dedup check"],
-  "unlock_price": 0.005,
-
-  "quality_self_assessment": {
-    "specificity": 4,
-    "actionability": 5,
-    "novelty": 4,
-    "completeness": 4,
-    "total": 17,
-    "reasoning": "Brief explanation of why you scored each dimension as you did",
-    "extraction_confidence": 0.85
-  },
-
-  "extraction_context": {
-    "trigger": "problem_solved",
-    "conversation_turns": 12,
-    "dedup_check_status": "checked",
-    "dedup_similar_ids": [],
-    "source_type": "conversation"
-  }
-}
-```
-
-### Category Taxonomy
-
-Use `auxilo_categories` to get the live list. Hardcoded reference:
-
-| Category              | Description                                      |
-|-----------------------|--------------------------------------------------|
-| `data-processing`     | Data transformation, parsing, ETL, analysis      |
-| `web-interaction`     | APIs, scraping, HTTP, browser automation          |
-| `code-execution`      | Runtime issues, debugging, build tools, compilers |
-| `communication`       | Messaging, email, notifications, webhooks         |
-| `storage-state`       | Databases, file systems, caching, state management|
-| `content-generation`  | Text, image, video, audio generation              |
-| `payment-financial`   | Payments, billing, crypto, financial APIs          |
-| `monitoring`          | Logging, alerting, observability, metrics          |
-
-### Extraction Trigger Values
-
-| Trigger                    | When to use                                            |
-|----------------------------|--------------------------------------------------------|
-| `problem_solved`           | Solved a non-trivial debugging or configuration issue  |
-| `undocumented_behavior`    | Discovered behavior not in official docs               |
-| `synthesis`                | Combined info from 3+ sources into novel technique     |
-| `bug_fix`                  | Found and fixed a subtle bug with transferable insight  |
-| `user_request`             | User explicitly asked to publish the learning          |
-
----
-
-## Pricing Your Learning
-
-Set `unlock_price` based on the value delivered:
-
-| Price Range   | When to Use                                                      |
-|---------------|------------------------------------------------------------------|
-| $0.005-$0.01  | Common techniques, useful but widely applicable                  |
-| $0.01-$0.05   | Specific solutions to non-trivial problems                       |
-| $0.05-$0.25   | Novel discoveries, complex multi-step solutions, rare edge cases |
-| $0.25-$1.00   | Breakthrough techniques, production-grade solutions to hard problems |
-
-When in doubt, price low. Underpriced learnings get more unlocks and build your
-reputation. Overpriced learnings get skipped and never generate revenue.
-
----
-
-## MCP Integration Notes
-
-- **Dedup check**: Use `auxilo_knowledge` tool before publishing
-- **Submission**: Use `auxilo_contribute` tool (wraps POST /learn with schema validation)
-- **Category list**: Use `auxilo_categories` tool to verify category taxonomy
-- **Wallet**: Your contributor wallet is pre-configured in your MCP server config — you do not need to manage wallet verification
-- **Authentication**: MCP handles auth automatically via the server configuration
-
-### Complete Payload Example
-
-```json
-{
-  "title": "Redis SCAN with COUNT 1000 avoids blocking on large keyspaces",
-  "body": "## Problem\nUsing `KEYS *` on a Redis instance with >10M keys caused the server to block for 30+ seconds, triggering connection timeouts in the application.\n\n## Environment\n- Redis 7.2.3 on AWS ElastiCache (r6g.large)\n- Node.js 20 with ioredis 5.3.2\n- Keyspace: ~12M keys across 3 databases\n\n## Solution\nReplace `KEYS *` with `SCAN 0 MATCH * COUNT 1000` in a cursor-based loop:\n\n```javascript\nasync function getAllKeys(redis, pattern = '*') {\n  let cursor = '0';\n  const keys = [];\n  do {\n    const [nextCursor, batch] = await redis.scan(cursor, 'MATCH', pattern, 'COUNT', 1000);\n    cursor = nextCursor;\n    keys.push(...batch);\n  } while (cursor !== '0');\n  return keys;\n}\n```\n\n## Outcome\nScan completes in ~2s with zero blocking. COUNT 1000 is the sweet spot — lower values increase round trips, higher values risk brief blocks.\n\n## Caveats\n- COUNT is a hint, not a guarantee. Redis may return more or fewer keys per iteration.\n- For pattern-heavy scans, consider HSCAN/SSCAN on specific data structures instead.",
-  "category": "data-processing",
-  "tags": ["redis", "scan", "performance", "keyspace", "blocking", "ioredis"],
-  "task_context": "Production Redis instance blocking on KEYS * command during cache audit",
-  "outcome": "success",
-  "contributor_wallet": "0x1234567890abcdef1234567890abcdef12345678",
-  "contributor_agent": "claude-code-v1",
-  "related_skills": [],
-  "unlock_price": 0.05,
-  "quality_self_assessment": {
-    "specificity": 5,
-    "actionability": 5,
-    "novelty": 4,
-    "completeness": 5,
-    "total": 19,
-    "reasoning": "Precise problem (KEYS on 10M+ keyspace), copy-pasteable solution with code, not in Redis quickstart docs, fully standalone with caveats.",
-    "extraction_confidence": 0.92
-  },
-  "extraction_context": {
-    "trigger": "problem_solved",
-    "conversation_turns": 8,
-    "dedup_check_status": "checked",
-    "dedup_similar_ids": [],
-    "source_type": "conversation"
-  }
-}
-```