edsger 0.43.0 → 0.45.0

package/dist/phases/run-sheet/index.js

@@ -0,0 +1,297 @@
+/**
+ * Run-sheet generation for a release.
+ *
+ * Given a release, fetches the product's `run_sheet_template`, clones the
+ * repo at the release tag (reusing the workspace layout used by
+ * smoke-test), renders placeholders, and upserts the result to the
+ * `run_sheets` table.
+ *
+ * Release tags are immutable, so if an existing run sheet has the same
+ * template_snapshot + tag and no clone error, we short-circuit without
+ * re-cloning. Pass `{ force: true }` to regenerate anyway.
+ */
+import { closeSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
+import { join } from 'path';
+import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getProduct } from '../../api/products.js';
+import { getRelease } from '../../api/releases.js';
+import { getRunSheetByRelease, upsertRunSheet, } from '../../api/run-sheets.js';
+import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
+import { cloneFeatureRepo, ensureWorkspaceDir, getFeatureRepoPath, syncRepoToRef, } from '../../workspace/workspace-manager.js';
+import { fetchCompare } from '../release-sync/github.js';
+import { isSafeGitRef, renderTemplate } from './render.js';
+// GitHub's compare endpoint is paginated; we don't page, so we warn when
+// we hit the first-page cap.
+const GITHUB_COMPARE_MAX_COMMITS = 250;
+async function fetchCommitsBetween(owner, repo, base, head, token) {
+    if (!base) {
+        return { text: '', truncated: false };
+    }
+    try {
+        const compare = await fetchCompare(owner, repo, base, head, token);
+        const commits = compare.commits ?? [];
+        const text = commits
+            .map((c) => `- ${c.sha.slice(0, 7)} ${(c.commit.message || '').split('\n')[0]}`)
+            .join('\n');
+        return {
+            text,
+            truncated: commits.length >= GITHUB_COMPARE_MAX_COMMITS,
+        };
+    }
+    catch (err) {
+        logWarning(`Could not fetch commits for run sheet: ${err instanceof Error ? err.message : String(err)}`);
+        return { text: '', truncated: false };
+    }
+}
+// Stale locks (e.g. left behind by a crashed or SIGKILLed CLI) are
+// considered abandoned after this many ms.
+const LOCK_STALE_MS = 15 * 60 * 1000;
+function writeLockFile(fd) {
+    const payload = { pid: process.pid, ts: Date.now() };
+    writeFileSync(fd, JSON.stringify(payload));
+    closeSync(fd);
+}
+function tryCreateLock(lockPath) {
+    try {
+        const fd = openSync(lockPath, 'wx');
+        writeLockFile(fd);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'EEXIST') {
+            return false;
+        }
+        throw err;
+    }
+}
+function isLockStale(lockPath) {
+    try {
+        const raw = readFileSync(lockPath, 'utf-8').trim();
+        let ts;
+        try {
+            ts = JSON.parse(raw).ts;
+        }
+        catch {
+            ts = Number(raw);
+        }
+        return !Number.isFinite(ts) || Date.now() - ts > LOCK_STALE_MS;
+    }
+    catch {
+        // Lock vanished between exists-check and read — treat as not held.
+        return true;
+    }
+}
+/**
+ * Atomic-create a `.lock` file alongside the workspace dir. Returns
+ * true if we acquired the lock, false if another CLI instance holds a
+ * fresh one. Stale locks (> LOCK_STALE_MS old) are stolen via a single
+ * unlink + create pair; concurrent stealers race fairly via O_EXCL on
+ * the second create.
+ */
+/** Exported for unit tests; not part of the public CLI surface. */
+export function tryAcquireFileLock(lockPath) {
+    mkdirSync(join(lockPath, '..'), { recursive: true });
+    // Pass 1: clean acquisition.
+    if (tryCreateLock(lockPath)) {
+        return true;
+    }
+    // Pass 2: someone holds it — only steal if their lock is stale.
+    if (!isLockStale(lockPath)) {
+        return false;
+    }
+    // Try to steal. Best-effort unlink (another stealer may have beaten
+    // us); the O_EXCL create then arbitrates fairly.
+    try {
+        unlinkSync(lockPath);
+    }
+    catch {
+        // Already gone — fine, race the create below.
+    }
+    return tryCreateLock(lockPath);
+}
+/** Exported for unit tests; not part of the public CLI surface. */
+export function releaseFileLock(lockPath) {
+    try {
+        unlinkSync(lockPath);
+    }
+    catch {
+        // Best-effort — lock will expire via LOCK_STALE_MS anyway.
+    }
+}
+function runSheetIsFresh(existing, template, tag) {
+    if (!existing || !existing.content) {
+        return false;
+    }
+    if (existing.template_snapshot !== template) {
+        return false;
+    }
+    const meta = existing.metadata ?? {};
+    if (meta.tag !== tag) {
+        return false;
+    }
+    if (meta.clone_error) {
+        return false;
+    }
+    return true;
+}
+export async function runRunSheet(options) {
+    const { releaseId, force, verbose } = options;
+    let release;
+    try {
+        release = await getRelease(releaseId, verbose);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            status: 'error',
+            releaseId,
+            summary: `Failed to load release: ${message}`,
+        };
+    }
+    if (!isSafeGitRef(release.tag)) {
+        return {
+            status: 'error',
+            releaseId,
+            releaseTag: release.tag,
+            summary: `Unsafe release tag: ${release.tag}`,
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mcp product shape is open
+    const product = (await getProduct(release.product_id, verbose));
+    const template = product?.run_sheet_template;
+    if (!template || !template.trim()) {
+        return {
+            status: 'error',
+            releaseId,
+            releaseTag: release.tag,
+            summary: 'Product has no run_sheet_template configured. Set one in product settings.',
+        };
+    }
+    // Short-circuit cache: identical template + tag, no prior clone error.
+    if (!force) {
+        const existing = await getRunSheetByRelease(releaseId, verbose).catch(() => null);
+        if (runSheetIsFresh(existing, template, release.tag)) {
+            logInfo(`Run sheet for ${release.tag} is already up-to-date (template unchanged).`);
+            return {
+                status: 'cached',
+                releaseId,
+                releaseTag: release.tag,
+                runSheetId: existing.id,
+                summary: 'Cached (no change since last render)',
+                missingPlaceholders: existing.metadata?.missing_placeholders ?? [],
+                cloneError: null,
+                commitsTruncated: Boolean(existing.metadata?.commits_truncated),
+            };
+        }
+    }
+    const gh = await getGitHubConfigByProduct(release.product_id, verbose);
+    const repoConfigured = gh.configured && gh.token && gh.owner && gh.repo;
+    // Clone at tag + fetch commits (both best-effort — we still render with
+    // whatever metadata we have).
+    let repoDir = null;
+    let cloneError = null;
+    let commits = '';
+    let commitsTruncated = false;
+    let lockPath = null;
+    if (repoConfigured) {
+        const owner = gh.owner;
+        const repo = gh.repo;
+        const token = gh.token;
+        // Serialise concurrent CLI invocations for the *same release* by
+        // taking a file lock next to the clone dir. Different releases get
+        // different lock files (per-release workspace).
+        const workspaceRoot = ensureWorkspaceDir();
+        const workspaceName = `run-sheet-${release.id}`;
+        const repoPathAhead = getFeatureRepoPath(workspaceRoot, workspaceName);
+        lockPath = `${repoPathAhead}.lock`;
+        if (!tryAcquireFileLock(lockPath)) {
+            return {
+                status: 'error',
+                releaseId: release.id,
+                releaseTag: release.tag,
+                summary: 'Another run-sheet generation is in progress for this release. Wait for it to finish or retry.',
+            };
+        }
+        try {
+            // Clone into a per-release directory so two releases of the same
+            // product don't stomp each other's checkout during concurrent
+            // generation. (smoke-test uses `release-${product_id}` — that races;
+            // we don't want to inherit that bug here.)
+            const { repoPath } = cloneFeatureRepo(workspaceRoot, workspaceName, owner, repo, token);
+            repoDir = repoPath;
+            try {
+                syncRepoToRef(repoPath, { tag: release.tag }, token);
+            }
+            catch (err) {
+                cloneError = `Could not checkout tag ${release.tag}: ${err instanceof Error ? err.message : String(err)}`;
+                logWarning(cloneError);
+            }
+        }
+        catch (err) {
+            cloneError = err instanceof Error ? err.message : String(err);
+            logWarning(`Clone failed: ${cloneError}`);
+        }
+        const c = await fetchCommitsBetween(owner, repo, release.previous_tag, release.tag, token);
+        commits = c.text;
+        commitsTruncated = c.truncated;
+    }
+    else {
+        cloneError = 'Product is not linked to a GitHub repository';
+    }
+    const { rendered, missing } = await renderTemplate(template, {
+        name: product?.name ?? 'Unknown product',
+        github_repository_full_name: product?.github_repository_full_name ?? null,
+    }, {
+        tag: release.tag,
+        name: release.name,
+        body: release.body,
+        url: release.url,
+        published_at: release.published_at,
+        previous_tag: release.previous_tag,
+        previous_published_at: release.previous_published_at,
+        diff_summary: release.diff_summary,
+        diff_stats: (release.diff_stats ?? {}),
+    }, repoDir, commits);
+    try {
+        const saved = await upsertRunSheet({
+            release_id: release.id,
+            content: rendered,
+            title: `Run Sheet — ${product?.name ?? ''} ${release.tag}`.trim(),
+            template_snapshot: template,
+            metadata: {
+                missing_placeholders: missing,
+                clone_error: cloneError,
+                repo: product?.github_repository_full_name ?? null,
+                tag: release.tag,
+                commits_truncated: commitsTruncated,
+            },
+            generated_at: new Date().toISOString(),
+        }, verbose);
+        logSuccess(`Generated run sheet for ${release.tag}`);
+        return {
+            status: 'success',
+            releaseId: release.id,
+            releaseTag: release.tag,
+            runSheetId: saved.id,
+            summary: `Rendered ${rendered.length} characters`,
+            missingPlaceholders: missing,
+            cloneError,
+            commitsTruncated,
+        };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logError(`Failed to upsert run sheet: ${message}`);
+        return {
+            status: 'error',
+            releaseId: release.id,
+            releaseTag: release.tag,
+            summary: `Failed to upsert run sheet: ${message}`,
+        };
+    }
+    finally {
+        if (lockPath) {
+            releaseFileLock(lockPath);
+        }
+    }
+}

package/dist/phases/run-sheet/render.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Pure template-rendering logic for run sheets.
+ *
+ * Intentionally identical to `web/src/services/run-sheets/render.ts` — any
+ * change here should mirror the web side (and its unit tests) so the CLI
+ * and the web `/api/releases/[id]/generate-run-sheet` route produce the
+ * exact same output for the same template + release.
+ */
+export declare const MAX_FILE_INCLUDE_BYTES: number;
+export declare const MAX_TOTAL_FILE_BYTES: number;
+export interface TemplateProduct {
+    name: string;
+    github_repository_full_name: string | null;
+}
+export interface TemplateRelease {
+    tag: string;
+    name: string | null;
+    body: string | null;
+    url: string | null;
+    published_at: string | null;
+    previous_tag: string | null;
+    previous_published_at: string | null;
+    diff_summary: string | null;
+    diff_stats: Record<string, unknown>;
+}
+export declare function isSafeGitRef(ref: string): boolean;
+export interface FileReadResult {
+    content: string | null;
+    bytes: number;
+    reason?: string;
+}
+export declare function safeReadRepoFile(repoDir: string, relPath: string, remainingBudget: number): Promise<FileReadResult>;
+export interface RenderResult {
+    rendered: string;
+    missing: string[];
+}
+/**
+ * Strip Markdown-style backslash escapes inside `{{ ... }}` spans so the
+ * Rich-text editor roundtrip doesn't break placeholder matching.
+ */
+export declare function normalizeTemplate(template: string): string;
+export declare function renderTemplate(template: string, product: TemplateProduct, release: TemplateRelease, repoDir: string | null, commits: string): Promise<RenderResult>;

package/dist/phases/run-sheet/render.js

@@ -0,0 +1,133 @@
+/**
+ * Pure template-rendering logic for run sheets.
+ *
+ * Intentionally identical to `web/src/services/run-sheets/render.ts` — any
+ * change here should mirror the web side (and its unit tests) so the CLI
+ * and the web `/api/releases/[id]/generate-run-sheet` route produce the
+ * exact same output for the same template + release.
+ */
+import { statSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { join, resolve } from 'path';
+export const MAX_FILE_INCLUDE_BYTES = 256 * 1024;
+export const MAX_TOTAL_FILE_BYTES = 1024 * 1024;
+export function isSafeGitRef(ref) {
+    if (typeof ref !== 'string' || ref.length === 0 || ref.length > 200) {
+        return false;
+    }
+    if (/\s/.test(ref) || /^[-.]/.test(ref)) {
+        return false;
+    }
+    if (ref.includes('..') || ref.includes('@{')) {
+        return false;
+    }
+    return /^[A-Za-z0-9._\-+/@]+$/.test(ref);
+}
+export async function safeReadRepoFile(repoDir, relPath, remainingBudget) {
+    if (!relPath || relPath.startsWith('/') || relPath.includes('\0')) {
+        return { content: null, bytes: 0, reason: 'invalid path' };
+    }
+    const repoDirResolved = resolve(repoDir);
+    const abs = resolve(join(repoDirResolved, relPath));
+    if (abs !== repoDirResolved && !abs.startsWith(`${repoDirResolved}/`)) {
+        return { content: null, bytes: 0, reason: 'path escape' };
+    }
+    let size;
+    try {
+        const stat = statSync(abs);
+        if (!stat.isFile()) {
+            return { content: null, bytes: 0, reason: 'not a file' };
+        }
+        size = stat.size;
+    }
+    catch {
+        return { content: null, bytes: 0, reason: 'not found' };
+    }
+    if (size > MAX_FILE_INCLUDE_BYTES) {
+        return {
+            content: null,
+            bytes: 0,
+            reason: `too large (${size} > ${MAX_FILE_INCLUDE_BYTES} bytes)`,
+        };
+    }
+    if (size > remainingBudget) {
+        return {
+            content: null,
+            bytes: 0,
+            reason: 'total file-inclusion budget exhausted',
+        };
+    }
+    try {
+        const content = await readFile(abs, 'utf-8');
+        return { content, bytes: size };
+    }
+    catch {
+        return { content: null, bytes: 0, reason: 'read failed' };
+    }
+}
+/**
+ * Strip Markdown-style backslash escapes inside `{{ ... }}` spans so the
+ * Rich-text editor roundtrip doesn't break placeholder matching.
+ */
+export function normalizeTemplate(template) {
+    return template.replace(/\{\{([^}]*)\}\}/g, (_match, inner) => `{{${inner.replace(/\\([_.\-\\/])/g, '$1')}}}`);
+}
+export async function renderTemplate(template, product, release, repoDir, commits) {
+    const missing = [];
+    const stats = release.diff_stats ?? {};
+    const normalized = normalizeTemplate(template);
+    const simpleVars = {
+        product_name: product.name,
+        release_tag: release.tag,
+        release_name: release.name ?? release.tag,
+        release_body: release.body ?? '',
+        release_url: release.url ?? '',
+        previous_tag: release.previous_tag ?? '',
+        published_at: release.published_at ?? '',
+        previous_published_at: release.previous_published_at ?? '',
+        diff_summary: release.diff_summary ?? '',
+        files_changed: String(stats.files_changed ?? ''),
+        additions: String(stats.additions ?? ''),
+        deletions: String(stats.deletions ?? ''),
+        commits_count: String(stats.commits_count ?? stats.total_commits ?? ''),
+        repository: product.github_repository_full_name ?? '',
+        generated_at: new Date().toISOString(),
+        commits,
+    };
+    const fileRegex = /\{\{\s*file:([^}]+?)\s*\}\}/g;
+    const fileMatches = [];
+    for (const m of normalized.matchAll(fileRegex)) {
+        fileMatches.push({ match: m[0], path: m[1].trim() });
+    }
+    let remainingBudget = MAX_TOTAL_FILE_BYTES;
+    const fileResults = new Map();
+    for (const { match, path } of fileMatches) {
+        if (fileResults.has(match)) {
+            continue;
+        }
+        if (!repoDir) {
+            missing.push(`file:${path} (no repo)`);
+            fileResults.set(match, `<!-- file ${path} unavailable: repo not cloned -->`);
+            continue;
+        }
+        // eslint-disable-next-line no-await-in-loop -- sequential so the byte budget is enforced
+        const res = await safeReadRepoFile(repoDir, path, remainingBudget);
+        if (res.content === null) {
+            missing.push(`file:${path} (${res.reason ?? 'unavailable'})`);
+            fileResults.set(match, `<!-- file ${path} unavailable: ${res.reason ?? 'unknown'} -->`);
+        }
+        else {
+            remainingBudget -= res.bytes;
+            fileResults.set(match, res.content);
+        }
+    }
+    let rendered = normalized.replace(fileRegex, (match) => fileResults.get(match) ?? match);
+    rendered = rendered.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (match, key) => {
+        if (key in simpleVars) {
+            return simpleVars[key];
+        }
+        missing.push(key);
+        return match;
+    });
+    return { rendered, missing };
+}

