specrails-desktop 2.36.0 → 2.42.2

package/server/dist/project-git.js

@@ -21,7 +21,7 @@ const GIT_MAX_BUFFER = 4 * 1024 * 1024;
 const COMMIT_SHA_RE = /^[0-9a-f]{40,64}$/i;
 function git(repoDir, args) {
     return new Promise((resolve, reject) => {
-        (0, child_process_1.execFile)('git', args, { cwd: repoDir, env: file_provenance_1.GIT_EXEC_ENV, timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER, windowsHide: true }, (err, stdout, stderr) => {
+        (0, child_process_1.execFile)('git', args, { cwd: repoDir, env: (0, file_provenance_1.gitExecEnv)(), timeout: GIT_TIMEOUT_MS, maxBuffer: GIT_MAX_BUFFER, windowsHide: true }, (err, stdout, stderr) => {
             if (err) {
                 const detail = String(stderr || err.message).trim();
                 reject(new Error(detail));
@@ -56,7 +56,7 @@ function parseWorktreePorcelain(out) {
     return worktrees;
 }
 async function listLocalBranches(repoDir) {
-    const out = await git(repoDir, ['branch', '--format=%(refname:short)']);
+    const out = await git(repoDir, ['branch', '--format=%(refname:lstrip=2)']);
     return out.split('\n').map((b) => b.trim()).filter(Boolean);
 }
 /** Lossless checkout preflight. Unlike the dashboard-oriented aggregate info,
@@ -90,7 +90,7 @@ async function getProjectGitInfo(repoDir) {
     let branch = null;
     let detached = false;
     try {
-        branch = await git(repoDir, ['symbolic-ref', '--short', 'HEAD']);
+        branch = (await git(repoDir, ['symbolic-ref', 'HEAD'])).replace(/^refs\/heads\//, '');
     }
     catch {
         detached = true;
@@ -159,7 +159,7 @@ async function checkoutProjectBranch(repoDir, branch) {
         return { ok: false, error: `Unknown local branch: ${branch}` };
     }
     try {
-        await git(repoDir, ['checkout', branch]);
+        await git(repoDir, ['checkout', '--no-overwrite-ignore', branch]);
         return { ok: true };
     }
     catch (err) {
@@ -192,19 +192,13 @@ async function checkoutProjectReviewBranch(repoDir, branch, expectedSha) {
     if (expected !== null && !COMMIT_SHA_RE.test(expected)) {
         return { ok: false, error: 'The verified delivery commit is invalid; checkout was not attempted.' };
     }
-    let dirty = false;
-    try {
-        // Tracked modifications only — see inspectProjectCheckoutCleanliness.
-        dirty = (await git(repoDir, ['status', '--porcelain', '--untracked-files=no'])) !== '';
-    }
-    catch (err) {
-        return { ok: false, error: err instanceof Error ? err.message : 'git status failed' };
-    }
-    if (dirty)
-        return { ok: false, error: 'Working tree has uncommitted changes. Commit or stash them before checkout.' };
-    // Best effort: refresh remote-tracking refs before deciding whether a branch
-    // can be materialized. Failure degrades to local-only checkout.
-    await git(repoDir, ['fetch', 'origin']).catch(() => { });
+    // Git's checkout transaction preserves compatible staged/unstaged changes
+    // and refuses only paths it would overwrite. A blanket dirty guard prevented
+    // reviewing any delivery while unrelated local edits existed. Include
+    // ignored files in that protection (Git otherwise overwrites them by default).
+    const cleanliness = await inspectProjectCheckoutCleanliness(repoDir);
+    if (!cleanliness.ok)
+        return { ok: false, error: cleanliness.detail };
     let branches;
     try {
         branches = await listLocalBranches(repoDir);
@@ -213,6 +207,10 @@ async function checkoutProjectReviewBranch(repoDir, branch, expectedSha) {
         return { ok: false, error: err instanceof Error ? err.message : 'git failed' };
     }
     try {
+        // A verified local branch needs no network. Refresh only when it must be
+        // materialized from origin, avoiding a fetch timeout on every local handoff.
+        if (!branches.includes(target))
+            await git(repoDir, ['fetch', 'origin']).catch(() => { });
         if (branches.includes(target)) {
             if (expected) {
                 const localSha = (await git(repoDir, ['rev-parse', '--verify', `refs/heads/${target}`])).toLowerCase();
@@ -223,7 +221,7 @@ async function checkoutProjectReviewBranch(repoDir, branch, expectedSha) {
                     };
                 }
             }
-            await git(repoDir, ['checkout', target]);
+            await git(repoDir, ['checkout', '--no-overwrite-ignore', target]);
         }
         else if (await remoteBranchExists(repoDir, target)) {
             if (expected) {
@@ -235,7 +233,7 @@ async function checkoutProjectReviewBranch(repoDir, branch, expectedSha) {
                     };
                 }
             }
-            await git(repoDir, ['checkout', '-b', target, '--track', `origin/${target}`]);
+            await git(repoDir, ['checkout', '--no-overwrite-ignore', '-b', target, '--track', `origin/${target}`]);
         }
         else {
             return { ok: false, error: `Unknown branch: ${target}` };
@@ -247,10 +245,10 @@ async function checkoutProjectReviewBranch(repoDir, branch, expectedSha) {
     if (expected) {
         try {
             const [currentBranch, currentSha] = await Promise.all([
-                git(repoDir, ['rev-parse', '--abbrev-ref', 'HEAD']),
+                git(repoDir, ['symbolic-ref', '--quiet', 'HEAD']),
                 git(repoDir, ['rev-parse', '--verify', 'HEAD']),
             ]);
-            if (currentBranch !== target || currentSha.toLowerCase() !== expected) {
+            if (currentBranch !== `refs/heads/${target}` || currentSha.toLowerCase() !== expected) {
                 return {
                     ok: false,
                     error: `Checkout changed concurrently and did not land on verified delivery ${expected.slice(0, 8)}. No reset or cleanup was performed.`,

package/server/dist/project-registry.js

@@ -10,6 +10,8 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const db_1 = require("./db");
+const project_repositories_1 = require("./project-repositories");
+const multi_repo_execution_store_1 = require("./multi-repo-execution-store");
 const queue_manager_1 = require("./queue-manager");
 const agent_defaults_1 = require("./agent-defaults");
 const chat_manager_1 = require("./chat-manager");
@@ -37,6 +39,13 @@ const workspace_manager_1 = require("./workspace-manager");
 const ticket_store_1 = require("./ticket-store");
 const jira_sync_manager_1 = require("./jira/jira-sync-manager");
 const stuck_run_detector_1 = require("./stuck-run-detector");
+const milestone_progress_1 = require("./milestone-progress");
+const milestone_chain_1 = require("./milestone-chain");
+const internal_api_1 = require("./internal-api");
+const blueprint_render_1 = require("./blueprint-render");
+const worktree_manager_1 = require("./worktree-manager");
+const integration_branch_1 = require("./integration-branch");
+const db_2 = require("./db");
 const loop_run_manager_1 = require("./loop-run-manager");
 const loop_executors_1 = require("./loop-executors");
 const rail_isolated_launch_1 = require("./rail-isolated-launch");
@@ -85,6 +94,9 @@ function reprojectActivePrDeliveries(ctx) {
     return rows.length;
 }
 // ─── ProjectRegistry ──────────────────────────────────────────────────────────
+class ProjectDatabaseBusyError extends Error {
+}
+const PROJECT_LOAD_RETRY_DELAYS_MS = [1000, 2000, 5000, 30000];
 class ProjectRegistry {
     _desktopDb;
     _contexts;
@@ -94,6 +106,8 @@ class ProjectRegistry {
     // M9: projects whose per-project DB failed to load at startup (corrupt, locked,
     // or migration-stuck). They stay registered but have no live context.
     _failedProjects;
+    _loadRetryTimers = new Map();
+    _shuttingDown = false;
     // App-wide shared browser context for "Add Spec from a website": ONE persistent
     // Chromium profile under ~/.specrails/browser-profile, so cookies/logins are
     // shared across every project. Launched lazily, disposed once at shutdown().
@@ -129,21 +143,52 @@ class ProjectRegistry {
             console.error('[project-registry] registry reconcile failed (non-fatal):', err);
         }
         for (const project of projects) {
-            try {
-                this._loadProjectContext(project);
-                this._failedProjects.delete(project.id);
+            this._tryLoadProject(project);
+        }
+    }
+    _tryLoadProject(project, retry = 0) {
+        this._clearLoadRetry(project.id);
+        if (this._shuttingDown)
+            return;
+        try {
+            this._loadProjectContext(project);
+            const recovered = this._failedProjects.delete(project.id);
+            if (recovered) {
+                try {
+                    this._broadcast({ type: 'desktop.project_recovered', projectId: project.id, timestamp: new Date().toISOString() });
+                }
+                catch { /* the available context remains authoritative */ }
             }
-            catch (err) {
-                // M9: a single corrupt / locked / migration-stuck per-project jobs.sqlite
-                // must NOT crash the whole app at startup (previously it did, killing
-                // every other project + the UI in a restart loop). Log it, record it as
-                // failed-to-load, and keep loading the rest.
-                const msg = err instanceof Error ? err.message : String(err);
-                console.error(`[project-registry] failed to load project ${project.id} (${project.slug}): ${msg}`);
-                this._failedProjects.set(project.id, { project, error: msg });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[project-registry] failed to load project ${project.id} (${project.slug}): ${msg}`);
+            this._failedProjects.set(project.id, { project, error: msg });
+            // Only an unopened DB can be retried safely: no managers/watchers or
+            // recovery work exist yet. Corruption and later constructor errors stay
+            // visible without repeatedly constructing partially initialized contexts.
+            if (err instanceof ProjectDatabaseBusyError) {
+                const timer = setTimeout(() => {
+                    this._loadRetryTimers.delete(project.id);
+                    const current = (0, desktop_db_1.getProject)(this._desktopDb, project.id);
+                    if (current)
+                        this._tryLoadProject(current, Math.min(retry + 1, PROJECT_LOAD_RETRY_DELAYS_MS.length - 1));
+                }, PROJECT_LOAD_RETRY_DELAYS_MS[retry]);
+                timer.unref?.();
+                this._loadRetryTimers.set(project.id, timer);
             }
         }
     }
+    _clearLoadRetry(id) {
+        const timer = this._loadRetryTimers.get(id);
+        if (timer)
+            clearTimeout(timer);
+        this._loadRetryTimers.delete(id);
+    }
+    /** The durable catalog includes projects whose DB could not be opened. */
+    listProjects() {
+        return (0, desktop_db_1.listProjects)(this._desktopDb);
+    }
     /** Projects whose per-project DB failed to load at startup (M9). */
     listFailedProjects() {
         return Array.from(this._failedProjects.values());
@@ -217,6 +262,7 @@ class ProjectRegistry {
         }
     }
     removeProject(id) {
+        this._clearLoadRetry(id);
         // Resolve the repo path BEFORE the DB row is deleted below so we can drop the
         // shared artifact-registry entry. Prefer the live context, fall back to the
         // desktop DB row (project may be registered-but-not-loaded, e.g. M9 failure).
@@ -249,6 +295,9 @@ class ProjectRegistry {
                 // deleting the data dir here would make that effect unrecoverable.
                 throw new Error('Project removal deferred: terminal job recovery is still pending');
             }
+            // Persistent history must be removable before deleting project databases
+            // or directories; a storage failure leaves the registered data retryable.
+            (0, transient_children_1.purgeBackgroundProcessHistory)({ projectId: id });
             try {
                 ctx.chatManager.shutdown();
             }
@@ -297,6 +346,10 @@ class ProjectRegistry {
                 ctx.stuckRunDetector.stop();
             }
             catch { /* ignore */ }
+            try {
+                ctx.milestoneProgress?.dispose();
+            }
+            catch { /* ignore */ }
             // Kill any terminal sessions belonging to this project
             try {
                 (0, terminal_manager_1.getTerminalManager)().killAllForProject(id);
@@ -333,6 +386,9 @@ class ProjectRegistry {
             catch { /* ignore */ }
             this._contexts.delete(id);
         }
+        else {
+            (0, transient_children_1.purgeBackgroundProcessHistory)({ projectId: id });
+        }
         // B54: remove the ENTIRE app-managed data dir even when context hydration
         // failed. The persisted row is authoritative for registered-but-not-loaded
         // projects and contains the slug needed for safe cleanup.
@@ -383,12 +439,82 @@ class ProjectRegistry {
     getContext(id) {
         return this._contexts.get(id);
     }
-    getContextByPath(projectPath) {
-        const row = (0, desktop_db_1.getProjectByPath)(this._desktopDb, projectPath);
+    getContextByPath(projectPath, projectId) {
+        const row = (0, project_repositories_1.resolveRepositoryProject)((0, desktop_db_1.listProjects)(this._desktopDb), projectPath, projectId);
         if (!row)
             return undefined;
         return this._contexts.get(row.id);
     }
+    /** Preserve manager closures and shared stores when the repository catalog changes. */
+    refreshProjectRepositories(projectId) {
+        const row = (0, desktop_db_1.getProject)(this._desktopDb, projectId);
+        if (!row)
+            throw new project_repositories_1.RepositoryValidationError('Project not found', 'project_not_found', 404);
+        const context = this._contexts.get(projectId);
+        if (context) {
+            for (const previous of (0, project_repositories_1.getProjectRepositories)(context.project)) {
+                const next = (0, project_repositories_1.getProjectRepositories)(row).find((repository) => repository.id === previous.id);
+                if (!next || next.path !== previous.path) {
+                    try {
+                        context.fileSummaryManager.detachWatcher(projectId, previous.id);
+                    }
+                    catch (err) {
+                        console.warn('[project-registry] repository watcher cleanup failed:', err);
+                    }
+                }
+            }
+            Object.assign(context.project, row);
+        }
+        const failed = this._failedProjects.get(projectId);
+        if (failed)
+            Object.assign(failed.project, row);
+        return context?.project ?? row;
+    }
+    addRepository(projectId, input) {
+        const repository = (0, desktop_db_1.addProjectRepository)(this._desktopDb, projectId, input);
+        this.refreshProjectRepositories(projectId);
+        return repository;
+    }
+    updateRepository(projectId, repositoryId, input) {
+        if (input.path !== undefined) {
+            const project = (0, desktop_db_1.getProject)(this._desktopDb, projectId);
+            if (!project)
+                throw new project_repositories_1.RepositoryValidationError('Project not found', 'project_not_found', 404);
+            const current = (0, project_repositories_1.resolveProjectRepository)(project, repositoryId);
+            if (!current.isPrimary && (0, project_repositories_1.repositoryPathKey)((0, project_repositories_1.canonicalRepositoryPath)(input.path)) === (0, project_repositories_1.repositoryPathKey)((0, project_repositories_1.canonicalRepositoryPath)(current.path))) {
+                input = { ...input };
+                delete input.path;
+            }
+        }
+        if (input.path !== undefined)
+            this._assertRepositoryUnreferenced(projectId, repositoryId);
+        const repository = (0, desktop_db_1.updateProjectRepository)(this._desktopDb, projectId, repositoryId, input);
+        this.refreshProjectRepositories(projectId);
+        return repository;
+    }
+    removeRepository(projectId, repositoryId) {
+        this._assertRepositoryUnreferenced(projectId, repositoryId);
+        (0, desktop_db_1.removeProjectRepository)(this._desktopDb, projectId, repositoryId);
+        this.refreshProjectRepositories(projectId);
+    }
+    _assertRepositoryUnreferenced(projectId, repositoryId) {
+        const project = (0, desktop_db_1.getProject)(this._desktopDb, projectId);
+        if (!project)
+            throw new project_repositories_1.RepositoryValidationError('Project not found', 'project_not_found', 404);
+        const repository = (0, project_repositories_1.resolveProjectRepository)(project, repositoryId);
+        if (repository.isPrimary)
+            throw new project_repositories_1.RepositoryValidationError('The primary repository cannot be removed or relocated here', 'primary_repository_protected', 409);
+        const context = this._contexts.get(projectId);
+        if (!context)
+            throw new project_repositories_1.RepositoryValidationError('Load this project before removing or relocating a repository', 'project_unavailable', 503);
+        const execution = (0, workspace_resolution_1.resolveProjectExecution)({ slug: project.slug, path: project.path });
+        const store = (0, ticket_store_1.readStore)(execution.relocated ? execution.ticketsPath : (0, ticket_store_1.resolveTicketStoragePath)(project.path));
+        const ticketIds = Object.values(store.tickets).filter((ticket) => ticket.repositoryIds?.includes(repositoryId)).map((ticket) => ticket.id);
+        const references = (0, multi_repo_execution_store_1.getRepositoryExecutionReferences)(context.db, repositoryId);
+        if (ticketIds.length || references.runIds.length || references.deliveryIds.length) {
+            throw new project_repositories_1.RepositoryValidationError('Repository is referenced by specs, runs or pending deliveries', 'repository_in_use', 409, { ticketIds, ...references });
+        }
+    }
     listContexts() {
         return Array.from(this._contexts.values());
     }
@@ -400,6 +526,9 @@ class ProjectRegistry {
      * exiting anyway).
      */
     shutdown() {
+        this._shuttingDown = true;
+        for (const id of this._loadRetryTimers.keys())
+            this._clearLoadRetry(id);
         for (const ctx of this._contexts.values()) {
             try {
                 ctx.queueManager.shutdown();
@@ -447,6 +576,10 @@ class ProjectRegistry {
                 ctx.stuckRunDetector.stop();
             }
             catch { /* ignore */ }
+            try {
+                ctx.milestoneProgress?.dispose();
+            }
+            catch { /* ignore */ }
             // Release chokidar watchers + abort in-flight generations so a restart
             // does not leak handles/children — mirror removeProject()'s per-project teardown.
             try {
@@ -473,13 +606,33 @@ class ProjectRegistry {
         // A context is visible synchronously, but no subprocess launch may enter
         // until durable loop callbacks and isolated worktrees have been reconciled.
         (0, process_admission_1.beginProjectProcessQuiescence)(project.id);
-        const db = (0, db_1.initDb)(project.db_path);
+        let db;
+        try {
+            db = (0, db_1.initDb)(project.db_path);
+        }
+        catch (err) {
+            const code = err?.code;
+            if (typeof code === 'string' && /^SQLITE_(BUSY|LOCKED)(_|$)/.test(code)) {
+                throw new ProjectDatabaseBusyError(err instanceof Error ? err.message : String(err), { cause: err });
+            }
+            throw err;
+        }
         // Bind broadcast with projectId so all WS messages carry context.
         // Also wire agent status: when a queued job reaches a terminal state,
         // clear current_job_id on any agent that was assigned to it.
+        // Milestone progress tap (premium-milestone-progress): every project-scoped
+        // broadcast that can change a milestone's counts/rails/chain schedules ONE
+        // debounced `blueprint.milestone_progress` re-derivation. Assigned below,
+        // once the rail maps exist; null until then (startup messages are few).
+        let milestoneProgress = null;
+        let milestoneChains = null;
         const boundBroadcast = (msg) => {
             const enriched = { ...msg, projectId: project.id };
             this._broadcast(enriched);
+            // Chain first: a delivery settle may launch the next chunk (async) and
+            // emit its own `milestone.chain_changed`; the progress tap then coalesces.
+            milestoneChains?.observe(msg);
+            milestoneProgress?.observe(msg);
             if (msg.type === 'queue') {
                 for (const job of msg.jobs) {
                     if (isTerminalJobStatus(job.status)) {
@@ -811,7 +964,7 @@ class ProjectRegistry {
                 }
             },
         });
-        const chatManager = new chat_manager_1.ChatManager(boundBroadcast, db, project.path, project.name, project.provider ?? 'claude', project.id, project.slug);
+        const chatManager = new chat_manager_1.ChatManager(boundBroadcast, db, project.path, project.name, project.provider ?? 'claude', project.id, project.slug, () => (0, project_repositories_1.getProjectRepositories)(project));
         const setupManager = new setup_manager_1.SetupManager(boundBroadcast, (pid, sid) => (0, desktop_db_1.setProjectSetupSession)(this._desktopDb, pid, sid), (pid) => (0, desktop_db_1.clearProjectSetupSession)(this._desktopDb, pid), 
         // LOW-2: resolve the per-project DB so phase-4 setup-chat AI turns record
         // an `ai_invocations` row (surface='setup'). Returns null until the project
@@ -912,11 +1065,11 @@ class ProjectRegistry {
         // byte-identical except for the explicit per-project passthrough overlay.
         // See resolveLoopBaseEnv.
         const loopRunManager = new loop_run_manager_1.LoopRunManager(db, boundBroadcast, (0, loop_executors_1.createLoopExecutors)({
+            pluginScope: () => ({ stateRoot: (0, workspace_resolution_1.resolveProjectExecution)(project).cwd, legacyProviderId: project.provider }),
             env: () => (0, workspace_resolution_1.resolveLoopBaseEnv)({ slug: project.slug, path: project.path }, undefined, (0, project_env_1.applyWorktreeEnvPassthrough)(db, process.env)),
-            // Global Specrails Agents defaults, loop path: per-agent model overrides
-            // ride SPECRAILS_PROFILE_PATH on each ai-step spawn. Resolved per step
-            // (no restart); inert (null) unless the global layer carries per-agent
-            // models for the provider — byte-identical legacy behaviour otherwise.
+            // Named rail profiles and global per-agent defaults ride the same
+            // SPECRAILS_PROFILE_PATH snapshot in both AI transports. An explicit null
+            // rail selection opts out; omitted selections keep Core's default rules.
             profilePathFor: (0, agent_defaults_1.createLoopProfilePathResolver)({
                 desktopDb: this._desktopDb,
                 profileRoot: () => (0, workspace_resolution_1.resolveProjectExecution)({ slug: project.slug, path: project.path }).cwd,
@@ -945,6 +1098,7 @@ class ProjectRegistry {
                     status: t.status,
                     priority: t.priority,
                     labels: t.labels,
+                    repositoryIds: t.repositoryIds,
                     jira_key: t.jira_key ?? null,
                     jira_url: t.jira_url ?? null,
                     openspecChangeName: typeof t.metadata?.openspecChangeName === 'string' ? t.metadata.openspecChangeName : undefined,
@@ -1074,6 +1228,15 @@ class ProjectRegistry {
                 });
                 const delivered = deliver();
                 railLoopRuns.delete(runId);
+                // Milestone chain fallback hook: records the engine outcome (names the
+                // pause reason) and settles delivery-less chunks. Isolated chunks
+                // advance from the later `rail.pr_state` settle instead.
+                try {
+                    milestoneChains?.onRunSettled(runId, effectiveOutcome, opts?.stallReason);
+                }
+                catch (err) {
+                    console.error('[milestone-chain] onRunSettled failed:', err);
+                }
                 for (const ticketId of delivered.changedIds) {
                     const ticket = delivered.store?.tickets[String(ticketId)];
                     if (!ticket)
@@ -1113,7 +1276,96 @@ class ProjectRegistry {
         };
         const stuckRunDetector = new stuck_run_detector_1.StuckRunDetector(project.id, { db }, boundBroadcast);
         stuckRunDetector.start();
-        const ctx = { project, db, queueManager, chatManager, setupManager, proposalManager, agentRefineManager, fileSummaryManager, specLauncherManager, ticketWatcher, browserCaptureManager, jiraSyncManager, stuckRunDetector, broadcast: boundBroadcast, railJobs, loopRunManager, railLoopRuns, onLoopRunFinished, getTicketSpec, desktopDb: this._desktopDb };
+        const blueprintWorkspace = () => (0, milestone_progress_1.resolveBlueprintWorkspace)({ slug: project.slug, path: project.path });
+        // Milestone launch chain (premium-milestone-progress D3): chunks launch
+        // through the app's OWN rails launch route over loopback (the single
+        // authority for every guard) — never by re-implementing the handler.
+        const internalApi = (0, internal_api_1.createInternalApi)({ port: this._desktopPort });
+        const railsBase = `/projects/${project.id}/rails`;
+        milestoneChains = new milestone_chain_1.MilestoneChainManager(db, project.id, {
+            createRail: async (name) => {
+                const r = await internalApi.call('POST', railsBase, { name });
+                const railIndex = r.body?.rail?.railIndex;
+                return r.ok && typeof railIndex === 'number'
+                    ? { ok: true, railIndex }
+                    : { ok: false, status: r.status, ...(0, internal_api_1.internalApiError)(r) };
+            },
+            assignTickets: async (railIndex, ticketIds) => {
+                const r = await internalApi.call('PUT', `${railsBase}/${railIndex}/tickets`, { ticketIds, mode: 'batch-implement' });
+                return r.ok ? { ok: true } : { ok: false, status: r.status, ...(0, internal_api_1.internalApiError)(r) };
+            },
+            launch: async (railIndex, body) => {
+                const r = await internalApi.call('POST', `${railsBase}/${railIndex}/launch`, body);
+                if (!r.ok)
+                    return { ok: false, status: r.status, ...(0, internal_api_1.internalApiError)(r) };
+                const data = (r.body ?? {});
+                const ids = Array.isArray(data.loopRunIds) ? data.loopRunIds
+                    : Array.isArray(data.jobIds) ? data.jobIds
+                        : typeof data.jobId === 'string' ? [data.jobId] : [];
+                return { ok: true, loopRunIds: ids.filter((v) => typeof v === 'string') };
+            },
+            activeDeliveryForRail: (railIndex) => {
+                const row = (0, rail_pr_store_1.getActivePrDeliveryByRail)(db, railIndex);
+                return row ? (0, rail_pr_store_1.toPrDeliverySnapshot)(row) : null;
+            },
+            findRailByName: (name) => {
+                try {
+                    const hit = (0, rails_store_1.getRails)(db).find((r) => r.name === name);
+                    return hit ? hit.railIndex : null;
+                }
+                catch {
+                    return null;
+                }
+            },
+            getDelivery: (id) => {
+                const row = (0, rail_pr_store_1.getPrDelivery)(db, id);
+                return row ? (0, rail_pr_store_1.toPrDeliverySnapshot)(row) : null;
+            },
+            branchExists: async (branch) => {
+                const r = await worktree_manager_1.defaultGitRunner.run(['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], project.path);
+                return r.code === 0;
+            },
+            readTickets: () => {
+                try {
+                    return Object.values((0, ticket_store_1.readStore)(ticketStorePath()).tickets).map((t) => ({ id: t.id, status: t.status, labels: t.labels ?? [] }));
+                }
+                catch {
+                    return [];
+                }
+            },
+            readBlueprint: () => { const ws = blueprintWorkspace(); return ws ? (0, blueprint_render_1.readBlueprint)(ws) : null; },
+            integrationBranch: async () => {
+                try {
+                    return (await (0, integration_branch_1.resolveIntegrationBranch)(worktree_manager_1.defaultGitRunner, { repoDir: project.path, projectSetting: (0, db_2.getProjectSettings)(db).integrationBranch })).branch;
+                }
+                catch {
+                    return null;
+                }
+            },
+            runState: (runId) => {
+                const run = (0, loop_runs_store_1.getLoopRun)(db, runId);
+                if (!run)
+                    return null;
+                return { settled: run.status !== 'running' && run.status !== 'paused', outcome: run.final_outcome ?? null };
+            },
+            broadcast: boundBroadcast,
+        });
+        milestoneProgress = new milestone_progress_1.MilestoneProgressBroadcaster({
+            projectId: project.id,
+            read: () => (0, milestone_progress_1.readMilestoneProgress)({
+                db,
+                projectId: project.id,
+                workspaceDir: blueprintWorkspace,
+                ticketsPath: ticketStorePath,
+                railJobs,
+                railLoopRuns,
+                chains: () => milestoneChains?.listForProgress() ?? [],
+            }),
+            persistDone: (milestoneId) => (0, milestone_progress_1.markMilestoneDone)(blueprintWorkspace(), milestoneId) !== null,
+            broadcast: boundBroadcast,
+        });
+        const ctx = { project, db, queueManager, chatManager, setupManager, proposalManager, agentRefineManager, fileSummaryManager, specLauncherManager, ticketWatcher, browserCaptureManager, jiraSyncManager, stuckRunDetector, broadcast: boundBroadcast, railJobs, loopRunManager, railLoopRuns, onLoopRunFinished, getTicketSpec, desktopDb: this._desktopDb, milestoneProgress };
+        ctx.milestoneChains = milestoneChains;
         this._contexts.set(project.id, ctx);
         const loopRecoveryOk = this._recoverOrphanLoopRuns(project, db, railLoopRuns, onLoopRunFinished, orphanLoopRuns);
         if (loopRecoveryOk) {