@compilr-dev/factory 0.1.19 → 0.1.21

package/dist/all-tools.js

@@ -12,6 +12,7 @@
 import { createModelTools } from './model/tools.js';
 import { createResearchModelTools } from './research-model/tools.js';
 import { createResearchScaffoldTool } from './research-model/scaffold-tool.js';
+import { createBusinessModelTools } from './business-model/tools.js';
 import { createFactoryTools } from './factory/tools.js';
 import { writeFileSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
@@ -32,6 +33,7 @@ export function createAllFactoryTools(config) {
     return [
         ...createModelTools({ context: config.context, cwd: config.cwd }),
         ...createResearchModelTools({ context: config.context }),
+        ...createBusinessModelTools({ context: config.context }),
         scaffoldTool,
         ...createFactoryTools({ context: config.context, cwd: config.cwd }),
     ];

package/dist/business-model/defaults.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Default Business Model creators.
+ */
+import type { BusinessModel } from './types.js';
+export declare function generateBusinessId(prefix?: string): string;
+export declare function resetBusinessIdCounter(): void;
+export declare function createDefaultBusinessModel(overrides?: Partial<BusinessModel>): BusinessModel;

package/dist/business-model/defaults.js

@@ -0,0 +1,54 @@
+/**
+ * Default Business Model creators.
+ */
+let _idCounter = 0;
+export function generateBusinessId(prefix = 'b') {
+    _idCounter++;
+    return `${prefix}_${Date.now().toString(36)}_${String(_idCounter)}`;
+}
+export function resetBusinessIdCounter() {
+    _idCounter = 0;
+}
+export function createDefaultBusinessModel(overrides) {
+    const now = new Date().toISOString();
+    return {
+        identity: {
+            name: 'My Business',
+            stage: 'idea',
+            ...overrides?.identity,
+        },
+        valueProposition: {
+            problem: '',
+            solution: '',
+            uniqueValue: '',
+            ...overrides?.valueProposition,
+        },
+        market: {
+            segments: [],
+            ...overrides?.market,
+        },
+        competitors: overrides?.competitors ?? [],
+        competitiveAdvantages: overrides?.competitiveAdvantages,
+        canvas: {
+            revenueStreams: [],
+            costStructure: [],
+            ...overrides?.canvas,
+        },
+        financials: {
+            revenueForecasts: [],
+            expenseForecasts: [],
+            ...overrides?.financials,
+        },
+        goToMarket: {
+            phases: [],
+            ...overrides?.goToMarket,
+        },
+        team: overrides?.team,
+        meta: {
+            revision: 1,
+            createdAt: now,
+            updatedAt: now,
+            ...overrides?.meta,
+        },
+    };
+}

package/dist/business-model/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Business Model — barrel export
+ */
+export type { BusinessModel, BusinessIdentity, BusinessStage, ValueProposition, Market, MarketSize, CustomerSegment, Competitor, MarketPosition, BusinessCanvas, RevenueStream, RevenueType, CostItem, Financials, ForecastEntry, GoToMarket, GTMPhase, TeamMember, BusinessMeta, PositioningMatrix, } from './types.js';
+export { createDefaultBusinessModel, generateBusinessId, resetBusinessIdCounter, } from './defaults.js';
+export { BusinessModelStore } from './persistence.js';
+export { validateBusinessModel } from './schema.js';
+export type { BusinessValidationError, BusinessValidationResult } from './schema.js';
+export { createBusinessModelTools } from './tools.js';
+export type { BusinessModelToolsConfig } from './tools.js';

package/dist/business-model/index.js

@@ -0,0 +1,7 @@
+/**
+ * Business Model — barrel export
+ */
+export { createDefaultBusinessModel, generateBusinessId, resetBusinessIdCounter, } from './defaults.js';
+export { BusinessModelStore } from './persistence.js';
+export { validateBusinessModel } from './schema.js';
+export { createBusinessModelTools } from './tools.js';

package/dist/business-model/persistence.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Business Model Store — Persistence Layer
+ */
+import type { IDocumentRepository } from '@compilr-dev/sdk';
+import type { BusinessModel } from './types.js';
+export declare class BusinessModelStore {
+    private readonly documents;
+    private readonly projectId;
+    constructor(config: {
+        documents: IDocumentRepository;
+        projectId: number;
+    });
+    get(): Promise<BusinessModel | null>;
+    save(model: BusinessModel): Promise<void>;
+    exists(): Promise<boolean>;
+}

package/dist/business-model/persistence.js

@@ -0,0 +1,37 @@
+/**
+ * Business Model Store — Persistence Layer
+ */
+const BIZ_MODEL_DOC_TYPE = 'business-model';
+const BIZ_MODEL_TITLE = 'Business Model';
+export class BusinessModelStore {
+    documents;
+    projectId;
+    constructor(config) {
+        this.documents = config.documents;
+        this.projectId = config.projectId;
+    }
+    async get() {
+        const doc = await this.documents.getByType(this.projectId, BIZ_MODEL_DOC_TYPE);
+        if (!doc)
+            return null;
+        try {
+            return JSON.parse(doc.content);
+        }
+        catch {
+            return null;
+        }
+    }
+    async save(model) {
+        const content = JSON.stringify(model, null, 2);
+        await this.documents.upsert({
+            project_id: this.projectId,
+            doc_type: BIZ_MODEL_DOC_TYPE,
+            title: BIZ_MODEL_TITLE,
+            content,
+        });
+    }
+    async exists() {
+        const doc = await this.documents.getByType(this.projectId, BIZ_MODEL_DOC_TYPE);
+        return doc !== null;
+    }
+}

package/dist/business-model/schema.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Business Model Validation
+ *
+ * Structural validation + business-quality warnings.
+ */
+import type { BusinessModel } from './types.js';
+export interface BusinessValidationError {
+    readonly path: string;
+    readonly message: string;
+    readonly severity: 'error' | 'warning';
+}
+export interface BusinessValidationResult {
+    readonly valid: boolean;
+    readonly errors: readonly BusinessValidationError[];
+    readonly warnings: readonly BusinessValidationError[];
+}
+export declare function validateBusinessModel(model: BusinessModel): BusinessValidationResult;

package/dist/business-model/schema.js

@@ -0,0 +1,126 @@
+/**
+ * Business Model Validation
+ *
+ * Structural validation + business-quality warnings.
+ */
+export function validateBusinessModel(model) {
+    const errors = [];
+    const warnings = [];
+    // ── Structural errors ──────────────────────────────────────────────────
+    if (!model.identity.name || model.identity.name.trim().length === 0) {
+        errors.push({ path: 'identity.name', message: 'Business name is required', severity: 'error' });
+    }
+    // Duplicate competitor IDs
+    const compIds = new Set();
+    for (const c of model.competitors) {
+        if (compIds.has(c.id)) {
+            errors.push({
+                path: `competitors[${c.id}]`,
+                message: `Duplicate competitor id "${c.id}"`,
+                severity: 'error',
+            });
+        }
+        compIds.add(c.id);
+        if (!c.name.trim()) {
+            errors.push({
+                path: `competitors[${c.id}].name`,
+                message: 'Competitor name is required',
+                severity: 'error',
+            });
+        }
+    }
+    // Duplicate segment IDs
+    const segIds = new Set();
+    for (const s of model.market.segments) {
+        if (segIds.has(s.id)) {
+            errors.push({
+                path: `market.segments[${s.id}]`,
+                message: `Duplicate segment id "${s.id}"`,
+                severity: 'error',
+            });
+        }
+        segIds.add(s.id);
+    }
+    // Duplicate revenue stream IDs
+    const rsIds = new Set();
+    for (const r of model.canvas.revenueStreams) {
+        if (rsIds.has(r.id)) {
+            errors.push({
+                path: `canvas.revenueStreams[${r.id}]`,
+                message: `Duplicate revenue stream id "${r.id}"`,
+                severity: 'error',
+            });
+        }
+        rsIds.add(r.id);
+    }
+    // ── Business quality warnings ──────────────────────────────────────────
+    if (!model.valueProposition.problem) {
+        warnings.push({
+            path: 'valueProposition.problem',
+            message: 'Problem statement is empty',
+            severity: 'warning',
+        });
+    }
+    if (!model.valueProposition.solution) {
+        warnings.push({
+            path: 'valueProposition.solution',
+            message: 'Solution is empty',
+            severity: 'warning',
+        });
+    }
+    if (!model.valueProposition.uniqueValue) {
+        warnings.push({
+            path: 'valueProposition.uniqueValue',
+            message: 'Unique value proposition is empty',
+            severity: 'warning',
+        });
+    }
+    if (!model.market.tam && !model.market.sam && !model.market.som) {
+        warnings.push({
+            path: 'market',
+            message: 'No market sizing defined (TAM/SAM/SOM)',
+            severity: 'warning',
+        });
+    }
+    if (model.market.segments.length === 0) {
+        warnings.push({
+            path: 'market.segments',
+            message: 'No customer segments defined',
+            severity: 'warning',
+        });
+    }
+    if (model.competitors.length === 0) {
+        warnings.push({
+            path: 'competitors',
+            message: 'No competitors identified',
+            severity: 'warning',
+        });
+    }
+    if (model.canvas.revenueStreams.length === 0) {
+        warnings.push({
+            path: 'canvas.revenueStreams',
+            message: 'No revenue streams defined',
+            severity: 'warning',
+        });
+    }
+    if (model.financials.revenueForecasts.length === 0 &&
+        model.financials.expenseForecasts.length === 0) {
+        warnings.push({
+            path: 'financials',
+            message: 'No financial projections defined',
+            severity: 'warning',
+        });
+    }
+    if (model.goToMarket.phases.length === 0) {
+        warnings.push({
+            path: 'goToMarket.phases',
+            message: 'No go-to-market phases defined',
+            severity: 'warning',
+        });
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}

package/dist/business-model/tools.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Business Model Tools
+ *
+ * business_model_get — scoped reads
+ * business_model_update — semantic operations
+ * business_model_validate — check completeness
+ */
+import type { Tool } from '@compilr-dev/agents';
+import type { PlatformContext } from '@compilr-dev/sdk';
+export interface BusinessModelToolsConfig {
+    readonly context: PlatformContext;
+}
+export declare function createBusinessModelTools(config: BusinessModelToolsConfig): Tool<never>[];

package/dist/business-model/tools.js

@@ -0,0 +1,587 @@
+/**
+ * Business Model Tools
+ *
+ * business_model_get — scoped reads
+ * business_model_update — semantic operations
+ * business_model_validate — check completeness
+ */
+import { defineTool, createSuccessResult, createErrorResult } from '@compilr-dev/agents';
+import { BusinessModelStore } from './persistence.js';
+import { validateBusinessModel } from './schema.js';
+import { createDefaultBusinessModel, generateBusinessId } from './defaults.js';
+function getProjectId(config, inputProjectId) {
+    const projectId = inputProjectId ?? config.context.currentProjectId;
+    if (!projectId)
+        throw new Error('No active project.');
+    return projectId;
+}
+function createStore(config, projectId) {
+    return new BusinessModelStore({ documents: config.context.documents, projectId });
+}
+function createBizModelGetTool(config) {
+    return defineTool({
+        name: 'business_model_get',
+        description: 'Read the Business Model. Supports scoped reads by section.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                scope: {
+                    type: 'string',
+                    enum: [
+                        'overview',
+                        'identity',
+                        'market',
+                        'competitors',
+                        'canvas',
+                        'financials',
+                        'gtm',
+                        'team',
+                        'full',
+                    ],
+                    description: 'Which section to return. "overview" for summary. Omit or "full" for everything.',
+                },
+                project_id: { type: 'number', description: 'Project ID. Uses active project if omitted.' },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            try {
+                const projectId = getProjectId(config, input.project_id);
+                const model = await createStore(config, projectId).get();
+                if (!model) {
+                    return createSuccessResult({
+                        exists: false,
+                        message: 'No Business Model found. Use business_model_update to start building one.',
+                    });
+                }
+                switch (input.scope) {
+                    case 'overview':
+                        return createSuccessResult({
+                            name: model.identity.name,
+                            stage: model.identity.stage,
+                            problem: model.valueProposition.problem,
+                            segments: model.market.segments.length,
+                            competitors: model.competitors.length,
+                            revenueStreams: model.canvas.revenueStreams.length,
+                            phases: model.goToMarket.phases.length,
+                            revision: model.meta.revision,
+                        });
+                    case 'identity':
+                        return createSuccessResult({
+                            identity: model.identity,
+                            valueProposition: model.valueProposition,
+                            meta: model.meta,
+                        });
+                    case 'market':
+                        return createSuccessResult({ market: model.market, meta: model.meta });
+                    case 'competitors':
+                        return createSuccessResult({
+                            competitors: model.competitors,
+                            competitiveAdvantages: model.competitiveAdvantages,
+                            meta: model.meta,
+                        });
+                    case 'canvas':
+                        return createSuccessResult({ canvas: model.canvas, meta: model.meta });
+                    case 'financials':
+                        return createSuccessResult({ financials: model.financials, meta: model.meta });
+                    case 'gtm':
+                        return createSuccessResult({ goToMarket: model.goToMarket, meta: model.meta });
+                    case 'team':
+                        return createSuccessResult({ team: model.team, meta: model.meta });
+                    default:
+                        return createSuccessResult(model);
+                }
+            }
+            catch (error) {
+                return createErrorResult(error instanceof Error ? error.message : String(error));
+            }
+        },
+        readonly: true,
+    });
+}
+const ALL_OPS = [
+    'set_identity',
+    'set_value_proposition',
+    'set_market_size',
+    'segment_add',
+    'segment_update',
+    'segment_remove',
+    'competitor_add',
+    'competitor_update',
+    'competitor_remove',
+    'set_competitive_advantages',
+    'revenue_stream_add',
+    'revenue_stream_update',
+    'revenue_stream_remove',
+    'cost_item_add',
+    'cost_item_update',
+    'cost_item_remove',
+    'set_canvas_fields',
+    'forecast_add',
+    'set_financials_fields',
+    'phase_add',
+    'phase_update',
+    'phase_remove',
+    'set_gtm_fields',
+    'set_team',
+    'set_positioning',
+];
+function createBizModelUpdateTool(config) {
+    return defineTool({
+        name: 'business_model_update',
+        description: 'Apply a semantic operation to the Business Model. Auto-creates if none exists.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                op: { type: 'string', enum: [...ALL_OPS], description: 'The operation to perform.' },
+                revision: { type: 'number', description: 'Expected revision for optimistic locking.' },
+                identity: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For set_identity: { name, tagline, mission, stage, industry, sector }',
+                },
+                value_proposition: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For set_value_proposition: { problem, solution, uniqueValue, targetCustomer }',
+                },
+                market_size: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For set_market_size: { tam?, sam?, som?, trends?, growthRate? }',
+                },
+                segment: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For segment_add/update: { name, description, size, painPoints, willingness }',
+                },
+                segment_id: { type: 'string', description: 'Segment ID for update/remove.' },
+                competitor: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For competitor_add/update: { name, description, strengths, weaknesses, marketPosition, pricing, url }',
+                },
+                competitor_id: { type: 'string', description: 'Competitor ID for update/remove.' },
+                advantages: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'For set_competitive_advantages.',
+                },
+                revenue_stream: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For revenue_stream_add/update: { name, type, description, projectedRevenue }',
+                },
+                stream_id: { type: 'string', description: 'Revenue stream ID for update/remove.' },
+                cost_item: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For cost_item_add/update: { category, name, amount, frequency }',
+                },
+                cost_id: { type: 'string', description: 'Cost item ID for update/remove.' },
+                canvas_field: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For set_canvas_fields: { keyResources?, keyActivities?, keyPartnerships?, channels?, customerRelationships? }',
+                },
+                financials_field: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For set_financials_fields: { breakEvenPoint?, fundingNeeds?, useOfFunds?, assumptions? }',
+                },
+                phase: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For phase_add/update: { name, description, targetDate, milestones }',
+                },
+                phase_id: { type: 'string', description: 'GTM phase ID for update/remove.' },
+                updates: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'Partial updates for update operations.',
+                },
+                team: {
+                    type: 'array',
+                    items: { type: 'object', additionalProperties: true },
+                    description: 'For set_team: [{ name, role, background }]',
+                },
+                positioning: {
+                    oneOf: [{ type: 'object', additionalProperties: true }, { type: 'string' }],
+                    description: 'For set_positioning: { xAxis, yAxis, selfX (0-100), selfY (0-100), xLow?, xHigh?, yLow?, yHigh? }. Competitors need positionX/positionY set via competitor_update.',
+                },
+                project_id: { type: 'number', description: 'Project ID. Uses active project if omitted.' },
+            },
+            required: ['op'],
+        },
+        execute: async (input) => {
+            try {
+                const projectId = getProjectId(config, input.project_id);
+                const store = createStore(config, projectId);
+                let model = await store.get();
+                if (!model)
+                    model = createDefaultBusinessModel();
+                if (input.revision !== undefined && input.revision !== model.meta.revision) {
+                    return createErrorResult(`Revision conflict: expected ${String(input.revision)}, current is ${String(model.meta.revision)}.`);
+                }
+                const updated = applyOperation(model, input);
+                const validation = validateBusinessModel(updated);
+                if (!validation.valid) {
+                    const msgs = validation.errors.map((e) => `${e.path}: ${e.message}`).join('; ');
+                    return createErrorResult(`Operation would produce invalid model: ${msgs}`);
+                }
+                await store.save(updated);
+                return createSuccessResult({
+                    op: input.op,
+                    revision: updated.meta.revision,
+                    message: `Operation "${input.op}" applied successfully.`,
+                    warnings: validation.warnings.length > 0
+                        ? validation.warnings.map((w) => `${w.path}: ${w.message}`)
+                        : undefined,
+                });
+            }
+            catch (error) {
+                return createErrorResult(error instanceof Error ? error.message : String(error));
+            }
+        },
+    });
+}
+// =============================================================================
+// Operation dispatcher
+// =============================================================================
+function coerce(value) {
+    if (typeof value === 'object' && value !== null && !Array.isArray(value))
+        return value;
+    if (typeof value === 'string') {
+        try {
+            const p = JSON.parse(value);
+            if (typeof p === 'object' && p !== null && !Array.isArray(p))
+                return p;
+        }
+        catch {
+            /* not JSON */
+        }
+    }
+    return null;
+}
+function bump(model) {
+    return {
+        ...model,
+        meta: { ...model.meta, revision: model.meta.revision + 1, updatedAt: new Date().toISOString() },
+    };
+}
+function applyOperation(model, input) {
+    switch (input.op) {
+        case 'set_identity': {
+            const data = coerce(input.identity);
+            if (!data)
+                throw new Error('set_identity requires "identity" object.');
+            return bump({
+                ...model,
+                identity: { ...model.identity, ...data },
+            });
+        }
+        case 'set_value_proposition': {
+            const data = coerce(input.value_proposition);
+            if (!data)
+                throw new Error('set_value_proposition requires "value_proposition" object.');
+            return bump({
+                ...model,
+                valueProposition: {
+                    ...model.valueProposition,
+                    ...data,
+                },
+            });
+        }
+        case 'set_market_size': {
+            const data = coerce(input.market_size);
+            if (!data)
+                throw new Error('set_market_size requires "market_size" object.');
+            return bump({ ...model, market: { ...model.market, ...data } });
+        }
+        case 'segment_add': {
+            const data = coerce(input.segment);
+            if (!data)
+                throw new Error('segment_add requires "segment" object with "name".');
+            const seg = {
+                id: generateBusinessId('seg'),
+                ...data,
+            };
+            return bump({
+                ...model,
+                market: { ...model.market, segments: [...model.market.segments, seg] },
+            });
+        }
+        case 'segment_update': {
+            if (!input.segment_id)
+                throw new Error('segment_update requires "segment_id".');
+            const data = coerce(input.updates ?? input.segment);
+            if (!data)
+                throw new Error('segment_update requires "updates" object.');
+            return bump({
+                ...model,
+                market: {
+                    ...model.market,
+                    segments: model.market.segments.map((s) => s.id === input.segment_id ? { ...s, ...data, id: s.id } : s),
+                },
+            });
+        }
+        case 'segment_remove': {
+            if (!input.segment_id)
+                throw new Error('segment_remove requires "segment_id".');
+            return bump({
+                ...model,
+                market: {
+                    ...model.market,
+                    segments: model.market.segments.filter((s) => s.id !== input.segment_id),
+                },
+            });
+        }
+        case 'competitor_add': {
+            const data = coerce(input.competitor);
+            if (!data)
+                throw new Error('competitor_add requires "competitor" object with "name".');
+            const comp = {
+                id: generateBusinessId('comp'),
+                strengths: [],
+                weaknesses: [],
+                ...data,
+            };
+            if (model.competitors.some((c) => c.name === comp.name))
+                throw new Error(`Competitor "${comp.name}" already exists.`);
+            return bump({ ...model, competitors: [...model.competitors, comp] });
+        }
+        case 'competitor_update': {
+            if (!input.competitor_id)
+                throw new Error('competitor_update requires "competitor_id".');
+            const data = coerce(input.updates ?? input.competitor);
+            if (!data)
+                throw new Error('competitor_update requires "updates" object.');
+            return bump({
+                ...model,
+                competitors: model.competitors.map((c) => c.id === input.competitor_id ? { ...c, ...data, id: c.id } : c),
+            });
+        }
+        case 'competitor_remove': {
+            if (!input.competitor_id)
+                throw new Error('competitor_remove requires "competitor_id".');
+            return bump({
+                ...model,
+                competitors: model.competitors.filter((c) => c.id !== input.competitor_id),
+            });
+        }
+        case 'set_competitive_advantages': {
+            if (!input.advantages)
+                throw new Error('set_competitive_advantages requires "advantages" array.');
+            return bump({ ...model, competitiveAdvantages: input.advantages });
+        }
+        case 'revenue_stream_add': {
+            const data = coerce(input.revenue_stream);
+            if (!data)
+                throw new Error('revenue_stream_add requires "revenue_stream" object.');
+            const rs = {
+                id: generateBusinessId('rs'),
+                ...data,
+            };
+            return bump({
+                ...model,
+                canvas: { ...model.canvas, revenueStreams: [...model.canvas.revenueStreams, rs] },
+            });
+        }
+        case 'revenue_stream_update': {
+            if (!input.stream_id)
+                throw new Error('revenue_stream_update requires "stream_id".');
+            const data = coerce(input.updates ?? input.revenue_stream);
+            if (!data)
+                throw new Error('revenue_stream_update requires "updates" object.');
+            return bump({
+                ...model,
+                canvas: {
+                    ...model.canvas,
+                    revenueStreams: model.canvas.revenueStreams.map((r) => r.id === input.stream_id ? { ...r, ...data, id: r.id } : r),
+                },
+            });
+        }
+        case 'revenue_stream_remove': {
+            if (!input.stream_id)
+                throw new Error('revenue_stream_remove requires "stream_id".');
+            return bump({
+                ...model,
+                canvas: {
+                    ...model.canvas,
+                    revenueStreams: model.canvas.revenueStreams.filter((r) => r.id !== input.stream_id),
+                },
+            });
+        }
+        case 'cost_item_add': {
+            const data = coerce(input.cost_item);
+            if (!data)
+                throw new Error('cost_item_add requires "cost_item" object.');
+            const ci = { id: generateBusinessId('ci'), ...data };
+            return bump({
+                ...model,
+                canvas: { ...model.canvas, costStructure: [...model.canvas.costStructure, ci] },
+            });
+        }
+        case 'cost_item_update': {
+            if (!input.cost_id)
+                throw new Error('cost_item_update requires "cost_id".');
+            const data = coerce(input.updates ?? input.cost_item);
+            if (!data)
+                throw new Error('cost_item_update requires "updates" object.');
+            return bump({
+                ...model,
+                canvas: {
+                    ...model.canvas,
+                    costStructure: model.canvas.costStructure.map((c) => c.id === input.cost_id ? { ...c, ...data, id: c.id } : c),
+                },
+            });
+        }
+        case 'cost_item_remove': {
+            if (!input.cost_id)
+                throw new Error('cost_item_remove requires "cost_id".');
+            return bump({
+                ...model,
+                canvas: {
+                    ...model.canvas,
+                    costStructure: model.canvas.costStructure.filter((c) => c.id !== input.cost_id),
+                },
+            });
+        }
+        case 'set_canvas_fields': {
+            const data = coerce(input.canvas_field);
+            if (!data)
+                throw new Error('set_canvas_fields requires "canvas_field" object.');
+            return bump({ ...model, canvas: { ...model.canvas, ...data } });
+        }
+        case 'forecast_add': {
+            const data = coerce(input.financials_field);
+            if (!data)
+                throw new Error('forecast_add requires "financials_field" with period, category, amount.');
+            const isRevenue = data.type === 'revenue';
+            const entry = {
+                period: data.period,
+                category: data.category,
+                amount: data.amount,
+                notes: data.notes,
+            };
+            if (isRevenue) {
+                return bump({
+                    ...model,
+                    financials: {
+                        ...model.financials,
+                        revenueForecasts: [...model.financials.revenueForecasts, entry],
+                    },
+                });
+            }
+            return bump({
+                ...model,
+                financials: {
+                    ...model.financials,
+                    expenseForecasts: [...model.financials.expenseForecasts, entry],
+                },
+            });
+        }
+        case 'set_financials_fields': {
+            const data = coerce(input.financials_field);
+            if (!data)
+                throw new Error('set_financials_fields requires "financials_field" object.');
+            return bump({
+                ...model,
+                financials: { ...model.financials, ...data },
+            });
+        }
+        case 'phase_add': {
+            const data = coerce(input.phase);
+            if (!data)
+                throw new Error('phase_add requires "phase" object with "name".');
+            const ph = { id: generateBusinessId('ph'), ...data };
+            return bump({
+                ...model,
+                goToMarket: { ...model.goToMarket, phases: [...model.goToMarket.phases, ph] },
+            });
+        }
+        case 'phase_update': {
+            if (!input.phase_id)
+                throw new Error('phase_update requires "phase_id".');
+            const data = coerce(input.updates ?? input.phase);
+            if (!data)
+                throw new Error('phase_update requires "updates" object.');
+            return bump({
+                ...model,
+                goToMarket: {
+                    ...model.goToMarket,
+                    phases: model.goToMarket.phases.map((p) => p.id === input.phase_id ? { ...p, ...data, id: p.id } : p),
+                },
+            });
+        }
+        case 'phase_remove': {
+            if (!input.phase_id)
+                throw new Error('phase_remove requires "phase_id".');
+            return bump({
+                ...model,
+                goToMarket: {
+                    ...model.goToMarket,
+                    phases: model.goToMarket.phases.filter((p) => p.id !== input.phase_id),
+                },
+            });
+        }
+        case 'set_gtm_fields': {
+            const data = coerce(input.updates);
+            if (!data)
+                throw new Error('set_gtm_fields requires "updates" object.');
+            return bump({
+                ...model,
+                goToMarket: { ...model.goToMarket, ...data },
+            });
+        }
+        case 'set_team': {
+            if (!input.team)
+                throw new Error('set_team requires "team" array.');
+            return bump({ ...model, team: input.team });
+        }
+        case 'set_positioning': {
+            const data = coerce(input.positioning);
+            if (!data)
+                throw new Error('set_positioning requires "positioning" object with xAxis, yAxis, selfX, selfY.');
+            return bump({ ...model, positioning: data });
+        }
+        default:
+            throw new Error(`Unknown operation: ${input.op}`);
+    }
+}
+function createBizModelValidateTool(config) {
+    return defineTool({
+        name: 'business_model_validate',
+        description: 'Validate the Business Model. Returns structural errors and business-quality warnings.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_id: { type: 'number', description: 'Project ID. Uses active project if omitted.' },
+            },
+            required: [],
+        },
+        execute: async (input) => {
+            try {
+                const projectId = getProjectId(config, input.project_id);
+                const model = await createStore(config, projectId).get();
+                if (!model) {
+                    return createSuccessResult({
+                        valid: false,
+                        errors: [{ path: '', message: 'No Business Model found' }],
+                        warnings: [],
+                    });
+                }
+                const result = validateBusinessModel(model);
+                return createSuccessResult({
+                    valid: result.valid,
+                    errors: result.errors,
+                    warnings: result.warnings,
+                    revision: model.meta.revision,
+                });
+            }
+            catch (error) {
+                return createErrorResult(error instanceof Error ? error.message : String(error));
+            }
+        },
+        readonly: true,
+    });
+}
+// =============================================================================
+// Public API
+// =============================================================================
+export function createBusinessModelTools(config) {
+    return [
+        createBizModelGetTool(config),
+        createBizModelUpdateTool(config),
+        createBizModelValidateTool(config),
+    ];
+}

