edsger 0.58.0 → 0.60.0

package/dist/api/cross-product.js

@@ -56,7 +56,6 @@ export async function listAllReadyIssues(verbose) {
             const allIssues = (data || []).map((row) => {
                 // The `product` join lands as a nested object; lift its name onto
                 // the row to keep the wire shape stable.
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- shape from PostgREST join
                 const r = row;
                 return {
                     ...r,

package/dist/api/issues/issue-utils.js

@@ -41,7 +41,6 @@ export async function claimNextIssue(productId, verbose) {
             }
             // RPC returns rows with `issue_*` prefixed column names — unwrap to
             // the IssueInfo shape callers already consume.
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any -- raw RPC row
             const r = row;
             const issue = {
                 id: r.issue_id,

package/dist/api/issues/update-issue.js

@@ -91,7 +91,7 @@ export async function markWorkflowPhaseCompleted(issueId, phaseName, verbose) {
                 // Fall through to MCP
             }
         }
-        if (issue == null) {
+        if (!issue) {
             const response = (await callMcpEndpoint('issues/get', {
                 issue_id: issueId,
             }));

package/dist/commands/agent-workflow/chat-worker.js

@@ -354,7 +354,7 @@ function startRealtime() {
             registerChannel(payload.new);
             // A channel created with messages already in it (unlikely but
             // possible if INSERTs race) deserves an immediate sweep.
-            const id = payload.new.id;
+            const { id } = payload.new;
             if (id) {
                 void claimAndProcess(id);
             }

package/dist/commands/checklists/index.js

@@ -116,7 +116,7 @@ export async function runChecklists(options) {
         ? createChecklistsMcpServer({ kind: 'team', teamId: teamId })
         : createChecklistsMcpServer({
             kind: 'product',
-            productId: productId,
+            productId,
         });
     const promptParts = isTeamScope
         ? [

package/dist/commands/product-techniques/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * CLI command: edsger product-techniques <productId> --techniques-id <id>
+ *
+ * Clones the product's repo, asks Claude to write a catalogue of the
+ * techniques the repo uses, and stores the markdown body in
+ * product_techniques. The desktop UI creates a pending row first then
+ * invokes the CLI with --techniques-id; the CLI flips status running →
+ * success/failed and populates the content/summary fields.
+ */
+export interface ProductTechniquesCliOptions {
+    techniquesId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runProductTechniques(productId: string, options: ProductTechniquesCliOptions): Promise<void>;

package/dist/commands/product-techniques/index.js

@@ -0,0 +1,37 @@
+/**
+ * CLI command: edsger product-techniques <productId> --techniques-id <id>
+ *
+ * Clones the product's repo, asks Claude to write a catalogue of the
+ * techniques the repo uses, and stores the markdown body in
+ * product_techniques. The desktop UI creates a pending row first then
+ * invokes the CLI with --techniques-id; the CLI flips status running →
+ * success/failed and populates the content/summary fields.
+ */
+import { runProductTechniquesPhase } from '../../phases/product-techniques/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runProductTechniques(productId, options) {
+    const { techniquesId, guidance, verbose } = options;
+    if (!productId) {
+        throw new Error('Product ID is required for product-techniques');
+    }
+    if (!techniquesId) {
+        throw new Error('--techniques-id is required (the pending product_techniques row id)');
+    }
+    logInfo(`Starting techniques generation for product ${productId}`);
+    const result = await runProductTechniquesPhase({
+        productId,
+        techniquesId,
+        guidance,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(result.message);
+        if (result.summary) {
+            logInfo(`\nSummary: ${result.summary}`);
+        }
+    }
+    else {
+        logError(result.message);
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,15 @@
+/**
+ * CLI command: edsger recipes <productId> --scan-id <id>
+ *
+ * Clones the product's repo, asks Claude to identify implementation recipes
+ * the product uses, and persists them via the recipes / product_recipes
+ * tables. The desktop UI creates a pending recipe_scans row first then
+ * invokes the CLI with --scan-id; the CLI flips status running →
+ * success/failed and writes recipes via the MCP toolkit.
+ */
+export interface RecipesCliOptions {
+    scanId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runRecipes(productId: string, options: RecipesCliOptions): Promise<void>;

package/dist/commands/recipes/index.js

@@ -0,0 +1,34 @@
+/**
+ * CLI command: edsger recipes <productId> --scan-id <id>
+ *
+ * Clones the product's repo, asks Claude to identify implementation recipes
+ * the product uses, and persists them via the recipes / product_recipes
+ * tables. The desktop UI creates a pending recipe_scans row first then
+ * invokes the CLI with --scan-id; the CLI flips status running →
+ * success/failed and writes recipes via the MCP toolkit.
+ */
+import { runRecipesPhase } from '../../phases/recipes/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runRecipes(productId, options) {
+    const { scanId, guidance, verbose } = options;
+    if (!productId) {
+        throw new Error('Product ID is required for recipes');
+    }
+    if (!scanId) {
+        throw new Error('--scan-id is required (the pending recipe_scans row id)');
+    }
+    logInfo(`Starting recipes scan for product ${productId}`);
+    const result = await runRecipesPhase({
+        productId,
+        scanId,
+        guidance,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(result.message);
+    }
+    else {
+        logError(result.message);
+        process.exit(1);
+    }
+}

package/dist/commands/workflow/executors/phase-executor.js

@@ -3,7 +3,7 @@
  */
 import { checkApprovalBeforePhaseExecution } from '../../../api/issues/approval-checker.js';
 import { updateIssueStatusForPhase } from '../../../api/issues/index.js';
-import { logIssuePhaseEvent, } from '../../../services/audit-logs.js';
+import { logIssuePhaseEvent } from '../../../services/audit-logs.js';
 import { getChecklistsForPhase, processChecklistItemResultsFromResponse, processChecklistResultsFromResponse, validateChecklistsForPhase, validateRequiredChecklistResults, } from '../../../services/checklist.js';
 import { runHooksForPhase } from '../../../services/phase-hooks/index.js';
 import { logDebug, logInfo, logWarning } from '../../../utils/logger.js';

package/dist/index.js

@@ -19,17 +19,18 @@ import { runFindBugs } from './commands/find-bugs/index.js';
 import { runFindFeatures } from './commands/find-features/index.js';
 import { parseCategoriesOption, runFindSmells, } from './commands/find-smells/index.js';
 import { runGrowthAnalysis } from './commands/growth-analysis/index.js';
-import { runScreenFlow } from './commands/screen-flow/index.js';
 import { runInit } from './commands/init/index.js';
 import { runIntelligence } from './commands/intelligence/index.js';
 import { runIssueAnalysisCommand } from './commands/issue-analysis/index.js';
 import { runPRResolve } from './commands/pr-resolve/index.js';
 import { runPRReview } from './commands/pr-review/index.js';
 import { runProductTestCases } from './commands/product-test-cases/index.js';
+import { runRecipes } from './commands/recipes/index.js';
 import { runQualityBenchmarkCli } from './commands/quality-benchmark/index.js';
 import { runRefactor } from './commands/refactor/refactor.js';
 import { runReleaseSyncCommand } from './commands/release-sync/index.js';
 import { runRunSheetCommand } from './commands/run-sheet/index.js';
+import { runScreenFlow } from './commands/screen-flow/index.js';
 import { runSmokeTestCommand } from './commands/smoke-test/index.js';
 import { runSyncGithubIssues } from './commands/sync-github-issues/index.js';
 import { runSyncSentryIssues } from './commands/sync-sentry-issues/index.js';
@@ -694,6 +695,28 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger recipes <productId>
+// ============================================================
+program
+    .command('recipes <productId>')
+    .description("Scan a product's repo for the implementation recipes it uses (which services/tools are chained together to deliver each capability) and persist them via the recipes / product_recipes tables. Writes against the pending recipe_scans row identified by --scan-id.")
+    .requiredOption('--scan-id <id>', 'Pending recipe_scans row id to drive (created by the desktop UI before invocation)')
+    .option('-g, --guidance <text>', 'Human direction for the AI (focus areas, exclusions)')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        await runRecipes(productId, {
+            scanId: opts.scanId,
+            guidance: opts.guidance,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
 // Subcommand: edsger pr-resolve <productId>
 // ============================================================
 program

package/dist/phases/analyze-logs/index.js

@@ -5,11 +5,11 @@
  * user's session logs (only if the latest log is >1 hour old), and creates
  * product_user_feedbacks for any issues or improvement suggestions found.
  */
+import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { getProduct } from '../../api/products.js';
 import { getPendingLogsByUser, markLogsAnalyzed, } from '../../services/product-logs.js';
 import { getSupabase, hasSupabaseSession } from '../../supabase/client.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../../api/mcp-client.js';
 import { executeLogAnalysis } from './agent.js';
 import { createAnalyzeLogsSystemPrompt, createAnalyzeLogsUserPrompt, } from './prompts.js';
 /**

package/dist/phases/bug-fixing/context-fetcher.js

@@ -41,8 +41,10 @@ export async function fetchBugFixingContext(issueId, verbose) {
                     // Fall through to MCP
                 }
             }
-            if (raw == null) {
-                const testReportResult = (await callMcpEndpoint('test_reports/latest', { issue_id: issueId }));
+            if (!raw) {
+                const testReportResult = (await callMcpEndpoint('test_reports/latest', {
+                    issue_id: issueId,
+                }));
                 raw = testReportResult.test_report ?? null;
             }
             if (raw) {

package/dist/phases/find-features/index.js

@@ -267,7 +267,7 @@ async function fetchIntelligenceReports(productId, focusReportId) {
                 if (error) {
                     throw new Error(error.message);
                 }
-                reports = (data || []);
+                reports = data || [];
                 usedSdk = true;
             }
             catch {

package/dist/phases/product-techniques/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * product-techniques phase: clone the product's repo, ask Claude (via the
+ * `submit_techniques` MCP tool) to write a catalogue of the techniques the
+ * repo uses, and persist the result to product_techniques via the Supabase
+ * SDK.
+ *
+ * Mirrors the screen-flow pattern. Production-grade behaviours layered on
+ * top of the basic generate-and-write loop:
+ *
+ *   - Heartbeat: `last_heartbeat_at` is refreshed on every assistant message
+ *     so the reader can detect stalled / crashed runs (see services/db/
+ *     product-techniques.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.
+ *   - Tool-based submission: validated server-side via Zod + content checks
+ *     (mcp-server.ts). Falls back to fenced JSON parsing for resilience.
+ */
+import type { SupabaseClient } from '@supabase/supabase-js';
+export interface ProductTechniquesOptions {
+    productId: string;
+    techniquesId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export interface ProductTechniquesResult {
+    status: 'success' | 'error' | 'cancelled';
+    message: string;
+    summary?: string;
+}
+export declare function runProductTechniquesPhase(options: ProductTechniquesOptions): Promise<ProductTechniquesResult>;
+/**
+ * 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 declare function markRunning(supabase: SupabaseClient, techniquesId: string): Promise<boolean>;
+/**
+ * Touch the heartbeat. Best-effort — if it fails (network blip, RLS), the
+ * agent loop keeps running; the reader treats this row as stale and marks
+ * it failed on next read, which is the correct behaviour.
+ */
+export declare function heartbeat(supabase: SupabaseClient, techniquesId: string): Promise<void>;
+/**
+ * Write failure status iff the row is still in an active state. Returns
+ * true if the row was actually updated (so the caller knows whether the
+ * agent's verdict made it to the DB). Returns false when the row has
+ * already been cancelled or otherwise resolved by someone else.
+ */
+export declare function markFailed(supabase: SupabaseClient, techniquesId: string, errorMessage: string): Promise<boolean>;
+export declare function markSuccess(supabase: SupabaseClient, techniquesId: string, summary: string, content: string): Promise<boolean>;

package/dist/phases/product-techniques/index.js

@@ -0,0 +1,268 @@
+/**
+ * product-techniques phase: clone the product's repo, ask Claude (via the
+ * `submit_techniques` MCP tool) to write a catalogue of the techniques the
+ * repo uses, and persist the result to product_techniques via the Supabase
+ * SDK.
+ *
+ * Mirrors the screen-flow pattern. Production-grade behaviours layered on
+ * top of the basic generate-and-write loop:
+ *
+ *   - Heartbeat: `last_heartbeat_at` is refreshed on every assistant message
+ *     so the reader can detect stalled / crashed runs (see services/db/
+ *     product-techniques.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.
+ *   - Tool-based submission: validated server-side via Zod + content checks
+ *     (mcp-server.ts). Falls back to fenced JSON parsing for resilience.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { getGitHubConfigByProduct } 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, tryExtractResult, } from '../pr-shared/agent-utils.js';
+import { createTechniquesCaptureState, createTechniquesMcpServer, validateContent, } from './mcp-server.js';
+import { createProductTechniquesSystemPrompt, createProductTechniquesUserPrompt, } from './prompts.js';
+import { isTechniquesExtraction, TECHNIQUES_CONTENT_MAX, TECHNIQUES_SUMMARY_MAX, } from './types.js';
+const WORKSPACE_KEY = 'product-techniques';
+const MAX_TURNS = 120;
+// 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 runProductTechniquesPhase(options) {
+    const { productId, techniquesId, guidance, verbose } = options;
+    logInfo(`Starting product-techniques generation for product ${productId}`);
+    const supabase = getSupabase();
+    const claimed = await markRunning(supabase, techniquesId);
+    if (!claimed) {
+        return {
+            status: 'cancelled',
+            message: 'Techniques row is no longer in a runnable state (likely cancelled before the CLI started)',
+        };
+    }
+    const githubConfig = 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.';
+        await markFailed(supabase, techniquesId, msg);
+        return { status: 'error', message: msg };
+    }
+    let repoPath;
+    let succeeded = false;
+    try {
+        const workspaceRoot = ensureWorkspaceDir();
+        const repoKey = `${WORKSPACE_KEY}-${productId}`;
+        ({ repoPath } = cloneIssueRepo(workspaceRoot, repoKey, githubConfig.owner, githubConfig.repo, githubConfig.token));
+        const product = await fetchProductBasics(productId);
+        const systemPrompt = createProductTechniquesSystemPrompt();
+        const userPrompt = createProductTechniquesUserPrompt({
+            productName: product.name,
+            productDescription: product.description,
+            guidance,
+        });
+        logInfo('Running Claude agent to write techniques catalogue...');
+        const captureState = createTechniquesCaptureState();
+        const mcpServer = createTechniquesMcpServer(captureState);
+        let lastAssistantResponse = '';
+        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: {
+                    'product-techniques': mcpServer,
+                },
+            },
+        })) {
+            if (message.type === 'assistant') {
+                lastAssistantResponse += extractTextFromContent(message.message?.content ?? [], verbose);
+                // Throttled heartbeat. Awaited (cheap UPDATE) so we don't pile up
+                // unresolved promises on a long run.
+                const now = Date.now();
+                if (now - lastHeartbeatAt >= HEARTBEAT_MIN_INTERVAL_MS) {
+                    lastHeartbeatAt = now;
+                    await heartbeat(supabase, techniquesId);
+                }
+                continue;
+            }
+            if (message.type !== 'result') {
+                continue;
+            }
+            // Prefer the MCP-captured extraction. Fall back to fenced JSON only
+            // if the agent ignored the tool — robustness, not a contract.
+            const fromTool = captureState.captured;
+            const fromFallback = fromTool
+                ? null
+                : tryFallbackParse(message, lastAssistantResponse);
+            const extraction = fromTool ?? fromFallback;
+            if (!extraction) {
+                const msg = message.subtype === 'success'
+                    ? 'Techniques generation failed: agent did not call submit_techniques and no parseable fallback was found'
+                    : `Techniques generation failed: agent ${message.subtype}`;
+                const written = await markFailed(supabase, techniquesId, msg);
+                return {
+                    status: written ? 'error' : 'cancelled',
+                    message: written
+                        ? msg
+                        : 'Generation was cancelled while the agent was running',
+                };
+            }
+            if (fromFallback) {
+                logWarning('Agent skipped submit_techniques; used fenced fallback JSON instead');
+            }
+            const written = await markSuccess(supabase, techniquesId, extraction.summary, extraction.content);
+            if (!written) {
+                return {
+                    status: 'cancelled',
+                    message: 'Generation was cancelled before the result could be written',
+                };
+            }
+            succeeded = true;
+            logSuccess(`Techniques catalogue generated (${extraction.content.length} chars of markdown)`);
+            return {
+                status: 'success',
+                message: 'Techniques catalogue generated',
+                summary: extraction.summary,
+            };
+        }
+        // Loop ended without a 'result' message — treat as failure.
+        const msg = 'Techniques generation ended without a result message';
+        await markFailed(supabase, techniquesId, msg);
+        return { status: 'error', message: msg };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Techniques generation failed: ${errorMessage}`);
+        await markFailed(supabase, techniquesId, errorMessage);
+        return { status: 'error', message: errorMessage };
+    }
+    finally {
+        if (succeeded) {
+            cleanupIssueRepo(repoPath);
+        }
+    }
+}
+// Fallback parser: extract a fenced `techniques` JSON block from the final
+// assistant text if the agent skipped the submit_techniques tool. Backstop
+// only — we expect the tool path to be the norm.
+function tryFallbackParse(resultMessage, assistantText) {
+    const responseText = resultMessage.subtype === 'success'
+        ? resultMessage.result || assistantText
+        : assistantText;
+    const parsed = tryExtractResult(responseText, 'techniques');
+    if (!isTechniquesExtraction(parsed)) {
+        return null;
+    }
+    if (parsed.summary.length > TECHNIQUES_SUMMARY_MAX) {
+        return null;
+    }
+    if (parsed.content.length > TECHNIQUES_CONTENT_MAX) {
+        return null;
+    }
+    const { error } = validateContent(parsed.content);
+    if (error) {
+        return null;
+    }
+    return parsed;
+}
+// ============================================================================
+// Persistence — exported for unit tests
+// ============================================================================
+/**
+ * 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, techniquesId) {
+    const { data, error } = await supabase
+        .from('product_techniques')
+        .update({
+        status: 'running',
+        error: null,
+        last_heartbeat_at: new Date().toISOString(),
+    })
+        .eq('id', techniquesId)
+        .in('status', ['pending', 'running'])
+        .select('id')
+        .maybeSingle();
+    if (error) {
+        logWarning(`Could not mark techniques as running: ${error.message}`);
+        return false;
+    }
+    return data !== null;
+}
+/**
+ * Touch the heartbeat. Best-effort — if it fails (network blip, RLS), the
+ * agent loop keeps running; the reader treats this row as stale and marks
+ * it failed on next read, which is the correct behaviour.
+ */
+export async function heartbeat(supabase, techniquesId) {
+    const { error } = await supabase
+        .from('product_techniques')
+        .update({ last_heartbeat_at: new Date().toISOString() })
+        .eq('id', techniquesId)
+        .eq('status', 'running');
+    if (error) {
+        logWarning(`Heartbeat failed: ${error.message}`);
+    }
+}
+/**
+ * Write failure status iff the row is still in an active state. Returns
+ * true if the row was actually updated (so the caller knows whether the
+ * agent's verdict made it to the DB). Returns false when the row has
+ * already been cancelled or otherwise resolved by someone else.
+ */
+export async function markFailed(supabase, techniquesId, errorMessage) {
+    const { data, error } = await supabase
+        .from('product_techniques')
+        .update({
+        status: 'failed',
+        error: errorMessage,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', techniquesId)
+        .in('status', ['pending', 'running'])
+        .select('id')
+        .maybeSingle();
+    if (error) {
+        logWarning(`Could not mark techniques as failed: ${error.message}`);
+        return false;
+    }
+    return data !== null;
+}
+export async function markSuccess(supabase, techniquesId, summary, content) {
+    const { data, error } = await supabase
+        .from('product_techniques')
+        .update({
+        status: 'success',
+        summary,
+        content,
+        error: null,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', techniquesId)
+        .in('status', ['pending', 'running'])
+        .select('id')
+        .maybeSingle();
+    if (error) {
+        logWarning(`Could not mark techniques as success: ${error.message}`);
+        return false;
+    }
+    return data !== null;
+}

package/dist/phases/product-techniques/mcp-server.d.ts

@@ -0,0 +1,41 @@
+/**
+ * In-process MCP server exposing a single tool — `submit_techniques` — that
+ * the Claude Agent SDK session calls to return the final markdown catalogue.
+ *
+ * Using a tool call instead of parsing a fenced JSON block lets the SDK
+ * enforce the schema (via Zod) and lets the agent self-correct when
+ * validation fails: the error message goes back as the tool result and the
+ * agent can re-call the tool with corrected data.
+ *
+ * The capture pattern: callers pass in a `TechniquesCaptureState`. The tool
+ * handler stores the validated args on `state.captured`. The orchestrator
+ * reads it after the SDK loop ends.
+ */
+import { z } from 'zod';
+import { type TechniquesExtraction } from './types.js';
+export interface TechniquesCaptureState {
+    captured: TechniquesExtraction | null;
+}
+export declare function createTechniquesCaptureState(): TechniquesCaptureState;
+/**
+ * Validation that goes beyond the basic Zod schema: enforce that the
+ * markdown actually has the H2 sections the prompt asks for. The agent gets
+ * an actionable error and can re-submit.
+ *
+ * We don't require ALL six sections — agents on tiny repos often legitimately
+ * collapse some. We require at least the first one ("Languages & Runtime")
+ * plus "Notable Techniques", which the prompt calls out as the whole point.
+ */
+export declare function validateContent(content: string): {
+    error: string | null;
+};
+/**
+ * Build the `submit_techniques` tool. Exported separately from the server
+ * so tests can exercise the handler directly without going through MCP
+ * transport.
+ */
+export declare function createSubmitTechniquesTool(state: TechniquesCaptureState): import("@anthropic-ai/claude-agent-sdk").SdkMcpToolDefinition<{
+    summary: z.ZodString;
+    content: z.ZodString;
+}>;
+export declare function createTechniquesMcpServer(state: TechniquesCaptureState): import("@anthropic-ai/claude-agent-sdk").McpSdkServerConfigWithInstance;