@crowdlisten/harness 1.0.0

package/dist/context/pipeline.js

@@ -0,0 +1,56 @@
+/**
+ * Orchestrator: parse -> redact -> chunk -> extract -> match -> store
+ */
+import { redactPII } from "./redactor.js";
+import { parseFile, chunkText } from "./parser.js";
+import { extractBlocks } from "./extractor.js";
+import { matchSkills } from "./matcher.js";
+import { createProvider } from "./providers.js";
+import { addBlocks, loadConfig } from "./store.js";
+/**
+ * Run the full context extraction pipeline.
+ */
+export async function runPipeline(opts) {
+    const config = opts.config || loadConfig();
+    if (!config) {
+        throw new Error("No LLM provider configured. Run: npx @crowdlisten/harness setup");
+    }
+    const provider = createProvider(config);
+    const source = opts.source || opts.filePath || "paste";
+    // 1. Get raw text
+    let rawText = opts.text || "";
+    if (opts.filePath) {
+        const parsed = await parseFile(opts.filePath);
+        rawText = rawText ? rawText + "\n\n---\n\n" + parsed : parsed;
+    }
+    if (!rawText.trim()) {
+        throw new Error("No content to process");
+    }
+    // 2. PII redaction
+    const { redactedText, stats: redactionStats, totalRedactions } = redactPII(rawText);
+    // 3. Chunk
+    const chunks = chunkText(redactedText);
+    const total = chunks.length;
+    // 4. Extract blocks from each chunk
+    const allBlocks = [];
+    const isChat = opts.isChat !== false; // default true
+    for (let i = 0; i < chunks.length; i++) {
+        opts.onProgress?.({ current: i + 1, total, blocksFound: allBlocks.length });
+        const blocks = await extractBlocks(provider, chunks[i], source, isChat);
+        allBlocks.push(...blocks);
+    }
+    // 5. Match skills
+    const skills = await matchSkills(allBlocks);
+    // 6. Store locally
+    if (allBlocks.length > 0) {
+        addBlocks(allBlocks, source);
+    }
+    opts.onProgress?.({ current: total, total, blocksFound: allBlocks.length });
+    return {
+        blocks: allBlocks,
+        skills,
+        redactionStats,
+        totalRedactions,
+        chunkCount: total,
+    };
+}

package/dist/context/prompts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * System prompts for LLM-based context extraction.
+ * Extracted from crowdlisten_deployed/frontend/src/services/contextBlockService.js
+ */
+export declare const EXTRACT_SYSTEM_PROMPT = "You are a context extraction engine. Analyze the provided text and extract reusable context blocks.\n\nExtract two categories:\n1. **style** \u2014 Writing patterns, tone, communication style, formatting habits, voice characteristics\n2. **insight** \u2014 Key facts, quotes, data points, actionable knowledge, domain expertise\n\nReturn JSON with this exact schema:\n{\n  \"blocks\": [\n    {\n      \"type\": \"style\" | \"insight\",\n      \"title\": \"Short descriptive title (3-8 words)\",\n      \"content\": \"The extracted context block content (1-3 sentences)\"\n    }\n  ]\n}\n\nRules:\n- Extract 3-10 blocks depending on content richness\n- Each block should be self-contained and reusable\n- Style blocks capture HOW the person communicates\n- Insight blocks capture WHAT knowledge is present\n- Titles should be specific and descriptive\n- Content should be concise but complete\n- Return valid JSON only, no markdown fences";
+export declare const CHAT_EXTRACT_SYSTEM_PROMPT = "You are a context extraction engine analyzing AI chat history. Extract reusable context blocks that capture the user's patterns, knowledge, and preferences.\n\nExtract four categories:\n1. **style** \u2014 Writing patterns, tone, communication style, formatting habits, voice characteristics\n2. **insight** \u2014 Key facts, domain expertise, actionable knowledge, important decisions or conclusions\n3. **pattern** \u2014 Recurring workflows, decision-making approaches, problem-solving methods, repeated processes\n4. **preference** \u2014 Tool choices, format preferences, working style, technology opinions, environment setup\n\nReturn JSON with this exact schema:\n{\n  \"blocks\": [\n    {\n      \"type\": \"style\" | \"insight\" | \"pattern\" | \"preference\",\n      \"title\": \"Short descriptive title (3-8 words)\",\n      \"content\": \"The extracted context block content (1-3 sentences)\"\n    }\n  ]\n}\n\nRules:\n- Extract 5-15 blocks depending on content richness\n- Each block should be self-contained and reusable across conversations\n- Deduplicate \u2014 if the same theme appears multiple times, synthesize into one block\n- Focus on the USER's behavior, not the assistant's\n- Style blocks capture HOW the person communicates\n- Insight blocks capture WHAT knowledge or expertise they have\n- Pattern blocks capture HOW they work and make decisions\n- Preference blocks capture WHAT tools/formats/approaches they choose\n- Titles should be specific and descriptive\n- Content should be concise but complete\n- Return valid JSON only, no markdown fences";