package/dist/business-model/types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Business Model Types
+ *
+ * The Business Model describes a business: identity, value proposition,
+ * market, competitors, financials, and go-to-market strategy.
+ */
+export interface BusinessModel {
+    readonly identity: BusinessIdentity;
+    readonly valueProposition: ValueProposition;
+    readonly market: Market;
+    readonly competitors: readonly Competitor[];
+    readonly competitiveAdvantages?: readonly string[];
+    /** Positioning matrix: defines the 2 axes for competitive comparison */
+    readonly positioning?: PositioningMatrix;
+    readonly canvas: BusinessCanvas;
+    readonly financials: Financials;
+    readonly goToMarket: GoToMarket;
+    readonly team?: readonly TeamMember[];
+    readonly meta: BusinessMeta;
+}
+export type BusinessStage = 'idea' | 'pre-seed' | 'seed' | 'series-a' | 'growth' | 'established';
+export interface BusinessIdentity {
+    readonly name: string;
+    readonly tagline?: string;
+    readonly mission?: string;
+    readonly stage: BusinessStage;
+    readonly industry?: string;
+    readonly sector?: string;
+}
+export interface ValueProposition {
+    readonly problem: string;
+    readonly solution: string;
+    readonly uniqueValue: string;
+    readonly targetCustomer?: string;
+}
+export interface MarketSize {
+    readonly value: string;
+    readonly description?: string;
+    readonly source?: string;
+}
+export interface CustomerSegment {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly size?: string;
+    readonly painPoints?: readonly string[];
+    readonly willingness?: string;
+}
+export interface Market {
+    readonly tam?: MarketSize;
+    readonly sam?: MarketSize;
+    readonly som?: MarketSize;
+    readonly trends?: readonly string[];
+    readonly growthRate?: string;
+    readonly segments: readonly CustomerSegment[];
+}
+export type MarketPosition = 'leader' | 'challenger' | 'niche' | 'emerging';
+export interface Competitor {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly strengths: readonly string[];
+    readonly weaknesses: readonly string[];
+    readonly marketPosition?: MarketPosition;
+    readonly pricing?: string;
+    readonly url?: string;
+    /** Position on the 2D matrix (0-100 on each axis) */
+    readonly positionX?: number;
+    readonly positionY?: number;
+}
+export interface PositioningMatrix {
+    /** X-axis label (e.g., "Price", "Domain Specialization") */
+    readonly xAxis: string;
+    /** Y-axis label (e.g., "Features", "Multi-Agent Capability") */
+    readonly yAxis: string;
+    /** X-axis low end label (e.g., "Low", "General") */
+    readonly xLow?: string;
+    /** X-axis high end label (e.g., "High", "Specialized") */
+    readonly xHigh?: string;
+    /** Y-axis low end label */
+    readonly yLow?: string;
+    /** Y-axis high end label */
+    readonly yHigh?: string;
+    /** Your business position on X (0-100) */
+    readonly selfX: number;
+    /** Your business position on Y (0-100) */
+    readonly selfY: number;
+}
+export type RevenueType = 'subscription' | 'one-time' | 'usage' | 'advertising' | 'commission' | 'licensing' | 'other';
+export interface RevenueStream {
+    readonly id: string;
+    readonly name: string;
+    readonly type: RevenueType;
+    readonly description?: string;
+    readonly projectedRevenue?: string;
+}
+export interface CostItem {
+    readonly id: string;
+    readonly category: 'fixed' | 'variable';
+    readonly name: string;
+    readonly amount?: string;
+    readonly frequency?: 'monthly' | 'yearly' | 'one-time';
+}
+export interface BusinessCanvas {
+    readonly revenueStreams: readonly RevenueStream[];
+    readonly costStructure: readonly CostItem[];
+    readonly keyResources?: readonly string[];
+    readonly keyActivities?: readonly string[];
+    readonly keyPartnerships?: readonly string[];
+    readonly channels?: readonly string[];
+    readonly customerRelationships?: readonly string[];
+}
+export interface ForecastEntry {
+    readonly period: string;
+    readonly category: string;
+    readonly amount: number;
+    readonly notes?: string;
+}
+export interface Financials {
+    readonly revenueForecasts: readonly ForecastEntry[];
+    readonly expenseForecasts: readonly ForecastEntry[];
+    readonly breakEvenPoint?: string;
+    readonly fundingNeeds?: string;
+    readonly useOfFunds?: string;
+    readonly assumptions?: readonly string[];
+}
+export interface GTMPhase {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly targetDate?: string;
+    readonly milestones?: readonly string[];
+}
+export interface GoToMarket {
+    readonly strategy?: string;
+    readonly phases: readonly GTMPhase[];
+    readonly channels?: readonly string[];
+    readonly salesStrategy?: string;
+}
+export interface TeamMember {
+    readonly name: string;
+    readonly role: string;
+    readonly background?: string;
+}
+export interface BusinessMeta {
+    readonly revision: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}

