edsger 0.68.0 → 0.70.0

package/dist/phases/er-diagram/types.js

@@ -0,0 +1,84 @@
+/**
+ * ER Diagram domain types.
+ *
+ * An ErEntity is a structured description of one persistence entity in a
+ * product — a table, a view, or an enum. The CLI extracts these from schema
+ * files (migrations, ORM models, type definitions) and the desktop renders
+ * them as an entity-relationship diagram.
+ *
+ * Companion to DataNodeSchema / ScreenSchema: same flow-graph shape (nodes +
+ * edges sharing the `diagrams` table storing the JSONB schema), different domain.
+ * ER edges describe foreign-key / inheritance relationships between entities,
+ * with a cardinality, not data movement or user navigation.
+ */
+// ============================================================================
+// Runtime validation for AI-produced extraction
+// ============================================================================
+const ENTITY_KINDS = new Set([
+    'entity',
+    'view',
+    'enum',
+    'junction',
+]);
+const RELATION_KINDS = new Set([
+    'one-to-one',
+    'one-to-many',
+    'many-to-many',
+    'inherits',
+]);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+function isErEntity(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (typeof value.slug !== 'string' || value.slug.length === 0) {
+        return false;
+    }
+    if (typeof value.name !== 'string' || value.name.length === 0) {
+        return false;
+    }
+    if (typeof value.kind !== 'string' ||
+        !ENTITY_KINDS.has(value.kind)) {
+        return false;
+    }
+    return true;
+}
+function isErRelation(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (typeof value.fromSlug !== 'string') {
+        return false;
+    }
+    if (typeof value.toSlug !== 'string') {
+        return false;
+    }
+    if (typeof value.kind !== 'string' ||
+        !RELATION_KINDS.has(value.kind)) {
+        return false;
+    }
+    return true;
+}
+export function isErDiagramExtraction(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    if (typeof value.summary !== 'string') {
+        return false;
+    }
+    if (!Array.isArray(value.entities)) {
+        return false;
+    }
+    if (!Array.isArray(value.relations)) {
+        return false;
+    }
+    if (!value.entities.every(isErEntity)) {
+        return false;
+    }
+    if (!value.relations.every(isErRelation)) {
+        return false;
+    }
+    return true;
+}

package/dist/phases/flow-shared/clone-repos.d.ts

@@ -35,8 +35,11 @@ export declare function safeDirName(fullName: string): string;
 /**
  * Resolve the repositories a flow targets (by id, preserving the stored
  * order), falling back to the product's primary repo.
+ *
+ * In repo-only mode there is no product, so no `fallback` is provided: the
+ * set is resolved purely from `repositoryIds`.
  */