package/dist/context/prompts.js

@@ -0,0 +1,60 @@
+/**
+ * System prompts for LLM-based context extraction.
+ * Extracted from crowdlisten_deployed/frontend/src/services/contextBlockService.js
+ */
+export const EXTRACT_SYSTEM_PROMPT = `You are a context extraction engine. Analyze the provided text and extract reusable context blocks.
+
+Extract two categories:
+1. **style** — Writing patterns, tone, communication style, formatting habits, voice characteristics
+2. **insight** — Key facts, quotes, data points, actionable knowledge, domain expertise
+
+Return JSON with this exact schema:
+{
+  "blocks": [
+    {
+      "type": "style" | "insight",
+      "title": "Short descriptive title (3-8 words)",
+      "content": "The extracted context block content (1-3 sentences)"
+    }
+  ]
+}
+
+Rules:
+- Extract 3-10 blocks depending on content richness
+- Each block should be self-contained and reusable
+- Style blocks capture HOW the person communicates
+- Insight blocks capture WHAT knowledge is present
+- Titles should be specific and descriptive
+- Content should be concise but complete
+- Return valid JSON only, no markdown fences`;
+export const CHAT_EXTRACT_SYSTEM_PROMPT = `You are a context extraction engine analyzing AI chat history. Extract reusable context blocks that capture the user's patterns, knowledge, and preferences.
+
+Extract four categories:
+1. **style** — Writing patterns, tone, communication style, formatting habits, voice characteristics
+2. **insight** — Key facts, domain expertise, actionable knowledge, important decisions or conclusions
+3. **pattern** — Recurring workflows, decision-making approaches, problem-solving methods, repeated processes
+4. **preference** — Tool choices, format preferences, working style, technology opinions, environment setup
+
+Return JSON with this exact schema:
+{
+  "blocks": [
+    {
+      "type": "style" | "insight" | "pattern" | "preference",
+      "title": "Short descriptive title (3-8 words)",
+      "content": "The extracted context block content (1-3 sentences)"
+    }
+  ]
+}
+
+Rules:
+- Extract 5-15 blocks depending on content richness
+- Each block should be self-contained and reusable across conversations
+- Deduplicate — if the same theme appears multiple times, synthesize into one block
+- Focus on the USER's behavior, not the assistant's
+- Style blocks capture HOW the person communicates
+- Insight blocks capture WHAT knowledge or expertise they have
+- Pattern blocks capture HOW they work and make decisions
+- Preference blocks capture WHAT tools/formats/approaches they choose
+- Titles should be specific and descriptive
+- Content should be concise but complete
+- Return valid JSON only, no markdown fences`;

package/dist/context/providers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * LLM provider abstraction: OpenAI, Anthropic, Ollama.
+ * Uses the user's own API key — configured via `npx @crowdlisten/harness setup`.
+ */
+import type { LLMProvider, ContextConfig } from "./types.js";
+export declare function createProvider(config: ContextConfig): LLMProvider;

package/dist/context/providers.js