package/dist/business-model/types.js

@@ -0,0 +1,7 @@
+/**
+ * Business Model Types
+ *
+ * The Business Model describes a business: identity, value proposition,
+ * market, competitors, financials, and go-to-market strategy.
+ */
+export {};

package/dist/index.d.ts

@@ -28,3 +28,5 @@ export { reactGoToolkit } from './toolkits/react-go/index.js';
 export { factoryScaffoldSkill, factorySkills } from './factory/skill.js';
 export type { ResearchModel, Section, SectionStatus, Claim, ClaimType, EvidenceStrength, SourceRef, Source, SourceRelevance, CitationInfo, CitationType, CitationStyle, ResearchQuestion, QuestionStatus, ResearchMeta, ResearchValidationError, ResearchValidationResult, ResearchModelOperation, ResearchModelToolsConfig, BibliographyOptions, BibTeXEntry, ResearchTemplate, ResearchTemplateFile, ResearchScaffoldConfig, } from './research-model/index.js';
 export { createDefaultResearchModel, createDefaultSection, createDefaultClaim, createDefaultSource, createDefaultQuestion, ResearchModelStore, applyResearchOperation, validateResearchModel, createResearchModelTools, generateBibliography, parseBibTeX, RESEARCH_TEMPLATES, getResearchTemplate, apaPaperTemplate, ieeePaperTemplate, thesisTemplate, literatureReviewTemplate, labReportTemplate, createResearchScaffoldTool, } from './research-model/index.js';
