44reports-mcp 1.0.9 → 1.2.0

package/dist/api-client.d.ts

@@ -52,6 +52,23 @@ export interface Folder {
     name: string;
     description: string | null;
     allowed_domains: string[];
+    allowed_emails: string[];
+    created_at: string;
+    updated_at: string;
+}
+export interface BacklogEntry {
+    id: string;
+    product_slug: string | null;
+    content: string;
+    source: string | null;
+    source_context: string | null;
+    domain_hint: string | null;
+    tags: string | null;
+    status: string;
+    result_summary: string | null;
+    applied_changes: string | null;
+    rejection_reason: string | null;
+    processed_at: string | null;
     created_at: string;
     updated_at: string;
 }
@@ -92,7 +109,8 @@ export declare class ApiClient {
         name: string;
         slug?: string;
         description?: string;
-        allowed_domains: string[];
+        allowed_domains?: string[];
+        allowed_emails?: string[];
     }): Promise<{
         folder: Folder;
     }>;
@@ -104,6 +122,7 @@ export declare class ApiClient {
         name?: string;
         description?: string;
         allowed_domains?: string[];
+        allowed_emails?: string[];
     }): Promise<{
         folder: Folder;
     }>;
@@ -117,4 +136,147 @@ export declare class ApiClient {
     removeReportFromFolder(folderSlug: string, reportSlug: string): Promise<{
         success: boolean;
     }>;
+    listProducts(options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        products: Array<{
+            id: string;
+            slug: string;
+            name: string;
+            description: string | null;
+            created_at: string;
+            updated_at: string;
+        }>;
+        total: number;
+    }>;
+    getProduct(slug: string, domain?: string): Promise<{
+        product: {
+            id: string;
+            slug: string;
+            name: string;
+            description: string | null;
+            created_at: string;
+            updated_at: string;
+        };
+        knowledge: Record<string, unknown>;
+        doc_files: Array<{
+            path: string;
+            size: number;
+            domain: string;
+        }>;
+        binary_files: Array<{
+            path: string;
+            size: number;
+            content_type: string;
+            domain: string;
+        }>;
+    }>;
+    getProductFile(slug: string, filepath: string): Promise<{
+        path: string;
+        content: unknown;
+        content_type: string;
+        size?: number;
+    }>;
+    updateProductFile(slug: string, filepath: string, body: {
+        content: unknown;
+        updated_by?: string;
+    }): Promise<{
+        success: boolean;
+        path: string;
+        merged?: unknown;
+    }>;
+    uploadProductFiles(slug: string, files: Array<{
+        path: string;
+        content: string;
+        content_type?: string;
+    }>): Promise<{
+        success: boolean;
+        uploaded: string[];
+    }>;
+    getProductHealth(slug: string): Promise<{
+        slug: string;
+        name: string;
+        overall_score: number;
+        files: Record<string, unknown>;
+        recommendations: string[];
+    }>;
+    getAllProductsHealth(): Promise<{
+        products: Array<{
+            slug: string;
+            name: string;
+            overall_score: number;
+            files: Record<string, {
+                score: number;
+                missing_required: string[];
+            }>;
+        }>;
+    }>;
+    createProduct(data: {
+        name: string;
+        slug?: string;
+        description?: string;
+    }): Promise<{
+        product: {
+            id: string;
+            slug: string;
+            name: string;
+            description: string | null;
+            created_at: string;
+            updated_at: string;
+        };
+    }>;
+    deleteProduct(slug: string): Promise<{
+        success: boolean;
+    }>;
+    deleteProductFile(slug: string, filepath: string): Promise<{
+        success: boolean;
+    }>;
+    getProductIndex(slug: string, domain?: string): Promise<{
+        product_slug: string;
+        updated_at: string;
+        files: Array<{
+            path: string;
+            title: string;
+            summary: string;
+            sections: string[];
+            domain: string;
+            content_type: string;
+            size: number;
+            updated_at: string;
+        }>;
+    }>;
+    pullProductFiles(slug: string, options?: {
+        files?: string[];
+        include_knowledge?: boolean;
+    }): Promise<{
+        files: PulledFile[];
+    }>;
+    addBacklogEntry(data: {
+        content: string;
+        product_slug?: string;
+        source?: string;
+        source_context?: string;
+        domain_hint?: string;
+        tags?: string[];
+    }): Promise<{
+        entry: BacklogEntry;
+    }>;
+    listBacklog(options?: {
+        product_slug?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        entries: BacklogEntry[];
+        total: number;
+    }>;
+    deleteBacklogEntry(id: string): Promise<{
+        success: boolean;
+    }>;
+    processBacklog(options?: {
+        product_slug?: string;
+        dry_run?: boolean;
+    }): Promise<unknown>;
 }

package/dist/api-client.js

@@ -90,4 +90,99 @@ export class ApiClient {
             method: 'DELETE',
         });
     }
