@webpresso/agent-kit 0.21.0

package/dist/esm/ai-memory/index.d.ts

@@ -0,0 +1,11 @@
+export { BaseCheckpointSaver, generateCheckpointId, generateThreadId } from './checkpoint/saver.js';
+export type { Checkpoint, CheckpointConfig, CheckpointId, CheckpointMetadata, CheckpointResult, CheckpointState, CheckpointTuple, ListCheckpointsOptions, SerializedMessage, SerializedToolCall, ThreadId, } from './checkpoint/types.js';
+export { createFactConsolidator, FactConsolidator } from './facts/consolidator.js';
+export type { FactDatabase } from './facts/consolidator.js';
+export { createFactExtractor, FactExtractor, FACT_EXTRACTION_PROMPT, generateFactId, } from './facts/extractor.js';
+export type { ExtractedFactData, FactExtractionLLM } from './facts/extractor.js';
+export type { ConfidenceLevel, Fact, FactCategory, FactConsolidationOptions, FactConsolidationResult, FactExtractionOptions, FactExtractionResult, FactId, FactRetrievalOptions, MemoryEntry, MemoryTier, RetrievedFact, } from './facts/types.js';
+export { createHierarchicalRetriever, DEFAULT_RETRIEVAL_CONFIG, formatContextForPrompt, HierarchicalRetriever, } from './hierarchy/retriever.js';
+export type { EmbeddingProvider, MemoryRetrievalConfig, MemoryStore, RetrievedContext, } from './hierarchy/retriever.js';
+export { SqliteAiMemoryStore } from './store/sqlite-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/ai-memory/index.js

@@ -0,0 +1,6 @@
+export { BaseCheckpointSaver, generateCheckpointId, generateThreadId } from './checkpoint/saver.js';
+export { createFactConsolidator, FactConsolidator } from './facts/consolidator.js';
+export { createFactExtractor, FactExtractor, FACT_EXTRACTION_PROMPT, generateFactId, } from './facts/extractor.js';
+export { createHierarchicalRetriever, DEFAULT_RETRIEVAL_CONFIG, formatContextForPrompt, HierarchicalRetriever, } from './hierarchy/retriever.js';
+export { SqliteAiMemoryStore } from './store/sqlite-store.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/ai-memory/store/sqlite-store.d.ts

@@ -0,0 +1,28 @@
+import { BaseCheckpointSaver } from '#ai-memory/checkpoint/saver.js';
+import type { Checkpoint, CheckpointConfig, CheckpointId, CheckpointResult, CheckpointState, ListCheckpointsOptions, ThreadId } from '#ai-memory/checkpoint/types.js';
+import type { FactDatabase } from '#ai-memory/facts/consolidator.js';
+import type { Fact, FactId, FactRetrievalOptions, RetrievedFact } from '#ai-memory/facts/types.js';
+import type { MemoryStore } from '#ai-memory/hierarchy/retriever.js';
+export declare class SqliteAiMemoryStore extends BaseCheckpointSaver implements FactDatabase, MemoryStore {
+    private readonly db;
+    constructor(dbPath: string);
+    close(): void;
+    save(config: CheckpointConfig, state: CheckpointState, parentId?: CheckpointId): Promise<CheckpointResult>;
+    loadLatest(threadId: ThreadId): Promise<Checkpoint | null>;
+    load(checkpointId: CheckpointId): Promise<Checkpoint | null>;
+    list(options?: ListCheckpointsOptions): Promise<Checkpoint[]>;
+    delete(checkpointId: CheckpointId): Promise<CheckpointResult>;
+    delete(id: FactId): Promise<void>;
+    clearThread(threadId: ThreadId): Promise<CheckpointResult>;
+    findByThread(threadId: string): Promise<Fact[]>;
+    update(id: FactId, updates: Partial<Fact>): Promise<void>;
+    insert(fact: Fact): Promise<void>;
+    getLatestCheckpoint(threadId: string): Promise<Checkpoint | null>;
+    getFacts(options: FactRetrievalOptions): Promise<RetrievedFact[]>;
+    touchFact(factId: string): Promise<void>;
+    private getFactById;
+    private estimateRelevance;
+    private mapCheckpoint;
+    private mapFact;
+}
+//# sourceMappingURL=sqlite-store.d.ts.map