+export type { BusinessModel, BusinessIdentity, BusinessStage, ValueProposition, Market, MarketSize, CustomerSegment, Competitor, MarketPosition, BusinessCanvas, RevenueStream, RevenueType, CostItem, Financials, ForecastEntry, GoToMarket, GTMPhase, TeamMember, BusinessMeta, BusinessValidationError, BusinessValidationResult, BusinessModelToolsConfig, } from './business-model/index.js';
+export { createDefaultBusinessModel, BusinessModelStore, validateBusinessModel, createBusinessModelTools, } from './business-model/index.js';

package/dist/index.js

@@ -34,3 +34,4 @@ export { reactGoToolkit } from './toolkits/react-go/index.js';
 // Factory skill (Phase 5)
 export { factoryScaffoldSkill, factorySkills } from './factory/skill.js';
 export { createDefaultResearchModel, createDefaultSection, createDefaultClaim, createDefaultSource, createDefaultQuestion, ResearchModelStore, applyResearchOperation, validateResearchModel, createResearchModelTools, generateBibliography, parseBibTeX, RESEARCH_TEMPLATES, getResearchTemplate, apaPaperTemplate, ieeePaperTemplate, thesisTemplate, literatureReviewTemplate, labReportTemplate, createResearchScaffoldTool, } from './research-model/index.js';
+export { createDefaultBusinessModel, BusinessModelStore, validateBusinessModel, createBusinessModelTools, } from './business-model/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@compilr-dev/factory",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "AI-driven application scaffolder for the compilr-dev ecosystem",
   "type": "module",
   "main": "dist/index.js",
@@ -45,6 +45,6 @@
     "code-generation"
   ],
   "dependencies": {
-    "@compilr-dev/sdk": "^0.6.0"
+    "@compilr-dev/sdk": "^0.7.2"
   }
 }