edsger 0.43.0 → 0.45.0

package/.claude/settings.local.json

@@ -1,8 +1,28 @@
 {
   "permissions": {
     "allow": [
-      "Bash(npx tsc:*)",
-      "Bash(npm run:*)"
-    ]
+      "Read(//Users/steven/development/edsger/**)",
+      "Bash(npm run build)",
+      "Bash(node:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(ls:*)",
+      "Bash(cat:*)",
+      "Bash(npm run typecheck:*)",
+      "Bash(git diff:*)",
+      "WebSearch",
+      "WebFetch(domain:supabase.com)",
+      "Bash(npm install:*)",
+      "Bash(grep:*)",
+      "Bash(npx supabase gen types typescript --help:*)",
+      "Bash(git -C /Users/steven/development/edsger status)",
+      "Bash(git -C /Users/steven/development/edsger diff)",
+      "Bash(git -C /Users/steven/development/edsger log --oneline -5)",
+      "Bash(git -C /Users/steven/development/edsger add supabase/migrations/20251231000000_drop_unused_views.sql)",
+      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views that are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")",
+      "Bash(git -C /Users/steven/development/edsger commit -m \"$\\(cat <<''EOF''\nchore: drop unused database views\n\nRemove test_report_summary and user_stories_with_context views\nthat are defined but never used in the application.\n\n🤖 Generated with [Claude Code]\\(https://claude.com/claude-code\\)\n\nCo-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>\nEOF\n\\)\")"
+    ],
+    "deny": [],
+    "ask": []
   }
 }

package/.env.local

@@ -0,0 +1,12 @@
+OPENAI_API_KEY=
+TRIGGER_SECRET_KEY=
+RECALL_AI_API_KEY=
+RECALL_WEBHOOK_SECRET=
+NEXT_PUBLIC_APP_URL=
+RESEND_API_KEY=
+EMAIL_FROM=
+GITHUB_APP_ID=
+GITHUB_APP_PRIVATE_KEY=
+GITHUB_APP_SLUG=
+DEEPGRAM_API_KEY=
+DEEPGRAM_PROJECT_ID=

package/dist/api/release-test-cases.d.ts

@@ -0,0 +1,7 @@
+export interface ReleaseTestCaseInput {
+    name: string;
+    description: string;
+    is_critical?: boolean;
+}
+export declare function clearReleaseTestCases(releaseId: string, verbose?: boolean): Promise<void>;
+export declare function createReleaseTestCases(releaseId: string, cases: ReleaseTestCaseInput[], verbose?: boolean): Promise<number>;

package/dist/api/release-test-cases.js

@@ -0,0 +1,21 @@
+import { logDebug, logInfo } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+export async function clearReleaseTestCases(releaseId, verbose) {
+    logDebug(`Clearing draft cases for release ${releaseId}`, verbose);
+    await callMcpEndpoint('releases/test_cases/clear', {
+        release_id: releaseId,
+    });
+}
+export async function createReleaseTestCases(releaseId, cases, verbose) {
+    if (cases.length === 0) {
+        return 0;
+    }
+    if (verbose) {
+        logInfo(`Inserting ${cases.length} release test cases`);
+    }
+    const result = (await callMcpEndpoint('releases/test_cases/create', {
+        release_id: releaseId,
+        test_cases: cases,
+    }));
+    return result.count;
+}

package/dist/api/releases.d.ts