-export declare function resolveTargetRepos(productId: string, repositoryIds: string[], fallback: {
+export declare function resolveTargetRepos(productId: string | undefined, repositoryIds: string[], fallback?: {
     owner: string;
     repo: string;
 }): Promise<{
@@ -45,7 +48,10 @@ export declare function resolveTargetRepos(productId: string, repositoryIds: str
     repo: string;
 }[]>;
 export declare function cloneFlowRepos(opts: {
-    productId: string;
+    /** Product-scoped flow. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only flow: a single repositories row, no product context. */
+    repoId?: string;
     repositoryIds: string[];
     workspaceKey: string;
     verbose?: boolean;

package/dist/phases/flow-shared/clone-repos.js

@@ -13,7 +13,7 @@
  * Falls back to the product's primary repo when `repository_ids` is empty
  * (older flows, or single-repo products).
  */
-import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, } from '../../api/github.js';
 import { getSupabase } from '../../supabase/client.js';
 import { logInfo, logWarning } from '../../utils/logger.js';
 import { cloneIssueRepo, ensureWorkspaceDir, getIssueRepoPath, } from '../../workspace/workspace-manager.js';
@@ -23,16 +23,22 @@ export function safeDirName(fullName) {
 /**
  * Resolve the repositories a flow targets (by id, preserving the stored
  * order), falling back to the product's primary repo.
+ *
+ * In repo-only mode there is no product, so no `fallback` is provided: the
+ * set is resolved purely from `repositoryIds`.
  */
 export async function resolveTargetRepos(productId, repositoryIds, fallback) {
     if (repositoryIds.length === 0) {
-        return [
-            {
-                fullName: `${fallback.owner}/${fallback.repo}`,
-                owner: fallback.owner,
-                repo: fallback.repo,
-            },
-        ];
+        if (fallback) {
+            return [
+                {
+                    fullName: `${fallback.owner}/${fallback.repo}`,
+                    owner: fallback.owner,
+                    repo: fallback.repo,
+                },
+            ];
+        }
+        return [];
     }
     const supabase = getSupabase();
     const { data } = await supabase
@@ -54,8 +60,8 @@ export async function resolveTargetRepos(productId, repositoryIds, fallback) {
         resolved.push({ fullName, owner, repo });
     }
     // If none resolved (deleted repos / RLS), fall back to the primary repo so
-    // generation still produces something useful.
-    if (resolved.length === 0) {
+    // generation still produces something useful (product mode only).
+    if (resolved.length === 0 && fallback) {
         return [
             {
                 fullName: `${fallback.owner}/${fallback.repo}`,
@@ -67,21 +73,33 @@ export async function resolveTargetRepos(productId, repositoryIds, fallback) {
     return resolved;
 }
 export async function cloneFlowRepos(opts) {
-    const { productId, repositoryIds, workspaceKey, verbose } = opts;
-    const gh = await getGitHubConfigByProduct(productId, verbose);
+    const { productId, repoId, repositoryIds, workspaceKey, verbose } = opts;
+    const repoOnly = !productId && Boolean(repoId);
+    // Resolve the auth token. Product mode reuses the product's installation /
+    // PAT for every repo; repo-only mode resolves it from the first (only) repo.
+    const gh = repoOnly
+        ? await getGitHubConfigByRepository(repositoryIds[0] ?? repoId, verbose)
+        : await getGitHubConfigByProduct(productId, verbose);
     if (!gh.configured || !gh.token || !gh.owner || !gh.repo) {
         return {
             ok: false,
             message: gh.message ||
-                'GitHub repository not configured for this product. Connect a repo first.',
+                (repoOnly
+                    ? 'GitHub repository not configured. Connect the repo first.'
+                    : 'GitHub repository not configured for this product. Connect a repo first.'),
+        };
+    }
+    // In repo-only mode there is no product primary-repo fallback; targets come
+    // purely from repositoryIds.
+    const targets = await resolveTargetRepos(productId, repositoryIds, repoOnly ? undefined : { owner: gh.owner, repo: gh.repo });
+    if (targets.length === 0) {
+        return {
+            ok: false,
+            message: 'No repositories resolved for this flow.',
         };
     }
-    const targets = await resolveTargetRepos(productId, repositoryIds, {
-        owner: gh.owner,
-        repo: gh.repo,
-    });
     const workspaceRoot = ensureWorkspaceDir();
-    const parentDir = getIssueRepoPath(workspaceRoot, `${workspaceKey}-${productId}`);
+    const parentDir = getIssueRepoPath(workspaceRoot, `${workspaceKey}-${repoOnly ? `repo-${repoId}` : productId}`);
     const repos = [];
     for (const target of targets) {
         try {

package/dist/phases/flowchart/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * flowchart phase: map the control flow of one process / function / algorithm
+ * as a flowchart — start/end, process steps, decisions (with branch labels),
+ * I/O, and subroutine calls. Persisted to the diagrams tables with
+ * `type = 'flowchart'`.
+ */
+import { type DiagramPhaseResult } from '../diagram-shared/generate.js';
+export interface FlowchartPhaseOptions {
+    productId?: string;
+    repoId?: string;
+    diagramId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runFlowchartPhase(options: FlowchartPhaseOptions): Promise<DiagramPhaseResult>;

package/dist/phases/flowchart/index.js

@@ -0,0 +1,50 @@
+/**
+ * flowchart phase: map the control flow of one process / function / algorithm
+ * as a flowchart — start/end, process steps, decisions (with branch labels),
+ * I/O, and subroutine calls. Persisted to the diagrams tables with
+ * `type = 'flowchart'`.
+ */
+import { z } from 'zod';
+import { generateDiagram, } from '../diagram-shared/generate.js';
+import { buildDiagramSystemPrompt, buildDiagramUserPrompt, } from '../diagram-shared/prompts.js';
+const flowchartNode = z.object({
+    slug: z.string().min(1),
+    name: z.string().min(1),
+    kind: z.enum(['start', 'end', 'process', 'decision', 'io', 'subroutine']),
+    file: z.string().optional(),
+    description: z.string().optional(),
+});
+const flowchartEdge = z.object({
+    fromSlug: z.string().min(1),
+    toSlug: z.string().min(1),
+    kind: z.enum(['flow', 'branch']),
+    /** Branch label for edges out of a decision, e.g. "yes" / "no" / "error". */
+    label: z.string().optional(),
+    sourceFile: z.string().optional(),
+});
+export function runFlowchartPhase(options) {
+    return generateDiagram({
+        ...options,
+        workspaceKey: 'flowchart',
+        fenceName: 'flowchart',
+        nounPlural: 'steps',
+        edgeNounPlural: 'arrows',
+        mcpConfig: {
+            name: 'flowchart',
+            toolName: 'flowchart',
+            summaryDescribe: '1-3 sentence narrative of the process this flowchart captures.',
+            nodesSchema: z.array(flowchartNode),
+            nodesDescribe: 'Every step: start / end / process / decision / io / subroutine. slug MUST be unique. Use exactly one `start`.',
+            edgesSchema: z.array(flowchartEdge),
+            edgesDescribe: 'Arrows. kind = flow (plain) or branch (out of a decision; set label to the branch condition like "yes"/"no"). Endpoints MUST reference emitted steps.',
+        },
+        buildSystemPrompt: (a) => buildDiagramSystemPrompt('phase/flowchart', 'flowchart', a),
+        buildUserPrompt: (a) => buildDiagramUserPrompt({
+            ...a,
+            task: 'Map a flowchart for',
+            mcpName: 'flowchart',
+            toolName: 'flowchart',
+            process: 'Pick ONE important process / function / algorithm (guidance may name it; otherwise choose a central one — a request handler, a core algorithm, a job). Read it top to bottom and translate its control flow into steps: a single `start`, `process` steps for actions, `decision` diamonds for branches (each outgoing edge a `branch` with a "yes"/"no"/condition label), `io` for reads/writes, `subroutine` for significant calls, and `end` node(s) for returns/exits. Follow the happy path plus the important branches.',
+        }),
+    });
+}

package/dist/phases/output-contracts.js

@@ -917,7 +917,7 @@ to keep the user informed during long runs. This is observability only — it
 does not affect the extraction.
 
 ScreenSchema fields:
-- \`slug\` (unique within the flow), \`name\`, \`route?\`, \`file?\`
+- \`slug\` (unique within the diagram), \`name\`, \`route?\`, \`file?\`
 - \`kind\`: one of \`page\`, \`modal\`, \`drawer\`, \`tab\`, \`state\`
 - \`layout\`: one of \`centered\`, \`sidebar\`, \`split\`, \`list-detail\`, \`tabs\`, \`stacked\`
 - \`header?\`: \`{ title, subtitle?, back?, actions?: [{ label, variant?, icon? }] }\`
@@ -971,7 +971,7 @@ to keep the user informed during long runs. This is observability only — it
 does not affect the extraction.
 
 DataNodeSchema fields:
-- \`slug\` (unique within the flow), \`name\`, \`kind\`, \`file?\`
+- \`slug\` (unique within the diagram), \`name\`, \`kind\`, \`file?\`
 - \`kind\`: one of \`source\`, \`dataset\`, \`transform\`, \`sink\`, \`queue\`, \`model\`
 - \`description?\`: one-sentence summary
 - \`tech?\`: technology / format hint (e.g. \`postgres\`, \`parquet\`, \`kafka\`, \`openai-api\`)
@@ -1021,5 +1021,181 @@ submit_data_flow({
   ]
 })
 \`\`\`
+`,
+    'er-diagram': `
+**CRITICAL — How to return the result**:
+
+Return the extraction by calling the MCP tool
+\`mcp__er-diagram__submit_er_diagram\` **exactly once** with three arguments:
+
+- \`summary\` — 1-3 sentence narrative of the data model (core entities + relationships)
+- \`entities\` — array of ErEntity objects (every table / view / enum / junction)
+- \`relations\` — array of ErRelation objects (foreign-key / inheritance edges)
+
+The tool validates the arguments against the schema. If it returns an error,
+fix the issue it describes and call the tool again. After a successful call,
+end your turn — do not also paste the same data as a fenced text block.
+
+You can also call \`mcp__er-diagram__record_progress({ phase, message })\` at
+each phase boundary (detection / enumeration / entities / relations / submission)
+to keep the user informed during long runs. This is observability only — it
+does not affect the extraction.
+
+ErEntity fields:
+- \`slug\` (unique within the diagram), \`name\`, \`kind\`, \`file?\`
+- \`kind\`: one of \`entity\`, \`view\`, \`enum\`, \`junction\`
+- \`description?\`: one-sentence summary
+- \`columns?\`: array of \`{ name, type?, isPrimaryKey?, isForeignKey?, isNullable?, isUnique?, description?, references? }\`
+  - \`references\`: for FKs, \`target-entity-slug.column\` (e.g. \`users.id\`)
+- \`stats?\`: array of \`{ label, value }\` (row counts, cardinality hints)
+
+ErRelation fields:
+- \`fromSlug\` (child / FK holder), \`toSlug\` (parent / referenced) — both MUST appear in entities
+- \`kind\`: one of \`one-to-one\`, \`one-to-many\`, \`many-to-many\`, \`inherits\`
+- \`label?\`: free-form descriptor (e.g. \`placed by\`, \`belongs to\`)
+- \`sourceColumn?\` / \`targetColumn?\`: the FK column and the referenced column
+- \`sourceFile?\`: file containing the FK constraint / association
+
+Direction convention: fromSlug holds the foreign key (child / "many" side),
+toSlug is the referenced entity (parent / "one" side). \`orders.user_id → users.id\`
+becomes \`{ fromSlug: "orders", toSlug: "users", kind: "one-to-many" }\`.
+
+Schematic example of the tool call:
+
+\`\`\`
+submit_er_diagram({
+  summary: "Storefront schema: users place orders made of order-items that reference products; roles are linked to users through a junction table.",
+  entities: [
+    { slug: "users", name: "users", kind: "entity",
+      file: "db/migrations/0001_users.sql",
+      columns: [
+        { name: "id", type: "uuid", isPrimaryKey: true },
+        { name: "email", type: "varchar(255)", isUnique: true },
+        { name: "created_at", type: "timestamptz" }
+      ] },
+    { slug: "orders", name: "orders", kind: "entity",
+      file: "db/migrations/0002_orders.sql",
+      columns: [
+        { name: "id", type: "uuid", isPrimaryKey: true },
+        { name: "user_id", type: "uuid", isForeignKey: true, references: "users.id" },
+        { name: "status", type: "order_status" }
+      ] },
+    { slug: "order-status", name: "order_status", kind: "enum",
+      file: "db/migrations/0002_orders.sql" }
+  ],
+  relations: [
+    { fromSlug: "orders", toSlug: "users", kind: "one-to-many",
+      label: "placed by", sourceColumn: "user_id", targetColumn: "id",
+      sourceFile: "db/migrations/0002_orders.sql" }
+  ]
+})
+\`\`\`
+`,
+    'sequence-diagram': `
+**CRITICAL — How to return the result**:
+
+Return the extraction by calling the MCP tool
+\`mcp__sequence-diagram__submit_sequence_diagram\` **exactly once** with three arguments:
+
+- \`summary\` — 1-3 sentence narrative naming the scenario, the participants, and the outcome
+- \`participants\` — array of SequenceParticipant objects (every lifeline)
+- \`messages\` — array of SequenceMessage objects, each with an explicit \`order\`
+
+The tool validates the arguments against the schema. If it returns an error,
+fix the issue it describes and call the tool again. After a successful call,
+end your turn — do not also paste the same data as a fenced text block.
+
+You can also call \`mcp__sequence-diagram__record_progress({ phase, message })\`
+at each phase boundary (detection / enumeration / participants / messages /
+submission) to keep the user informed during long runs. This is observability
+only — it does not affect the extraction.
+
+A sequence diagram captures ONE scenario. Map a single end-to-end flow of control.
+
+SequenceParticipant fields:
+- \`slug\` (unique within the diagram), \`name\`, \`kind\`, \`file?\`
+- \`kind\`: one of \`actor\`, \`service\`, \`component\`, \`database\`, \`queue\`, \`external\`
+- \`description?\`: one-sentence role summary
+
+SequenceMessage fields:
+- \`fromSlug\` (sender), \`toSlug\` (receiver) — both MUST appear in participants
+- \`kind\`: one of \`sync\`, \`async\`, \`return\`, \`self\`
+- \`order\`: **1-based integer** position in the execution timeline (do not skip or reuse numbers)
+- \`label?\`: the call / message text (\`POST /login\`, \`validateToken(jwt)\`, \`rows\`)
+- \`sourceFile?\`: file (+ line) where the call happens
+
+Order convention: number messages in real execution order; a \`return\` comes
+after the \`sync\` call it answers. A \`self\` message has \`fromSlug === toSlug\`.
+
+Schematic example of the tool call:
+
+\`\`\`
+submit_sequence_diagram({
+  summary: "Email/password login: the browser posts credentials to AuthService, which verifies them against the users table and issues a JWT.",
+  participants: [
+    { slug: "user", name: "User", kind: "actor" },
+    { slug: "auth-service", name: "AuthService", kind: "service",
+      file: "src/routes/auth.ts" },
+    { slug: "users", name: "users", kind: "database",
+      file: "db/migrations/0001_users.sql" }
+  ],
+  messages: [
+    { fromSlug: "user", toSlug: "auth-service", kind: "sync", order: 1,
+      label: "POST /login {email, password}", sourceFile: "src/routes/auth.ts" },
+    { fromSlug: "auth-service", toSlug: "users", kind: "sync", order: 2,
+      label: "SELECT … WHERE email = ?", sourceFile: "src/routes/auth.ts" },
+    { fromSlug: "users", toSlug: "auth-service", kind: "return", order: 3,
+      label: "user row" },
+    { fromSlug: "auth-service", toSlug: "auth-service", kind: "self", order: 4,
+      label: "verifyPassword()" },
+    { fromSlug: "auth-service", toSlug: "user", kind: "return", order: 5,
+      label: "200 {token}" }
+  ]
+})
+\`\`\`
+`,
+    'state-diagram': `
+**CRITICAL — How to return the result**:
+
+Call \`mcp__state-diagram__submit_state_diagram\` **exactly once** with:
+- \`summary\` — what this state machine models
+- \`nodes\` — states: \`{ slug, name, kind, file?, description?, onEntry?, onExit?, activity? }\`; \`kind\` ∈ \`initial\` | \`state\` | \`final\` | \`choice\` | \`composite\` (exactly one \`initial\`)
+- \`edges\` — transitions: \`{ fromSlug, toSlug, kind: "transition", label?, sourceFile? }\`; put \`trigger [guard] / action\` in \`label\`
+
+Every fromSlug / toSlug MUST reference a node slug. The tool validates; on error,
+fix and call again. You may call \`mcp__state-diagram__record_progress\` for status.
+`,
+    'class-diagram': `
+**CRITICAL — How to return the result**:
+
+Call \`mcp__class-diagram__submit_class_diagram\` **exactly once** with:
+- \`summary\` — the core types and how they relate
+- \`nodes\` — \`{ slug, name, kind, file?, description?, stereotype?, attributes?: [{ name, type?, visibility?, isStatic? }], methods?: [{ name, params?, returnType?, visibility?, isStatic?, isAbstract? }] }\`; \`kind\` ∈ \`class\` | \`interface\` | \`abstract\` | \`enum\`
+- \`edges\` — \`{ fromSlug, toSlug, kind, label?, sourceFile? }\`; \`kind\` ∈ \`inheritance\` | \`implementation\` | \`composition\` | \`aggregation\` | \`association\` | \`dependency\` (fromSlug = child/owner/dependent)
+
+Every fromSlug / toSlug MUST reference a node slug. The tool validates; on error,
+fix and call again. You may call \`mcp__class-diagram__record_progress\` for status.
+`,
+    'architecture-diagram': `
+**CRITICAL — How to return the result**:
+
+Call \`mcp__architecture-diagram__submit_architecture_diagram\` **exactly once** with:
+- \`summary\` — the architecture and its main building blocks
+- \`nodes\` — components: \`{ slug, name, kind, file?, description?, tech?, responsibilities?: [string] }\`; \`kind\` ∈ \`module\` | \`service\` | \`package\` | \`ui\` | \`datastore\` | \`external\`
+- \`edges\` — dependencies: \`{ fromSlug, toSlug, kind, label?, sourceFile? }\`; \`kind\` ∈ \`depends-on\` | \`calls\` | \`imports\` | \`data\` (fromSlug = depender)
+
+Every fromSlug / toSlug MUST reference a node slug. The tool validates; on error,
+fix and call again. You may call \`mcp__architecture-diagram__record_progress\` for status.
+`,
+    flowchart: `
+**CRITICAL — How to return the result**:
+
+Call \`mcp__flowchart__submit_flowchart\` **exactly once** with:
+- \`summary\` — the process this flowchart captures
+- \`nodes\` — steps: \`{ slug, name, kind, file?, description? }\`; \`kind\` ∈ \`start\` | \`end\` | \`process\` | \`decision\` | \`io\` | \`subroutine\` (exactly one \`start\`)
+- \`edges\` — \`{ fromSlug, toSlug, kind, label?, sourceFile? }\`; \`kind\` ∈ \`flow\` | \`branch\` (branch edges out of a \`decision\` set \`label\` to "yes"/"no"/condition)
+
+Every fromSlug / toSlug MUST reference a node slug. The tool validates; on error,
+fix and call again. You may call \`mcp__flowchart__record_progress\` for status.
 `,
 };

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

@@ -19,7 +19,10 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
 import type { RecipeSummary } from './types.js';
 export interface RecipesPhaseOptions {
-    productId: string;
+    /** Product-scoped scan. Mutually exclusive with `repoId`. */
+    productId?: string;
+    /** Repo-only scan: a single repositories row, no product context. */
+    repoId?: string;
     scanId: string;
     guidance?: string;
     verbose?: boolean;
@@ -44,6 +47,10 @@ export declare function listProductRecipeLinks(supabase: SupabaseClient, product
     recipe_id: string;
     name: string;
 }[]>;
+export declare function listRepositoryRecipeLinks(supabase: SupabaseClient, repositoryId: string): Promise<{
+    recipe_id: string;
+    name: string;
+}[]>;
 /**
  * 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

package/dist/phases/recipes/index.js

@@ -17,7 +17,7 @@
  *     progress survives even if the agent later errors out.
  */
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { getGitHubConfigByProduct } from '../../api/github.js';
+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';
@@ -33,8 +33,14 @@ const MAX_TURNS = 200;
 // 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, scanId, guidance, verbose } = options;
-    logInfo(`Starting recipes scan for product ${productId}`);
+    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) {
@@ -43,19 +49,42 @@ export async function runRecipesPhase(options) {
             message: 'Recipe scan row is no longer in a runnable state (likely cancelled before the CLI started)',
         };
     }
-    const 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 };
+    // 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 };
+        }
     }
-    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    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 ||
-            'GitHub repository not configured for this product. Connect a repo first.';
+            (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 };
     }
@@ -63,13 +92,22 @@ export async function runRecipesPhase(options) {
     let succeeded = false;
     try {
         const workspaceRoot = ensureWorkspaceDir();
-        const repoKey = `${WORKSPACE_KEY}-${productId}`;
+        const repoKey = repoOnly
+            ? `${WORKSPACE_KEY}-repo-${repoId}`
+            : `${WORKSPACE_KEY}-${productId}`;
         ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, githubConfig.owner, githubConfig.repo, githubConfig.token));
-        const [product, scanMeta, teamRecipes, existingLinks] = await Promise.all([
-            fetchProductBasics(productId),
+        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),
-            listProductRecipeLinks(supabase, productId),
+            repoOnly
+                ? listRepositoryRecipeLinks(supabase, repoId)
+                : listProductRecipeLinks(supabase, productId),
         ]);
         if (!scanMeta) {
             const msg = 'recipe_scans row vanished mid-run; aborting';
@@ -78,8 +116,8 @@ export async function runRecipesPhase(options) {
         }
         const systemPrompt = createRecipesSystemPrompt();
         const userPrompt = createRecipesUserPrompt({
-            productName: product.name,
-            productDescription: product.description,
+            productName: basics.name,
+            productDescription: basics.description,
             guidance,
             teamRecipes,
             existingLinks: existingLinks.map((l) => ({
@@ -92,7 +130,8 @@ export async function runRecipesPhase(options) {
         const mcpServer = createRecipesMcpServer({
             supabase,
             teamId,
-            productId,
+            productId: repoOnly ? undefined : productId,
+            repositoryId: repoOnly ? repoId : undefined,
             createdBy: scanMeta.created_by,
         }, counts, teamRecipes, existingLinkIds);
         logInfo('Running Claude agent to identify recipes...');
@@ -229,6 +268,24 @@ export async function listProductRecipeLinks(supabase, productId) {
     }
     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

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

@@ -22,7 +22,10 @@ import { type RecipeSummary } from './types.js';
 export interface RecipesToolContext {
     supabase: SupabaseClient;
     teamId: string;
-    productId: 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;
 }
 /**