+    // --- Product Knowledge ---
+    async listProducts(options) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options ?? {})) {
+            if (value !== undefined) {
+                params.set(key, String(value));
+            }
+        }
+        const query = params.toString();
+        return this.request(`/api/products${query ? `?${query}` : ''}`);
+    }
+    async getProduct(slug, domain) {
+        const query = domain ? `?domain=${encodeURIComponent(domain)}` : '';
+        return this.request(`/api/products/${slug}${query}`);
+    }
+    async getProductFile(slug, filepath) {
+        return this.request(`/api/products/${slug}/files/${filepath}`);
+    }
+    async updateProductFile(slug, filepath, body) {
+        return this.request(`/api/products/${slug}/files/${filepath}`, {
+            method: 'PUT',
+            body: JSON.stringify(body),
+        });
+    }
+    async uploadProductFiles(slug, files) {
+        return this.request(`/api/products/${slug}/files`, {
+            method: 'POST',
+            body: JSON.stringify({ files }),
+        });
+    }
+    async getProductHealth(slug) {
+        return this.request(`/api/products/${slug}/health`);
+    }
+    async getAllProductsHealth() {
+        return this.request('/api/products/health');
+    }
+    async createProduct(data) {
+        return this.request('/api/products', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async deleteProduct(slug) {
+        return this.request(`/api/products/${slug}`, {
+            method: 'DELETE',
+        });
+    }
+    async deleteProductFile(slug, filepath) {
+        return this.request(`/api/products/${slug}/files/${filepath}`, {
+            method: 'DELETE',
+        });
+    }
+    async getProductIndex(slug, domain) {
+        const query = domain ? `?domain=${encodeURIComponent(domain)}` : '';
+        return this.request(`/api/products/${slug}/index${query}`);
+    }
+    async pullProductFiles(slug, options) {
+        return this.request(`/api/products/${slug}/pull`, {
+            method: 'POST',
+            body: JSON.stringify(options ?? {}),
+        });
+    }
+    // --- Agent Backlog ---
+    async addBacklogEntry(data) {
+        return this.request('/api/backlog', {
+            method: 'POST',
+            body: JSON.stringify(data),
+        });
+    }
+    async listBacklog(options) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(options ?? {})) {
+            if (value !== undefined) {
+                params.set(key, String(value));
+            }
+        }
+        const query = params.toString();
+        return this.request(`/api/backlog${query ? `?${query}` : ''}`);
+    }
+    async deleteBacklogEntry(id) {
+        return this.request(`/api/backlog/${id}`, {
+            method: 'DELETE',
+        });
+    }
+    async processBacklog(options) {
+        const params = new URLSearchParams();
+        if (options?.product_slug)
+            params.set('product_slug', options.product_slug);
+        if (options?.dry_run !== undefined)
+            params.set('dry_run', String(options.dry_run));
+        const query = params.toString();
+        return this.request(`/api/backlog/process${query ? `?${query}` : ''}`, {
+            method: 'POST',
+        });
+    }
 }

package/dist/index.js

