44reports-mcp 1.1.0 → 1.3.0

package/dist/api-client.d.ts

@@ -56,6 +56,22 @@ export interface Folder {
     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;
+}
 export declare class ApiClient {
     private readonly config;
     constructor(config: Config);
@@ -120,17 +136,22 @@ export declare class ApiClient {
     removeReportFromFolder(folderSlug: string, reportSlug: string): Promise<{
         success: boolean;
     }>;
-    listProducts(): Promise<{
+    listProducts(options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
         products: Array<{
             id: string;
             slug: string;
             name: string;
             description: string | null;
-            json_file_count: number;
-            binary_file_count: number;
+            created_at: string;
+            updated_at: string;
         }>;
+        total: number;
     }>;
-    getProduct(slug: string): Promise<{
+    getProduct(slug: string, domain?: string): Promise<{
         product: {
             id: string;
             slug: string;
@@ -140,10 +161,16 @@ export declare class ApiClient {
             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<{
@@ -168,4 +195,88 @@ export declare class ApiClient {
         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

@@ -16,7 +16,11 @@ export class ApiClient {
         });
         if (!response.ok) {
             const error = await response.json().catch(() => ({ error: response.statusText }));
-            throw new Error(error.error || `HTTP ${response.status}`);
+            const message = error.error || `HTTP ${response.status}`;
+            if (response.status === 401) {
+                throw new Error(`${message}. Reporter token rejected. Generate or rotate yours at ${this.config.apiUrl.replace('reporter.44pixels.workers.dev', 'reporter-directory.pages.dev')} → Settings, then update REPORTER_API_KEY in your Claude config and restart Claude Code.`);
+            }
+            throw new Error(message);
         }
         return response.json();
     }
@@ -91,11 +95,19 @@ export class ApiClient {
         });
     }
     // --- Product Knowledge ---
-    async listProducts() {
-        return this.request('/api/products');
+    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) {
-        return this.request(`/api/products/${slug}`);
+    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}`);
@@ -112,4 +124,69 @@ export class ApiClient {
             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,7 +8,9 @@ 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, createListProductsTool, createGetProductTool, createReadProductFileTool, createUpdateProductKnowledgeTool, createUploadProductFilesTool, createPullProductFilesTool, } from './tools/products.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 { createUploadProductDirectoryTool, uploadProductDirectorySchema, UPLOAD_DIRECTORY_DESCRIPTION, } from './tools/upload-directory.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 = {}) {
@@ -139,18 +141,24 @@ const toolDefinitions = [
     },
     {
         name: 'list_products',
-        description: 'List all 44pixels products in the knowledge repository (Cue, Deep, Pixi, Clara, Vivi, Wordcast, etc.) with their knowledge file inventory. Call this first to discover available products and which knowledge files are already populated.',
-        inputSchema: { type: 'object', properties: {} },
+        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 knowledge files (product.json, brand.json, copy.json, meta-ads.json, cpps.json) fully parsed, plus a listing of binary assets. This is the primary tool to read before generating creative work, writing ad copy, or configuring campaigns — it gives you brand voice, product positioning, hooks, and ad account IDs in one call.',
+        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'],
         },
@@ -159,12 +167,12 @@ const toolDefinitions = [
     },
     {
         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 — especially useful for binary files (logos, PDFs) returned as base64 data URIs.',
+        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., "meta-ads.json", "brand-assets/logo.png")'),
+                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'],
         },
@@ -173,12 +181,12 @@ const toolDefinitions = [
     },
     {
         name: 'update_product_knowledge',
-        description: 'Write or update product knowledge using deep merge-patch — only the keys you send are changed, all other data is preserved. This is the canonical way to store brand knowledge: ALWAYS use this (not deploy_context) for product profiles, brand guidelines, copy, ad accounts, and CPP config.\n\nKnowledge files per product:\n- product.json — core info, target audience, pain points, selling points, competitors\n- brand.json — colors, typography, voice/tone, brand archetypes, power words\n- copy.json — taglines, hooks, CTAs, approved/banned claims\n- meta-ads.json — Meta account IDs, pixels, creative test config\n- cpps.json — CPP motivations and custom product page config\n\nAlways pass updated_by with your agent name so humans can see who wrote each update.',
+        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', 'Knowledge file to update (e.g., "meta-ads.json", "brand.json", "product.json", "copy.json", "cpps.json")'),
+                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)'),
             },
@@ -189,7 +197,12 @@ const toolDefinitions = [
     },
     {
         name: 'upload_product_files',
-        description: 'Upload binary assets to a product — logos, brand books, App Store screenshots, ad creatives, videos. Files are organized into sections:\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',
+        description: 'Upload one or more files to a product. For multiple files in a directory, prefer ' +
+            'upload_product_directory.\n\n' +
+            'Place files at media/<domain>/ for binaries, docs/<domain>/ for markdown:\n' +
+            '  media/brand/, media/product-research/, media/copy/, media/advertising/, media/app-store/\n' +
+            '  docs/brand/, docs/research/, docs/copy/, docs/advertising/, docs/app-store/\n\n' +
+            'Pass content as a LOCAL PATH (preferred), a base64 data URI, or plain text.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -211,21 +224,161 @@ const toolDefinitions = [
         schema: uploadProductFilesSchema,
         handler: createUploadProductFilesTool(client),
     },
+    {
+        name: 'upload_product_directory',
+        description: UPLOAD_DIRECTORY_DESCRIPTION,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                slug: prop('string', 'Product slug'),
+                local_dir: prop('string', 'Absolute or relative path to the local directory to upload'),
+                domain: {
+                    type: 'string',
+                    enum: ['product-research', 'brand', 'copy', 'advertising', 'app-store'],
+                    description: 'Product domain — determines target folder (media/<domain>/)',
+                },
+                dest_prefix: prop('string', 'Subpath under media/<domain>/. Defaults to basename of local_dir.'),
+                glob: prop('string', 'Include filter, e.g. "**/*.{png,jpg,mp4}". Default: "**/*".'),
+                exclude: prop('array', 'Exclude patterns. Default: [".*", "**/.*", "node_modules/**"].', {
+                    items: { type: 'string' },
+                }),
+                dry_run: prop('boolean', 'If true, returns the planned uploads without sending. Default: false.'),
+            },
+            required: ['slug', 'local_dir', 'domain'],
+        },
+        schema: uploadProductDirectorySchema,
+        handler: createUploadProductDirectoryTool(client),
+    },
     {
         name: 'pull_product_files',
-        description: 'Download binary files from a product to a local directory.',
+        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 {};