package/dist/esm/ai-memory/store/sqlite-store.js

@@ -0,0 +1,213 @@
+import { Database } from '#db/sqlite.js';
+import { BaseCheckpointSaver } from '#ai-memory/checkpoint/saver.js';
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS ai_checkpoints (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  parent_id TEXT,
+  state_json TEXT NOT NULL,
+  metadata_json TEXT,
+  created_at TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_ai_checkpoints_thread_created
+  ON ai_checkpoints(thread_id, created_at DESC);
+
+CREATE TABLE IF NOT EXISTS ai_facts (
+  id TEXT PRIMARY KEY,
+  thread_id TEXT NOT NULL,
+  category TEXT NOT NULL,
+  content TEXT NOT NULL,
+  confidence TEXT NOT NULL,
+  source_id TEXT,
+  embedding_json TEXT,
+  access_count INTEGER NOT NULL,
+  last_accessed_at TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  invalidated INTEGER NOT NULL DEFAULT 0,
+  invalidation_reason TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_ai_facts_thread_created
+  ON ai_facts(thread_id, created_at DESC);
+`;
+export class SqliteAiMemoryStore extends BaseCheckpointSaver {
+    db;
+    constructor(dbPath) {
+        super();
+        this.db = new Database(dbPath);
+        this.db.exec('PRAGMA busy_timeout = 5000');
+        this.db.exec('PRAGMA journal_mode = WAL');
+        this.db.exec('PRAGMA foreign_keys = ON');
+        this.db.exec(SCHEMA_SQL);
+    }
+    close() {
+        this.db.close();
+    }
+    async save(config, state, parentId) {
+        const checkpointId = `ckpt_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+        const now = new Date().toISOString();
+        this.db
+            .prepare(`INSERT INTO ai_checkpoints
+          (id, thread_id, parent_id, state_json, metadata_json, created_at)
+         VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(checkpointId, config.threadId, parentId ?? null, JSON.stringify(state), null, now);
+        return { success: true, checkpointId };
+    }
+    async loadLatest(threadId) {
+        const row = this.db
+            .prepare(`SELECT id, thread_id, parent_id, state_json, metadata_json, created_at
+         FROM ai_checkpoints
+         WHERE thread_id = ?
+         ORDER BY created_at DESC
+         LIMIT 1`)
+            .get(threadId);
+        return row ? this.mapCheckpoint(row) : null;
+    }
+    async load(checkpointId) {
+        const row = this.db
+            .prepare(`SELECT id, thread_id, parent_id, state_json, metadata_json, created_at
+         FROM ai_checkpoints
+         WHERE id = ?`)
+            .get(checkpointId);
+        return row ? this.mapCheckpoint(row) : null;
+    }
+    async list(options) {
+        const limit = options?.limit ?? 100;
+        const offset = options?.offset ?? 0;
+        const orderField = options?.orderBy === 'step' ? 'created_at' : 'created_at';
+        const orderDir = options?.order === 'asc' ? 'ASC' : 'DESC';
+        if (options?.threadId) {
+            const rows = this.db
+                .prepare(`SELECT id, thread_id, parent_id, state_json, metadata_json, created_at
+           FROM ai_checkpoints
+           WHERE thread_id = ?
+           ORDER BY ${orderField} ${orderDir}
+           LIMIT ? OFFSET ?`)
+                .all(options.threadId, limit, offset);
+            return rows.map((row) => this.mapCheckpoint(row));
+        }
+        const rows = this.db
+            .prepare(`SELECT id, thread_id, parent_id, state_json, metadata_json, created_at
+         FROM ai_checkpoints
+         ORDER BY ${orderField} ${orderDir}
+         LIMIT ? OFFSET ?`)
+            .all(limit, offset);
+        return rows.map((row) => this.mapCheckpoint(row));
+    }
+    async delete(id) {
+        const checkpointResult = this.db.prepare('DELETE FROM ai_checkpoints WHERE id = ?').run(id);
+        if (checkpointResult.changes > 0) {
+            return { success: true, checkpointId: id };
+        }
+        this.db.prepare('DELETE FROM ai_facts WHERE id = ?').run(id);
+    }
+    async clearThread(threadId) {
+        this.db.prepare('DELETE FROM ai_checkpoints WHERE thread_id = ?').run(threadId);
+        return { success: true };
+    }
+    async findByThread(threadId) {
+        const rows = this.db
+            .prepare(`SELECT id, thread_id, category, content, confidence, source_id, embedding_json,
+                access_count, last_accessed_at, created_at, invalidated, invalidation_reason
+         FROM ai_facts
+         WHERE thread_id = ?
+         ORDER BY created_at DESC`)
+            .all(threadId);
+        return rows.map((row) => this.mapFact(row));
+    }
+    async update(id, updates) {
+        const current = await this.getFactById(id);
+        if (!current)
+            return;
+        const next = { ...current, ...updates };
+        this.db
+            .prepare(`UPDATE ai_facts
+         SET category = ?, content = ?, confidence = ?, source_id = ?, embedding_json = ?,
+             access_count = ?, last_accessed_at = ?, created_at = ?, invalidated = ?, invalidation_reason = ?
+         WHERE id = ?`)
+            .run(next.category, next.content, next.confidence, next.sourceId ?? null, next.embedding ? JSON.stringify(next.embedding) : null, next.accessCount, next.lastAccessedAt.toISOString(), next.createdAt.toISOString(), next.invalidated ? 1 : 0, next.invalidationReason ?? null, id);
+    }
+    async insert(fact) {
+        this.db
+            .prepare(`INSERT INTO ai_facts
+          (id, thread_id, category, content, confidence, source_id, embedding_json,
+           access_count, last_accessed_at, created_at, invalidated, invalidation_reason)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(fact.id, fact.threadId, fact.category, fact.content, fact.confidence, fact.sourceId ?? null, fact.embedding ? JSON.stringify(fact.embedding) : null, fact.accessCount, fact.lastAccessedAt.toISOString(), fact.createdAt.toISOString(), fact.invalidated ? 1 : 0, fact.invalidationReason ?? null);
+    }
+    async getLatestCheckpoint(threadId) {
+        return await this.loadLatest(threadId);
+    }
+    async getFacts(options) {
+        const rows = this.db
+            .prepare(`SELECT id, thread_id, category, content, confidence, source_id, embedding_json,
+                access_count, last_accessed_at, created_at, invalidated, invalidation_reason
+         FROM ai_facts
+         WHERE thread_id = ?
+         ORDER BY created_at DESC`)
+            .all(options.threadId);
+        return rows
+            .map((row) => this.mapFact(row))
+            .filter((fact) => options.includeInvalidated || !fact.invalidated)
+            .filter((fact) => !options.categories || options.categories.includes(fact.category))
+            .map((fact) => ({
+            ...fact,
+            relevance: this.estimateRelevance(fact, options.query),
+        }))
+            .filter((fact) => fact.relevance >= (options.minRelevance ?? 0))
+            .slice(0, options.limit ?? 50);
+    }
+    async touchFact(factId) {
+        const current = await this.getFactById(factId);
+        if (!current)
+            return;
+        this.db
+            .prepare('UPDATE ai_facts SET access_count = ?, last_accessed_at = ? WHERE id = ?')
+            .run(current.accessCount + 1, new Date().toISOString(), factId);
+    }
+    async getFactById(id) {
+        const row = this.db
+            .prepare(`SELECT id, thread_id, category, content, confidence, source_id, embedding_json,
+                access_count, last_accessed_at, created_at, invalidated, invalidation_reason
+         FROM ai_facts
+         WHERE id = ?`)
+            .get(id);
+        return row ? this.mapFact(row) : null;
+    }
+    estimateRelevance(fact, query) {
+        if (!query || query.trim() === '')
+            return 1;
+        const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+        const haystack = fact.content.toLowerCase();
+        const matches = words.filter((word) => haystack.includes(word)).length;
+        return words.length === 0 ? 1 : matches / words.length;
+    }
+    mapCheckpoint(row) {
+        return {
+            id: row.id,
+            threadId: row.thread_id,
+            parentId: row.parent_id ?? undefined,
+            state: JSON.parse(row.state_json),
+            metadata: row.metadata_json
+                ? JSON.parse(row.metadata_json, (_key, value) => value)
+                : undefined,
+            createdAt: new Date(row.created_at),
+        };
+    }
+    mapFact(row) {
+        return {
+            id: row.id,
+            threadId: row.thread_id,
+            category: row.category,
+            content: row.content,
+            confidence: row.confidence,
+            sourceId: row.source_id ?? undefined,
+            embedding: row.embedding_json ? JSON.parse(row.embedding_json) : undefined,
+            accessCount: row.access_count,
+            lastAccessedAt: new Date(row.last_accessed_at),
+            createdAt: new Date(row.created_at),
+            invalidated: row.invalidated === 1,
+            invalidationReason: row.invalidation_reason ?? undefined,
+        };
+    }
+}
+//# sourceMappingURL=sqlite-store.js.map

package/dist/esm/ai-prompts/business-canvas.d.ts

@@ -0,0 +1,52 @@
+export interface FeatureProposal {
+    name: string;
+    description: string;
+    priority: 'must-have' | 'should-have' | 'nice-to-have';
+    complexity: 'low' | 'medium' | 'high';
+}
+export interface TargetAudience {
+    persona: string;
+    painPoints: string[];
+    demographics?: string;
+    marketSize?: string;
+}
+export interface SuccessMetric {
+    name: string;
+    target: string;
+    timeframe: string;
+}
+export interface MarketResearch {
+    competitors: Array<{
+        name: string;
+        pricing: string;
+        strengths: string[];
+        weaknesses: string[];
+    }>;
+    trends: string[];
+    gaps: string[];
+}
+export interface BusinessCanvas {
+    problem: string;
+    solution: string;
+    targetAudience: TargetAudience[];
+    successMetrics: SuccessMetric[];
+    keyMetrics: string[];
+    uniqueValue: string;
+    channels: string[];
+    revenueModel: string;
+    costStructure: string;
+    features: FeatureProposal[];
+    marketResearch?: MarketResearch;
+}
+export type ViabilityDecision = 'GO' | 'NO_GO' | 'NEEDS_MORE_INFO';
+export interface ParsedSteveResponse {
+    message: string;
+    canvas?: BusinessCanvas;
+    viability?: ViabilityDecision;
+    rationale?: string;
+}
+export declare const BUSINESS_CANVAS_SYSTEM_PROMPT = "You are conducting a business viability analysis conversation.\n\n## Conversation Flow\n\nGuide the user through these phases naturally (don't announce phases):\n\n1. **Problem Discovery** (2-3 questions)\n   - What problem are you solving?\n   - Who experiences this problem most acutely?\n   - How do they currently solve it?\n\n2. **Target Audience Deep Dive** (1-2 questions)\n   - Who is the ideal customer persona?\n   - What are their specific pain points and demographics?\n\n3. **Market Validation** (2-3 questions)\n   - Who are your competitors?\n   - What's your target price point?\n   - How big is your addressable market?\n\n4. **Differentiation & Success Criteria** (1-2 questions)\n   - What makes your solution unique?\n   - What metrics will define success for MVP?\n\n5. **Canvas Generation**\n   When you have enough information (typically 5-8 exchanges), generate the canvas.\n\n## Output Format\n\nWhen ready to generate the canvas, include these XML tags in your response:\n\n<business_canvas>\n{\n  \"problem\": \"Clear problem statement describing the pain point\",\n  \"solution\": \"Your proposed solution summary\",\n  \"targetAudience\": [\n    {\n      \"persona\": \"Primary user type (e.g., 'Freelance designers')\",\n      \"painPoints\": [\"Specific pain point 1\", \"Specific pain point 2\"],\n      \"demographics\": \"Age, role, industry, etc.\",\n      \"marketSize\": \"Estimated TAM for this segment\"\n    }\n  ],\n  \"successMetrics\": [\n    {\n      \"name\": \"MRR\",\n      \"target\": \"$10K\",\n      \"timeframe\": \"6 months post-launch\"\n    },\n    {\n      \"name\": \"Active Users\",\n      \"target\": \"500\",\n      \"timeframe\": \"3 months post-launch\"\n    }\n  ],\n  \"keyMetrics\": [\"MRR\", \"Churn Rate\", \"DAU\"],\n  \"uniqueValue\": \"What makes this unique/differentiated\",\n  \"channels\": [\"ProductHunt\", \"Twitter\", \"Content Marketing\"],\n  \"revenueModel\": \"How you'll make money (e.g., $15/mo subscription)\",\n  \"costStructure\": \"Estimated monthly costs breakdown\",\n  \"features\": [\n    {\n      \"name\": \"Feature Name\",\n      \"description\": \"What it does and why it matters\",\n      \"priority\": \"must-have\",\n      \"complexity\": \"medium\"\n    }\n  ],\n  \"marketResearch\": {\n    \"competitors\": [\n      {\n        \"name\": \"Competitor Name\",\n        \"pricing\": \"$X/mo\",\n        \"strengths\": [\"Strength 1\"],\n        \"weaknesses\": [\"Weakness 1\"]\n      }\n    ],\n    \"trends\": [\"Market trend 1\", \"Market trend 2\"],\n    \"gaps\": [\"Gap in market 1\", \"Gap in market 2\"]\n  }\n}\n</business_canvas>\n\n<viability_decision>GO|NO_GO|NEEDS_MORE_INFO</viability_decision>\n<viability_rationale>Why this decision...</viability_rationale>\n\n## Feature Prioritization Rules\n\nWhen generating features, follow strict MVP prioritization:\n\n- **must-have** (Week 1-2): Core features that validate the hypothesis. Max 3-4 features.\n- **should-have** (Week 2-4): Important but not blocking validation. Max 2-3 features.\n- **nice-to-have** (Post-MVP): Polish and expansion features.\n\nComplexity estimates:\n- **low**: Can be built in < 1 day\n- **medium**: 1-3 days of development\n- **high**: 3+ days or requires external integrations\n\n## Viability Criteria\n\n- **GO**: Clear problem, addressable market (>$1B TAM), differentiated solution, viable unit economics (LTV:CAC > 3:1)\n- **NO_GO**: No clear problem, saturated market with dominant players, no differentiation, unsustainable costs\n- **NEEDS_MORE_INFO**: Missing critical information to make a decision (e.g., unknown pricing, unclear target audience)\n\n## Guidelines\n\n- Ask one question at a time (occasionally two if related)\n- Challenge assumptions politely but directly\n- Use investor terminology naturally (CAC, LTV, Churn, ROI, TAM, SAM)\n- Provide insights from market patterns you've seen\n- When generating canvas, prioritize features ruthlessly for MVP\n- Always include your conversational response before the canvas tags\n- Include at least 2 success metrics with realistic targets\n- Identify at least 2 competitors in market research\n";
+export declare const BUSINESS_CANVAS_USER_PROMPT = "Continue the conversation to understand this business idea.\nIf you have enough information (5-8 exchanges), generate the Business Canvas.\n\nPrevious conversation:\n{conversation_history}\n\nUser's latest message:\n{user_message}\n";
+export declare function parseBusinessCanvas(response: string): ParsedSteveResponse;
+export declare function isValidBusinessCanvas(canvas: unknown): canvas is BusinessCanvas;
+//# sourceMappingURL=business-canvas.d.ts.map

package/dist/esm/ai-prompts/business-canvas.js

@@ -0,0 +1,292 @@
+export const BUSINESS_CANVAS_SYSTEM_PROMPT = `You are conducting a business viability analysis conversation.
+
+## Conversation Flow
+
+Guide the user through these phases naturally (don't announce phases):
+
+1. **Problem Discovery** (2-3 questions)
+   - What problem are you solving?
+   - Who experiences this problem most acutely?
+   - How do they currently solve it?
+
+2. **Target Audience Deep Dive** (1-2 questions)
+   - Who is the ideal customer persona?
+   - What are their specific pain points and demographics?
+
+3. **Market Validation** (2-3 questions)
+   - Who are your competitors?
+   - What's your target price point?
+   - How big is your addressable market?
+
+4. **Differentiation & Success Criteria** (1-2 questions)
+   - What makes your solution unique?
+   - What metrics will define success for MVP?
+
+5. **Canvas Generation**
+   When you have enough information (typically 5-8 exchanges), generate the canvas.
+
+## Output Format
+
+When ready to generate the canvas, include these XML tags in your response:
+
+<business_canvas>
+{
+  "problem": "Clear problem statement describing the pain point",
+  "solution": "Your proposed solution summary",
+  "targetAudience": [
+    {
+      "persona": "Primary user type (e.g., 'Freelance designers')",
+      "painPoints": ["Specific pain point 1", "Specific pain point 2"],
+      "demographics": "Age, role, industry, etc.",
+      "marketSize": "Estimated TAM for this segment"
+    }
+  ],
+  "successMetrics": [
+    {
+      "name": "MRR",
+      "target": "$10K",
+      "timeframe": "6 months post-launch"
+    },
+    {
+      "name": "Active Users",
+      "target": "500",
+      "timeframe": "3 months post-launch"
+    }
+  ],
+  "keyMetrics": ["MRR", "Churn Rate", "DAU"],
+  "uniqueValue": "What makes this unique/differentiated",
+  "channels": ["ProductHunt", "Twitter", "Content Marketing"],
+  "revenueModel": "How you'll make money (e.g., $15/mo subscription)",
+  "costStructure": "Estimated monthly costs breakdown",
+  "features": [
+    {
+      "name": "Feature Name",
+      "description": "What it does and why it matters",
+      "priority": "must-have",
+      "complexity": "medium"
+    }
+  ],
+  "marketResearch": {
+    "competitors": [
+      {
+        "name": "Competitor Name",
+        "pricing": "$X/mo",
+        "strengths": ["Strength 1"],
+        "weaknesses": ["Weakness 1"]
+      }
+    ],
+    "trends": ["Market trend 1", "Market trend 2"],
+    "gaps": ["Gap in market 1", "Gap in market 2"]
+  }
+}
+</business_canvas>
+
+<viability_decision>GO|NO_GO|NEEDS_MORE_INFO</viability_decision>
+<viability_rationale>Why this decision...</viability_rationale>
+
+## Feature Prioritization Rules
+
+When generating features, follow strict MVP prioritization:
+
+- **must-have** (Week 1-2): Core features that validate the hypothesis. Max 3-4 features.
+- **should-have** (Week 2-4): Important but not blocking validation. Max 2-3 features.
+- **nice-to-have** (Post-MVP): Polish and expansion features.
+
+Complexity estimates:
+- **low**: Can be built in < 1 day
+- **medium**: 1-3 days of development
+- **high**: 3+ days or requires external integrations
+
+## Viability Criteria
+
+- **GO**: Clear problem, addressable market (>$1B TAM), differentiated solution, viable unit economics (LTV:CAC > 3:1)
+- **NO_GO**: No clear problem, saturated market with dominant players, no differentiation, unsustainable costs
+- **NEEDS_MORE_INFO**: Missing critical information to make a decision (e.g., unknown pricing, unclear target audience)
+
+## Guidelines
+
+- Ask one question at a time (occasionally two if related)
+- Challenge assumptions politely but directly
+- Use investor terminology naturally (CAC, LTV, Churn, ROI, TAM, SAM)
+- Provide insights from market patterns you've seen
+- When generating canvas, prioritize features ruthlessly for MVP
+- Always include your conversational response before the canvas tags
+- Include at least 2 success metrics with realistic targets
+- Identify at least 2 competitors in market research
+`;
+export const BUSINESS_CANVAS_USER_PROMPT = `Continue the conversation to understand this business idea.
+If you have enough information (5-8 exchanges), generate the Business Canvas.
+
+Previous conversation:
+{conversation_history}
+
+User's latest message:
+{user_message}
+`;
+export function parseBusinessCanvas(response) {
+    const canvasMatch = response.match(/<business_canvas>([\s\S]*?)<\/business_canvas>/);
+    const viabilityMatch = response.match(/<viability_decision>(\w+)<\/viability_decision>/);
+    const rationaleMatch = response.match(/<viability_rationale>([\s\S]*?)<\/viability_rationale>/);
+    const message = response
+        .replace(/<business_canvas>[\s\S]*?<\/business_canvas>/g, '')
+        .replace(/<viability_decision>[\s\S]*?<\/viability_decision>/g, '')
+        .replace(/<viability_rationale>[\s\S]*?<\/viability_rationale>/g, '')
+        .trim();
+    let canvas;
+    if (canvasMatch?.[1]) {
+        try {
+            canvas = JSON.parse(canvasMatch[1].trim());
+        }
+        catch {
+            console.warn('Failed to parse business canvas JSON');
+        }
+    }
+    let viability;
+    if (viabilityMatch?.[1]) {
+        const decision = viabilityMatch[1].toUpperCase();
+        if (decision === 'GO' || decision === 'NO_GO' || decision === 'NEEDS_MORE_INFO') {
+            viability = decision;
+        }
+    }
+    const rationale = rationaleMatch?.[1]?.trim();
+    return {
+        message,
+        canvas,
+        viability,
+        rationale,
+    };
+}
+function isValidTargetAudience(audience) {
+    if (!audience || typeof audience !== 'object') {
+        return false;
+    }
+    const a = audience;
+    if (typeof a.persona !== 'string' || !a.persona) {
+        return false;
+    }
+    if (!Array.isArray(a.painPoints) || !a.painPoints.length) {
+        return false;
+    }
+    return true;
+}
+function isValidSuccessMetric(metric) {
+    if (!metric || typeof metric !== 'object') {
+        return false;
+    }
+    const m = metric;
+    if (typeof m.name !== 'string' || !m.name) {
+        return false;
+    }
+    if (typeof m.target !== 'string' || !m.target) {
+        return false;
+    }
+    if (typeof m.timeframe !== 'string' || !m.timeframe) {
+        return false;
+    }
+    return true;
+}
+function hasValidCanvasStrings(c) {
+    const requiredStrings = [
+        'problem',
+        'solution',
+        'uniqueValue',
+        'revenueModel',
+        'costStructure',
+    ];
+    for (const field of requiredStrings) {
+        if (typeof c[field] !== 'string' || !c[field]) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasValidCanvasArrays(c) {
+    const requiredArrays = [
+        'keyMetrics',
+        'channels',
+        'features',
+        'targetAudience',
+        'successMetrics',
+    ];
+    for (const field of requiredArrays) {
+        if (!Array.isArray(c[field])) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasValidCanvasAudience(c) {
+    const targetAudience = c.targetAudience;
+    if (!targetAudience.length) {
+        return false;
+    }
+    for (const audience of targetAudience) {
+        if (!isValidTargetAudience(audience)) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasValidCanvasMetrics(c) {
+    const successMetrics = c.successMetrics;
+    if (!successMetrics.length) {
+        return false;
+    }
+    for (const metric of successMetrics) {
+        if (!isValidSuccessMetric(metric)) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasValidCanvasFeatures(c) {
+    const features = c.features;
+    for (const feature of features) {
+        if (!isValidFeatureProposal(feature)) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isValidBusinessCanvas(canvas) {
+    if (!canvas || typeof canvas !== 'object') {
+        return false;
+    }
+    const c = canvas;
+    if (!hasValidCanvasStrings(c)) {
+        return false;
+    }
+    if (!hasValidCanvasArrays(c)) {
+        return false;
+    }
+    if (!hasValidCanvasAudience(c)) {
+        return false;
+    }
+    if (!hasValidCanvasMetrics(c)) {
+        return false;
+    }
+    if (!hasValidCanvasFeatures(c)) {
+        return false;
+    }
+    return true;
+}
+function isValidFeatureProposal(feature) {
+    if (!feature || typeof feature !== 'object') {
+        return false;
+    }
+    const f = feature;
+    if (typeof f.name !== 'string' || !f.name) {
+        return false;
+    }
+    if (typeof f.description !== 'string' || !f.description) {
+        return false;
+    }
+    if (!['must-have', 'should-have', 'nice-to-have'].includes(f.priority)) {
+        return false;
+    }
+    if (!['low', 'medium', 'high'].includes(f.complexity)) {
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=business-canvas.js.map

package/dist/esm/ai-prompts/circuit-breaker.d.ts

@@ -0,0 +1,35 @@
+import type { DebateOutcome, DebateState } from './persona-debate.js';
+export interface CircuitBreakerConfig {
+    maxTokensPerDebate: number;
+    requireHumanReviewFor: Array<DebateOutcome['decision']>;
+    similarityThreshold: number;
+    minRoundsForSimilarityCheck: number;
+}
+export declare const DEFAULT_CIRCUIT_BREAKER_CONFIG: CircuitBreakerConfig;
+export interface CircuitBreakerState {
+    totalTokensUsed: number;
+    roundSimilarities: number[];
+    humanReviewRequired: boolean;
+    breakerTripped: boolean;
+    tripReason?: CircuitBreakerTripReason;
+    trippedAt?: Date;
+}
+export type CircuitBreakerTripReason = 'max_tokens_exceeded' | 'hallucination_loop_detected' | 'human_review_required';
+export declare function createCircuitBreakerState(): CircuitBreakerState;
+export declare function updateTokens(state: CircuitBreakerState, inputTokens: number, outputTokens: number, config?: CircuitBreakerConfig): CircuitBreakerState;
+export declare function calculateSimilarity(text1: string, text2: string): number;
+export declare function checkForHallucinationLoop(state: DebateState, config?: CircuitBreakerConfig): {
+    detected: boolean;
+    similarity: number;
+};
+export declare function updateSimilarity(state: CircuitBreakerState, similarity: number, isLoop: boolean): CircuitBreakerState;
+export declare function requiresHumanReview(outcome: DebateOutcome, config?: CircuitBreakerConfig): boolean;
+export declare function flagForHumanReview(state: CircuitBreakerState): CircuitBreakerState;
+export interface CircuitBreakerCheckResult {
+    shouldContinue: boolean;
+    state: CircuitBreakerState;
+    message?: string;
+}
+export declare function checkCircuitBreaker(debateState: DebateState, breakerState: CircuitBreakerState, config?: CircuitBreakerConfig): CircuitBreakerCheckResult;
+export declare function createCircuitBreakerLog(debateId: string, state: CircuitBreakerState, event: 'check' | 'trip' | 'human_review_flagged'): Record<string, unknown>;
+//# sourceMappingURL=circuit-breaker.d.ts.map