@@ -0,0 +1,106 @@
+/**
+ * LLM provider abstraction: OpenAI, Anthropic, Ollama.
+ * Uses the user's own API key — configured via `npx @crowdlisten/harness setup`.
+ */
+// ─── OpenAI ──────────────────────────────────────────────────────────────────
+class OpenAIProvider {
+    name = "openai";
+    apiKey;
+    defaultModel;
+    constructor(apiKey, model) {
+        this.apiKey = apiKey;
+        this.defaultModel = model || "gpt-4o-mini";
+    }
+    async complete(messages, opts) {
+        const body = {
+            model: opts?.model || this.defaultModel,
+            messages,
+            temperature: opts?.temperature ?? 0.3,
+        };
+        if (opts?.maxTokens)
+            body.max_tokens = opts.maxTokens;
+        if (opts?.jsonMode)
+            body.response_format = { type: "json_object" };
+        const res = await fetch("https://api.openai.com/v1/chat/completions", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new Error(err.error?.message || `OpenAI request failed (${res.status})`);
+        }
+        const data = (await res.json());
+        return data.choices?.[0]?.message?.content || "";
+    }
+    async embed(texts) {
+        const res = await fetch("https://api.openai.com/v1/embeddings", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: "text-embedding-3-small",
+                input: texts,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`OpenAI embeddings failed (${res.status})`);
+        }
+        const data = (await res.json());
+        return data.data.map((d) => d.embedding);
+    }
+}
+// ─── Anthropic ───────────────────────────────────────────────────────────────
+class AnthropicProvider {
+    name = "anthropic";
+    apiKey;
+    defaultModel;
+    constructor(apiKey, model) {
+        this.apiKey = apiKey;
+        this.defaultModel = model || "claude-sonnet-4-20250514";
+    }
+    async complete(messages, opts) {
+        const systemMsg = messages.find((m) => m.role === "system");
+        const nonSystem = messages.filter((m) => m.role !== "system");
+        const body = {
+            model: opts?.model || this.defaultModel,
+            max_tokens: opts?.maxTokens || 4096,
+            messages: nonSystem.map((m) => ({ role: m.role, content: m.content })),
+        };
+        if (systemMsg)
+            body.system = systemMsg.content;
+        const res = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": this.apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const err = await res.json().catch(() => ({}));
+            throw new Error(err.error?.message ||
+                `Anthropic request failed (${res.status})`);
+        }
+        const data = (await res.json());
+        const textBlock = data.content?.find((c) => c.type === "text");
+        return textBlock?.text || "";
+    }
+}
+// ─── Factory ─────────────────────────────────────────────────────────────────
+export function createProvider(config) {
+    switch (config.provider) {
+        case "openai":
+            return new OpenAIProvider(config.apiKey, config.model);
+        case "anthropic":
+            return new AnthropicProvider(config.apiKey, config.model);
+        default:
+            throw new Error(`Unknown provider: ${config.provider}`);
+    }
+}

package/dist/context/redactor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Client-side PII redaction using regex patterns.
+ * Runs entirely locally — no data leaves before redaction.
+ * Ported from crowdlisten_deployed/frontend/src/lib/piiRedactor.js
+ */
+import type { RedactionResult } from "./types.js";
+/**
+ * Redact PII from text using local regex patterns.
+ */
+export declare function redactPII(text: string): RedactionResult;

package/dist/context/redactor.js

@@ -0,0 +1,68 @@
+/**
+ * Client-side PII redaction using regex patterns.
+ * Runs entirely locally — no data leaves before redaction.
+ * Ported from crowdlisten_deployed/frontend/src/lib/piiRedactor.js
+ */
+const PATTERNS = [
+    {
+        name: "emails",
+        regex: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+        replacement: "[EMAIL]",
+    },
+    {
+        name: "phones",
+        regex: /(?:\+?\d{1,3}[-.\s]?)?\(?\d{2,4}\)?[-.\s]?\d{3,4}[-.\s]?\d{3,4}\b/g,
+        replacement: "[PHONE]",
+    },
+    {
+        name: "ssns",
+        regex: /\b\d{3}-\d{2}-\d{4}\b/g,
+        replacement: "[SSN]",
+    },
+    {
+        name: "creditCards",
+        regex: /\b(?:\d[ -]*?){13,19}\b/g,
+        replacement: "[CREDIT_CARD]",
+    },
+    {
+        name: "ipAddresses",
+        regex: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+        replacement: "[IP_ADDRESS]",
+    },
+    {
+        name: "apiKeys",
+        regex: /\b(?:sk-|pk-|api[_-]|token[_-]|bearer\s+|ghp_|gho_|xox[bpsa]-)[A-Za-z0-9_\-/.]{20,}\b/gi,
+        replacement: "[API_KEY]",
+    },
+    {
+        name: "genericTokens",
+        regex: /\b[A-Fa-f0-9]{40,}\b/g,
+        replacement: "[TOKEN]",
+    },
+    {
+        name: "urlCredentials",
+        regex: /https?:\/\/[^:]+:[^@]+@[^\s]+/g,
+        replacement: "[URL_WITH_CREDENTIALS]",
+    },
+];
+/**
+ * Redact PII from text using local regex patterns.
+ */
+export function redactPII(text) {
+    if (!text)
+        return { redactedText: "", stats: {}, totalRedactions: 0 };
+    let redactedText = text;
+    const stats = {};
+    let totalRedactions = 0;
+    for (const { name, regex, replacement } of PATTERNS) {
+        regex.lastIndex = 0;
+        const matches = redactedText.match(regex);
+        const count = matches?.length || 0;
+        if (count > 0) {
+            stats[name] = count;
+            totalRedactions += count;
+            redactedText = redactedText.replace(regex, replacement);
+        }
+    }
+    return { redactedText, stats, totalRedactions };
+}

