edsger 0.76.0 → 0.78.0

package/dist/phases/recipes/index.js

@@ -1,358 +0,0 @@
-/**
- * Recipes phase: clone the product's repo, ask Claude to identify each
- * non-trivial capability the product implements, and persist HOW it's built
- * via the recipes / product_recipes tables.
- *
- * Production-grade behaviours layered on top of the basic agent loop:
- *
- *   - Heartbeat: `last_heartbeat_at` on the recipe_scans row is refreshed
- *     on every assistant message so the reader can detect stalled / crashed
- *     runs (see desktop-app/.../services/db/recipe-scans.ts for the lazy
- *     reaper).
- *   - Cancellation-safe writes: markRunning / markSuccess / markFailed only
- *     touch rows whose status is in {pending, running}. If the user clicked
- *     Stop and the row is now 'cancelled', the final write no-ops.
- *   - Per-call MCP writes: agent commits each create / update / link /
- *     unlink as it goes. There is no "submit at the end" buffer — partial
- *     progress survives even if the agent later errors out.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getGitHubConfigByProduct, getGitHubConfigByRepository, getRepositoryBasics, } from '../../api/github.js';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { getSupabase } from '../../supabase/client.js';
-import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
-import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
-import { fetchProductBasics } from '../find-shared/mcp.js';
-import { createPromptGenerator, extractTextFromContent, } from '../pr-shared/agent-utils.js';
-import { createRecipesMcpServer, createRecipesMutationCounts, } from './mcp-server.js';
-import { createRecipesSystemPrompt, createRecipesUserPrompt, } from './prompts.js';
-const WORKSPACE_KEY = 'recipes';
-const MAX_TURNS = 200;
-// Heartbeat cadence: at most one DB write per HEARTBEAT_MIN_INTERVAL_MS.
-// Triggered on every assistant message so a stalled agent (no messages
-// flowing) lets the row go stale and the reader can mark it failed.
-const HEARTBEAT_MIN_INTERVAL_MS = 15_000;
-export async function runRecipesPhase(options) {
-    const { productId, repoId, scanId, guidance, verbose } = options;
-    const repoOnly = !productId && Boolean(repoId);
-    if (productId) {
-        logInfo(`Starting recipes scan for product ${productId}`);
-    }
-    else {
-        logInfo(`Starting recipes scan for repository ${repoId}`);
-    }
-    const supabase = getSupabase();
-    const claimed = await markRunning(supabase, scanId);
-    if (!claimed) {
-        return {
-            status: 'cancelled',
-            message: 'Recipe scan row is no longer in a runnable state (likely cancelled before the CLI started)',
-        };
-    }
-    // Resolve the team (recipes are team-scoped) + repo basics. In repo-only
-    // mode both come off the repositories row; in product mode from the product.
-    let teamId;
-    let repoBasics = {
-        fullName: null,
-        description: null,
-    };
-    if (repoOnly) {
-        const basics = await getRepositoryBasics(repoId);
-        teamId = basics.teamId;
-        repoBasics = { fullName: basics.fullName, description: basics.description };
-        if (!teamId) {
-            const msg = 'Repository is not associated with a team; recipes are team-scoped and require one.';
-            await markFailed(supabase, scanId, msg);
-            return { status: 'error', message: msg };
-        }
-    }
-    else {
-        teamId = await getProductTeamId(supabase, productId);
-        if (!teamId) {
-            const msg = 'Product is not associated with a team; recipes are team-scoped and require one.';
-            await markFailed(supabase, scanId, msg);
-            return { status: 'error', message: msg };
-        }
-    }
-    const githubConfig = repoOnly
-        ? await getGitHubConfigByRepository(repoId, verbose)
-        : await getGitHubConfigByProduct(productId, verbose);
-    if (!githubConfig.configured ||
-        !githubConfig.token ||
-        !githubConfig.owner ||
-        !githubConfig.repo) {
-        const msg = githubConfig.message ||
-            (repoOnly
-                ? 'GitHub repository not configured. Connect the repo first.'
-                : 'GitHub repository not configured for this product. Connect a repo first.');
-        await markFailed(supabase, scanId, msg);
-        return { status: 'error', message: msg };
-    }
-    let repoPath;
-    let succeeded = false;
-    try {
-        const workspaceRoot = ensureWorkspaceDir();
-        const repoKey = repoOnly
-            ? `${WORKSPACE_KEY}-repo-${repoId}`
-            : `${WORKSPACE_KEY}-${productId}`;
-        ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, githubConfig.owner, githubConfig.repo, githubConfig.token));
-        const [basics, scanMeta, teamRecipes, existingLinks] = await Promise.all([
-            repoOnly
-                ? Promise.resolve({
-                    name: repoBasics.fullName ?? `${githubConfig.owner}/${githubConfig.repo}`,
-                    description: repoBasics.description ?? undefined,
-                })
-                : fetchProductBasics(productId),
-            getScanCreator(supabase, scanId),
-            listTeamRecipes(supabase, teamId),
-            repoOnly
-                ? listRepositoryRecipeLinks(supabase, repoId)
-                : listProductRecipeLinks(supabase, productId),
-        ]);
-        if (!scanMeta) {
-            const msg = 'recipe_scans row vanished mid-run; aborting';
-            await markFailed(supabase, scanId, msg);
-            return { status: 'error', message: msg };
-        }
-        const systemPrompt = createRecipesSystemPrompt();
-        const userPrompt = createRecipesUserPrompt({
-            productName: basics.name,
-            productDescription: basics.description,
-            guidance,
-            teamRecipes,
-            existingLinks: existingLinks.map((l) => ({
-                recipeId: l.recipe_id,
-                name: l.name,
-            })),
-        });
-        const counts = createRecipesMutationCounts();
-        const existingLinkIds = new Set(existingLinks.map((l) => l.recipe_id));
-        const mcpServer = createRecipesMcpServer({
-            supabase,
-            teamId,
-            productId: repoOnly ? undefined : productId,
-            repositoryId: repoOnly ? repoId : undefined,
-            createdBy: scanMeta.created_by,
-        }, counts, teamRecipes, existingLinkIds);
-        logInfo('Running Claude agent to identify recipes...');
-        let lastHeartbeatAt = 0;
-        for await (const message of query({
-            prompt: createPromptGenerator(userPrompt),
-            options: {
-                systemPrompt: {
-                    type: 'preset',
-                    preset: 'claude_code',
-                    append: systemPrompt,
-                },
-                model: DEFAULT_MODEL,
-                maxTurns: MAX_TURNS,
-                permissionMode: 'bypassPermissions',
-                cwd: repoPath,
-                mcpServers: {
-                    recipes: mcpServer,
-                },
-            },
-        })) {
-            if (message.type === 'assistant') {
-                extractTextFromContent(message.message?.content ?? [], verbose);
-                const now = Date.now();
-                if (now - lastHeartbeatAt >= HEARTBEAT_MIN_INTERVAL_MS) {
-                    lastHeartbeatAt = now;
-                    await heartbeat(supabase, scanId);
-                }
-                continue;
-            }
-            if (message.type !== 'result') {
-                continue;
-            }
-            if (message.subtype !== 'success') {
-                const msg = `Recipes scan failed: agent ${message.subtype}`;
-                const written = await markFailed(supabase, scanId, msg);
-                return {
-                    status: written ? 'error' : 'cancelled',
-                    message: written
-                        ? msg
-                        : 'Scan was cancelled while the agent was running',
-                    counts,
-                };
-            }
-            const written = await markSuccess(supabase, scanId);
-            if (!written) {
-                return {
-                    status: 'cancelled',
-                    message: 'Scan was cancelled before the result could be written',
-                    counts,
-                };
-            }
-            succeeded = true;
-            const summary = `created ${counts.created}, updated ${counts.updated}, linked ${counts.linked}, unlinked ${counts.unlinked}`;
-            logSuccess(`Recipes scan complete — ${summary}`);
-            return {
-                status: 'success',
-                message: `Recipes scan complete (${summary})`,
-                counts,
-            };
-        }
-        const msg = 'Recipes scan ended without a result message';
-        await markFailed(supabase, scanId, msg);
-        return { status: 'error', message: msg, counts };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Recipes scan failed: ${errorMessage}`);
-        await markFailed(supabase, scanId, errorMessage);
-        return { status: 'error', message: errorMessage };
-    }
-    finally {
-        if (succeeded) {
-            cleanupIssueRepo(repoPath);
-        }
-    }
-}
-// ============================================================================
-// DB helpers — exported for unit tests
-// ============================================================================
-export async function getProductTeamId(supabase, productId) {
-    const { data, error } = await supabase
-        .from('products')
-        .select('team_id')
-        .eq('id', productId)
-        .maybeSingle();
-    if (error || !data) {
-        return null;
-    }
-    return data.team_id ?? null;
-}
-export async function getScanCreator(supabase, scanId) {
-    const { data, error } = await supabase
-        .from('recipe_scans')
-        .select('created_by')
-        .eq('id', scanId)
-        .maybeSingle();
-    if (error || !data) {
-        return null;
-    }
-    return data;
-}
-export async function listTeamRecipes(supabase, teamId) {
-    const { data, error } = await supabase
-        .from('recipes')
-        .select('id, name, summary, services')
-        .eq('team_id', teamId)
-        .order('updated_at', { ascending: false });
-    if (error || !data) {
-        return [];
-    }
-    return data.map((r) => ({
-        id: r.id,
-        name: r.name,
-        summary: r.summary,
-        services: Array.isArray(r.services) ? r.services : [],
-    }));
-}
-export async function listProductRecipeLinks(supabase, productId) {
-    const { data, error } = await supabase
-        .from('product_recipes')
-        .select('recipe_id, recipes(name)')
-        .eq('product_id', productId);
-    if (error || !data) {
-        return [];
-    }
-    const rows = data;
-    const out = [];
-    for (const r of rows) {
-        const recipe = Array.isArray(r.recipes) ? r.recipes[0] : r.recipes;
-        if (recipe) {
-            out.push({ recipe_id: r.recipe_id, name: recipe.name });
-        }
-    }
-    return out;
-}
-export async function listRepositoryRecipeLinks(supabase, repositoryId) {
-    const { data, error } = await supabase
-        .from('repository_recipes')
-        .select('recipe_id, recipes(name)')
-        .eq('repository_id', repositoryId);
-    if (error || !data) {
-        return [];
-    }
-    const rows = data;
-    const out = [];
-    for (const r of rows) {
-        const recipe = Array.isArray(r.recipes) ? r.recipes[0] : r.recipes;
-        if (recipe) {
-            out.push({ recipe_id: r.recipe_id, name: recipe.name });
-        }
-    }
-    return out;
-}
-/**
- * Claim the row by flipping `pending` → `running`. Returns true on success
- * (we won the claim) and false when the row has already moved on (e.g. user
- * cancelled before the CLI started). Bounded by the status filter so we
- * can't accidentally resurrect a 'cancelled' row.
- */
-export async function markRunning(supabase, scanId) {
-    const { data, error } = await supabase
-        .from('recipe_scans')
-        .update({
-        status: 'running',
-        error: null,
-        last_heartbeat_at: new Date().toISOString(),
-    })
-        .eq('id', scanId)
-        .in('status', ['pending', 'running'])
-        .select('id')
-        .maybeSingle();
-    if (error) {
-        logWarning(`Could not mark scan as running: ${error.message}`);
-        return false;
-    }
-    return data !== null;
-}
-export async function heartbeat(supabase, scanId) {
-    const { error } = await supabase
-        .from('recipe_scans')
-        .update({ last_heartbeat_at: new Date().toISOString() })
-        .eq('id', scanId)
-        .eq('status', 'running');
-    if (error) {
-        logWarning(`Heartbeat failed: ${error.message}`);
-    }
-}
-export async function markFailed(supabase, scanId, errorMessage) {
-    const { data, error } = await supabase
-        .from('recipe_scans')
-        .update({
-        status: 'failed',
-        error: errorMessage,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', scanId)
-        .in('status', ['pending', 'running'])
-        .select('id')
-        .maybeSingle();
-    if (error) {
-        logWarning(`Could not mark scan as failed: ${error.message}`);
-        return false;
-    }
-    return data !== null;
-}
-export async function markSuccess(supabase, scanId) {
-    const { data, error } = await supabase
-        .from('recipe_scans')
-        .update({
-        status: 'success',
-        error: null,
-        completed_at: new Date().toISOString(),
-    })
-        .eq('id', scanId)
-        .in('status', ['pending', 'running'])
-        .select('id')
-        .maybeSingle();
-    if (error) {
-        logWarning(`Could not mark scan as success: ${error.message}`);
-        return false;
-    }
-    return data !== null;
-}

package/dist/phases/recipes/mcp-server.d.ts

@@ -1,66 +0,0 @@
-/**
- * In-process MCP server exposing the recipes toolkit. Five tools:
- *
- *   - get_recipe_detail  read-only: fetch full content of a team recipe
- *   - create_recipe      INSERT recipe + INSERT product_recipe link
- *   - update_recipe      UPDATE recipe (latest-wins overwrite) + UPSERT link
- *   - link_recipe        UPSERT product_recipe link only (no content change)
- *   - unlink_recipe      DELETE product_recipe link for a previously-linked
- *                        recipe the agent confirmed is no longer present
- *
- * All writes are scoped to:
- *   - the active recipe_scan's product_id (the link target)
- *   - the team that owns that product (recipes are team-scoped)
- *
- * The handlers persist directly via the Supabase client passed in by the
- * orchestrator — there is no captured-extraction buffer to flush at the
- * end. Each tool call is its own committed effect.
- */
-import type { SupabaseClient } from '@supabase/supabase-js';
-import { z } from 'zod';
-import { type RecipeSummary } from './types.js';
-export interface RecipesToolContext {
-    supabase: SupabaseClient;
-    teamId: string;
-    /** Set in product-scoped scans; links go to `product_recipes`. */
-    productId?: string;
-    /** Set in repo-only scans; links go to `repository_recipes`. */
-    repositoryId?: string;
-    createdBy: string;
-}
-/**
- * Records how many of each kind of mutation the agent made — exported so the
- * orchestrator can print a summary line at the end of the scan.
- */
-export interface RecipesMutationCounts {
-    created: number;
-    updated: number;
-    linked: number;
-    unlinked: number;
-}
-export declare function createRecipesMutationCounts(): RecipesMutationCounts;
-export declare function createGetRecipeDetailTool(ctx: RecipesToolContext, teamRecipeIds: Set<string>): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    recipe_id: z.ZodString;
-}>;
-export declare function createCreateRecipeTool(ctx: RecipesToolContext, counts: RecipesMutationCounts, teamRecipeIds: Set<string>): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    name: z.ZodString;
-    summary: z.ZodString;
-    content: z.ZodString;
-    services: z.ZodArray<z.ZodString>;
-    evidence: z.ZodString;
-}>;
-export declare function createUpdateRecipeTool(ctx: RecipesToolContext, counts: RecipesMutationCounts, teamRecipeIds: Set<string>): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    recipe_id: z.ZodString;
-    summary: z.ZodOptional<z.ZodString>;
-    content: z.ZodOptional<z.ZodString>;
-    services: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    evidence: z.ZodString;
-}>;
-export declare function createLinkRecipeTool(ctx: RecipesToolContext, counts: RecipesMutationCounts, teamRecipeIds: Set<string>): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    recipe_id: z.ZodString;
-    evidence: z.ZodString;
-}>;
-export declare function createUnlinkRecipeTool(ctx: RecipesToolContext, counts: RecipesMutationCounts, existingLinkIds: Set<string>): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
-    recipe_id: z.ZodString;
-}>;
-export declare function createRecipesMcpServer(ctx: RecipesToolContext, counts: RecipesMutationCounts, teamRecipes: RecipeSummary[], existingLinkIds: Set<string>): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;

