edsger 0.73.0 → 0.75.0

package/dist/api/adr.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Architecture Decision Record API for the CLI.
+ *
+ * The desktop app creates the `adrs` draft row (the human types the decision
+ * topic + context); the CLI agent reads it here, fills `adr_options` with
+ * pros/cons, and flips `generation_status` to `ready`. All writes go through the
+ * user-scoped Supabase client (RLS gates on product/repository access), so the
+ * CLI must run with a synced desktop session.
+ */
+export interface AdrRow {
+    id: string;
+    product_id: string | null;
+    repository_id: string | null;
+    sequence: number;
+    title: string;
+    context: string | null;
+    generation_prompt: string | null;
+}
+export interface AdrOptionInput {
+    title: string;
+    summary?: string;
+    pros: string[];
+    cons: string[];
+    is_recommended?: boolean;
+}
+/** Context gathered for the agent prompt. */
+export interface AdrContext {
+    scope: 'product' | 'repo';
+    name: string;
+    description: string | null;
+    /** Repo full names linked to the product, or the single repo's name. */
+    repos: string[];
+    /** Recent issue titles (product scope only) for situational awareness. */
+    issues: string[];
+}
+export declare function getAdr(adrId: string): Promise<AdrRow>;
+/**
+ * Gather lightweight context for the decision: the product/repo identity, its
+ * linked repositories, and (for products) a sample of recent issue titles.
+ */
+export declare function loadAdrContext(adr: AdrRow): Promise<AdrContext>;
+/**
+ * Replace the ADR's options with a freshly generated set and mark the run
+ * ready for the human to choose. Clears any prior options so re-runs are clean.
+ */
+export declare function saveAdrOptions(adrId: string, options: AdrOptionInput[]): Promise<void>;
+export declare function markGenerationReady(adrId: string): Promise<void>;
+export declare function markGenerationFailed(adrId: string, message: string): Promise<void>;

package/dist/api/adr.js