package/dist/context/server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Express server for context extraction web UI.
+ * Serves static files + API routes on port 3847.
+ */
+export declare function startContextServer(): Promise<void>;

package/dist/context/server.js

@@ -0,0 +1,134 @@
+/**
+ * Express server for context extraction web UI.
+ * Serves static files + API routes on port 3847.
+ */
+import * as http from "http";
+import * as path from "path";
+import * as fs from "fs";
+import { fileURLToPath } from "url";
+import { handleApiRequest } from "./api.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PORT = 3847;
+// MIME types for static file serving
+const MIME = {
+    ".html": "text/html",
+    ".js": "application/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+};
+function serveStatic(res, filePath) {
+    const ext = path.extname(filePath);
+    const mime = MIME[ext] || "application/octet-stream";
+    try {
+        const content = fs.readFileSync(filePath);
+        res.writeHead(200, { "Content-Type": mime });
+        res.end(content);
+    }
+    catch {
+        // SPA fallback: serve index.html for any non-API, non-file route
+        try {
+            const indexPath = path.join(getWebDistDir(), "index.html");
+            const content = fs.readFileSync(indexPath);
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(content);
+        }
+        catch {
+            res.writeHead(404);
+            res.end("Not found");
+        }
+    }
+}
+function getWebDistDir() {
+    // Check for built web UI in various locations
+    const candidates = [
+        path.join(__dirname, "..", "..", "web-dist"),
+        path.join(__dirname, "..", "web-dist"),
+        path.join(__dirname, "web-dist"),
+    ];
+    for (const dir of candidates) {
+        if (fs.existsSync(path.join(dir, "index.html"))) {
+            return dir;
+        }
+    }
+    // Fallback: return the first candidate (will show instructions if missing)
+    return candidates[0];
+}
+function openBrowser(url) {
+    import("child_process").then(({ execSync }) => {
+        try {
+            if (process.platform === "darwin")
+                execSync(`open "${url}"`);
+            else if (process.platform === "win32")
+                execSync(`start "${url}"`);
+            else
+                execSync(`xdg-open "${url}" || sensible-browser "${url}"`);
+        }
+        catch {
+            // Silently fail — user can open manually
+        }
+    });
+}
+export async function startContextServer() {
+    const webDir = getWebDistDir();
+    const hasWebUI = fs.existsSync(path.join(webDir, "index.html"));
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url || "/", `http://localhost:${PORT}`);
+        // CORS headers for local development
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // API routes
+        if (url.pathname.startsWith("/api/")) {
+            await handleApiRequest(req, res, url);
+            return;
+        }
+        // Static files
+        if (hasWebUI) {
+            const filePath = path.join(webDir, url.pathname === "/" ? "index.html" : url.pathname);
+            serveStatic(res, filePath);
+        }
+        else {
+            // No web UI built — show instructions
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(`
+<!DOCTYPE html>
+<html>
+<head><title>CrowdListen Context</title></head>
+<body style="font-family: system-ui; max-width: 600px; margin: 60px auto; padding: 0 20px;">
+  <h1>CrowdListen Context</h1>
+  <p>The web UI hasn't been built yet. You can:</p>
+  <ol>
+    <li>Use the CLI: <code>npx @crowdlisten/harness context &lt;file&gt;</code></li>
+    <li>Build the web UI: <code>npm run build:web</code></li>
+  </ol>
+  <h2>API Endpoints</h2>
+  <ul>
+    <li><code>POST /api/process</code> — Process text through the pipeline</li>
+    <li><code>GET /api/blocks</code> — Get stored context blocks</li>
+    <li><code>GET /api/skills</code> — Get skill recommendations</li>
+    <li><code>GET /api/config</code> — Get current config status</li>
+    <li><code>POST /api/config</code> — Update LLM config</li>
+  </ul>
+</body>
+</html>`);
+        }
+    });
+    server.listen(PORT, "127.0.0.1", () => {
+        console.error(`\n🚀 CrowdListen Context server running at http://localhost:${PORT}\n`);
+        if (hasWebUI) {
+            openBrowser(`http://localhost:${PORT}`);
+        }
+        else {
+            console.error("   Web UI not built. Run 'npm run build:web' or use the API directly.\n");
+        }
+    });
+}

package/dist/context/store.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Local JSON storage in ~/.crowdlisten/ for context blocks, config, and history.
+ */
+import type { ContextBlock, ContextConfig, StoredData } from "./types.js";
+export declare function loadConfig(): ContextConfig | null;
+export declare function saveConfig(config: ContextConfig): void;
+export declare function getBlocks(): ContextBlock[];
+export declare function addBlocks(blocks: ContextBlock[], source: string): ContextBlock[];
+export declare function deleteBlock(index: number): void;
+export declare function updateBlock(index: number, updates: Partial<ContextBlock>): void;
+export declare function clearBlocks(): void;
+export declare function getHistory(): StoredData["history"];