@@ -8,6 +8,8 @@ import { deployReportSchema, updateReportSchema, createDeployTool, createUpdateT
 import { listReportsSchema, getReportSchema, deleteReportSchema, createListTool, createGetTool, createDeleteTool, } from './tools/reports.js';
 import { pullContextSchema, createPullTool, } from './tools/pull.js';
 import { manageFoldersSchema, createManageFoldersTool, } from './tools/folders.js';
+import { listProductsSchema, getProductSchema, readProductFileSchema, updateProductKnowledgeSchema, uploadProductFilesSchema, pullProductFilesSchema, createProductSchema, deleteProductSchema, deleteProductFileSchema, getProductHealthSchema, getProductIndexSchema, createListProductsTool, createGetProductTool, createReadProductFileTool, createUpdateProductKnowledgeTool, createUploadProductFilesTool, createPullProductFilesTool, createGetProductHealthTool, createGetProductIndexTool, createCreateProductTool, createDeleteProductTool, createDeleteProductFileTool, } from './tools/products.js';
+import { addToBacklogSchema, listBacklogSchema, processBacklogSchema, createAddToBacklogTool, createListBacklogTool, createProcessBacklogTool, } from './tools/backlog.js';
 const config = loadConfig();
 const client = new ApiClient(config);
 function prop(type, description, extra = {}) {
@@ -18,7 +20,7 @@ const FOLDER_PATH_DESC = 'RECOMMENDED for most contexts. Uploads all supported f
 const toolDefinitions = [
     {
         name: 'deploy_context',
-        description: 'Deploy files to the context repository. Supports any text-based files (code, docs, data, config) and binary files (images, fonts). For simple single-file contexts, use content. For multi-file contexts, use folder_path (recommended). Returns a stable URL for viewing and sharing.',
+        description: 'Deploy an output artifact to the context repository — use for one-time or versioned outputs: research reports, data analysis, dashboards, HTML visualizations, CSV exports, agent session summaries.\n\nIMPORTANT: Do NOT use this for brand or product knowledge (guidelines, copy, ad accounts, CPPs, product positioning). For persistent product knowledge that agents read and update over time, use update_product_knowledge instead.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -40,7 +42,7 @@ const toolDefinitions = [
     },
     {
         name: 'update_context',
-        description: 'Update an existing context. The URL remains stable. You can update metadata, content, or both.',
+        description: 'Update an existing output artifact context. The URL remains stable. You can update metadata, content, or both.\n\nIMPORTANT: Do NOT use this for brand or product knowledge. Use update_product_knowledge for product profiles, brand guidelines, copy, and ad accounts.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -116,7 +118,7 @@ const toolDefinitions = [
     },
     {
         name: 'manage_folders',
-        description: 'Manage folders for domain-scoped access control. Folders let you share specific contexts with external users by email domain (e.g., share investor reports with vgames.vc).',
+        description: 'Manage folders for access control. Folders let you share contexts with external users by email domain (e.g., vgames.vc) or individual email address (e.g., investor@gmail.com).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -126,7 +128,8 @@ const toolDefinitions = [
                 slug: prop('string', 'Folder slug (required for get/update/delete/add_reports/remove_report)'),
                 name: prop('string', 'Folder name (required for create)'),
                 description: prop('string', 'Folder description'),
-                allowed_domains: prop('array', 'Email domains that can access this folder (required for create)', { items: { type: 'string' } }),
+                allowed_domains: prop('array', 'Email domains that can access this folder', { items: { type: 'string' } }),
+                allowed_emails: prop('array', 'Individual email addresses that can access this folder', { items: { type: 'string' } }),
                 report_slugs: prop('array', 'Report slugs to add to folder (for add_reports)', { items: { type: 'string' } }),
                 report_slug: prop('string', 'Report slug to remove (for remove_report)'),
             },
@@ -135,6 +138,216 @@ const toolDefinitions = [
         schema: manageFoldersSchema,
         handler: createManageFoldersTool(client),
     },
+    {
+        name: 'list_products',
+        description: 'List all products in the knowledge repository with their knowledge file inventory. Call this first to discover available products and which knowledge files are already populated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                search: prop('string', 'Search term to filter products by name or description'),
+            },
+        },
+        schema: listProductsSchema,
+        handler: createListProductsTool(client),
+    },
+    {
+        name: 'get_product',
+        description: 'Get a product\'s complete knowledge — returns all JSON config files (meta-ads.json, cpps.json, brand-config.json) fully parsed, plus listings of markdown docs and binary assets. This is the primary tool to read before generating creative work, writing ad copy, or configuring campaigns. For narrative knowledge (brand voice, product positioning, research), use get_product_index to find the right markdown doc, then read_product_file to get its content.\n\nOptionally filter by domain to get only files relevant to a specific area: product-research, brand, copy, advertising, or app-store. Note: JSON config files are domain-scoped (meta-ads.json → advertising, brand-config.json → brand, cpps.json → app-store), so domains without a config file will return an empty knowledge object.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                domain: prop('string', 'Filter files by domain', { enum: ['product-research', 'brand', 'copy', 'advertising', 'app-store'] }),
+            },
+            required: ['slug'],
+        },
+        schema: getProductSchema,
+        handler: createGetProductTool(client),
+    },
+    {
+        name: 'read_product_file',
+        description: 'Read a single file from a product by path. Use get_product to read all knowledge files at once (more efficient). Use read_product_file only when you need one specific file — works for markdown docs, JSON configs, and binary files (logos, PDFs returned as base64 data URIs).\n\nTypical workflow: get_product_index → find the file you need → read_product_file.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                filepath: prop('string', 'File path within the product (e.g., "docs/research/user-research.md", "meta-ads.json", "brand-assets/logo.png")'),
+            },
+            required: ['slug', 'filepath'],
+        },
+        schema: readProductFileSchema,
+        handler: createReadProductFileTool(client),
+    },
+    {
+        name: 'update_product_knowledge',
+        description: 'Write or update product knowledge JSON config using deep merge-patch — only the keys you send are changed, all other data is preserved. Use this for programmatic config files that agents plug into API calls.\n\nConfig files per product:\n- meta-ads.json — Meta account IDs, pixels, creative test config\n- cpps.json — CPP motivations and custom product page config\n- brand-config.json — brand color palette hex values, font families\n\nFor narrative knowledge (product info, brand voice, copy, research), create or update Markdown docs using upload_product_files instead. Place docs in the correct domain prefix:\n- docs/research/ — user research, competitive analysis, hypotheses, GTM strategy, roadmap\n- docs/brand/ — brand voice, positioning\n- docs/copy/ — copy guidelines, messaging\n- docs/advertising/ — campaign briefs, ad copy\n- docs/app-store/ — store listing copy, metadata\n\nAlways pass updated_by with your agent name so humans can see who wrote each update.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                filepath: prop('string', 'Config file to update (e.g., "meta-ads.json", "cpps.json", "brand-config.json")'),
+                content: prop('object', 'JSON object to deep merge-patch into the knowledge file. Use null values to delete keys.'),
+                updated_by: prop('string', 'Agent name or ID writing the update (optional)'),
+            },
+            required: ['slug', 'filepath', 'content'],
+        },
+        schema: updateProductKnowledgeSchema,
+        handler: createUpdateProductKnowledgeTool(client),
+    },
+    {
+        name: 'upload_product_files',
+        description: 'Upload files to a product — binary assets or Markdown knowledge docs. Files are organized into sections:\n\nBinary assets:\n- brand-assets/ — logos, brand book PDFs, color swatches\n- store-listings/ — App Store / Play Store screenshots and preview videos\n- assets/ — ad creatives, icons, campaign videos\n\nMarkdown docs (use these prefixes for knowledge documents):\n- docs/research/ — user research, competitive analysis, hypotheses, GTM strategy, roadmap\n- docs/brand/ — brand voice, positioning\n- docs/copy/ — copy guidelines, messaging\n- docs/advertising/ — campaign briefs, ad copy\n- docs/app-store/ — store listing copy, metadata',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                files: prop('array', 'Files to upload', {
+                    items: {
+                        type: 'object',
+                        properties: {
+                            path: { type: 'string', description: 'File path within the product (e.g., "brand-assets/logo.png")' },
+                            content: { type: 'string', description: 'File content as text, base64 data URI, or local file path' },
+                            content_type: { type: 'string', description: 'MIME type (auto-detected if not provided)' },
+                        },
+                        required: ['path', 'content'],
+                    },
+                }),
+            },
+            required: ['slug', 'files'],
+        },
+        schema: uploadProductFilesSchema,
+        handler: createUploadProductFilesTool(client),
+    },
+    {
+        name: 'pull_product_files',
+        description: 'Download files from a product to a local directory. By default pulls binary assets (logos, screenshots, videos). Set include_knowledge to also pull JSON config files. To pull markdown docs, specify their paths in the files array (e.g., ["docs/research/user-research.md"]).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                output_dir: prop('string', 'Local directory to write files to. Will be created if needed.'),
+                files: prop('array', 'Specific file paths to pull. If omitted, all binary files are pulled.', { items: { type: 'string' } }),
+                include_knowledge: prop('boolean', 'Include knowledge JSON files in addition to binary files. Default: false.'),
+            },
+            required: ['slug', 'output_dir'],
+        },
+        schema: pullProductFilesSchema,
+        handler: createPullProductFilesTool(client),
+    },
+    {
+        name: 'get_product_health',
+        description: 'Get knowledge completeness scores for a product or all products. Scores both JSON config files (field-level completeness) and expected markdown docs (presence check). Shows missing required/optional fields and missing docs, with an overall health score (0-100). Use to identify gaps before generating content.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug. If omitted, returns health summary for all products.'),
+            },
+        },
+        schema: getProductHealthSchema,
+        handler: createGetProductHealthTool(client),
+    },
+    {
+        name: 'get_product_index',
+        description: 'Get a lightweight file index for a product — a table of contents listing every file with its title, summary, sections, domain, and size. Use this FIRST to discover what knowledge is available before pulling specific files. Much faster than get_product since it returns metadata only, not file contents.\n\nTypical workflow: list_products → get_product_index → read_product_file (for specific docs) or get_product (for all JSON configs at once).\n\nOptionally filter by domain to see only files in a specific area: product-research, brand, copy, advertising, or app-store.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                domain: prop('string', 'Filter index entries by domain', { enum: ['product-research', 'brand', 'copy', 'advertising', 'app-store'] }),
+            },
+            required: ['slug'],
+        },
+        schema: getProductIndexSchema,
+        handler: createGetProductIndexTool(client),
+    },
+    {
+        name: 'create_product',
+        description: 'Create a new product in the knowledge repository. The slug is auto-generated from the name if not provided. Use this before uploading knowledge files or assets.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: prop('string', 'Product name'),
+                slug: prop('string', 'URL-friendly slug (auto-generated from name if not provided)'),
+                description: prop('string', 'Product description'),
+            },
+            required: ['name'],
+        },
+        schema: createProductSchema,
+        handler: createCreateProductTool(client),
+    },
+    {
+        name: 'delete_product',
+        description: 'Delete a product and all its associated knowledge files and assets from the repository. This action is irreversible.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug to delete'),
+            },
+            required: ['slug'],
+        },
+        schema: deleteProductSchema,
+        handler: createDeleteProductTool(client),
+    },
+    {
+        name: 'delete_product_file',
+        description: 'Delete a single file from a product. Use for removing outdated assets or resetting a knowledge file.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                filepath: prop('string', 'File path within the product to delete (e.g., "brand-assets/old-logo.png")'),
+            },
+            required: ['slug', 'filepath'],
+        },
+        schema: deleteProductFileSchema,
+        handler: createDeleteProductFileTool(client),
+    },
+    {
+        name: 'add_to_backlog',
+        description: 'Add an unstructured observation to the agent backlog for later processing. Low-friction way for any agent to contribute signals — competitor insights, user feedback, research findings, or any data that should eventually enrich product knowledge. Only content is required; everything else is optional.\n\nIf you know which product this relates to, pass product_slug. Otherwise, omit it — the backlog processor will auto-route it to the right product (or reject it as noise).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                content: prop('string', 'The observation or data (100-2000 chars typical). Be specific — include sources, numbers, quotes when available.'),
+                product_slug: prop('string', 'Product slug if known. Omit for global entries that will be auto-routed.'),
+                source: prop('string', 'Your agent name or ID (e.g., "research-agent", "competitor-monitor")'),
+                source_context: prop('string', 'Context slug this observation came from, if applicable'),
+                domain_hint: prop('string', 'Knowledge domain hint', { enum: ['product-research', 'brand', 'copy', 'advertising', 'app-store'] }),
+                tags: prop('array', 'Free-form tags for categorization', { items: { type: 'string' } }),
+            },
+            required: ['content'],
+        },
+        schema: addToBacklogSchema,
+        handler: createAddToBacklogTool(client),
+    },
+    {
+        name: 'list_backlog',
+        description: 'List backlog entries — inspect the queue of pending observations waiting to be processed into product knowledge. Filter by product, status, or both.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product_slug: prop('string', 'Filter by product slug. Use "global" for unrouted entries without a product.'),
+                status: prop('string', 'Filter by status', { enum: ['pending', 'processing', 'applied', 'rejected', 'partial'] }),
+                limit: prop('number', 'Maximum number of results (default: 50)'),
+                offset: prop('number', 'Offset for pagination'),
+            },
+        },
+        schema: listBacklogSchema,
+        handler: createListBacklogTool(client),
+    },
+    {
+        name: 'process_backlog',
+        description: 'Trigger backlog processing — routes global entries to products, then uses LLM to triage and apply changes to product knowledge (JSON configs and markdown docs). Defaults to dry_run=true for safety.\n\nProcessing stages:\n1. Route: Global entries (no product_slug) are matched to products or rejected\n2. Process: Per-product entries are classified and generate JSON patches or markdown operations\n3. Apply: Only high-confidence changes are auto-applied; medium/low are marked as partial with suggestions',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                product_slug: prop('string', 'Process entries for a specific product only. Omit to process all products including global routing.'),
+                dry_run: prop('boolean', 'Preview changes without applying them. Default: true.'),
+            },
+        },
+        schema: processBacklogSchema,
+        handler: createProcessBacklogTool(client),
+    },
 ];
 const toolHandlers = Object.fromEntries(toolDefinitions.map((t) => [t.name, { schema: t.schema, handler: t.handler }]));
 const server = new Server({ name: '44reports', version: '1.0.0' }, { capabilities: { tools: {} } });