package/dist/phases/smoke-test/__tests__/agent.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for smoke-test agent response parsing.
+ */
+export {};

package/dist/phases/smoke-test/__tests__/agent.test.js

@@ -0,0 +1,85 @@
+/**
+ * Unit tests for smoke-test agent response parsing.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { findBalancedJsonObject } from '../../../utils/json-extract.js';
+import { extractJson } from '../agent.js';
+void describe('extractJson', () => {
+    void it('parses a plain JSON object', () => {
+        const raw = `{
+      "summary": "one thing changed",
+      "test_cases": [
+        { "name": "login still works", "description": "step 1", "is_critical": true }
+      ]
+    }`;
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'one thing changed');
+        assert.strictEqual(parsed.test_cases.length, 1);
+        assert.strictEqual(parsed.test_cases[0].is_critical, true);
+    });
+    void it('strips ```json fences', () => {
+        const raw = '```json\n{"summary":"x","test_cases":[{"name":"a","description":"b"}]}\n```';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+        assert.strictEqual(parsed.test_cases[0].name, 'a');
+    });
+    void it('strips unlabeled fences', () => {
+        const raw = '```\n{"summary":"x","test_cases":[]}\n```';
+        const parsed = extractJson(raw);
+        assert.deepStrictEqual(parsed.test_cases, []);
+    });
+    void it('tolerates leading and trailing prose', () => {
+        const raw = `Here you go:
+{"summary":"x","test_cases":[{"name":"a","description":"b"}]}
+
+Hope that helps.`;
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+    });
+    void it('throws when test_cases is missing', () => {
+        assert.throws(() => extractJson('{"summary":"x"}'), /test_cases/);
+    });
+    void it('throws on invalid JSON', () => {
+        assert.throws(() => extractJson('not json'));
+    });
+    void it('picks the first balanced object when prose contains decoy braces', () => {
+        const raw = 'Note: { pseudo-json example } but the real answer is:\n' +
+            '{"summary":"x","test_cases":[{"name":"a","description":"b"}]}\n' +
+            'Let me know if you want changes.';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'x');
+        assert.strictEqual(parsed.test_cases[0].name, 'a');
+    });
+    void it('preserves braces inside JSON string values', () => {
+        const raw = '{"summary":"changes to {pricing} and {checkout}","test_cases":[{"name":"n","description":"d"}]}';
+        const parsed = extractJson(raw);
+        assert.strictEqual(parsed.summary, 'changes to {pricing} and {checkout}');
+    });
+    void it('throws when test_cases is not an array', () => {
+        assert.throws(() => extractJson('{"summary":"x","test_cases":"nope"}'), /test_cases/);
+    });
+});
+void describe('findBalancedJsonObject', () => {
+    void it('returns null when there is no opening brace', () => {
+        assert.strictEqual(findBalancedJsonObject('no braces here'), null);
+    });
+    void it('returns the first balanced top-level object', () => {
+        assert.strictEqual(findBalancedJsonObject('prefix {"a": 1} and {"b": 2} suffix'), '{"a": 1}');
+    });
+    void it('handles nested braces', () => {
+        const text = 'xxx {"a": {"b": {"c": 1}}} yyy';
+        assert.strictEqual(findBalancedJsonObject(text), '{"a": {"b": {"c": 1}}}');
+    });
+    void it('ignores braces inside strings', () => {
+        const text = '{"msg": "this has { and } inside", "ok": true}';
+        assert.strictEqual(findBalancedJsonObject(text), text);
+    });
+    void it('handles escaped quotes inside strings', () => {
+        const text = '{"msg": "she said \\"hi\\" {not object}"}';
+        assert.strictEqual(findBalancedJsonObject(text), text);
+    });
+    void it('returns null on unbalanced input', () => {
+        assert.strictEqual(findBalancedJsonObject('{"a": 1'), null);
+    });
+});

package/dist/phases/smoke-test/agent.d.ts

@@ -0,0 +1,12 @@
+import { type EdsgerConfig } from '../../types/index.js';
+export interface GeneratedSmokeTestPlan {
+    summary: string;
+    test_cases: {
+        name: string;
+        description: string;
+        is_critical?: boolean;
+    }[];
+}
+/** @internal Exported for unit tests only. */
+export declare function extractJson(raw: string): GeneratedSmokeTestPlan;
+export declare function executeSmokeTestQuery(systemPrompt: string, userPrompt: string, config: EdsgerConfig, verbose?: boolean, cwd?: string): Promise<GeneratedSmokeTestPlan>;