package/dist/phases/recipes/mcp-server.js

@@ -1,229 +0,0 @@
-/**
- * In-process MCP server exposing the recipes toolkit. Five tools:
- *
- *   - get_recipe_detail  read-only: fetch full content of a team recipe
- *   - create_recipe      INSERT recipe + INSERT product_recipe link
- *   - update_recipe      UPDATE recipe (latest-wins overwrite) + UPSERT link
- *   - link_recipe        UPSERT product_recipe link only (no content change)
- *   - unlink_recipe      DELETE product_recipe link for a previously-linked
- *                        recipe the agent confirmed is no longer present
- *
- * All writes are scoped to:
- *   - the active recipe_scan's product_id (the link target)
- *   - the team that owns that product (recipes are team-scoped)
- *
- * The handlers persist directly via the Supabase client passed in by the
- * orchestrator — there is no captured-extraction buffer to flush at the
- * end. Each tool call is its own committed effect.
- */
-import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import { RECIPE_CONTENT_MAX, RECIPE_EVIDENCE_MAX, RECIPE_NAME_MAX, RECIPE_SERVICE_NAME_MAX, RECIPE_SERVICES_MAX, RECIPE_SUMMARY_MAX, } from './types.js';
-function resolveLinkScope(ctx) {
-    if (ctx.repositoryId) {
-        return {
-            table: 'repository_recipes',
-            column: 'repository_id',
-            id: ctx.repositoryId,
-            onConflict: 'repository_id,recipe_id',
-            label: 'this repository',
-        };
-    }
-    if (ctx.productId) {
-        return {
-            table: 'product_recipes',
-            column: 'product_id',
-            id: ctx.productId,
-            onConflict: 'product_id,recipe_id',
-            label: 'this product',
-        };
-    }
-    throw new Error('RecipesToolContext requires either productId or repositoryId to scope links');
-}
-export function createRecipesMutationCounts() {
-    return { created: 0, updated: 0, linked: 0, unlinked: 0 };
-}
-const servicesSchema = z
-    .array(z.string().min(1).max(RECIPE_SERVICE_NAME_MAX))
-    .max(RECIPE_SERVICES_MAX)
-    .describe('Sorted list of canonical service/tool/library names this recipe chains together (e.g. ["ElevenLabs","ffmpeg","Whisper"]). Sort alphabetically.');
-function normalizeServices(services) {
-    const cleaned = services.map((s) => s.trim()).filter((s) => s.length > 0);
-    return Array.from(new Set(cleaned)).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
-}
-function textError(message) {
-    return {
-        content: [{ type: 'text', text: message }],
-        isError: true,
-    };
-}
-function textOk(message) {
-    return {
-        content: [{ type: 'text', text: message }],
-    };
-}
-export function createGetRecipeDetailTool(ctx, teamRecipeIds) {
-    return tool('get_recipe_detail', 'Fetch the full markdown content of an existing team recipe by id. Call this when the prompt summary is not enough to decide between link / update / create.', {
-        recipe_id: z.string().uuid().describe('id from the team recipe list'),
-    }, async (args) => {
-        if (!teamRecipeIds.has(args.recipe_id)) {
-            return textError(`recipe_id ${args.recipe_id} is not in this team's recipe list.`);
-        }
-        const { data, error } = await ctx.supabase
-            .from('recipes')
-            .select('id, name, summary, content, services')
-            .eq('id', args.recipe_id)
-            .eq('team_id', ctx.teamId)
-            .maybeSingle();
-        if (error) {
-            return textError(`Failed to read recipe: ${error.message}`);
-        }
-        if (!data) {
-            return textError(`Recipe ${args.recipe_id} not found.`);
-        }
-        return textOk(JSON.stringify(data));
-    });
-}
-export function createCreateRecipeTool(ctx, counts, teamRecipeIds) {
-    return tool('create_recipe', 'Register a brand-new recipe in the team library AND link it to this product. Use only when no existing recipe matches the capability. Pass a fully-formed recipe — name, one-paragraph summary, markdown content, sorted services list, and product-specific evidence.', {
-        name: z.string().min(1).max(RECIPE_NAME_MAX),
-        summary: z.string().min(1).max(RECIPE_SUMMARY_MAX),
-        content: z.string().min(1).max(RECIPE_CONTENT_MAX),
-        services: servicesSchema,
-        evidence: z
-            .string()
-            .min(1)
-            .max(RECIPE_EVIDENCE_MAX)
-            .describe('Plain-text paragraph saying where in THIS product the recipe shows up (file paths, entry points).'),
-    }, async (args) => {
-        const services = normalizeServices(args.services);
-        const insertRecipe = await ctx.supabase
-            .from('recipes')
-            .insert({
-            team_id: ctx.teamId,
-            name: args.name.trim(),
-            summary: args.summary.trim(),
-            content: args.content,
-            services,
-            created_by: ctx.createdBy,
-        })
-            .select('id')
-            .single();
-        if (insertRecipe.error || !insertRecipe.data) {
-            return textError(`Failed to create recipe: ${insertRecipe.error?.message ?? 'unknown error'}`);
-        }
-        const recipeId = insertRecipe.data.id;
-        const scope = resolveLinkScope(ctx);
-        const linkErr = await ctx.supabase.from(scope.table).insert({
-            [scope.column]: scope.id,
-            recipe_id: recipeId,
-            evidence: args.evidence.trim(),
-        });
-        if (linkErr.error) {
-            return textError(`Recipe created (${recipeId}) but linking to ${scope.label} failed: ${linkErr.error.message}`);
-        }
-        teamRecipeIds.add(recipeId);
-        counts.created += 1;
-        return textOk(`Created recipe ${recipeId} and linked to ${scope.label}.`);
-    });
-}
-export function createUpdateRecipeTool(ctx, counts, teamRecipeIds) {
-    return tool('update_recipe', 'Overwrite an existing recipe (latest-wins) with better information you discovered in this repo AND link this product to it. Use when the existing entry is broadly correct but lacks detail / has outdated services / has a vague summary. Omit fields you do not want to change.', {
-        recipe_id: z.string().uuid(),
-        summary: z.string().min(1).max(RECIPE_SUMMARY_MAX).optional(),
-        content: z.string().min(1).max(RECIPE_CONTENT_MAX).optional(),
-        services: servicesSchema.optional(),
-        evidence: z.string().min(1).max(RECIPE_EVIDENCE_MAX),
-    }, async (args) => {
-        if (!teamRecipeIds.has(args.recipe_id)) {
-            return textError(`recipe_id ${args.recipe_id} is not in this team's recipe list. Use create_recipe for new entries.`);
-        }
-        const patch = {};
-        if (args.summary !== undefined) {
-            patch.summary = args.summary.trim();
-        }
-        if (args.content !== undefined) {
-            patch.content = args.content;
-        }
-        if (args.services !== undefined) {
-            patch.services = normalizeServices(args.services);
-        }
-        if (Object.keys(patch).length > 0) {
-            const updateErr = await ctx.supabase
-                .from('recipes')
-                .update(patch)
-                .eq('id', args.recipe_id)
-                .eq('team_id', ctx.teamId);
-            if (updateErr.error) {
-                return textError(`Failed to update recipe: ${updateErr.error.message}`);
-            }
-        }
-        const scope = resolveLinkScope(ctx);
-        const linkErr = await ctx.supabase.from(scope.table).upsert({
-            [scope.column]: scope.id,
-            recipe_id: args.recipe_id,
-            evidence: args.evidence.trim(),
-        }, { onConflict: scope.onConflict });
-        if (linkErr.error) {
-            return textError(`Recipe updated but linking to ${scope.label} failed: ${linkErr.error.message}`);
-        }
-        counts.updated += 1;
-        return textOk(`Updated recipe ${args.recipe_id} and linked to ${scope.label}.`);
-    });
-}
-export function createLinkRecipeTool(ctx, counts, teamRecipeIds) {
-    return tool('link_recipe', 'Link this product to an existing recipe that already describes the capability accurately. Does NOT modify the recipe content. Use this whenever possible — the whole point of the team library is cross-product reuse.', {
-        recipe_id: z.string().uuid(),
-        evidence: z.string().min(1).max(RECIPE_EVIDENCE_MAX),
-    }, async (args) => {
-        if (!teamRecipeIds.has(args.recipe_id)) {
-            return textError(`recipe_id ${args.recipe_id} is not in this team's recipe list. Use create_recipe for new entries.`);
-        }
-        const scope = resolveLinkScope(ctx);
-        const linkErr = await ctx.supabase.from(scope.table).upsert({
-            [scope.column]: scope.id,
-            recipe_id: args.recipe_id,
-            evidence: args.evidence.trim(),
-        }, { onConflict: scope.onConflict });
-        if (linkErr.error) {
-            return textError(`Failed to link recipe: ${linkErr.error.message}`);
-        }
-        counts.linked += 1;
-        return textOk(`Linked recipe ${args.recipe_id} to ${scope.label}.`);
-    });
-}
-export function createUnlinkRecipeTool(ctx, counts, existingLinkIds) {
-    return tool('unlink_recipe', 'Drop a previously-linked recipe that you have confirmed is NO LONGER present in this repo. Only call this for ids in the "Currently linked" list. Does not delete the recipe itself.', {
-        recipe_id: z.string().uuid(),
-    }, async (args) => {
-        if (!existingLinkIds.has(args.recipe_id)) {
-            return textError(`recipe_id ${args.recipe_id} is not in the "Currently linked" list — nothing to unlink.`);
-        }
-        const scope = resolveLinkScope(ctx);
-        const { error } = await ctx.supabase
-            .from(scope.table)
-            .delete()
-            .eq(scope.column, scope.id)
-            .eq('recipe_id', args.recipe_id);
-        if (error) {
-            return textError(`Failed to unlink recipe: ${error.message}`);
-        }
-        existingLinkIds.delete(args.recipe_id);
-        counts.unlinked += 1;
-        return textOk(`Unlinked recipe ${args.recipe_id} from ${scope.label}.`);
-    });
-}
-export function createRecipesMcpServer(ctx, counts, teamRecipes, existingLinkIds) {
-    const teamRecipeIds = new Set(teamRecipes.map((r) => r.id));
-    return createSdkMcpServer({
-        name: 'recipes',
-        version: '1.0.0',
-        tools: [
-            createGetRecipeDetailTool(ctx, teamRecipeIds),
-            createCreateRecipeTool(ctx, counts, teamRecipeIds),
-            createUpdateRecipeTool(ctx, counts, teamRecipeIds),
-            createLinkRecipeTool(ctx, counts, teamRecipeIds),
-            createUnlinkRecipeTool(ctx, counts, existingLinkIds),
-        ],
-    });
-}