package/dist/context/store.js

@@ -0,0 +1,82 @@
+/**
+ * Local JSON storage in ~/.crowdlisten/ for context blocks, config, and history.
+ */
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const BASE_DIR = path.join(os.homedir(), ".crowdlisten");
+const CONFIG_FILE = path.join(BASE_DIR, "config.json");
+const DATA_FILE = path.join(BASE_DIR, "context.json");
+function ensureDir() {
+    if (!fs.existsSync(BASE_DIR)) {
+        fs.mkdirSync(BASE_DIR, { recursive: true });
+    }
+}
+// ─── Config ──────────────────────────────────────────────────────────────────
+export function loadConfig() {
+    try {
+        if (!fs.existsSync(CONFIG_FILE))
+            return null;
+        const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    ensureDir();
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+// ─── Context Data ────────────────────────────────────────────────────────────
+function loadData() {
+    try {
+        if (!fs.existsSync(DATA_FILE))
+            return { blocks: [], history: [] };
+        const raw = fs.readFileSync(DATA_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { blocks: [], history: [] };
+    }
+}
+function saveData(data) {
+    ensureDir();
+    fs.writeFileSync(DATA_FILE, JSON.stringify(data, null, 2));
+}
+export function getBlocks() {
+    return loadData().blocks;
+}
+export function addBlocks(blocks, source) {
+    const data = loadData();
+    data.blocks.push(...blocks);
+    data.history.push({
+        timestamp: new Date().toISOString(),
+        source,
+        blockCount: blocks.length,
+    });
+    saveData(data);
+    return data.blocks;
+}
+export function deleteBlock(index) {
+    const data = loadData();
+    if (index >= 0 && index < data.blocks.length) {
+        data.blocks.splice(index, 1);
+        saveData(data);
+    }
+}
+export function updateBlock(index, updates) {
+    const data = loadData();
+    if (index >= 0 && index < data.blocks.length) {
+        data.blocks[index] = { ...data.blocks[index], ...updates };
+        saveData(data);
+    }
+}
+export function clearBlocks() {
+    const data = loadData();
+    data.blocks = [];
+    saveData(data);
+}
+export function getHistory() {
+    return loadData().history;
+}

package/dist/context/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Type definitions for the context extraction pipeline.
+ */
+export interface RedactionResult {
+    redactedText: string;
+    stats: Record<string, number>;
+    totalRedactions: number;
+}
+export interface ContextBlock {
+    type: "style" | "insight" | "pattern" | "preference" | "decision";
+    title: string;
+    content: string;
+    source?: string;
+}
+export interface SkillMatch {
+    skillId: string;
+    name: string;
+    description: string;
+    score: number;
+    matchedKeywords: string[];
+}
+export interface SkillCatalogEntry {
+    id: string;
+    name: string;
+    description: string;
+    keywords: string[];
+}
+export type SkillTier = "crowdlisten" | "community";
+export type SkillCategory = "development" | "data" | "content" | "research" | "automation" | "design" | "business" | "productivity";
+export type InstallMethod = "copy" | "npx" | "git-clone";
+export interface ExtendedSkillCatalogEntry extends SkillCatalogEntry {
+    tier: SkillTier;
+    category: SkillCategory;
+    installMethod: InstallMethod;
+    installTarget: string;
+    source: string;
+    author?: string;
+}
+export interface ExtendedSkillMatch extends SkillMatch {
+    tier: SkillTier;
+    category: SkillCategory;
+    installMethod: InstallMethod;
+    installTarget: string;
+}
+export interface LLMMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface LLMOpts {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    jsonMode?: boolean;
+}
+export interface LLMProvider {
+    name: string;
+    complete(messages: LLMMessage[], opts?: LLMOpts): Promise<string>;
+    embed?(texts: string[]): Promise<number[][]>;
+}
+export interface ContextConfig {
+    provider: "openai" | "anthropic";
+    apiKey: string;
+    model?: string;
+}
+export interface PipelineResult {
+    blocks: ContextBlock[];
+    skills: SkillMatch[];
+    redactionStats: Record<string, number>;
+    totalRedactions: number;
+    chunkCount: number;
+}
+export interface StoredData {
+    blocks: ContextBlock[];
+    history: Array<{
+        timestamp: string;
+        source: string;
+        blockCount: number;
+    }>;
+}

package/dist/context/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for the context extraction pipeline.
+ */
+export {};