package/dist/phases/smoke-test/agent.js

@@ -0,0 +1,94 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { findBalancedJsonObject } from '../../utils/json-extract.js';
+import { logDebug, logError, logInfo } from '../../utils/logger.js';
+function userMessage(content) {
+    return { type: 'user', message: { role: 'user', content } };
+}
+// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
+async function* makePrompt(text) {
+    yield userMessage(text);
+}
+/** @internal Exported for unit tests only. */
+export function extractJson(raw) {
+    let body = raw.trim();
+    const fence = body.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (fence) {
+        body = fence[1].trim();
+    }
+    // Try parsing the whole body first — if the model returned clean JSON
+    // it round-trips without needing to slice.
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        const object = findBalancedJsonObject(body);
+        if (!object) {
+            throw new Error('No JSON object found in model output');
+        }
+        parsed = JSON.parse(object);
+    }
+    if (typeof parsed !== 'object' ||
+        parsed === null ||
+        !Array.isArray(parsed.test_cases)) {
+        throw new Error('Model response is missing test_cases array');
+    }
+    return parsed;
+}
+// eslint-disable-next-line complexity -- agent loop with message type handling
+export async function executeSmokeTestQuery(systemPrompt, userPrompt, config, verbose, cwd) {
+    let lastAssistant = '';
+    let plan = null;
+    let parseError = null;
+    let turnCount = 0;
+    if (verbose) {
+        logInfo('Connecting to Claude Code for smoke-test generation...');
+    }
+    for await (const message of query({
+        prompt: makePrompt(userPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 20,
+            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 desc = content.input?.description || content.input?.command || 'Running...';
+                    if (verbose) {
+                        logInfo(`[Turn ${turnCount}] ${content.name}: ${typeof desc === 'string' ? desc.slice(0, 120) : 'Running...'}`);
+                    }
+                }
+            }
+        }
+        if (message.type === 'result') {
+            const text = ('result' in message ? message.result : '') || lastAssistant;
+            try {
+                plan = extractJson(text);
+            }
+            catch (err) {
+                parseError = err instanceof Error ? err.message : String(err);
+            }
+            if (message.subtype !== 'success') {
+                logError(`Smoke-test query incomplete: ${message.subtype}`);
+            }
+        }
+    }
+    if (!plan) {
+        throw new Error(`Failed to parse smoke-test plan from model output: ${parseError ?? 'no result message received'}`);
+    }
+    return plan;
+}