@@ -0,0 +1,139 @@
+/**
+ * Architecture Decision Record API for the CLI.
+ *
+ * The desktop app creates the `adrs` draft row (the human types the decision
+ * topic + context); the CLI agent reads it here, fills `adr_options` with
+ * pros/cons, and flips `generation_status` to `ready`. All writes go through the
+ * user-scoped Supabase client (RLS gates on product/repository access), so the
+ * CLI must run with a synced desktop session.
+ */
+import { ensureSupabaseSession, getSupabase } from '../supabase/client.js';
+import { logInfo } from '../utils/logger.js';
+async function requireSession() {
+    const ready = await ensureSupabaseSession();
+    if (!ready) {
+        throw new Error('Supabase session unavailable. Sign in to the Edsger desktop app to authorize the CLI.');
+    }
+}
+export async function getAdr(adrId) {
+    await requireSession();
+    const { data, error } = await getSupabase()
+        .from('adrs')
+        .select('id, product_id, repository_id, sequence, title, context, generation_prompt')
+        .eq('id', adrId)
+        .single();
+    if (error) {
+        throw new Error(`Failed to load ADR ${adrId}: ${error.message}`);
+    }
+    return data;
+}
+/**
+ * Gather lightweight context for the decision: the product/repo identity, its
+ * linked repositories, and (for products) a sample of recent issue titles.
+ */
+export async function loadAdrContext(adr) {
+    const sb = getSupabase();
+    if (adr.product_id) {
+        const { data: product } = await sb
+            .from('products')
+            .select('name, description, product_repositories(repositories(full_name))')
+            .eq('id', adr.product_id)
+            .single();
+        const { data: issues } = await sb
+            .from('issues')
+            .select('name')
+            .eq('product_id', adr.product_id)
+            .order('created_at', { ascending: false })
+            .limit(25);
+        const repoLinks = (product?.product_repositories ??
+            []);
+        return {
+            scope: 'product',
+            name: product?.name ?? 'Unknown product',
+            description: product?.description ?? null,
+            repos: repoLinks
+                .flatMap((l) => Array.isArray(l.repositories)
+                ? l.repositories
+                : l.repositories
+                    ? [l.repositories]
+                    : [])
+                .map((r) => r.full_name)
+                .filter((n) => Boolean(n)),
+            issues: (issues ?? []).map((i) => i.name),
+        };
+    }
+    const { data: repo } = await sb
+        .from('repositories')
+        .select('full_name, description, language')
+        .eq('id', adr.repository_id)
+        .single();
+    return {
+        scope: 'repo',
+        name: repo?.full_name ?? 'Unknown repository',
+        description: repo?.description ?? null,
+        repos: repo?.full_name ? [repo.full_name] : [],
+        issues: [],
+    };
+}
+/**
+ * Replace the ADR's options with a freshly generated set and mark the run
+ * ready for the human to choose. Clears any prior options so re-runs are clean.
+ */
+export async function saveAdrOptions(adrId, options) {
+    await requireSession();
+    const sb = getSupabase();
+    // Detach the previously selected option (FK) before clearing options, so the
+    // delete can't trip the ON DELETE SET NULL ordering on a re-run.
+    await sb.from('adrs').update({ selected_option_id: null }).eq('id', adrId);
+    const { error: delError } = await sb
+        .from('adr_options')
+        .delete()
+        .eq('adr_id', adrId);
+    if (delError) {
+        throw new Error(`Failed to clear prior options: ${delError.message}`);
+    }
+    if (options.length > 0) {
+        const rows = options.map((o, i) => ({
+            adr_id: adrId,
+            position: i,
+            title: o.title,
+            summary: o.summary ?? null,
+            pros: o.pros ?? [],
+            cons: o.cons ?? [],
+            is_recommended: o.is_recommended ?? false,
+            source: 'ai_generated',
+        }));
+        const { error } = await sb.from('adr_options').insert(rows);
+        if (error) {
+            throw new Error(`Failed to save options: ${error.message}`);
+        }
+    }
+    logInfo(`Saved ${options.length} decision options`);
+}
+export async function markGenerationReady(adrId) {
+    const { error } = await getSupabase()
+        .from('adrs')
+        .update({
+        generation_status: 'ready',
+        generation_error: null,
+        status: 'proposed',
+    })
+        .eq('id', adrId);
+    if (error) {
+        throw new Error(`Failed to mark ADR ready: ${error.message}`);
+    }
+}
+export async function markGenerationFailed(adrId, message) {
+    try {
+        await getSupabase()
+            .from('adrs')
+            .update({
+            generation_status: 'failed',
+            generation_error: message.slice(0, 1000),
+        })
+            .eq('id', adrId);
+    }
+    catch {
+        // Best-effort — the caller already logged the underlying error.
+    }
+}

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

@@ -0,0 +1,13 @@
+export interface AdrCommandOptions {
+    adrId: string;
+    verbose?: boolean;
+}
+/**
+ * Generate decision options for a draft ADR. The desktop app creates the draft
+ * row (the human types the decision topic) and passes its id here; this run
+ * fills it with options + pros/cons for the human to choose from.
+ *
+ * The cli_sessions `command` column is keyed off EDSGER_PROCESS_KEY (set by the
+ * desktop runner to `adr:<scopeId>`), so the originating tab can replay logs.
+ */
+export declare const runAdr: (options: AdrCommandOptions) => Promise<void>;

package/dist/commands/adr/index.js