package/dist/phases/recipes/prompts.d.ts

@@ -1,35 +0,0 @@
-/**
- * Prompts for the recipes phase.
- *
- * Agent's job: explore the cloned product repo and identify each non-trivial
- * CAPABILITY the product implements ("AI video generation", "PDF export",
- * "real-time presence", "Stripe subscription billing", etc.) and document
- * HOW the capability is built — which services / tools / libraries are
- * chained together. NOT a tech-stack inventory.
- *
- * The agent is fed the team's existing recipes (compact form: id + name +
- * summary + services) and must, for each capability it identifies, pick one
- * of:
- *   - link_recipe   — existing recipe describes this capability correctly,
- *                     just record this product uses it
- *   - update_recipe — existing recipe is close but the agent has better /
- *                     more accurate info from this repo; overwrite
- *   - create_recipe — no existing recipe matches; new entry
- *   - unlink_recipe — this product was previously linked to a recipe that
- *                     is no longer present in the repo
- *
- * Submission is via MCP tool calls only — no fenced JSON.
- */
-import type { RecipeSummary } from './types.js';
-export interface RecipesPromptContext {
-    productName: string;
-    productDescription?: string;
-    guidance?: string;
-    teamRecipes: RecipeSummary[];
-    existingLinks: {
-        recipeId: string;
-        name: string;
-    }[];
-}
-export declare function createRecipesSystemPrompt(): string;
-export declare function createRecipesUserPrompt(ctx: RecipesPromptContext): string;