edsger 0.73.0 → 0.75.0

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

@@ -0,0 +1,15 @@
+export interface AdrGenerationOptions {
+    adrId: string;
+    verbose?: boolean;
+}
+export interface AdrGenerationResult {
+    status: 'success' | 'error';
+    optionCount: number;
+    error?: string;
+}
+/**
+ * Generate decision options for a draft ADR: gather context, run the agent,
+ * persist the resulting options, and flip the ADR to `proposed`/`ready` for the
+ * human to choose. The draft row is created by the desktop app beforehand.
+ */
+export declare function generateAdr(options: AdrGenerationOptions): Promise<AdrGenerationResult>;

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

@@ -0,0 +1,66 @@
+import { getAdr, loadAdrContext, markGenerationFailed, markGenerationReady, saveAdrOptions, } from '../../api/adr.js';
+import { getGitHubConfigByProduct, getGitHubConfigByRepository, } from '../../api/github.js';
+import { logError, logInfo, logSuccess } from '../../utils/logger.js';
+import { cleanupIssueRepo, cloneIssueRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
+import { executeAdrQuery } from './agent.js';
+import { buildAdrUserPrompt, createAdrSystemPrompt } from './prompts.js';
+/** Best-effort clone of the relevant repo so the agent can read the codebase. */
+async function tryCloneRepo(adr, verbose) {
+    try {
+        const gh = adr.product_id
+            ? await getGitHubConfigByProduct(adr.product_id, verbose)
+            : await getGitHubConfigByRepository(adr.repository_id, verbose);
+        if (gh.configured && gh.token && gh.owner && gh.repo) {
+            const workspaceRoot = ensureWorkspaceDir();
+            const { repoPath } = cloneIssueRepo(workspaceRoot, `adr-${adr.id}`, gh.owner, gh.repo, gh.token);
+            logInfo(`Repository cloned to: ${repoPath}`);
+            return repoPath;
+        }
+    }
+    catch (error) {
+        logInfo(`Could not clone repo (continuing without codebase): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return undefined;
+}
+/**
+ * Generate decision options for a draft ADR: gather context, run the agent,
+ * persist the resulting options, and flip the ADR to `proposed`/`ready` for the
+ * human to choose. The draft row is created by the desktop app beforehand.
+ */
+export async function generateAdr(options) {
+    const { adrId, verbose } = options;
+    let repoCwd;
+    try {
+        const adr = await getAdr(adrId);
+        logInfo(`Generating decision options for: ${adr.title}`);
+        const context = await loadAdrContext(adr);
+        repoCwd = await tryCloneRepo(adr, verbose);
+        const systemPrompt = await createAdrSystemPrompt(Boolean(repoCwd));
+        const userPrompt = buildAdrUserPrompt(adr, context);
+        const generated = await executeAdrQuery(userPrompt, systemPrompt, verbose, repoCwd);
+        if (!generated || generated.length === 0) {
+            const message = 'The agent did not return any decision options.';
+            await markGenerationFailed(adrId, message);
+            return { status: 'error', optionCount: 0, error: message };
+        }
+        await saveAdrOptions(adrId, generated);
+        await markGenerationReady(adrId);
+        logSuccess(`Generated ${generated.length} decision options.`);
+        for (const o of generated) {
+            logInfo(`  ${o.is_recommended ? '★' : '•'} ${o.title}`);
+        }
+        logInfo('\nReview and choose one in the Desktop app → ADR tab');
+        return { status: 'success', optionCount: generated.length };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logError(`ADR generation failed: ${message}`);
+        await markGenerationFailed(adrId, message);
+        return { status: 'error', optionCount: 0, error: message };
+    }
+    finally {
+        if (repoCwd) {
+            cleanupIssueRepo(repoCwd);
+        }
+    }
+}

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

@@ -0,0 +1,12 @@
+import { type AdrOptionInput } from '../../api/adr.js';
+/**
+ * Pure parsing/normalization helpers for the ADR agent response. Kept separate
+ * from agent.ts (which owns the SDK query loop) so they can be unit-tested
+ * without spinning up the model.
+ */
+/** Index of the matching closer for the opener at `start`, respecting strings. */
+export declare function findMatchingClose(text: string, start: number): number;
+export declare function extractJSON(text: string): any | null;
+export declare function asStringArray(value: unknown): string[];
+/** Coerce the parsed JSON into validated option inputs. */
+export declare function normalizeOptions(parsed: unknown): AdrOptionInput[];

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

@@ -0,0 +1,123 @@
+/**
+ * Pure parsing/normalization helpers for the ADR agent response. Kept separate
+ * from agent.ts (which owns the SDK query loop) so they can be unit-tested
+ * without spinning up the model.
+ */
+/** Index of the matching closer for the opener at `start`, respecting strings. */
+export function findMatchingClose(text, start) {
+    const opener = text[start];
+    const closer = opener === '{' ? '}' : ']';
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = start; i < text.length; i++) {
+        const ch = text[i];
+        if (escape) {
+            escape = false;
+            continue;
+        }
+        if (ch === '\\' && inString) {
+            escape = true;
+            continue;
+        }
+        if (ch === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (inString) {
+            continue;
+        }
+        if (ch === opener) {
+            depth++;
+        }
+        else if (ch === closer) {
+            depth--;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractJSON(text) {
+    // Largest ```json block first.
+    const jsonBlocks = [...text.matchAll(/```json\s*\n([\s\S]*?)\n\s*```/g)];
+    if (jsonBlocks.length > 0) {
+        const largest = jsonBlocks.reduce((a, b) => a[1].length >= b[1].length ? a : b);
+        try {
+            return JSON.parse(largest[1]);
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    // Generic code block.
+    const codeBlock = text.match(/```\s*\n([\s\S]*?)\n\s*```/);
+    if (codeBlock) {
+        try {
+            return JSON.parse(codeBlock[1]);
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    // Balanced { ... } scan.
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === '{') {
+            const end = findMatchingClose(text, i);
+            if (end !== -1) {
+                try {
+                    return JSON.parse(text.slice(i, end + 1));
+                }
+                catch {
+                    i = end;
+                }
+            }
+        }
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+export function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .map((v) => (typeof v === 'string' ? v : String(v)))
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+/** Coerce the parsed JSON into validated option inputs. */
+export function normalizeOptions(parsed) {
+    const root = parsed;
+    const rawOptions = Array.isArray(root?.options)
+        ? root?.options
+        : Array.isArray(parsed)
+            ? parsed
+            : [];
+    const options = [];
+    for (const raw of rawOptions ?? []) {
+        const o = raw;
+        const title = typeof o.title === 'string' ? o.title.trim() : '';
+        if (!title) {
+            continue;
+        }
+        options.push({
+            title,
+            summary: typeof o.summary === 'string' ? o.summary.trim() : undefined,
+            pros: asStringArray(o.pros),
+            cons: asStringArray(o.cons),
+            is_recommended: o.is_recommended === true,
+        });
+    }
+    // Guarantee exactly one recommended option when any exist.
+    if (options.length > 0 && !options.some((o) => o.is_recommended)) {
+        options[0].is_recommended = true;
+    }
+    return options;
+}

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

@@ -0,0 +1,8 @@
+import { type AdrContext, type AdrRow } from '../../api/adr.js';
+/**
+ * Build the ADR agent's system prompt from the bundled (and user-overridable)
+ * `phase/adr-generation` SKILL.md. Conditional blocks are toggled by whether a
+ * codebase is available in the working directory.
+ */
+export declare function createAdrSystemPrompt(hasCodebase: boolean, projectDir?: string): Promise<string>;
+export declare function buildAdrUserPrompt(adr: AdrRow, context: AdrContext): string;

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

@@ -0,0 +1,35 @@
+import { processConditionals, resolveSkill, } from '../../services/skill-resolver.js';
+/**
+ * Build the ADR agent's system prompt from the bundled (and user-overridable)
+ * `phase/adr-generation` SKILL.md. Conditional blocks are toggled by whether a
+ * codebase is available in the working directory.
+ */
+export async function createAdrSystemPrompt(hasCodebase, projectDir) {
+    const skill = await resolveSkill('phase/adr-generation', { projectDir });
+    if (!skill) {
+        throw new Error('Failed to load skill: phase/adr-generation');
+    }
+    return processConditionals(skill.prompt, { hasCodebase });
+}
+export function buildAdrUserPrompt(adr, context) {
+    const lines = [];
+    lines.push(`# Decision to make\n${adr.title}`);
+    if (adr.generation_prompt && adr.generation_prompt !== adr.title) {
+        lines.push(`\n## Direction from the human\n${adr.generation_prompt}`);
+    }
+    if (adr.context) {
+        lines.push(`\n## Additional context\n${adr.context}`);
+    }
+    lines.push(`\n## ${context.scope === 'product' ? 'Product' : 'Repository'}\n${context.name}${context.description ? `\n${context.description}` : ''}`);
+    if (context.repos.length > 0) {
+        lines.push(`\n## Linked repositories\n${context.repos.join('\n')}`);
+    }
+    if (context.issues.length > 0) {
+        lines.push(`\n## Recent issues (for situational awareness)\n${context.issues
+            .slice(0, 25)
+            .map((i) => `- ${i}`)
+            .join('\n')}`);
+    }
+    lines.push(`\nProduce the options JSON per the output contract. Investigate before answering.`);
+    return lines.join('\n');
+}

package/dist/phases/data-flow/mcp-server.d.ts

@@ -25,8 +25,8 @@ export declare function createSubmitDataFlowTool(state: DataFlowCaptureState): i
         slug: z.ZodString;
         name: z.ZodString;
         kind: z.ZodEnum<{
-            model: "model";
             source: "source";
+            model: "model";
             transform: "transform";
             dataset: "dataset";
             sink: "sink";

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

@@ -0,0 +1,65 @@
+/**
+ * Features phase: clone EVERY repository linked to the product
+ * (product_repositories), ask Claude to catalogue the user-facing features
+ * the product delivers, and persist them via the product_features table.
+ *
+ * Multi-repo: unlike recipes (single primary repo), features are discovered
+ * across the whole product. Repo resolution + cloning is shared with the
+ * diagram phases (cloneDiagramRepos): each repo is cloned into its own
+ * subdirectory of a per-product parent dir, and the agent runs in the
+ * parent so it can explore all of them in one pass.
+ *
+ * Production-grade behaviours layered on top of the basic agent loop
+ * (mirrors the recipes phase):
+ *
+ *   - Heartbeat: `last_heartbeat_at` on the feature_scans row is refreshed
+ *     on every assistant message so the reader can detect stalled / crashed
+ *     runs (see desktop-app/.../services/db/feature-scans.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.
+ *   - Per-call MCP writes: agent commits each create / update / remove as
+ *     it goes. There is no "submit at the end" buffer — partial progress
+ *     survives even if the agent later errors out.
+ */
+import type { SupabaseClient } from '@supabase/supabase-js';
+import { type ClonedRepo } from '../diagram-shared/clone-repos.js';
+import type { FeatureSummary } from './types.js';
+export interface FeaturesPhaseOptions {
+    productId: string;
+    scanId: string;
+    guidance?: string;
+    verbose?: boolean;
+}
+export interface FeaturesPhaseResult {
+    status: 'success' | 'error' | 'cancelled';
+    message: string;
+    counts?: {
+        created: number;
+        updated: number;
+        removed: number;
+    };
+}
+/**
+ * Repo-scope note for the agent's user prompt. Unlike the diagram phases'
+ * describeRepoScope (which asks for one unified flow), this tells the agent
+ * the exact full names it may use in the `repos` field of each feature.
+ */
+export declare function describeFeatureRepoScope(repos: ClonedRepo[]): string;
+export declare function runFeaturesPhase(options: FeaturesPhaseOptions): Promise<FeaturesPhaseResult>;
+export declare function listProductRepositoryIds(supabase: SupabaseClient, productId: string): Promise<string[]>;
+export declare function getScanCreator(supabase: SupabaseClient, scanId: string): Promise<{
+    created_by: string;
+} | null>;
+export declare function listProductFeatures(supabase: SupabaseClient, productId: string): Promise<FeatureSummary[]>;
+/**
+ * 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, scanId: string): Promise<boolean>;
+export declare function heartbeat(supabase: SupabaseClient, scanId: string): Promise<void>;
+export declare function markFailed(supabase: SupabaseClient, scanId: string, errorMessage: string): Promise<boolean>;
+export declare function markSuccess(supabase: SupabaseClient, scanId: string): Promise<boolean>;

package/dist/phases/features/index.js

@@ -0,0 +1,292 @@
+/**
+ * Features phase: clone EVERY repository linked to the product
+ * (product_repositories), ask Claude to catalogue the user-facing features
+ * the product delivers, and persist them via the product_features table.
+ *
+ * Multi-repo: unlike recipes (single primary repo), features are discovered
+ * across the whole product. Repo resolution + cloning is shared with the
+ * diagram phases (cloneDiagramRepos): each repo is cloned into its own
+ * subdirectory of a per-product parent dir, and the agent runs in the
+ * parent so it can explore all of them in one pass.
+ *
+ * Production-grade behaviours layered on top of the basic agent loop
+ * (mirrors the recipes phase):
+ *
+ *   - Heartbeat: `last_heartbeat_at` on the feature_scans row is refreshed
+ *     on every assistant message so the reader can detect stalled / crashed
+ *     runs (see desktop-app/.../services/db/feature-scans.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.
+ *   - Per-call MCP writes: agent commits each create / update / remove as
+ *     it goes. There is no "submit at the end" buffer — partial progress
+ *     survives even if the agent later errors out.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { getSupabase } from '../../supabase/client.js';
+import { logError, logInfo, logSuccess, logWarning, } from '../../utils/logger.js';
+import { cleanupIssueRepo } from '../../workspace/workspace-manager.js';
+import { cloneDiagramRepos, safeDirName, } from '../diagram-shared/clone-repos.js';
+import { fetchProductBasics } from '../find-shared/mcp.js';
+import { createPromptGenerator, extractTextFromContent, } from '../pr-shared/agent-utils.js';
+import { createFeaturesMcpServer, createFeaturesMutationCounts, } from './mcp-server.js';
+import { createFeaturesSystemPrompt, createFeaturesUserPrompt, } from './prompts.js';
+const WORKSPACE_KEY = 'features';
+const MAX_TURNS = 200;
+// 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;
+/**
+ * Repo-scope note for the agent's user prompt. Unlike the diagram phases'
+ * describeRepoScope (which asks for one unified flow), this tells the agent
+ * the exact full names it may use in the `repos` field of each feature.
+ */
+export function describeFeatureRepoScope(repos) {
+    if (repos.length === 1) {
+        return `The working directory is a clone of \`${repos[0].fullName}\`. Use that full name in the \`repos\` field.`;
+    }
+    const list = repos.map((r) => `- ${r.fullName} (subdirectory: ${safeDirName(r.fullName)})`);
+    return [
+        `This product spans ${repos.length} repositories, each cloned into its own subdirectory of the working directory:`,
+        ...list,
+        'Explore all of them. A feature implemented across several repositories is ONE feature listing every repo it touches in `repos` — do not duplicate it per repo.',
+    ].join('\n');
+}
+export async function runFeaturesPhase(options) {
+    const { productId, scanId, guidance, verbose } = options;
+    logInfo(`Starting features scan for product ${productId}`);
+    const supabase = getSupabase();
+    const claimed = await markRunning(supabase, scanId);
+    if (!claimed) {
+        return {
+            status: 'cancelled',
+            message: 'Feature scan row is no longer in a runnable state (likely cancelled before the CLI started)',
+        };
+    }
+    let cleanupDir;
+    let succeeded = false;
+    try {
+        // Every repo linked to the product, in stored order. cloneDiagramRepos
+        // falls back to the product's primary repo when the list is empty
+        // (older single-repo products with no product_repositories rows).
+        const repositoryIds = await listProductRepositoryIds(supabase, productId);
+        const cloned = await cloneDiagramRepos({
+            productId,
+            repositoryIds,
+            workspaceKey: WORKSPACE_KEY,
+            verbose,
+        });
+        if (!cloned.ok) {
+            await markFailed(supabase, scanId, cloned.message);
+            return { status: 'error', message: cloned.message };
+        }
+        ;
+        ({ cleanupDir } = cloned);
+        const [basics, scanMeta, existingFeatures] = await Promise.all([
+            fetchProductBasics(productId),
+            getScanCreator(supabase, scanId),
+            listProductFeatures(supabase, productId),
+        ]);
+        if (!scanMeta) {
+            const msg = 'feature_scans row vanished mid-run; aborting';
+            await markFailed(supabase, scanId, msg);
+            return { status: 'error', message: msg };
+        }
+        const systemPrompt = createFeaturesSystemPrompt();
+        const userPrompt = createFeaturesUserPrompt({
+            productName: basics.name,
+            productDescription: basics.description,
+            guidance,
+            existingFeatures,
+            repoScopeNote: describeFeatureRepoScope(cloned.repos),
+        });
+        const counts = createFeaturesMutationCounts();
+        const mcpServer = createFeaturesMcpServer({
+            supabase,
+            productId,
+            createdBy: scanMeta.created_by,
+        }, counts, existingFeatures);
+        logInfo(`Running Claude agent to identify features across ${cloned.repos.length} repo(s)...`);
+        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: cloned.projectDir,
+                mcpServers: {
+                    features: mcpServer,
+                },
+            },
+        })) {
+            if (message.type === 'assistant') {
+                extractTextFromContent(message.message?.content ?? [], verbose);
+                const now = Date.now();
+                if (now - lastHeartbeatAt >= HEARTBEAT_MIN_INTERVAL_MS) {
+                    lastHeartbeatAt = now;
+                    await heartbeat(supabase, scanId);
+                }
+                continue;
+            }
+            if (message.type !== 'result') {
+                continue;
+            }
+            if (message.subtype !== 'success') {
+                const msg = `Features scan failed: agent ${message.subtype}`;
+                const written = await markFailed(supabase, scanId, msg);
+                return {
+                    status: written ? 'error' : 'cancelled',
+                    message: written
+                        ? msg
+                        : 'Scan was cancelled while the agent was running',
+                    counts,
+                };
+            }
+            const written = await markSuccess(supabase, scanId);
+            if (!written) {
+                return {
+                    status: 'cancelled',
+                    message: 'Scan was cancelled before the result could be written',
+                    counts,
+                };
+            }
+            succeeded = true;
+            const summary = `created ${counts.created}, updated ${counts.updated}, removed ${counts.removed}`;
+            logSuccess(`Features scan complete — ${summary}`);
+            return {
+                status: 'success',
+                message: `Features scan complete (${summary})`,
+                counts,
+            };
+        }
+        const msg = 'Features scan ended without a result message';
+        await markFailed(supabase, scanId, msg);
+        return { status: 'error', message: msg, counts };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Features scan failed: ${errorMessage}`);
+        await markFailed(supabase, scanId, errorMessage);
+        return { status: 'error', message: errorMessage };
+    }
+    finally {
+        if (succeeded) {
+            cleanupIssueRepo(cleanupDir);
+        }
+    }
+}
+// ============================================================================
+// DB helpers — exported for unit tests
+// ============================================================================
+export async function listProductRepositoryIds(supabase, productId) {
+    const { data, error } = await supabase
+        .from('product_repositories')
+        .select('repository_id, position')
+        .eq('product_id', productId)
+        .order('position', { ascending: true });
+    if (error || !data) {
+        return [];
+    }
+    return data.map((r) => r.repository_id);
+}
+export async function getScanCreator(supabase, scanId) {
+    const { data, error } = await supabase
+        .from('feature_scans')
+        .select('created_by')
+        .eq('id', scanId)
+        .maybeSingle();
+    if (error || !data) {
+        return null;
+    }
+    return data;
+}
+export async function listProductFeatures(supabase, productId) {
+    const { data, error } = await supabase
+        .from('product_features')
+        .select('id, name, description, status, source')
+        .eq('product_id', productId)
+        .order('created_at', { ascending: true });
+    if (error || !data) {
+        return [];
+    }
+    return data;
+}
+/**
+ * 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, scanId) {
+    const { data, error } = await supabase
+        .from('feature_scans')
+        .update({
+        status: 'running',
+        error: null,
+        last_heartbeat_at: new Date().toISOString(),
+    })
+        .eq('id', scanId)
+        .in('status', ['pending', 'running'])
+        .select('id')
+        .maybeSingle();
+    if (error) {
+        logWarning(`Could not mark scan as running: ${error.message}`);
+        return false;
+    }
+    return data !== null;
+}
+export async function heartbeat(supabase, scanId) {
+    const { error } = await supabase
+        .from('feature_scans')
+        .update({ last_heartbeat_at: new Date().toISOString() })
+        .eq('id', scanId)
+        .eq('status', 'running');
+    if (error) {
+        logWarning(`Heartbeat failed: ${error.message}`);
+    }
+}
+export async function markFailed(supabase, scanId, errorMessage) {
+    const { data, error } = await supabase
+        .from('feature_scans')
+        .update({
+        status: 'failed',
+        error: errorMessage,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', scanId)
+        .in('status', ['pending', 'running'])
+        .select('id')
+        .maybeSingle();
+    if (error) {
+        logWarning(`Could not mark scan as failed: ${error.message}`);
+        return false;
+    }
+    return data !== null;
+}
+export async function markSuccess(supabase, scanId) {
+    const { data, error } = await supabase
+        .from('feature_scans')
+        .update({
+        status: 'success',
+        error: null,
+        completed_at: new Date().toISOString(),
+    })
+        .eq('id', scanId)
+        .in('status', ['pending', 'running'])
+        .select('id')
+        .maybeSingle();
+    if (error) {
+        logWarning(`Could not mark scan as success: ${error.message}`);
+        return false;
+    }
+    return data !== null;
+}