@straiffi/archon 1.0.0

package/dist/server/lib/tickets.js

@@ -0,0 +1,981 @@
+import { randomUUID } from 'crypto';
+import db from '../db.js';
+import { getDependencyOrderedBundleTicketIds, getStableBundleExecutionOrder } from './buildSequences.js';
+import { getBundlePullRequestRecord, serializeBundlePullRequest } from './bundlePullRequests.js';
+import { getBuildChainTicketState } from './buildChains.js';
+import { getBoardGitStatus, getBoardWorktreeGitStatus, getGitDiffFiles, getGitStatus, getProjectBranch, getWorktreeDiffStats, getWorktreeGitStatus, resolveExistingWorktreePath, summarizeTicketDiffFiles } from './git.js';
+import { getGitHubConnectionConfig } from './integrations/index.js';
+import { getEffectiveProject, getProjectById, hasProjectRunIde } from './projects.js';
+import { getReviewContextState } from './reviewFindings.js';
+import { hasRunConfig, isRunning } from './run.js';
+import { listTicketMessages, upsertTicketDescriptionMessage } from './ticketMessages.js';
+import { getTicketUndo } from './ticketUndo.js';
+const ticketSelect = `
+  SELECT
+    tickets.*,
+    worktree_bundles.id AS bundle_id,
+    worktree_bundles.name AS bundle_name,
+    worktree_bundles.branch AS bundle_branch,
+    worktree_bundles.kind AS bundle_kind,
+    (
+      SELECT COUNT(*)
+      FROM tickets AS bundle_tickets
+      WHERE bundle_tickets.worktree_bundle_id = worktree_bundles.id
+        AND bundle_tickets.project_id = worktree_bundles.project_id
+    ) AS bundle_ticket_count
+  FROM tickets
+  LEFT JOIN worktree_bundles
+    ON worktree_bundles.id = tickets.worktree_bundle_id
+    AND worktree_bundles.project_id = tickets.project_id
+`;
+const bundleSelect = `
+  SELECT
+    worktree_bundles.*,
+    (
+      SELECT COUNT(*)
+      FROM tickets
+      WHERE tickets.worktree_bundle_id = worktree_bundles.id
+        AND tickets.project_id = worktree_bundles.project_id
+    ) AS ticket_count
+  FROM worktree_bundles
+`;
+const ORDER_STEP = 1000;
+const PROJECT_ROOT_BUNDLE_NAME = 'Project root';
+const PROJECT_ROOT_BUNDLE_BRANCH = '__project_root__';
+const ACTIVE_STATE_ORDER = {
+    plan: 0,
+    build: 1,
+    review: 2,
+};
+const getNextLaneOrder = (projectId, state) => {
+    const rows = db.prepare('SELECT worktree_bundle_id, lane_order FROM tickets WHERE project_id = ? AND state = ? AND parked_at IS NULL ORDER BY lane_order DESC, updated_at DESC, id DESC').all(projectId, state);
+    const normalizeOrder = (value) => Number(value ?? 0);
+    if (rows.length === 0) {
+        return ORDER_STEP;
+    }
+    return normalizeOrder(rows[0].lane_order) + ORDER_STEP;
+};
+const getNextDoneOrder = (projectId) => {
+    const rows = db.prepare('SELECT worktree_bundle_id, done_order FROM tickets WHERE project_id = ? AND parked_at IS NOT NULL ORDER BY done_order DESC, updated_at DESC, id DESC').all(projectId);
+    const normalizeOrder = (value) => Number(value ?? 0);
+    if (rows.length === 0) {
+        return ORDER_STEP;
+    }
+    return normalizeOrder(rows[0].done_order) + ORDER_STEP;
+};
+export const assignTicketLaneOrder = (ticket) => {
+    if (!ticket.project_id) {
+        return null;
+    }
+    return getNextLaneOrder(ticket.project_id, ticket.state);
+};
+export const assignTicketDoneOrder = (ticket) => {
+    if (!ticket.project_id) {
+        return null;
+    }
+    return getNextDoneOrder(ticket.project_id);
+};
+const canAutoParkTicket = (ticket) => {
+    if (ticket.parked_at !== null || ticket.agent_status === 'running') {
+        return false;
+    }
+    if (ticket.state === 'build') {
+        return ticket.agent_status === 'done';
+    }
+    return ticket.state === 'review';
+};
+const shouldClearAutoParkDismissal = (ticket) => {
+    if (ticket.parked_at !== null || ticket.agent_status === 'running') {
+        return false;
+    }
+    if (ticket.is_stale !== true) {
+        return true;
+    }
+    return !canAutoParkTicket(ticket);
+};
+export const reconcileAutoParkDismissal = (ticketId) => {
+    let ticket = getTicket(ticketId);
+    if (!ticket) {
+        return ticket;
+    }
+    if (!ticket.auto_park_dismissed_at || !shouldClearAutoParkDismissal(ticket)) {
+        return ticket;
+    }
+    db.prepare('UPDATE tickets SET auto_park_dismissed_at = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(ticket.id);
+    ticket = getTicket(ticket.id);
+    return ticket;
+};
+export const clearAutoParkDismissalIfNeeded = (ticket) => {
+    if (!ticket?.auto_park_dismissed_at || !shouldClearAutoParkDismissal(ticket)) {
+        return false;
+    }
+    db.prepare('UPDATE tickets SET auto_park_dismissed_at = NULL, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(ticket.id);
+    return true;
+};
+const normalizeBundleRow = (row) => {
+    if (!row) {
+        return null;
+    }
+    return {
+        ...row,
+        kind: row.kind === 'project_root' ? 'project_root' : 'worktree',
+        ticket_count: Number(row.ticket_count ?? 0),
+    };
+};
+const serializeBundle = (row, options = {}) => {
+    if (!row?.bundle_id || !row.bundle_name || !row.bundle_branch) {
+        return null;
+    }
+    const kind = row.bundle_kind === 'project_root' ? 'project_root' : 'worktree';
+    const project = row.project_id ? getProjectById(row.project_id) : null;
+    const branch = kind === 'project_root'
+        ? getProjectBranch(project, { includeDiffStats: false }).branch ?? PROJECT_ROOT_BUNDLE_BRANCH
+        : row.bundle_branch;
+    const hasGitHubConnection = row.project_id
+        ? resolveProjectGitHubConnection(row.project_id, options.githubConnectionCache)
+        : false;
+    const pullRequest = row.project_id
+        ? resolveBundlePullRequest(row.project_id, row.bundle_id, hasGitHubConnection, options.bundlePullRequestCache)
+        : null;
+    return {
+        id: row.bundle_id,
+        name: row.bundle_name,
+        branch,
+        kind,
+        ticket_count: Number(row.bundle_ticket_count ?? 0),
+        pull_request: pullRequest,
+    };
+};
+const parseTicketSkills = (value) => {
+    if (!value) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        return parsed
+            .filter((entry) => typeof entry === 'string')
+            .map(entry => entry.trim())
+            .filter(Boolean)
+            .filter((entry, index, values) => values.indexOf(entry) === index);
+    }
+    catch {
+        return [];
+    }
+};
+const parsePlanningContext = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        if ((parsed.source_kind !== 'single' && parsed.source_kind !== 'multi')
+            || typeof parsed.initiative_prompt !== 'string'
+            || !Array.isArray(parsed.related_ticket_ids)) {
+            return null;
+        }
+        return {
+            source_kind: parsed.source_kind,
+            initiative_prompt: parsed.initiative_prompt,
+            related_ticket_ids: parsed.related_ticket_ids
+                .filter((entry) => typeof entry === 'string')
+                .map(entry => entry.trim())
+                .filter(Boolean)
+                .filter((entry, index, values) => values.indexOf(entry) === index),
+            open_questions: Array.isArray(parsed.open_questions)
+                ? parsed.open_questions
+                    .filter((entry) => typeof entry === 'string')
+                    .map(entry => entry.trim())
+                    .filter(Boolean)
+                    .filter((entry, index, values) => values.indexOf(entry) === index)
+                : [],
+        };
+    }
+    catch {
+        return null;
+    }
+};
+const parseExternalSource = (row) => {
+    if (row.external_provider !== 'jira'
+        || !row.external_id
+        || !row.external_key) {
+        return null;
+    }
+    let metadata = null;
+    if (row.external_metadata_json) {
+        try {
+            const parsed = JSON.parse(row.external_metadata_json);
+            metadata = parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+        }
+        catch {
+            metadata = null;
+        }
+    }
+    return {
+        provider: 'jira',
+        external_id: row.external_id,
+        external_key: row.external_key,
+        external_url: row.external_url ?? null,
+        metadata,
+    };
+};
+export const serializePlanningContext = (context) => {
+    if (!context) {
+        return null;
+    }
+    return JSON.stringify({
+        source_kind: context.source_kind,
+        initiative_prompt: context.initiative_prompt,
+        related_ticket_ids: context.related_ticket_ids,
+        open_questions: context.open_questions,
+    });
+};
+const isReviewFollowUpActive = (row, messages = []) => {
+    if (row.state !== 'review') {
+        return false;
+    }
+    if (row.agent_status !== 'running' && row.agent_status !== 'stopped') {
+        return false;
+    }
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message.role === 'user' && message.kind === 'follow_up') {
+            return true;
+        }
+        if (message.role === 'assistant' && message.kind === 'final_response') {
+            return false;
+        }
+    }
+    return false;
+};
+const getWorkspaceDiffKey = (projectRepoPath, branch) => `${projectRepoPath}::${branch}`;
+const BOARD_ENRICHMENT_CACHE_TTL_MS = 10_000;
+const boardEnrichmentCache = new Map();
+const TICKET_TIMING_ENABLED = process.env.ARCHON_API_TIMING === '1';
+const getCachedBoardEnrichment = (cacheKey) => {
+    const cached = boardEnrichmentCache.get(cacheKey);
+    if (!cached) {
+        return null;
+    }
+    if (Date.now() - cached.cachedAt > BOARD_ENRICHMENT_CACHE_TTL_MS) {
+        boardEnrichmentCache.delete(cacheKey);
+        return null;
+    }
+    return cached;
+};
+export const clearBoardEnrichmentCache = () => {
+    boardEnrichmentCache.clear();
+};
+const shouldIncludeBoardDiffStats = (row, includeDetail, includeDiffStats) => {
+    if (!includeDiffStats) {
+        return false;
+    }
+    if (includeDetail) {
+        return true;
+    }
+    return row.state !== 'plan';
+};
+const shouldResolveStaleGitStatus = (row, includeStaleState) => {
+    if (!includeStaleState) {
+        return false;
+    }
+    if (row.state !== 'build' && row.state !== 'review') {
+        return false;
+    }
+    return row.build_completed_at !== null;
+};
+const getBundlePullRequestCacheKey = (projectId, bundleId) => `${projectId}:${bundleId}`;
+const resolveProjectGitHubConnection = (projectId, cache) => {
+    if (cache?.has(projectId)) {
+        return cache.get(projectId) === true;
+    }
+    const hasConnection = getGitHubConnectionConfig(projectId) !== null;
+    cache?.set(projectId, hasConnection);
+    return hasConnection;
+};
+const resolveBundlePullRequest = (projectId, bundleId, hasGitHubConnection, cache) => {
+    if (!hasGitHubConnection) {
+        return null;
+    }
+    const key = getBundlePullRequestCacheKey(projectId, bundleId);
+    if (cache?.has(key)) {
+        return cache.get(key) ?? null;
+    }
+    const pullRequest = serializeBundlePullRequest(getBundlePullRequestRecord(bundleId, projectId));
+    cache?.set(key, pullRequest);
+    return pullRequest;
+};
+const compareBundleTickets = (left, right) => {
+    const createdAtComparison = left.created_at.localeCompare(right.created_at);
+    if (createdAtComparison !== 0) {
+        return createdAtComparison;
+    }
+    const titleComparison = left.title.localeCompare(right.title, undefined, { sensitivity: 'base' });
+    if (titleComparison !== 0) {
+        return titleComparison;
+    }
+    return left.id.localeCompare(right.id);
+};
+const buildBundleExecutionPositionMap = (tickets) => {
+    const ticketsByBundleId = new Map();
+    for (const ticket of tickets) {
+        if (!ticket.project_id || !ticket.worktree_bundle_id) {
+            continue;
+        }
+        const bundleTickets = ticketsByBundleId.get(ticket.worktree_bundle_id);
+        if (bundleTickets) {
+            bundleTickets.push(ticket);
+            continue;
+        }
+        ticketsByBundleId.set(ticket.worktree_bundle_id, [ticket]);
+    }
+    const executionPositionByTicketId = new Map();
+    for (const [bundleId, bundleTickets] of ticketsByBundleId) {
+        const projectId = bundleTickets[0]?.project_id;
+        if (!projectId) {
+            continue;
+        }
+        const latestExecutionOrder = getStableBundleExecutionOrder(projectId, bundleId);
+        const bundleTicketIds = bundleTickets.map(ticket => ticket.id);
+        const fallbackDependencyOrder = getDependencyOrderedBundleTicketIds(projectId, bundleTicketIds);
+        const fallbackTicketIds = [...bundleTickets]
+            .sort(compareBundleTickets)
+            .map(ticket => ticket.id);
+        const orderedTicketIds = [
+            ...latestExecutionOrder,
+            ...fallbackDependencyOrder,
+            ...fallbackTicketIds,
+        ].filter((ticketId, index, values) => bundleTicketIds.includes(ticketId) && values.indexOf(ticketId) === index);
+        orderedTicketIds.forEach((ticketId, index) => {
+            executionPositionByTicketId.set(ticketId, index);
+        });
+    }
+    return executionPositionByTicketId;
+};
+const applyBundleExecutionPositions = (tickets) => {
+    const bundleExecutionPositionByTicketId = buildBundleExecutionPositionMap(tickets);
+    return tickets.map(ticket => ({
+        ...ticket,
+        bundle_execution_position: bundleExecutionPositionByTicketId.get(ticket.id) ?? ticket.bundle_execution_position ?? null,
+    }));
+};
+const resolveTicketWorktree = (row, projectRepoPath, branch, existingWorktreePaths, worktreeRecordsCache) => {
+    if ('bundle_kind' in row && row.bundle_kind === 'project_root') {
+        return projectRepoPath;
+    }
+    if (!projectRepoPath || !branch) {
+        return null;
+    }
+    const key = getWorkspaceDiffKey(projectRepoPath, branch);
+    if (existingWorktreePaths?.has(key)) {
+        return existingWorktreePaths.get(key) ?? null;
+    }
+    const project = getEffectiveProject(row);
+    const existingWorktreePath = project
+        ? resolveExistingWorktreePath(branch, project, { worktreeRecordsCache })
+        : null;
+    existingWorktreePaths?.set(key, existingWorktreePath);
+    return existingWorktreePath;
+};
+const resolveTicketDiffStats = (row, projectRepoPath, branch, hasWorktree, cache) => {
+    if (!projectRepoPath || !branch || !hasWorktree) {
+        return null;
+    }
+    const key = getWorkspaceDiffKey(projectRepoPath, branch);
+    if (cache?.has(key)) {
+        return cache.get(key) ?? null;
+    }
+    const project = getEffectiveProject(row);
+    const diffStats = project ? getWorktreeDiffStats(branch, project) : null;
+    cache?.set(key, diffStats);
+    return diffStats;
+};
+const resolveTicketGitStatus = (row, projectRepoPath, branch, hasWorktree, cache) => {
+    if (!projectRepoPath || !branch || !hasWorktree) {
+        return null;
+    }
+    const key = getWorkspaceDiffKey(projectRepoPath, branch);
+    if (cache?.has(key)) {
+        return cache.get(key) ?? null;
+    }
+    const project = getEffectiveProject(row);
+    const gitStatus = project ? getWorktreeGitStatus(branch, project) : null;
+    cache?.set(key, gitStatus);
+    return gitStatus;
+};
+const isTicketStale = (ticket, gitStatus, bundle, hasGitHubConnection) => {
+    if (ticket.state !== 'build' && ticket.state !== 'review') {
+        return false;
+    }
+    if (ticket.build_completed_at === null || !gitStatus) {
+        return false;
+    }
+    if (gitStatus.is_dirty !== false || gitStatus.ahead !== 0) {
+        return false;
+    }
+    if (!hasGitHubConnection || !ticket.project_id || !ticket.worktree_bundle_id || isProjectRootBundle(bundle)) {
+        return true;
+    }
+    return bundle?.pull_request?.state === 'merged' || bundle?.pull_request?.state === 'closed';
+};
+export const serializeTicket = (row, options = {}) => {
+    if (!row) {
+        return null;
+    }
+    const { diffStatsCache, gitStatusCache, existingWorktreePaths, worktreeRecordsCache, includeDetail = true, includeMessages = includeDetail, includeLogs = includeDetail, includeUndo = includeDetail, includeDiffStats = includeDetail, includeStaleState = includeDetail, includeWorktreeState = includeDetail, bundleExecutionPositionByTicketId, githubConnectionCache, bundlePullRequestCache, } = options;
+    const project = getEffectiveProject(row);
+    const bundle = serializeBundle(row, {
+        githubConnectionCache,
+        bundlePullRequestCache,
+    });
+    const branch = bundle?.branch ?? row.branch ?? null;
+    const includeResolvedDiffStats = shouldIncludeBoardDiffStats(row, includeDetail, includeDiffStats);
+    const includeResolvedStaleState = shouldResolveStaleGitStatus(row, includeStaleState);
+    const shouldResolveWorktreeState = includeWorktreeState || includeResolvedDiffStats || includeResolvedStaleState;
+    const hasWorktree = (project?.repo_path && branch && shouldResolveWorktreeState)
+        ? resolveTicketWorktree(row, project.repo_path, branch, existingWorktreePaths, worktreeRecordsCache) !== null
+        : undefined;
+    const diffStats = includeResolvedDiffStats
+        ? resolveTicketDiffStats(row, project?.repo_path ?? null, branch, hasWorktree === true, diffStatsCache)
+        : null;
+    const gitStatus = includeResolvedStaleState
+        ? resolveTicketGitStatus(row, project?.repo_path ?? null, branch, hasWorktree === true, gitStatusCache)
+        : null;
+    const messages = includeMessages
+        ? (() => {
+            const storedMessages = listTicketMessages(row.id);
+            return storedMessages.some(message => message.kind === 'description')
+                ? storedMessages
+                : [
+                    {
+                        id: `description:${row.id}`,
+                        ticket_id: row.id,
+                        role: 'user',
+                        kind: 'description',
+                        content: row.description ?? '',
+                        created_at: row.created_at,
+                    },
+                    ...storedMessages,
+                ];
+        })()
+        : undefined;
+    const buildChain = getBuildChainTicketState(row.id);
+    const hasRunConfigValue = project ? hasRunConfig(project) : hasRunConfig();
+    const reviewFollowUpActive = messages ? isReviewFollowUpActive(row, messages) : undefined;
+    const reviewContextState = getReviewContextState({
+        ticketId: row.id,
+        projectId: row.project_id,
+        worktreeBundleId: row.worktree_bundle_id,
+    });
+    const hasGitHubConnection = row.project_id
+        ? resolveProjectGitHubConnection(row.project_id, githubConnectionCache)
+        : false;
+    const canReReview = reviewContextState.hasCompletedReview
+        && reviewContextState.hasFollowUpSinceLastReview
+        && row.agent_status !== 'running';
+    const ticketBase = {
+        id: row.id,
+        title: row.title,
+        description: row.description ?? '',
+        state: row.state,
+        has_completed_review: reviewContextState.hasCompletedReview || undefined,
+        has_follow_up_since_last_review: reviewContextState.hasFollowUpSinceLastReview || undefined,
+        can_re_review: canReReview || undefined,
+        agent_status: row.agent_status,
+        parked_at: row.parked_at,
+        auto_park_dismissed_at: row.auto_park_dismissed_at ?? null,
+        build_completed_at: row.build_completed_at,
+        run_setup_status: row.run_setup_status ?? null,
+        branch: row.branch,
+        tool: row.tool,
+        model: row.model,
+        variant: row.variant,
+        skills: parseTicketSkills(row.skills_json),
+        session_id: row.session_id,
+        planning_session_id: row.planning_session_id,
+        planning_context: parsePlanningContext(row.planning_context_json),
+        worktree_bundle_id: row.worktree_bundle_id,
+        project_id: row.project_id,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        bundle_execution_position: bundleExecutionPositionByTicketId?.get(row.id) ?? null,
+        bundle,
+        is_running: isRunning(row),
+        has_run_config: hasRunConfigValue,
+        has_run_ide: hasProjectRunIde(project),
+        ...(hasWorktree !== undefined ? { has_worktree: hasWorktree } : {}),
+        build_chain: buildChain,
+        external_source: parseExternalSource(row),
+    };
+    const ticketWithOptionalFields = {
+        ...ticketBase,
+        ...(messages ? { messages } : {}),
+        ...(reviewFollowUpActive !== undefined ? { review_follow_up_active: reviewFollowUpActive } : {}),
+        ...(includeLogs ? {
+            agent_log: row.agent_log,
+            streaming_response: row.streaming_response,
+        } : {}),
+        ...(includeResolvedDiffStats ? { diff_stats: diffStats } : {}),
+        ...(includeStaleState ? {
+            is_stale: isTicketStale({
+                state: row.state,
+                build_completed_at: row.build_completed_at,
+                project_id: row.project_id,
+                worktree_bundle_id: row.worktree_bundle_id,
+            }, gitStatus, bundle, hasGitHubConnection),
+        } : {}),
+    };
+    return {
+        ...ticketWithOptionalFields,
+        undo: includeUndo
+            ? getTicketUndo({
+                ...ticketWithOptionalFields,
+                messages: messages ?? [],
+                agent_log: includeLogs ? (row.agent_log ?? null) : null,
+                streaming_response: includeLogs ? (row.streaming_response ?? null) : null,
+            })
+            : undefined,
+    };
+};
+export const listTickets = (projectId, options = {}) => {
+    const detail = options.detail ?? 'full';
+    const includeFullDetail = detail === 'full';
+    const startedAt = performance.now();
+    const diffStatsCache = new Map();
+    const gitStatusCache = new Map();
+    const existingWorktreePaths = new Map();
+    const worktreeRecordsCache = new Map();
+    const githubConnectionCache = new Map();
+    const bundlePullRequestCache = new Map();
+    const rows = projectId === undefined
+        ? db.prepare(`${ticketSelect}
+      ORDER BY
+        CASE WHEN tickets.parked_at IS NULL THEN 0 ELSE 1 END ASC,
+        CASE WHEN tickets.parked_at IS NULL THEN CASE tickets.state
+          WHEN 'plan' THEN ${ACTIVE_STATE_ORDER.plan}
+          WHEN 'build' THEN ${ACTIVE_STATE_ORDER.build}
+          WHEN 'review' THEN ${ACTIVE_STATE_ORDER.review}
+          ELSE 99
+        END ELSE 0 END ASC,
+        CASE WHEN tickets.parked_at IS NULL THEN COALESCE(tickets.lane_order, 0) ELSE COALESCE(tickets.done_order, 0) END DESC,
+        tickets.updated_at DESC,
+        tickets.id DESC`).all()
+        : db.prepare(`${ticketSelect}
+      WHERE tickets.project_id = ?
+      ORDER BY
+        CASE WHEN tickets.parked_at IS NULL THEN 0 ELSE 1 END ASC,
+        CASE WHEN tickets.parked_at IS NULL THEN CASE tickets.state
+          WHEN 'plan' THEN ${ACTIVE_STATE_ORDER.plan}
+          WHEN 'build' THEN ${ACTIVE_STATE_ORDER.build}
+          WHEN 'review' THEN ${ACTIVE_STATE_ORDER.review}
+          ELSE 99
+        END ELSE 0 END ASC,
+        CASE WHEN tickets.parked_at IS NULL THEN COALESCE(tickets.lane_order, 0) ELSE COALESCE(tickets.done_order, 0) END DESC,
+        tickets.updated_at DESC,
+        tickets.id DESC`).all(projectId);
+    const rowsLoadedAt = performance.now();
+    const serializedRows = rows
+        .map(row => serializeTicket(row, {
+        includeDetail: includeFullDetail,
+        includeMessages: includeFullDetail,
+        includeLogs: includeFullDetail,
+        includeUndo: true,
+        includeDiffStats: includeFullDetail,
+        includeStaleState: includeFullDetail,
+        diffStatsCache,
+        gitStatusCache,
+        existingWorktreePaths,
+        worktreeRecordsCache,
+        githubConnectionCache,
+        bundlePullRequestCache,
+    }))
+        .filter((ticket) => ticket !== null);
+    const rowsSerializedAt = performance.now();
+    const tickets = applyBundleExecutionPositions(serializedRows);
+    if (TICKET_TIMING_ENABLED) {
+        console.info('[perf]', JSON.stringify({
+            route: 'listTickets',
+            detail,
+            project_id: projectId,
+            row_count: rows.length,
+            total_ms: Number((performance.now() - startedAt).toFixed(1)),
+            phases: [
+                {
+                    label: 'load_rows',
+                    ms: Number((rowsLoadedAt - startedAt).toFixed(1)),
+                },
+                {
+                    label: 'serialize_rows',
+                    ms: Number((rowsSerializedAt - rowsLoadedAt).toFixed(1)),
+                },
+                {
+                    label: 'apply_bundle_execution_positions',
+                    ms: Number((performance.now() - rowsSerializedAt).toFixed(1)),
+                },
+            ],
+        }));
+    }
+    return tickets;
+};
+export const listBoardTicketEnrichment = (projectId) => {
+    const startedAt = performance.now();
+    const githubConnectionCache = new Map();
+    const bundlePullRequestCache = new Map();
+    const worktreeRecordsCache = new Map();
+    const rows = projectId === undefined
+        ? db.prepare(`${ticketSelect}
+      ORDER BY
+        CASE WHEN tickets.parked_at IS NULL THEN 0 ELSE 1 END ASC,
+        CASE WHEN tickets.parked_at IS NULL THEN CASE tickets.state
+          WHEN 'plan' THEN ${ACTIVE_STATE_ORDER.plan}
+          WHEN 'build' THEN ${ACTIVE_STATE_ORDER.build}
+          WHEN 'review' THEN ${ACTIVE_STATE_ORDER.review}
+          ELSE 99
+        END ELSE 0 END ASC,
+        CASE WHEN tickets.parked_at IS NULL THEN COALESCE(tickets.lane_order, 0) ELSE COALESCE(tickets.done_order, 0) END DESC,
+        tickets.updated_at DESC,
+        tickets.id DESC`).all()
+        : db.prepare(`${ticketSelect}
+      WHERE tickets.project_id = ?
+      ORDER BY
+        CASE WHEN tickets.parked_at IS NULL THEN 0 ELSE 1 END ASC,
+        CASE WHEN tickets.parked_at IS NULL THEN CASE tickets.state
+          WHEN 'plan' THEN ${ACTIVE_STATE_ORDER.plan}
+          WHEN 'build' THEN ${ACTIVE_STATE_ORDER.build}
+          WHEN 'review' THEN ${ACTIVE_STATE_ORDER.review}
+          ELSE 99
+        END ELSE 0 END ASC,
+        CASE WHEN tickets.parked_at IS NULL THEN COALESCE(tickets.lane_order, 0) ELSE COALESCE(tickets.done_order, 0) END DESC,
+        tickets.updated_at DESC,
+        tickets.id DESC`).all(projectId);
+    const rowsLoadedAt = performance.now();
+    let cacheHits = 0;
+    let cacheMisses = 0;
+    let bundleMs = 0;
+    let worktreeMs = 0;
+    let diffStatsMs = 0;
+    let gitStatusMs = 0;
+    const enrichment = rows.map((row) => {
+        const project = getEffectiveProject(row);
+        const projectRepoPath = project?.repo_path ?? null;
+        const branch = row.bundle_kind === 'project_root'
+            ? row.bundle_branch ?? row.branch ?? PROJECT_ROOT_BUNDLE_BRANCH
+            : row.bundle_branch ?? row.branch ?? null;
+        const bundleStartedAt = performance.now();
+        const hasGitHubConnection = row.project_id
+            ? resolveProjectGitHubConnection(row.project_id, githubConnectionCache)
+            : false;
+        const bundle = row.bundle_id
+            ? {
+                kind: row.bundle_kind === 'project_root' ? 'project_root' : 'worktree',
+                pull_request: row.project_id
+                    ? resolveBundlePullRequest(row.project_id, row.bundle_id, hasGitHubConnection, bundlePullRequestCache)
+                    : null,
+            }
+            : null;
+        bundleMs += performance.now() - bundleStartedAt;
+        let hasWorktree = false;
+        let diffStats = null;
+        let gitStatus = null;
+        if (projectRepoPath && branch) {
+            const cacheKey = getWorkspaceDiffKey(projectRepoPath, branch);
+            const cached = getCachedBoardEnrichment(cacheKey);
+            if (cached) {
+                cacheHits += 1;
+                hasWorktree = cached.hasWorktree;
+                diffStats = cached.diffStats;
+                gitStatus = cached.gitStatus;
+            }
+            else {
+                cacheMisses += 1;
+                const worktreeStartedAt = performance.now();
+                if (row.bundle_kind === 'project_root') {
+                    hasWorktree = true;
+                }
+                else {
+                    hasWorktree =
+                        resolveTicketWorktree(row, projectRepoPath, branch, undefined, worktreeRecordsCache) !== null;
+                }
+                worktreeMs += performance.now() - worktreeStartedAt;
+                if (hasWorktree) {
+                    const diffStatsStartedAt = performance.now();
+                    diffStats = row.state === 'plan'
+                        ? null
+                        : row.bundle_kind === 'project_root'
+                            ? summarizeTicketDiffFiles(getGitDiffFiles(projectRepoPath))
+                            : project
+                                ? getWorktreeDiffStats(branch, project)
+                                : null;
+                    diffStatsMs += performance.now() - diffStatsStartedAt;
+                    const gitStatusStartedAt = performance.now();
+                    gitStatus = shouldResolveStaleGitStatus(row, true)
+                        ? row.bundle_kind === 'project_root'
+                            ? getBoardGitStatus(projectRepoPath, null, project)
+                            : project
+                                ? getBoardWorktreeGitStatus(branch, project)
+                                : null
+                        : null;
+                    gitStatusMs += performance.now() - gitStatusStartedAt;
+                }
+                boardEnrichmentCache.set(cacheKey, {
+                    cachedAt: Date.now(),
+                    hasWorktree,
+                    diffStats,
+                    gitStatus,
+                });
+            }
+        }
+        return {
+            id: row.id,
+            diff_stats: diffStats,
+            is_stale: isTicketStale({
+                state: row.state,
+                build_completed_at: row.build_completed_at,
+                project_id: row.project_id,
+                worktree_bundle_id: row.worktree_bundle_id,
+            }, gitStatus, bundle, hasGitHubConnection),
+        };
+    });
+    if (TICKET_TIMING_ENABLED) {
+        console.info('[perf]', JSON.stringify({
+            route: 'listBoardTicketEnrichment',
+            project_id: projectId,
+            row_count: rows.length,
+            total_ms: Number((performance.now() - startedAt).toFixed(1)),
+            cache_hits: cacheHits,
+            cache_misses: cacheMisses,
+            phases: [
+                {
+                    label: 'load_rows',
+                    ms: Number((rowsLoadedAt - startedAt).toFixed(1)),
+                },
+                {
+                    label: 'resolve_bundle_state',
+                    ms: Number(bundleMs.toFixed(1)),
+                },
+                {
+                    label: 'resolve_worktree',
+                    ms: Number(worktreeMs.toFixed(1)),
+                },
+                {
+                    label: 'resolve_diff_stats',
+                    ms: Number(diffStatsMs.toFixed(1)),
+                },
+                {
+                    label: 'resolve_git_status',
+                    ms: Number(gitStatusMs.toFixed(1)),
+                },
+            ],
+        }));
+    }
+    return enrichment;
+};
+export const getTicket = (id) => {
+    const row = db.prepare(`${ticketSelect} WHERE tickets.id = ?`).get(id);
+    const ticket = serializeTicket(row, {
+        includeDetail: true,
+        githubConnectionCache: new Map(),
+        bundlePullRequestCache: new Map(),
+    });
+    if (!ticket) {
+        return null;
+    }
+    if (!ticket.project_id || !ticket.worktree_bundle_id) {
+        return ticket;
+    }
+    const bundleTickets = db.prepare('SELECT id, title, created_at FROM tickets WHERE project_id = ? AND worktree_bundle_id = ?').all(ticket.project_id, ticket.worktree_bundle_id);
+    const bundleTicketIds = bundleTickets.map(entry => entry.id);
+    const latestExecutionOrder = getStableBundleExecutionOrder(ticket.project_id, ticket.worktree_bundle_id);
+    const fallbackDependencyOrder = getDependencyOrderedBundleTicketIds(ticket.project_id, bundleTicketIds);
+    const fallbackTicketIds = [...bundleTickets]
+        .sort(compareBundleTickets)
+        .map(entry => entry.id);
+    const orderedTicketIds = [
+        ...latestExecutionOrder,
+        ...fallbackDependencyOrder,
+        ...fallbackTicketIds,
+    ].filter((ticketId, index, values) => bundleTicketIds.includes(ticketId) && values.indexOf(ticketId) === index);
+    const bundleExecutionPosition = orderedTicketIds.findIndex(ticketId => ticketId === ticket.id);
+    return {
+        ...ticket,
+        bundle_execution_position: bundleExecutionPosition >= 0 ? bundleExecutionPosition : null,
+    };
+};
+export const createTicketRecord = ({ title, description, model, variant, skills, tool, agentStatus, projectId, worktreeBundleId, planningContext, externalSource, }) => {
+    const id = randomUUID();
+    const laneOrder = getNextLaneOrder(projectId, 'plan');
+    const skillsJson = JSON.stringify(skills);
+    db.prepare(`INSERT INTO tickets (
+      id,
+      title,
+      description,
+      model,
+      variant,
+      skills_json,
+      tool,
+      agent_status,
+      worktree_bundle_id,
+      project_id,
+      planning_context_json,
+      lane_order,
+      external_provider,
+      external_id,
+      external_key,
+      external_url,
+      external_metadata_json
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, title.trim(), description, model, variant, skillsJson, tool, agentStatus ?? null, worktreeBundleId ?? null, projectId, serializePlanningContext(planningContext), laneOrder, externalSource?.provider ?? null, externalSource?.external_id ?? null, externalSource?.external_key ?? null, externalSource?.external_url ?? null, externalSource?.metadata ? JSON.stringify(externalSource.metadata) : null);
+    upsertTicketDescriptionMessage(id, description);
+    return getTicket(id);
+};
+export const autoParkTicketIfStale = (ticketId) => {
+    let ticket = reconcileAutoParkDismissal(ticketId);
+    if (!ticket) {
+        return ticket;
+    }
+    if (ticket.is_stale !== true) {
+        return ticket;
+    }
+    const project = getEffectiveProject(ticket);
+    if (!project || !project.auto_park_stale_tickets || !canAutoParkTicket(ticket) || ticket.auto_park_dismissed_at) {
+        return ticket;
+    }
+    db.prepare('UPDATE tickets SET parked_at = CURRENT_TIMESTAMP, done_order = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(assignTicketDoneOrder(ticket) ?? null, ticket.id);
+    return getTicket(ticket.id);
+};
+export const listTicketsInRunContext = (ticket, options = {}) => {
+    if (!ticket) {
+        return [];
+    }
+    if (ticket.worktree_bundle_id) {
+        const includeDetail = options.includeDetail ?? true;
+        const diffStatsCache = new Map();
+        const gitStatusCache = new Map();
+        const existingWorktreePaths = new Map();
+        const worktreeRecordsCache = new Map();
+        const githubConnectionCache = new Map();
+        const bundlePullRequestCache = new Map();
+        const rows = db.prepare(`${ticketSelect} WHERE tickets.worktree_bundle_id = ? AND tickets.project_id = ?
+       ORDER BY
+         CASE WHEN tickets.parked_at IS NULL THEN 0 ELSE 1 END ASC,
+         CASE WHEN tickets.parked_at IS NULL THEN CASE tickets.state
+           WHEN 'plan' THEN ${ACTIVE_STATE_ORDER.plan}
+           WHEN 'build' THEN ${ACTIVE_STATE_ORDER.build}
+           WHEN 'review' THEN ${ACTIVE_STATE_ORDER.review}
+           ELSE 99
+         END ELSE 0 END ASC,
+         CASE WHEN tickets.parked_at IS NULL THEN COALESCE(tickets.lane_order, 0) ELSE COALESCE(tickets.done_order, 0) END DESC,
+         tickets.updated_at DESC,
+         tickets.id DESC`).all(ticket.worktree_bundle_id, ticket.project_id);
+        return applyBundleExecutionPositions(rows
+            .map(row => serializeTicket(row, {
+            includeDetail,
+            includeMessages: options.includeMessages,
+            includeLogs: options.includeLogs,
+            includeUndo: options.includeUndo,
+            includeDiffStats: options.includeDiffStats,
+            includeStaleState: options.includeStaleState,
+            includeWorktreeState: options.includeWorktreeState,
+            diffStatsCache,
+            gitStatusCache,
+            existingWorktreePaths,
+            worktreeRecordsCache,
+            githubConnectionCache,
+            bundlePullRequestCache,
+        }))
+            .filter((entry) => entry !== null));
+    }
+    const resolvedTicket = getTicket(ticket.id);
+    return resolvedTicket ? [resolvedTicket] : [];
+};
+export const listBundles = (projectId) => {
+    const rows = db.prepare(`${bundleSelect} WHERE project_id = ? ORDER BY updated_at DESC, created_at DESC`).all(projectId);
+    const project = getProjectById(projectId);
+    const projectBranch = getProjectBranch(project, { includeDiffStats: false }).branch;
+    return rows
+        .map(row => normalizeBundleRow(row))
+        .filter((row) => row !== null)
+        .map(row => {
+        if (row.kind !== 'project_root') {
+            return row;
+        }
+        return {
+            ...row,
+            branch: projectBranch ?? PROJECT_ROOT_BUNDLE_BRANCH,
+        };
+    });
+};
+export const getBundle = (id, projectId) => {
+    const row = db.prepare(`${bundleSelect} WHERE id = ? AND project_id = ?`).get(id, projectId);
+    return normalizeBundleRow(row);
+};
+export const getBundleByName = (name, projectId) => {
+    const row = db.prepare(`${bundleSelect} WHERE name = ? AND project_id = ?`).get(name, projectId);
+    return normalizeBundleRow(row);
+};
+export const getBundleByBranch = (branch, projectId) => {
+    const row = db.prepare(`${bundleSelect} WHERE branch = ? AND project_id = ?`).get(branch, projectId);
+    return normalizeBundleRow(row);
+};
+export const getBundleRepresentativeTicketContext = (projectId, bundleId) => {
+    return db.prepare(`
+    SELECT id, project_id, worktree_bundle_id
+    FROM tickets
+    WHERE project_id = ?
+      AND worktree_bundle_id = ?
+    ORDER BY rowid ASC
+    LIMIT 1
+  `).get(projectId, bundleId) ?? null;
+};
+export const createBundle = ({ name, branch, projectId }) => {
+    return createBundleRecord({ name, branch, projectId, kind: 'worktree' });
+};
+export const createBundleRecord = ({ name, branch, projectId, kind, }) => {
+    const id = randomUUID();
+    db.prepare('INSERT INTO worktree_bundles (id, name, branch, project_id, kind) VALUES (?, ?, ?, ?, ?)').run(id, name, branch, projectId, kind);
+    return getBundle(id, projectId);
+};
+export const getProjectRootBundle = (projectId) => {
+    const row = db.prepare(`${bundleSelect} WHERE project_id = ? AND kind = 'project_root' LIMIT 1`).get(projectId);
+    return normalizeBundleRow(row);
+};
+export const ensureProjectRootBundle = (projectId) => {
+    const existing = getProjectRootBundle(projectId);
+    if (existing) {
+        return existing;
+    }
+    return createBundleRecord({
+        name: PROJECT_ROOT_BUNDLE_NAME,
+        branch: PROJECT_ROOT_BUNDLE_BRANCH,
+        projectId,
+        kind: 'project_root',
+    });
+};
+export const isProjectRootBundle = (bundle) => bundle?.kind === 'project_root';
+export const isProjectRootBundleId = (bundleId, projectId) => {
+    if (!bundleId || !projectId) {
+        return false;
+    }
+    return getProjectRootBundle(projectId)?.id === bundleId;
+};
+export const getProjectRootBundleName = () => PROJECT_ROOT_BUNDLE_NAME;
+export const deleteBundle = (id, projectId) => {
+    db.prepare('DELETE FROM worktree_bundles WHERE id = ? AND project_id = ?').run(id, projectId);
+};
+export const countBundleTickets = (id, projectId) => {
+    const row = db.prepare('SELECT COUNT(*) AS count FROM tickets WHERE worktree_bundle_id = ? AND project_id = ?').get(id, projectId);
+    return Number(row?.count ?? 0);
+};
+export const isBundledTicket = (ticket) => Boolean(ticket?.worktree_bundle_id);
+export const resolveTicketBranch = (ticket) => ticket?.bundle?.branch ?? ticket?.bundle_branch ?? ticket?.branch ?? null;
+export const resolveTicketContextKey = (ticket) => ticket?.worktree_bundle_id ?? ticket?.id ?? null;
+export const resolveTicketWorkerKey = (ticket, workerKind) => {
+    const contextKey = resolveTicketContextKey(ticket);
+    if (!contextKey) {
+        return null;
+    }
+    return `${workerKind}:${contextKey}`;
+};
+export const resolveTicketTool = (ticket, fallbackTool = 'opencode') => ticket?.tool ?? fallbackTool;
+//# sourceMappingURL=tickets.js.map