package/dist/tools/backlog.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const addToBacklogSchema: z.ZodObject<{
+    content: z.ZodString;
+    product_slug: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    source_context: z.ZodOptional<z.ZodString>;
+    domain_hint: z.ZodOptional<z.ZodEnum<["product-research", "brand", "copy", "advertising", "app-store"]>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    product_slug?: string | undefined;
+    tags?: string[] | undefined;
+    source?: string | undefined;
+    source_context?: string | undefined;
+    domain_hint?: "product-research" | "brand" | "copy" | "advertising" | "app-store" | undefined;
+}, {
+    content: string;
+    product_slug?: string | undefined;
+    tags?: string[] | undefined;
+    source?: string | undefined;
+    source_context?: string | undefined;
+    domain_hint?: "product-research" | "brand" | "copy" | "advertising" | "app-store" | undefined;
+}>;
+export declare const listBacklogSchema: z.ZodObject<{
+    product_slug: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<["pending", "processing", "applied", "rejected", "partial"]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status?: "pending" | "processing" | "applied" | "rejected" | "partial" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    product_slug?: string | undefined;
+}, {
+    status?: "pending" | "processing" | "applied" | "rejected" | "partial" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    product_slug?: string | undefined;
+}>;
+export declare const processBacklogSchema: z.ZodObject<{
+    product_slug: z.ZodOptional<z.ZodString>;
+    dry_run: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    dry_run: boolean;
+    product_slug?: string | undefined;
+}, {
+    product_slug?: string | undefined;
+    dry_run?: boolean | undefined;
+}>;
+export declare function createAddToBacklogTool(client: ApiClient): (input: z.infer<typeof addToBacklogSchema>) => Promise<{
+    entry: import("../api-client.js").BacklogEntry;
+}>;
+export declare function createListBacklogTool(client: ApiClient): (input: z.infer<typeof listBacklogSchema>) => Promise<{
+    entries: import("../api-client.js").BacklogEntry[];
+    total: number;
+}>;
+export declare function createProcessBacklogTool(client: ApiClient): (input: z.infer<typeof processBacklogSchema>) => Promise<unknown>;