@@ -0,0 +1,31 @@
+import { generateAdr } from '../../phases/adr-generation/index.js';
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo } from '../../utils/logger.js';
+import { validateConfiguration } from '../../utils/validation.js';
+/**
+ * Generate decision options for a draft ADR. The desktop app creates the draft
+ * row (the human types the decision topic) and passes its id here; this run
+ * fills it with options + pros/cons for the human to choose from.
+ *
+ * The cli_sessions `command` column is keyed off EDSGER_PROCESS_KEY (set by the
+ * desktop runner to `adr:<scopeId>`), so the originating tab can replay logs.
+ */
+export const runAdr = async (options) => {
+    const { adrId } = options;
+    // Establish CLI config (validates auth/env) before doing any work.
+    validateConfiguration({ verbose: options.verbose });
+    await registerSession({ command: 'adr' });
+    logInfo(`Starting ADR generation for: ${adrId}`);
+    try {
+        const result = await generateAdr({ adrId, verbose: options.verbose });
+        if (result.status !== 'success') {
+            logError(`ADR generation failed: ${result.error || 'Unknown error'}`);
+        }
+    }
+    catch (error) {
+        logError(`ADR generation error: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    finally {
+        await deregisterSession();
+    }
+};

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

@@ -0,0 +1,15 @@
+/**
+ * CLI command: edsger features <productId> --scan-id <id>
+ *
+ * Clones every repository linked to the product, asks Claude to catalogue
+ * the user-facing features it delivers, and persists them via the
+ * product_features table. The desktop UI creates a pending feature_scans
+ * row first then invokes the CLI with --scan-id; the CLI flips status
+ * running → success/failed and writes features via the MCP toolkit.
+ */
+export interface FeaturesCliOptions {
+    scanId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export declare function runFeatures(productId: string, options: FeaturesCliOptions): Promise<void>;

package/dist/commands/features/index.js

@@ -0,0 +1,34 @@
+/**
+ * CLI command: edsger features <productId> --scan-id <id>
+ *
+ * Clones every repository linked to the product, asks Claude to catalogue
+ * the user-facing features it delivers, and persists them via the
+ * product_features table. The desktop UI creates a pending feature_scans
+ * row first then invokes the CLI with --scan-id; the CLI flips status
+ * running → success/failed and writes features via the MCP toolkit.
+ */
+import { runFeaturesPhase } from '../../phases/features/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runFeatures(productId, options) {
+    const { scanId, guidance, verbose } = options;
+    if (!productId) {
+        throw new Error('A product ID is required for features');
+    }
+    if (!scanId) {
+        throw new Error('--scan-id is required (the pending feature_scans row id)');
+    }
+    logInfo(`Starting features scan for product ${productId}`);
+    const result = await runFeaturesPhase({
+        productId,
+        scanId,
+        guidance,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(result.message);
+    }
+    else {
+        logError(result.message);
+        process.exit(1);
+    }
+}

package/dist/commands/pr-resolve/index.d.ts

@@ -5,7 +5,9 @@
 export interface PRResolveCliOptions {
     prUrl: string;
     prId?: string;
+    /** Repo-only mode: resolve GitHub config from a repositories row. */
+    repoId?: string;
     verbose?: boolean;
     learn?: boolean;
 }
-export declare function runPRResolve(productId: string, options: PRResolveCliOptions): Promise<void>;
+export declare function runPRResolve(productId: string | undefined, options: PRResolveCliOptions): Promise<void>;

package/dist/commands/pr-resolve/index.js

@@ -2,31 +2,36 @@
  * CLI command: edsger pr-resolve <productId> --pr-url <url>
  * Resolves PR change requests: fixes what's genuinely better, explains what it won't change.
  */
-import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, } from '../../api/github.js';
 import { resolveStandalonePR } from '../../phases/pr-resolve/index.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 export async function runPRResolve(productId, options) {
-    const { prUrl, prId, verbose } = options;
-    logInfo(`Starting PR resolve for product ${productId}`);
+    const { prUrl, prId, repoId, verbose } = options;
+    const scopeLabel = repoId ? `repository ${repoId}` : `product ${productId}`;
+    logInfo(`Starting PR resolve for ${scopeLabel}`);
     logInfo(`PR URL: ${prUrl}`);
-    // Get GitHub config via product developer settings
-    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    // Resolve GitHub config from the repository (repo-only mode) or the product.
+    const githubConfig = repoId
+        ? await getGitHubConfigByRepository(repoId, verbose)
+        : await getGitHubConfigByProduct(productId ?? '', verbose);
     if (!githubConfig.configured ||
         !githubConfig.token ||
         !githubConfig.owner ||
         !githubConfig.repo) {
-        logError(`GitHub not configured for product ${productId}: ${githubConfig.message || 'No installation found'}`);
+        logError(`GitHub not configured for ${scopeLabel}: ${githubConfig.message || 'No installation found'}`);
         process.exit(1);
     }
     const result = await resolveStandalonePR({
         productId,
+        repositoryId: repoId,
         pullRequestUrl: prUrl,
         githubToken: githubConfig.token,
         owner: githubConfig.owner,
         repo: githubConfig.repo,
         prId,
         verbose,
-        learn: options.learn,
+        // Checklist learning is product-scoped; skip it in repo-only mode.
+        learn: repoId ? false : options.learn,
     });
     if (result.status === 'success') {
         logSuccess(`PR resolve completed: ${result.message}`);

package/dist/commands/pr-review/index.d.ts

@@ -5,6 +5,8 @@
 export interface PRReviewCliOptions {
     prUrl: string;
     prId?: string;
+    /** Repo-only mode: resolve GitHub config from a repositories row. */
+    repoId?: string;
     verbose?: boolean;
 }
-export declare function runPRReview(productId: string, options: PRReviewCliOptions): Promise<void>;
+export declare function runPRReview(productId: string | undefined, options: PRReviewCliOptions): Promise<void>;

package/dist/commands/pr-review/index.js

@@ -2,24 +2,28 @@
  * CLI command: edsger pr-review <productId> --pr-url <url>
  * Reviews a standalone GitHub PR and posts comments.
  */
-import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, } from '../../api/github.js';
 import { reviewStandalonePR } from '../../phases/pr-review/index.js';
 import { logError, logInfo, logSuccess } from '../../utils/logger.js';
 export async function runPRReview(productId, options) {
-    const { prUrl, prId, verbose } = options;
-    logInfo(`Starting PR review for product ${productId}`);
+    const { prUrl, prId, repoId, verbose } = options;
+    const scopeLabel = repoId ? `repository ${repoId}` : `product ${productId}`;
+    logInfo(`Starting PR review for ${scopeLabel}`);
     logInfo(`PR URL: ${prUrl}`);
-    // Get GitHub config via product developer settings
-    const githubConfig = await getGitHubConfigByProduct(productId, verbose);
+    // Resolve GitHub config from the repository (repo-only mode) or the product.
+    const githubConfig = repoId
+        ? await getGitHubConfigByRepository(repoId, verbose)
+        : await getGitHubConfigByProduct(productId ?? '', verbose);
     if (!githubConfig.configured ||
         !githubConfig.token ||
         !githubConfig.owner ||
         !githubConfig.repo) {
-        logError(`GitHub not configured for product ${productId}: ${githubConfig.message || 'No installation found'}`);
+        logError(`GitHub not configured for ${scopeLabel}: ${githubConfig.message || 'No installation found'}`);
         process.exit(1);
     }
     const result = await reviewStandalonePR({
         productId,
+        repositoryId: repoId,
         pullRequestUrl: prUrl,
         githubToken: githubConfig.token,
         owner: githubConfig.owner,

package/dist/commands/sync-github-pull-requests/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CLI command: `edsger sync-github-pull-requests <repoId>`
+ *
+ * Mirrors a connected GitHub repo's pull requests into the local
+ * `pull_requests` table (scoped by repository_id) for the repo detail page.
+ * Idempotent — already-synced PRs are refreshed, never duplicated.
+ */
+export interface SyncGithubPullRequestsCliOptions {
+    verbose?: boolean;
+}
+export declare function runSyncGithubPullRequests(repositoryId: string, options?: SyncGithubPullRequestsCliOptions): Promise<void>;

package/dist/commands/sync-github-pull-requests/index.js

@@ -0,0 +1,42 @@
+/**
+ * CLI command: `edsger sync-github-pull-requests <repoId>`
+ *
+ * Mirrors a connected GitHub repo's pull requests into the local
+ * `pull_requests` table (scoped by repository_id) for the repo detail page.
+ * Idempotent — already-synced PRs are refreshed, never duplicated.
+ */
+import { getGitHubConfigByRepository } from '../../api/github.js';
+import { syncGithubPullRequests } from '../../phases/sync-github-pull-requests/index.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+export async function runSyncGithubPullRequests(repositoryId, options = {}) {
+    const { verbose } = options;
+    logInfo(`Starting GitHub pull request sync for repository ${repositoryId}`);
+    const githubConfig = await getGitHubConfigByRepository(repositoryId, verbose);
+    if (!githubConfig.configured ||
+        !githubConfig.token ||
+        !githubConfig.owner ||
+        !githubConfig.repo) {
+        logError(`GitHub not configured for repository ${repositoryId}: ${githubConfig.message || 'No installation found'}`);
+        process.exit(1);
+    }
+    const result = await syncGithubPullRequests({
+        repositoryId,
+        githubToken: githubConfig.token,
+        owner: githubConfig.owner,
+        repo: githubConfig.repo,
+        verbose,
+    });
+    if (result.status === 'success') {
+        logSuccess(`GitHub PR sync completed: ${result.message}`);
+        if (result.repository) {
+            logInfo(`Repository: ${result.repository}`);
+        }
+        if (result.fetchedCount !== undefined) {
+            logInfo(`Fetched ${result.fetchedCount} · created ${result.createdCount ?? 0} · updated ${result.updatedCount ?? 0}`);
+        }
+    }
+    else {
+        logError(`GitHub PR sync failed: ${result.message}`);
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -6,6 +6,7 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { applyEnvStore } from './auth/env-store.js';
 import { runLogin, runLogout, runStatus } from './auth/login.js';
+import { runAdr } from './commands/adr/index.js';
 import { runAgentWorkflow } from './commands/agent-workflow/index.js';
 import { runAnalyzeLogs } from './commands/analyze-logs/index.js';
 import { runAppStoreGeneration } from './commands/app-store/index.js';
@@ -19,6 +20,7 @@ import { runConfigGet, runConfigList, runConfigSet, runConfigUnset, } from './co
 import { runDataFlow } from './commands/data-flow/index.js';
 import { runDiscover } from './commands/discover/index.js';
 import { runErDiagram } from './commands/er-diagram/index.js';
+import { runFeatures } from './commands/features/index.js';
 import { runFinancingDeck } from './commands/financing-deck/index.js';
 import { runFindArchitecture } from './commands/find-architecture/index.js';
 import { runFindBugs } from './commands/find-bugs/index.js';
@@ -46,6 +48,7 @@ import { runStateDiagram } from './commands/state-diagram/index.js';
 import { runSyncAws } from './commands/sync-aws/index.js';
 import { runSyncDatadog } from './commands/sync-datadog/index.js';
 import { runSyncGithubIssues } from './commands/sync-github-issues/index.js';
+import { runSyncGithubPullRequests } from './commands/sync-github-pull-requests/index.js';
 import { runSyncOrgRepos } from './commands/sync-org-repos/index.js';
 import { runSyncSentryIssues } from './commands/sync-sentry-issues/index.js';
 import { runSyncTerraform } from './commands/sync-terraform/index.js';
@@ -462,6 +465,21 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger adr <adrId>
+// ============================================================
+program
+    .command('adr <adrId>')
+    .description('Generate decision options (pros/cons) for a draft Architecture Decision Record')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (adrId, opts) => {
+    try {
+        await runAdr({ adrId, verbose: opts.verbose });
+    }
+    catch (error) {
+        exitWithError(error);
+    }
+});
+// ============================================================
 // Subcommand: edsger app-store <productId>
 // ============================================================
 program
@@ -763,13 +781,17 @@ program
 // Subcommand: edsger pr-review <productId>
 // ============================================================
 program
-    .command('pr-review <productId>')
-    .description('AI-review a GitHub PR for a product')
+    .command('pr-review [productId]')
+    .description('AI-review a GitHub PR for a product (or standalone repository)')
     .requiredOption('--pr-url <url>', 'GitHub PR URL')
     .option('--pr-id <id>', 'Pull request record ID in database')
+    .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
     try {
+        if (!productId && !opts.repoId) {
+            throw new Error('Provide a productId or --repo-id (repo-only mode) for pr-review');
+        }
         await runPRReview(productId, opts);
     }
     catch (error) {
@@ -842,6 +864,21 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger sync-github-pull-requests <repoId>
+// ============================================================
+program
+    .command('sync-github-pull-requests <repoId>')
+    .description("Mirror a connected GitHub repo's pull requests into the local pull_requests list for the repo detail page (idempotent — refreshes, never duplicates)")
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (repoId, opts) => {
+    try {
+        await runSyncGithubPullRequests(repoId, opts);
+    }
+    catch (error) {
+        exitWithError(error);
+    }
+});
+// ============================================================
 // Subcommand: edsger sync-org-repos <teamId>
 // ============================================================
 program
@@ -1081,17 +1118,42 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger features <productId>
+// ============================================================
+program
+    .command('features <productId>')
+    .description('Scan every repository linked to a product for the user-facing features it delivers and persist them via the product_features table. Manually defined features are enriched, never rewritten. Writes against the pending feature_scans row identified by --scan-id.')
+    .requiredOption('--scan-id <id>', 'Pending feature_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 runFeatures(productId, {
+            scanId: opts.scanId,
+            guidance: opts.guidance,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        exitWithError(error);
+    }
+});
+// ============================================================
 // Subcommand: edsger pr-resolve <productId>
 // ============================================================
 program
-    .command('pr-resolve <productId>')
-    .description('AI-resolve change requests on a GitHub PR')
+    .command('pr-resolve [productId]')
+    .description('AI-resolve change requests on a GitHub PR for a product (or standalone repository)')
     .requiredOption('--pr-url <url>', 'GitHub PR URL')
     .option('--pr-id <id>', 'Pull request record ID in database')
+    .option('--repo-id <id>', 'Run in repo-only mode against a single repositories row (no product context)')
     .option('--no-learn', 'Skip checklist learning after resolve')
     .option('-v, --verbose', 'Verbose output')
     .action(async (productId, opts) => {
     try {
+        if (!productId && !opts.repoId) {
+            throw new Error('Provide a productId or --repo-id (repo-only mode) for pr-resolve');
+        }
         await runPRResolve(productId, opts);
     }
     catch (error) {

package/dist/phases/adr-generation/agent.d.ts

@@ -0,0 +1,6 @@
+import { type AdrOptionInput } from '../../api/adr.js';
+/**
+ * Run the ADR agent. Returns the validated options, or null if the model
+ * produced nothing parseable.
+ */
+export declare function executeAdrQuery(userPrompt: string, systemPrompt: string, verbose?: boolean, cwd?: string): Promise<AdrOptionInput[] | null>;

package/dist/phases/adr-generation/agent.js

@@ -0,0 +1,69 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logDebug, logError, logInfo } from '../../utils/logger.js';
+import { extractJSON, normalizeOptions } from './parse.js';
+// eslint-disable-next-line @typescript-eslint/require-await
+async function* promptStream(text) {
+    yield { type: 'user', message: { role: 'user', content: text } };
+}
+/**
+ * Run the ADR agent. Returns the validated options, or null if the model
+ * produced nothing parseable.
+ */
+export async function executeAdrQuery(userPrompt, systemPrompt, verbose, cwd) {
+    let lastAssistant = '';
+    let result = null;
+    let turnCount = 0;
+    logInfo('Connecting to AI agent for decision analysis...');
+    for await (const message of query({
+        prompt: promptStream(userPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 1000,
+            permissionMode: 'bypassPermissions',
+            ...(cwd ? { cwd } : {}),
+        },
+    })) {
+        if (message.type === 'assistant' && message.message?.content) {
+            turnCount++;
+            for (const content of message.message.content) {
+                if (content.type === 'text') {
+                    lastAssistant += `${content.text}\n`;
+                    logDebug(`${content.text}`, verbose);
+                }
+                else if (content.type === 'tool_use') {
+                    const input = (content.input ?? {});
+                    const desc = input.description ?? input.command ?? 'Running...';
+                    logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
+                }
+            }
+        }
+        if (message.type === 'result') {
+            const text = message.subtype === 'success'
+                ? message.result || lastAssistant
+                : lastAssistant;
+            if (message.subtype === 'success') {
+                logInfo(`\nAnalysis completed after ${turnCount} turns, parsing...`);
+            }
+            else {
+                logError(`\nAnalysis incomplete: ${message.subtype}`);
+            }
+            const parsed = extractJSON(text);
+            if (parsed) {
+                const options = normalizeOptions(parsed);
+                if (options.length > 0) {
+                    result = options;
+                }
+            }
+        }
+    }
+    if (!result) {
+        logError('Could not extract decision options from the agent response.');
+    }
+    return result;
+}