@@ -0,0 +1,41 @@
+export interface Release {
+    id: string;
+    product_id: string;
+    tag: string;
+    name: string | null;
+    body: string | null;
+    url: string | null;
+    published_at: string | null;
+    previous_tag: string | null;
+    previous_published_at: string | null;
+    status: 'pending' | 'generating' | 'ready' | 'failed';
+    generation_error: string | null;
+    diff_summary: string | null;
+    diff_stats: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+export interface UpsertReleaseParams {
+    product_id: string;
+    tag: string;
+    name?: string | null;
+    body?: string | null;
+    url?: string | null;
+    published_at?: string | null;
+    previous_tag?: string | null;
+    previous_published_at?: string | null;
+    status?: 'pending' | 'generating' | 'ready' | 'failed';
+    diff_stats?: Record<string, unknown>;
+}
+export interface UpdateReleaseParams {
+    release_id: string;
+    status?: 'pending' | 'generating' | 'ready' | 'failed';
+    generation_error?: string | null;
+    diff_summary?: string | null;
+    diff_stats?: Record<string, unknown>;
+}
+export declare function upsertRelease(params: UpsertReleaseParams, verbose?: boolean): Promise<Release>;
+export declare function updateRelease(params: UpdateReleaseParams, verbose?: boolean): Promise<Release>;
+export declare function getRelease(releaseId: string, verbose?: boolean): Promise<Release>;
+export declare function getLatestReleaseForProduct(productId: string, verbose?: boolean): Promise<Release | null>;
+export declare function getReleaseByTag(productId: string, tag: string, verbose?: boolean): Promise<Release | null>;

package/dist/api/releases.js

@@ -0,0 +1,31 @@
+import { logDebug } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+export async function upsertRelease(params, verbose) {
+    logDebug(`Upserting release ${params.product_id}@${params.tag}`, verbose);
+    return (await callMcpEndpoint('releases/upsert', params));
+}
+export async function updateRelease(params, verbose) {
+    logDebug(`Updating release ${params.release_id}`, verbose);
+    return (await callMcpEndpoint('releases/update', params));
+}
+export async function getRelease(releaseId, verbose) {
+    logDebug(`Fetching release ${releaseId}`, verbose);
+    return (await callMcpEndpoint('releases/get', {
+        release_id: releaseId,
+    }));
+}
+export async function getLatestReleaseForProduct(productId, verbose) {
+    logDebug(`Fetching latest release for product ${productId}`, verbose);
+    const result = (await callMcpEndpoint('releases/latest_for_product', {
+        product_id: productId,
+    }));
+    return result.release;
+}
+export async function getReleaseByTag(productId, tag, verbose) {
+    logDebug(`Looking up release ${productId}@${tag}`, verbose);
+    const result = (await callMcpEndpoint('releases/get_by_tag', {
+        product_id: productId,
+        tag,
+    }));
+    return result.release;
+}

package/dist/api/run-sheets.d.ts

@@ -0,0 +1,22 @@
+export interface RunSheet {
+    id: string;
+    release_id: string;
+    title: string | null;
+    content: string;
+    template_snapshot: string | null;
+    metadata: Record<string, unknown>;
+    generated_at: string | null;
+    created_by: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface UpsertRunSheetParams {
+    release_id: string;
+    content: string;
+    title?: string | null;
+    template_snapshot?: string | null;
+    metadata?: Record<string, unknown>;
+    generated_at?: string;
+}
+export declare function getRunSheetByRelease(releaseId: string, verbose?: boolean): Promise<RunSheet | null>;
+export declare function upsertRunSheet(params: UpsertRunSheetParams, verbose?: boolean): Promise<RunSheet>;

package/dist/api/run-sheets.js

@@ -0,0 +1,13 @@
+import { logDebug } from '../utils/logger.js';
+import { callMcpEndpoint } from './mcp-client.js';
+export async function getRunSheetByRelease(releaseId, verbose) {
+    logDebug(`Fetching run sheet for release ${releaseId}`, verbose);
+    const result = (await callMcpEndpoint('run_sheets/get', {
+        release_id: releaseId,
+    }));
+    return result.run_sheet;
+}
+export async function upsertRunSheet(params, verbose) {
+    logDebug(`Upserting run sheet for release ${params.release_id}`, verbose);
+    return (await callMcpEndpoint('run_sheets/upsert', params));
+}

package/dist/commands/release-sync/index.d.ts

@@ -0,0 +1,5 @@
+export interface ReleaseSyncCliOptions {
+    productId: string;
+    verbose?: boolean;
+}
+export declare const runReleaseSyncCommand: (options: ReleaseSyncCliOptions) => Promise<void>;

package/dist/commands/release-sync/index.js

@@ -0,0 +1,38 @@
+import { runReleaseSync, } from '../../phases/release-sync/index.js';
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo } from '../../utils/logger.js';
+import { validateConfiguration } from '../../utils/validation.js';
+export const runReleaseSyncCommand = async (options) => {
+    const { productId } = options;
+    if (!productId) {
+        throw new Error('Product ID is required for release-sync');
+    }
+    const config = validateConfiguration({
+        verbose: options.verbose,
+    });
+    await registerSession({ command: 'release-sync', productId });
+    logInfo(`Starting release sync for product: ${productId}`);
+    try {
+        const result = await runReleaseSync({
+            productId,
+            verbose: options.verbose,
+        }, config);
+        if (result.status === 'success') {
+            logInfo(result.summary);
+            for (const r of result.syncedReleases ?? []) {
+                logInfo(`  - ${r.tag}${r.isSnapshot ? ' (snapshot)' : ''}`);
+            }
+        }
+        else {
+            logError(`Release sync failed: ${result.summary}`);
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        logError(`Release sync failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+    finally {
+        await deregisterSession();
+    }
+};

package/dist/commands/run-sheet/index.d.ts

@@ -0,0 +1,6 @@
+export interface RunSheetCliOptions {
+    releaseId: string;
+    force?: boolean;
+    verbose?: boolean;
+}
+export declare const runRunSheetCommand: (options: RunSheetCliOptions) => Promise<void>;

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

@@ -0,0 +1,48 @@
+import { runRunSheet, } from '../../phases/run-sheet/index.js';
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo } from '../../utils/logger.js';
+import { validateConfiguration } from '../../utils/validation.js';
+export const runRunSheetCommand = async (options) => {
+    const { releaseId } = options;
+    if (!releaseId) {
+        throw new Error('Release ID is required for run-sheet');
+    }
+    validateConfiguration({ verbose: options.verbose });
+    await registerSession({ command: 'run-sheet' });
+    logInfo(`Starting run sheet generation for release: ${releaseId}`);
+    try {
+        const result = await runRunSheet({
+            releaseId,
+            force: options.force,
+            verbose: options.verbose,
+        });
+        if (result.status === 'error') {
+            logError(`Run sheet generation failed: ${result.summary}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (result.status === 'cached') {
+            logInfo(`Run sheet unchanged for ${result.releaseTag} — skipped clone.`);
+        }
+        else {
+            logInfo(`Generated run sheet for ${result.releaseTag}`);
+        }
+        if (result.cloneError) {
+            logInfo(`Clone warning: ${result.cloneError}`);
+        }
+        if (result.missingPlaceholders && result.missingPlaceholders.length > 0) {
+            logInfo(`Unresolved placeholders: ${result.missingPlaceholders.join(', ')}`);
+        }
+        if (result.commitsTruncated) {
+            logInfo('Commit list truncated at GitHub 250-commit cap.');
+        }
+        logInfo('View it in the Release detail page of your product dashboard.');
+    }
+    catch (error) {
+        logError(`Run sheet generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+    finally {
+        await deregisterSession();
+    }
+};

package/dist/commands/smoke-test/index.d.ts

@@ -0,0 +1,5 @@
+export interface SmokeTestCliOptions {
+    releaseId: string;
+    verbose?: boolean;
+}
+export declare const runSmokeTestCommand: (options: SmokeTestCliOptions) => Promise<void>;

package/dist/commands/smoke-test/index.js

@@ -0,0 +1,40 @@
+import { runSmokeTest, } from '../../phases/smoke-test/index.js';
+import { deregisterSession, registerSession, } from '../../system/session-manager.js';
+import { logError, logInfo } from '../../utils/logger.js';
+import { validateConfiguration } from '../../utils/validation.js';
+export const runSmokeTestCommand = async (options) => {
+    const { releaseId } = options;
+    if (!releaseId) {
+        throw new Error('Release ID is required for smoke-test');
+    }
+    const config = validateConfiguration({
+        verbose: options.verbose,
+    });
+    await registerSession({ command: 'smoke-test' });
+    logInfo(`Starting smoke-test generation for release: ${releaseId}`);
+    try {
+        const result = await runSmokeTest({
+            releaseId,
+            verbose: options.verbose,
+        }, config);
+        if (result.status === 'success') {
+            logInfo(result.isSnapshot
+                ? `Release: ${result.releaseTag} (snapshot — not yet published on GitHub)`
+                : `Release: ${result.releaseTag}`);
+            logInfo(`Previous: ${result.previousReleaseTag ?? '(none)'}`);
+            logInfo(`Cases generated: ${result.casesCount}`);
+            logInfo('View in the Release detail page of your product dashboard.');
+        }
+        else {
+            logError(`Smoke-test generation failed: ${result.summary}`);
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        logError(`Smoke-test generation failed: ${error instanceof Error ? error.message : String(error)}`);
+        process.exitCode = 1;
+    }
+    finally {
+        await deregisterSession();
+    }
+};

package/dist/index.js

@@ -19,6 +19,9 @@ import { runIntelligence } from './commands/intelligence/index.js';
 import { runPRResolve } from './commands/pr-resolve/index.js';
 import { runPRReview } from './commands/pr-review/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 { runSmokeTestCommand } from './commands/smoke-test/index.js';
 import { runTaskWorker } from './commands/task-worker/index.js';
 import { runWorkflow } from './commands/workflow/index.js';
 import { logError, logInfo } from './utils/logger.js';
@@ -274,6 +277,65 @@ program
     }
 });
 // ============================================================
+// Subcommand: edsger release-sync <productId>
+// ============================================================
+program
+    .command('release-sync <productId>')
+    .description('Sync GitHub releases (and any unreleased snapshot version) into the releases table for a product')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (productId, opts) => {
+    try {
+        await runReleaseSyncCommand({
+            productId,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
+// Subcommand: edsger smoke-test <releaseId>
+// ============================================================
+program
+    .command('smoke-test <releaseId>')
+    .description('Generate smoke-test cases for a specific release (requires the release to be synced first — see `edsger release-sync`)')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (releaseId, opts) => {
+    try {
+        await runSmokeTestCommand({
+            releaseId,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
+// Subcommand: edsger run-sheet <releaseId>
+// ============================================================
+program
+    .command('run-sheet <releaseId>')
+    .description('Render the product run sheet template against a release (clones the repo at the release tag to resolve {{file:...}} placeholders)')
+    .option('-f, --force', 'Regenerate even if the cached run sheet is fresh')
+    .option('-v, --verbose', 'Verbose output')
+    .action(async (releaseId, opts) => {
+    try {
+        await runRunSheetCommand({
+            releaseId,
+            force: opts.force,
+            verbose: opts.verbose,
+        });
+    }
+    catch (error) {
+        logError(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+// ============================================================
 // Subcommand: edsger pr-review <productId>
 // ============================================================
 program

package/dist/phases/release-sync/__tests__/github.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Unit tests for smoke-test github helpers.
+ *
+ * Covers the pure functions that shape GitHub compare data into a
+ * prompt-ready digest. Network-facing functions (fetchLatestTwoReleases,
+ * fetchCompare) are exercised only indirectly — their output shape is
+ * fed through buildDiffDigest / summariseStats here.
+ */
+export {};

package/dist/phases/release-sync/__tests__/github.test.js

@@ -0,0 +1,123 @@
+/**
+ * Unit tests for smoke-test github helpers.
+ *
+ * Covers the pure functions that shape GitHub compare data into a
+ * prompt-ready digest. Network-facing functions (fetchLatestTwoReleases,
+ * fetchCompare) are exercised only indirectly — their output shape is
+ * fed through buildDiffDigest / summariseStats here.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildDiffDigest, summariseStats, } from '../github.js';
+function makeCompare(over = {}) {
+    return {
+        total_commits: 2,
+        commits: [
+            {
+                sha: '1111111aaaaaaaa',
+                commit: {
+                    message: 'feat: add checkout flow\n\nmore body',
+                    author: null,
+                },
+            },
+            {
+                sha: '2222222bbbbbbbb',
+                commit: { message: 'fix: null deref', author: { name: 'Ada' } },
+            },
+        ],
+        files: [
+            {
+                filename: 'src/checkout.ts',
+                status: 'modified',
+                additions: 10,
+                deletions: 2,
+                changes: 12,
+                patch: '@@ -1 +1 @@\n-old\n+new',
+            },
+            {
+                filename: 'src/util.ts',
+                status: 'added',
+                additions: 5,
+                deletions: 0,
+                changes: 5,
+            },
+        ],
+        ...over,
+    };
+}
+void describe('summariseStats', () => {
+    void it('sums additions, deletions, and file count', () => {
+        const stats = summariseStats(makeCompare());
+        assert.deepStrictEqual(stats, {
+            files_changed: 2,
+            additions: 15,
+            deletions: 2,
+            total_commits: 2,
+        });
+    });
+    void it('handles an empty diff', () => {
+        const stats = summariseStats({
+            total_commits: 0,
+            commits: [],
+            files: [],
+        });
+        assert.deepStrictEqual(stats, {
+            files_changed: 0,
+            additions: 0,
+            deletions: 0,
+            total_commits: 0,
+        });
+    });
+});
+void describe('buildDiffDigest', () => {
+    void it('includes commit subjects, file list, and patches', () => {
+        const digest = buildDiffDigest(makeCompare());
+        assert.match(digest, /Total commits: 2/);
+        assert.match(digest, /1111111 feat: add checkout flow/);
+        assert.match(digest, /2222222 fix: null deref/);
+        assert.match(digest, /modified src\/checkout\.ts \(\+10\/-2\)/);
+        assert.match(digest, /added src\/util\.ts \(\+5\/-0\)/);
+        assert.match(digest, /--- src\/checkout\.ts ---/);
+        assert.match(digest, /\+new/);
+    });
+    void it('truncates only the subject line of multi-line commit messages', () => {
+        const digest = buildDiffDigest(makeCompare());
+        // "more body" from the first commit's message body must not leak in.
+        assert.ok(!digest.includes('more body'));
+    });
+    void it('caps the patch budget and appends a truncation marker', () => {
+        const huge = 'x'.repeat(200_000);
+        const compare = makeCompare({
+            files: [
+                {
+                    filename: 'src/big.ts',
+                    status: 'modified',
+                    additions: 1,
+                    deletions: 0,
+                    changes: 1,
+                    patch: huge,
+                },
+            ],
+        });
+        const digest = buildDiffDigest(compare);
+        assert.match(digest, /\[truncated\]/);
+        // Even with a 200k patch, digest stays bounded by the internal budget.
+        assert.ok(digest.length < 200_000);
+    });
+    void it('skips files without patches in the patches section', () => {
+        const compare = makeCompare({
+            files: [
+                {
+                    filename: 'vendored.min.js',
+                    status: 'added',
+                    additions: 1,
+                    deletions: 0,
+                    changes: 1,
+                },
+            ],
+        });
+        const digest = buildDiffDigest(compare);
+        assert.ok(digest.includes('== Patches (truncated) =='));
+        assert.ok(!digest.includes('--- vendored.min.js ---'));
+    });
+});

package/dist/phases/release-sync/__tests__/snapshot.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Unit tests for snapshot-detection pure helpers.
+ *
+ * The network / SDK path (`detectSnapshotVersion`) is not covered here
+ * — it's exercised end-to-end when the CLI runs — but the parser and
+ * the plausibility check are critical and easy to cover.
+ */
+export {};

package/dist/phases/release-sync/__tests__/snapshot.test.js

@@ -0,0 +1,93 @@
+/**
+ * Unit tests for snapshot-detection pure helpers.
+ *
+ * The network / SDK path (`detectSnapshotVersion`) is not covered here
+ * — it's exercised end-to-end when the CLI runs — but the parser and
+ * the plausibility check are critical and easy to cover.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+import { buildSnapshotDetectionPrompt, isPlausibleSnapshotTag, parseSnapshotDetection, } from '../snapshot.js';
+void describe('parseSnapshotDetection', () => {
+    void it('parses a clean JSON object', () => {
+        const raw = '{"snapshot_tag":"v2.0.0","source":"package.json","reasoning":"next ver"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v2.0.0');
+        assert.strictEqual(parsed.source, 'package.json');
+        assert.match(parsed.reasoning, /next ver/);
+    });
+    void it('strips ```json fences', () => {
+        const raw = '```json\n{"snapshot_tag":"v1.0.1","source":"VERSION","reasoning":"x"}\n```';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v1.0.1');
+    });
+    void it('tolerates leading and trailing prose', () => {
+        const raw = `I checked package.json:
+{"snapshot_tag":"v3.0.0","source":"package.json","reasoning":"bumped"}
+Done.`;
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v3.0.0');
+    });
+    void it('returns null snapshot_tag when model reports no snapshot', () => {
+        const raw = '{"snapshot_tag": null, "source": null, "reasoning": "version matches latest release"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, null);
+        assert.strictEqual(parsed.source, null);
+    });
+    void it('treats empty string snapshot_tag as null', () => {
+        const raw = '{"snapshot_tag":"","source":null,"reasoning":"nothing found"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, null);
+    });
+    void it('falls back to balanced-brace extraction for surrounding prose', () => {
+        const raw = 'Analysis: { could be v1 } — but the real answer is ' +
+            '{"snapshot_tag":"v1.2.0","source":"CHANGELOG","reasoning":"unreleased section present"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v1.2.0');
+        assert.strictEqual(parsed.source, 'CHANGELOG');
+    });
+    void it('throws when no JSON object is present', () => {
+        assert.throws(() => parseSnapshotDetection('no json at all'), /JSON/);
+    });
+    void it('supplies default reasoning when missing', () => {
+        const raw = '{"snapshot_tag":"v1","source":"package.json"}';
+        const parsed = parseSnapshotDetection(raw);
+        assert.strictEqual(parsed.snapshot_tag, 'v1');
+        assert.strictEqual(parsed.reasoning, '(no reasoning given)');
+    });
+});
+void describe('isPlausibleSnapshotTag', () => {
+    void it('accepts normal version tags', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('v2.0.0', 'v1.9.0'), true);
+        assert.strictEqual(isPlausibleSnapshotTag('2.0.0-rc.1', '1.9.0'), true);
+        assert.strictEqual(isPlausibleSnapshotTag('v1.2.3-SNAPSHOT', 'v1.2.2'), true);
+        assert.strictEqual(isPlausibleSnapshotTag('release/2.0', 'release/1.9'), true);
+    });
+    void it('rejects tags identical to the latest release', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('v1.0.0', 'v1.0.0'), false);
+    });
+    void it('rejects empty or overlong tags', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('x'.repeat(101), 'v1'), false);
+    });
+    void it('rejects whitespace and shell metacharacters', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('v 2', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('v2;rm -rf', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('v2$PATH', 'v1'), false);
+    });
+    void it('rejects leading dot or dash, double dot, @{ reflog', () => {
+        assert.strictEqual(isPlausibleSnapshotTag('.v2', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('-v2', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('v2..rc', 'v1'), false);
+        assert.strictEqual(isPlausibleSnapshotTag('v2@{1}', 'v1'), false);
+    });
+});
+void describe('buildSnapshotDetectionPrompt', () => {
+    void it('injects the latest release tag into the prompt', () => {
+        const prompt = buildSnapshotDetectionPrompt('v1.4.2');
+        assert.match(prompt, /v1\.4\.2/);
+        // Must ask for JSON output
+        assert.match(prompt, /JSON/);
+        assert.match(prompt, /snapshot_tag/);
+    });
+});