package/dist/tools/backlog.js

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+const DOMAIN_VALUES = ['product-research', 'brand', 'copy', 'advertising', 'app-store'];
+const STATUS_VALUES = ['pending', 'processing', 'applied', 'rejected', 'partial'];
+// --- Schemas ---
+export const addToBacklogSchema = z.object({
+    content: z.string().describe('The observation or data to add to the backlog'),
+    product_slug: z.string().optional().describe('Product slug — omit for global entries that will be auto-routed'),
+    source: z.string().optional().describe('Agent name or ID submitting this entry'),
+    source_context: z.string().optional().describe('Context slug this observation came from'),
+    domain_hint: z.enum(DOMAIN_VALUES).optional().describe('Knowledge domain hint'),
+    tags: z.array(z.string()).optional().describe('Free-form tags for categorization'),
+});
+export const listBacklogSchema = z.object({
+    product_slug: z.string().optional().describe('Filter by product slug. Use "global" for unrouted entries.'),
+    status: z.enum(STATUS_VALUES).optional().describe('Filter by status'),
+    limit: z.number().optional().describe('Maximum number of results (default: 50)'),
+    offset: z.number().optional().describe('Offset for pagination'),
+});
+export const processBacklogSchema = z.object({
+    product_slug: z.string().optional().describe('Process entries for a specific product. Omit to process all including global routing.'),
+    dry_run: z.boolean().optional().default(true).describe('Preview changes without applying. Default: true.'),
+});
+// --- Tool factories ---
+export function createAddToBacklogTool(client) {
+    return async (input) => {
+        return client.addBacklogEntry(input);
+    };
+}
+export function createListBacklogTool(client) {
+    return async (input) => {
+        return client.listBacklog({
+            product_slug: input.product_slug,
+            status: input.status,
+            limit: input.limit,
+            offset: input.offset,
+        });
+    };
+}
+export function createProcessBacklogTool(client) {
+    return async (input) => {
+        return client.processBacklog({
+            product_slug: input.product_slug,
+            dry_run: input.dry_run,
+        });
+    };
+}

package/dist/tools/backlog.test.d.ts

@@ -0,0 +1 @@
+export {};