specrails-desktop 2.36.0 → 2.42.2

package/server/dist/project-repositories.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryValidationError = void 0;
+exports.repositoryPathKey = repositoryPathKey;
+exports.canonicalRepositoryPath = canonicalRepositoryPath;
+exports.repositoryAvailable = repositoryAvailable;
+exports.legacyRepositoryKind = legacyRepositoryKind;
+exports.getProjectRepositories = getProjectRepositories;
+exports.resolveProjectRepository = resolveProjectRepository;
+exports.validateTicketRepositoryIds = validateTicketRepositoryIds;
+exports.inspectRepositoryPath = inspectRepositoryPath;
+exports.assertDistinctRepositories = assertDistinctRepositories;
+exports.isRepositoryPathWithin = isRepositoryPathWithin;
+exports.resolveRepositoryProject = resolveRepositoryProject;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+class RepositoryValidationError extends Error {
+    code;
+    status;
+    details;
+    constructor(message, code = 'invalid_repository', status = 400, details) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.details = details;
+        this.name = 'RepositoryValidationError';
+    }
+}
+exports.RepositoryValidationError = RepositoryValidationError;
+function repositoryPathKey(value) {
+    const absolute = path_1.default.resolve(value);
+    return process.platform === 'win32' || process.platform === 'darwin' ? absolute.toLowerCase() : absolute;
+}
+function canonicalRepositoryPath(value) {
+    const absolute = path_1.default.resolve(value);
+    let existing = absolute;
+    while (true) {
+        try {
+            return path_1.default.resolve(fs_1.default.realpathSync(existing), path_1.default.relative(existing, absolute));
+        }
+        catch { /* Resolve through the nearest existing parent (e.g. an unsaved src path). */ }
+        const parent = path_1.default.dirname(existing);
+        if (parent === existing)
+            return absolute;
+        existing = parent;
+    }
+}
+function repositoryAvailable(value) {
+    try {
+        return fs_1.default.statSync(value).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Cheap fallback for old fixtures and missing roots; persisted memberships carry the inspected kind. */
+function legacyRepositoryKind(value) {
+    let dir = path_1.default.resolve(value);
+    while (true) {
+        if (fs_1.default.existsSync(path_1.default.join(dir, '.git')))
+            return 'git';
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            return 'folder';
+        dir = parent;
+    }
+}
+function getProjectRepositories(project) {
+    if (project.repositories?.length)
+        return project.repositories;
+    return [{
+            id: `primary-${project.id}`, projectId: project.id,
+            name: project.name ?? path_1.default.basename(project.path), path: project.path, isPrimary: true,
+            kind: legacyRepositoryKind(project.path), integrationBranch: null,
+            addedAt: project.added_at ?? '', available: repositoryAvailable(project.path),
+        }];
+}
+function resolveProjectRepository(project, repositoryId) {
+    const repositories = getProjectRepositories(project);
+    const repository = repositoryId === undefined
+        ? repositories.find((item) => item.isPrimary)
+        : repositories.find((item) => item.id === repositoryId && item.projectId === project.id);
+    if (!repository)
+        throw new RepositoryValidationError('Repository does not belong to this project', 'repository_not_found', 404);
+    return repository;
+}
+function validateTicketRepositoryIds(project, value) {
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.length === 0 || value.some((id) => typeof id !== 'string' || !id.trim())) {
+        throw new RepositoryValidationError('repositoryIds must be a nonempty array of repository IDs', 'invalid_repository_ids');
+    }
+    if (new Set(value).size !== value.length)
+        throw new RepositoryValidationError('repositoryIds must not contain duplicates', 'invalid_repository_ids');
+    for (const id of value) {
+        try {
+            resolveProjectRepository(project, id);
+        }
+        catch {
+            throw new RepositoryValidationError(`Repository ${id} does not belong to this project`, 'invalid_repository_ids');
+        }
+    }
+    return [...value];
+}
+function inspectRepositoryPath(input, requireAvailable = true) {
+    if (!input || typeof input.path !== 'string' || !input.path.trim())
+        throw new RepositoryValidationError('Repository path is required');
+    if (input.name !== undefined && (typeof input.name !== 'string' || !input.name.trim()))
+        throw new RepositoryValidationError('Repository name must not be empty');
+    if (input.integrationBranch !== undefined && input.integrationBranch !== null && (typeof input.integrationBranch !== 'string' || !input.integrationBranch.trim() || /[\r\n\0]/.test(input.integrationBranch))) {
+        throw new RepositoryValidationError('integrationBranch must be a branch name or null');
+    }
+    const canonical = canonicalRepositoryPath(input.path);
+    if (requireAvailable && !repositoryAvailable(canonical))
+        throw new RepositoryValidationError(`Repository directory is unavailable: ${canonical}`, 'repository_unavailable');
+    let gitIdentity = null;
+    if (repositoryAvailable(canonical)) {
+        try {
+            const commonDir = (0, child_process_1.execFileSync)('git', ['-C', canonical, 'rev-parse', '--git-common-dir'], { encoding: 'utf8', timeout: 3000, stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+            gitIdentity = repositoryPathKey(canonicalRepositoryPath(path_1.default.resolve(canonical, commonDir)));
+        }
+        catch { /* Non-Git context folders are supported. */ }
+    }
+    return { ...input, path: canonical, name: input.name?.trim(), integrationBranch: input.integrationBranch?.trim() || null, canonicalKey: repositoryPathKey(canonical), gitIdentity, kind: gitIdentity ? 'git' : 'folder' };
+}
+function assertDistinctRepositories(repositories) {
+    for (let i = 0; i < repositories.length; i++) {
+        for (let j = 0; j < i; j++) {
+            const a = repositories[i], b = repositories[j];
+            const overlapping = isRepositoryPathWithin(a.canonicalKey, b.canonicalKey) || isRepositoryPathWithin(b.canonicalKey, a.canonicalKey);
+            if (overlapping || (a.gitIdentity !== null && a.gitIdentity === b.gitIdentity)) {
+                throw new RepositoryValidationError('Repositories in one project must have distinct, non-overlapping roots and Git identities', 'duplicate_repository', 409);
+            }
+        }
+    }
+}
+function isRepositoryPathWithin(root, candidate) {
+    const relative = path_1.default.relative(repositoryPathKey(root), repositoryPathKey(candidate));
+    return relative === '' || (relative !== '..' && !relative.startsWith(`..${path_1.default.sep}`) && !path_1.default.isAbsolute(relative));
+}
+/** Explicit project context wins; legacy primary matches precede shared secondary matches. */
+function resolveRepositoryProject(projects, inputPath, projectId) {
+    const canonical = canonicalRepositoryPath(inputPath);
+    const candidates = projects.filter((project) => (!projectId || project.id === projectId) && getProjectRepositories(project).some((repo) => isRepositoryPathWithin(canonicalRepositoryPath(repo.path), canonical)));
+    if (projectId)
+        return candidates[0];
+    const primaryMatches = candidates.filter((project) => isRepositoryPathWithin(canonicalRepositoryPath(project.path), canonical));
+    const selected = primaryMatches.length ? primaryMatches : candidates;
+    if (selected.length > 1 && !primaryMatches.length) {
+        throw new RepositoryValidationError('This path belongs to several projects; provide projectId', 'ambiguous_project_path', 409, { projectIds: selected.map((project) => project.id) });
+    }
+    return selected.sort((a, b) => b.path.length - a.path.length)[0];
+}

package/server/dist/project-repository-provenance.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateRepositoryProvenance = migrateRepositoryProvenance;
+exports.provenanceRepositoryFilter = provenanceRepositoryFilter;
+/** Project migration 60. Historical rows belong to the primary repository. */
+function migrateRepositoryProvenance(db) {
+    const columns = db.prepare('PRAGMA table_info(file_provenance)').all();
+    if (!columns.some(column => column.name === 'repository_id')) {
+        db.exec('ALTER TABLE file_provenance ADD COLUMN repository_id TEXT');
+    }
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_file_provenance_repository_path
+    ON file_provenance(repository_id, file_path, at);
+    CREATE INDEX IF NOT EXISTS idx_file_provenance_repository_job
+    ON file_provenance(repository_id, job_id, file_path);`);
+}
+/** Unscoped internal callers retain the project-wide history view. REST/code
+ * callers always supply a resolved member; a missing column never exposes a
+ * primary's historical files as a secondary repository's history. */
+function provenanceRepositoryFilter(db, scope, alias = '') {
+    if (!scope)
+        return { sql: '1 = 1', params: [] };
+    const columns = db.prepare('PRAGMA table_info(file_provenance)').all();
+    if (!columns.some(column => column.name === 'repository_id')) {
+        return { sql: scope.includeLegacy ? '1 = 1' : '0 = 1', params: [] };
+    }
+    const column = `${alias ? `${alias}.` : ''}repository_id`;
+    return {
+        sql: scope.includeLegacy ? `(${column} = ? OR ${column} IS NULL)` : `${column} = ?`,
+        params: [scope.repositoryId],
+    };
+}

package/server/dist/project-router-background-processes.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerBackgroundProcessRoutes = registerBackgroundProcessRoutes;
+const transient_children_1 = require("./transient-children");
+const project_repositories_1 = require("./project-repositories");
+const background_process_service_1 = require("./background-process-service");
+function processQuery(req, res) {
+    const pid = Number(req.params.pid);
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+        res.status(400).json({ error: 'pid must be a positive integer' });
+        return null;
+    }
+    const chatId = typeof req.query.chatId === 'string' ? req.query.chatId.trim() : '';
+    if (!chatId) {
+        res.status(400).json({ error: 'chatId is required' });
+        return null;
+    }
+    const processId = req.query.processId;
+    if (processId !== undefined && (typeof processId !== 'string' || !processId.trim() || processId.length > 200)) {
+        res.status(400).json({ error: 'processId must be a nonempty execution identity' });
+        return null;
+    }
+    return { pid, chatId, ...(typeof processId === 'string' ? { processId } : {}) };
+}
+function registerBackgroundProcessRoutes({ router, ctx }) {
+    router.get('/:projectId/background-processes', (req, res) => {
+        const c = ctx(req);
+        const chatId = typeof req.query.chatId === 'string' && req.query.chatId.trim() ? req.query.chatId.trim() : undefined;
+        res.json({ processes: (0, transient_children_1.listBackgroundProcesses)({ projectId: c.project.id,
+                ...(chatId ? { chatId } : {}), ...(req.query.includeFinished === 'true' ? { includeFinished: true } : {}) }) });
+    });
+    router.get('/:projectId/background-processes/:pid/logs', (req, res) => {
+        const c = ctx(req);
+        const query = processQuery(req, res);
+        if (!query)
+            return;
+        const { pid, ...owner } = query;
+        const limit = req.query.limit === undefined ? undefined : Number(req.query.limit);
+        if (limit !== undefined && (!Number.isSafeInteger(limit) || limit <= 0)) {
+            res.status(400).json({ error: 'limit must be a positive integer' });
+            return;
+        }
+        const logs = (0, transient_children_1.getBackgroundProcessLogs)(pid, { projectId: c.project.id, ...owner, ...(limit !== undefined ? { limit } : {}) });
+        if (!logs) {
+            res.status(404).json({ error: 'background process logs not found for project/chat or execution has expired' });
+            return;
+        }
+        res.json(logs);
+    });
+    router.post('/:projectId/background-processes', (req, res) => {
+        const { command, cwd, chatId, repositoryId, confirmed, allowWhileBusy } = req.body ?? {};
+        const c = ctx(req);
+        if (typeof command !== 'string' || !command.trim()) {
+            res.status(400).json({ error: 'command is required' });
+            return;
+        }
+        if (typeof chatId !== 'string' || !chatId.trim()) {
+            res.status(400).json({ error: 'chatId is required' });
+            return;
+        }
+        if (confirmed !== true) {
+            res.status(400).json({ error: 'confirmed must be true after explicit user confirmation' });
+            return;
+        }
+        try {
+            const busyReason = (0, background_process_service_1.backgroundStartBusyReason)(c);
+            if (busyReason && allowWhileBusy !== true) {
+                res.status(409).json({ error: 'project is busy', reason: busyReason, hint: 'Wait for the running job/loop to finish, or pass allowWhileBusy:true only after explicit user confirmation.' });
+                return;
+            }
+            if (repositoryId !== undefined && (typeof repositoryId !== 'string' || !repositoryId.trim()))
+                throw new project_repositories_1.RepositoryValidationError('repositoryId must be a nonempty string');
+            if ((0, project_repositories_1.getProjectRepositories)(c.project).length > 1 && repositoryId === undefined)
+                throw new project_repositories_1.RepositoryValidationError('repositoryId is required for multi-repository projects', 'repository_required');
+            const repository = (0, project_repositories_1.resolveProjectRepository)(c.project, repositoryId);
+            const process = (0, transient_children_1.startBackgroundProcess)(command.trim(), (0, background_process_service_1.resolveBackgroundCwd)(repository.path, cwd), chatId.trim(), c.project.id, (0, background_process_service_1.backgroundProcessHooks)(c.broadcast), { repositoryId: repository.id, repositoryName: repository.name });
+            res.status(202).json({ ok: true, repositoryId: repository.id, process });
+        }
+        catch (err) {
+            res.status(err instanceof project_repositories_1.RepositoryValidationError ? err.status : 500).json({ error: err instanceof Error ? err.message : 'background process failed to start' });
+        }
+    });
+    router.delete('/:projectId/background-processes/:pid', (req, res) => {
+        const c = ctx(req);
+        const query = processQuery(req, res);
+        if (!query)
+            return;
+        const { pid, ...owner } = query;
+        try {
+            const process = (0, background_process_service_1.stopOwnedBackgroundProcess)(pid, { projectId: c.project.id, ...owner });
+            if (!process) {
+                res.status(404).json({ error: 'background process not found for project/chat or execution identity' });
+                return;
+            }
+            if (process.error && !['stopping', 'exited', 'killed', 'failed'].includes(process.status)) {
+                res.status(500).json({ error: process.error, process });
+                return;
+            }
+            res.status(process.status === 'stopping' ? 202 : 200).json({ ok: true, pid, status: process.status, process });
+        }
+        catch (err) {
+            res.status(err instanceof background_process_service_1.BackgroundProcessOwnershipLostError ? err.status : 500).json({ error: err instanceof Error ? err.message : 'background process could not be stopped' });
+        }
+    });
+}

package/server/dist/project-router-git.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerGitRoutes = registerGitRoutes;
 const project_git_1 = require("./project-git");
@@ -6,31 +9,66 @@ const git_diagnostics_1 = require("./git-diagnostics");
 const pr_publisher_1 = require("./pr-publisher");
 const repo_lock_1 = require("./repo-lock");
 const process_admission_1 = require("./process-admission");
+const project_repositories_1 = require("./project-repositories");
+const node_fs_1 = __importDefault(require("node:fs"));
 // ─── Git domain routes (/api/projects/:projectId/git) ─────────────────────────
 //
 // Backs the Agent-Mode git bar: current branch + last commit + local branches,
-// and a user-initiated branch switch. Git always runs against project.path (the
-// REAL repo — under artifact relocation the workspace never holds the code).
+// and a user-initiated branch switch. Git runs against the selected member's
+// checkout; legacy routes default to the primary, never the artifact workspace.
 function registerGitRoutes(deps) {
     const { router, ctx } = deps;
     const exec = deps.exec ?? pr_publisher_1.defaultExec;
-    router.get('/:projectId/git', async (req, res) => {
+    function selectedRepository(req, res, repositoryId = req.params.repositoryId) {
+        let repository;
         try {
-            res.json(await (0, project_git_1.getProjectGitInfo)(ctx(req).project.path));
+            repository = (0, project_repositories_1.resolveProjectRepository)(ctx(req).project, repositoryId);
+        }
+        catch (err) {
+            res.status(404).json({ error: 'repository_not_found', detail: err.message });
+            return null;
+        }
+        try {
+            if (!node_fs_1.default.statSync(repository.path).isDirectory())
+                throw new Error('not a directory');
+        }
+        catch {
+            res.status(503).json({ error: 'repository_unavailable', repositoryId: repository.id });
+            return null;
+        }
+        return repository;
+    }
+    function requireGit(req, res, repositoryId = req.params.repositoryId) {
+        const repository = selectedRepository(req, res, repositoryId);
+        if (repository?.kind === 'folder') {
+            res.status(409).json({ error: 'repository_is_not_git', repositoryId: repository.id });
+            return null;
+        }
+        return repository;
+    }
+    router.get(['/:projectId/repositories/:repositoryId/git', '/:projectId/git'], async (req, res) => {
+        const repository = selectedRepository(req, res);
+        if (!repository)
+            return;
+        try {
+            res.json({ ...(repository.kind === 'folder' ? { git: false } : await (0, project_git_1.getProjectGitInfo)(repository.path)), repositoryId: repository.id });
         }
         catch (err) {
             console.error('[project-git] info failed:', err);
             res.status(500).json({ error: 'Failed to read git info' });
         }
     });
-    router.get('/:projectId/git/pull-requests/:number', async (req, res) => {
+    router.get(['/:projectId/repositories/:repositoryId/git/pull-requests/:number', '/:projectId/git/pull-requests/:number'], async (req, res) => {
+        const repository = requireGit(req, res);
+        if (!repository)
+            return;
         const prNumber = Number.parseInt(String(req.params.number ?? ''), 10);
         if (!Number.isInteger(prNumber) || prNumber <= 0) {
             res.status(400).json({ error: 'invalid_pull_request_number' });
             return;
         }
         try {
-            const r = await exec.run('gh', ['pr', 'view', String(prNumber), '--json', 'url'], ctx(req).project.path);
+            const r = await exec.run('gh', ['pr', 'view', String(prNumber), '--json', 'url'], repository.path);
             if (r.code !== 0) {
                 res.status(404).json({ error: 'pull_request_not_found' });
                 return;
@@ -40,7 +78,7 @@ function registerGitRoutes(deps) {
                 res.status(404).json({ error: 'pull_request_not_found' });
                 return;
             }
-            res.json({ prNumber, url: parsed.url });
+            res.json({ prNumber, url: parsed.url, repositoryId: repository.id });
         }
         catch (err) {
             console.error('[project-git] pull request lookup failed:', err);
@@ -49,35 +87,56 @@ function registerGitRoutes(deps) {
     });
     // READ-ONLY git/gh diagnostics (backs the specrails_git MCP tool). A fixed
     // allowlist of read-only commands — the query only names an action, never
-    // arguments. Git runs against project.path (the real repo; the workspace never
-    // holds code under relocation).
-    router.get('/:projectId/git/diagnostic', async (req, res) => {
+    // arguments. Validate that allowlist before resolving filesystem state.
+    router.get(['/:projectId/repositories/:repositoryId/git/diagnostic', '/:projectId/git/diagnostic'], async (req, res) => {
         const action = String(req.query.action ?? '');
         if (!(0, git_diagnostics_1.isGitDiagnosticAction)(action)) {
             res.status(400).json({ error: 'invalid_action', allowed: git_diagnostics_1.GIT_DIAGNOSTIC_ACTIONS });
             return;
         }
+        // The legacy diagnostic reports Git's own informative nonzero result for a
+        // primary folder without Git. Explicit context-only members reject Git.
+        const repository = req.params.repositoryId === undefined ? selectedRepository(req, res) : requireGit(req, res);
+        if (!repository)
+            return;
         try {
-            res.json(await (0, git_diagnostics_1.runGitDiagnostic)(action, ctx(req).project.path));
+            res.json({ ...await (0, git_diagnostics_1.runGitDiagnostic)(action, repository.path), repositoryId: repository.id });
         }
         catch (err) {
             console.error('[project-git] diagnostic failed:', err);
             res.status(500).json({ error: 'diagnostic_failed', detail: err instanceof Error ? err.message : String(err) });
         }
     });
-    router.post('/:projectId/git/checkout', async (req, res) => {
+    router.post(['/:projectId/repositories/:repositoryId/git/checkout', '/:projectId/git/checkout'], async (req, res) => {
         const body = (req.body ?? {});
+        const routeRepositoryId = req.params.repositoryId;
+        if (body.repositoryId !== undefined && (typeof body.repositoryId !== 'string' || !body.repositoryId || (routeRepositoryId && body.repositoryId !== routeRepositoryId))) {
+            res.status(400).json({ error: 'invalid_repository_id' });
+            return;
+        }
+        const repositoryId = routeRepositoryId ?? body.repositoryId;
+        const project = ctx(req).project;
+        if (repositoryId === undefined && (0, project_repositories_1.getProjectRepositories)(project).length > 1) {
+            res.status(400).json({ error: 'repository_required', repositories: (0, project_repositories_1.getProjectRepositories)(project).map(({ id, name }) => ({ id, name })) });
+            return;
+        }
+        const repository = requireGit(req, res, repositoryId);
+        if (!repository)
+            return;
         const branch = typeof body.branch === 'string' ? body.branch.trim() : '';
         if (!branch) {
             res.status(400).json({ error: 'branch is required' });
             return;
         }
-        const project = ctx(req).project;
-        const repoDir = project.path;
+        const repoDir = repository.path;
         try {
             const admission = (0, process_admission_1.captureProcessAdmission)(project.id);
-            const result = await (0, repo_lock_1.withRepoLock)(repoDir, () => {
+            const result = await (0, repo_lock_1.withRepoLock)(repoDir, async () => {
                 admission.assertCurrent();
+                const current = (0, project_repositories_1.getProjectRepositories)(ctx(req).project).find(member => member.id === repository.id);
+                if (!current || current.path !== repoDir || current.kind !== 'git') {
+                    return { ok: false, error: 'Repository membership changed; refresh before switching branches.' };
+                }
                 return (0, project_git_1.checkoutProjectBranch)(repoDir, branch);
             });
             if (!result.ok) {
@@ -85,7 +144,7 @@ function registerGitRoutes(deps) {
                 res.status(409).json({ error: result.error });
                 return;
             }
-            res.json(await (0, project_git_1.getProjectGitInfo)(repoDir));
+            res.json({ ...await (0, project_git_1.getProjectGitInfo)(repoDir), repositoryId: repository.id });
         }
         catch (err) {
             if (err instanceof process_admission_1.ProcessAdmissionClosedError) {

package/server/dist/project-router-jobs.js

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerJobsRoutes = registerJobsRoutes;
-const path_1 = __importDefault(require("path"));
 const ids_1 = require("./ids");
 const db_1 = require("./db");
 const queue_manager_1 = require("./queue-manager");
@@ -21,22 +17,8 @@ const loop_runs_store_1 = require("./loop-runs-store");
 const metrics_1 = require("./metrics");
 const job_listing_1 = require("./job-listing");
 const ticket_store_1 = require("./ticket-store");
-const transient_children_1 = require("./transient-children");
+const project_router_background_processes_1 = require("./project-router-background-processes");
 const project_router_helpers_1 = require("./project-router-helpers");
-function backgroundStartBusyReason(c) {
-    const activeJobId = typeof c.queueManager?.getActiveJobId === 'function' ? c.queueManager.getActiveJobId() : null;
-    if (activeJobId)
-        return `job ${activeJobId} is still running`;
-    try {
-        const activeLoops = (0, loop_runs_store_1.listActiveLoopRuns)(c.db, c.project.id);
-        if (activeLoops.length > 0)
-            return `loop run ${activeLoops[0].id} is still running`;
-    }
-    catch {
-        // If the loop table is unavailable in a test harness, do not block startup.
-    }
-    return null;
-}
 function registerJobsRoutes(deps) {
     const { router, registry, ctx, ticketPath } = deps;
     // ─── Queue / Spawn routes ────────────────────────────────────────────────────
@@ -218,113 +200,7 @@ function registerJobsRoutes(deps) {
             },
         });
     });
-    router.get('/:projectId/background-processes', (req, res) => {
-        const c = ctx(req);
-        const chatId = typeof req.query.chatId === 'string' && req.query.chatId.trim() ? req.query.chatId.trim() : undefined;
-        res.json({
-            processes: (0, transient_children_1.listBackgroundProcesses)({
-                projectId: c.project.id,
-                ...(chatId ? { chatId } : {}),
-            }),
-        });
-    });
-    router.get('/:projectId/background-processes/:pid/logs', (req, res) => {
-        const c = ctx(req);
-        const pid = Number(req.params.pid);
-        const chatId = typeof req.query.chatId === 'string' ? req.query.chatId : '';
-        const limit = typeof req.query.limit === 'string' ? Number(req.query.limit) : undefined;
-        if (!Number.isFinite(pid)) {
-            res.status(400).json({ error: 'pid must be numeric' });
-            return;
-        }
-        if (!chatId.trim()) {
-            res.status(400).json({ error: 'chatId is required' });
-            return;
-        }
-        if (limit !== undefined && (!Number.isFinite(limit) || limit <= 0)) {
-            res.status(400).json({ error: 'limit must be a positive number' });
-            return;
-        }
-        const logs = (0, transient_children_1.getBackgroundProcessLogs)(pid, {
-            projectId: c.project.id,
-            chatId: chatId.trim(),
-            ...(limit !== undefined ? { limit } : {}),
-        });
-        if (!logs) {
-            res.status(404).json({ error: 'background process logs not found for project/chat' });
-            return;
-        }
-        res.json(logs);
-    });
-    router.post('/:projectId/background-processes', (req, res) => {
-        const { command, cwd, chatId, confirmed, allowWhileBusy } = req.body ?? {};
-        const c = ctx(req);
-        if (!command || typeof command !== 'string' || !command.trim()) {
-            res.status(400).json({ error: 'command is required' });
-            return;
-        }
-        if (!chatId || typeof chatId !== 'string' || !chatId.trim()) {
-            res.status(400).json({ error: 'chatId is required' });
-            return;
-        }
-        if (confirmed !== true) {
-            res.status(400).json({ error: 'confirmed must be true after explicit user confirmation' });
-            return;
-        }
-        const busyReason = backgroundStartBusyReason(c);
-        if (busyReason && allowWhileBusy !== true) {
-            res.status(409).json({
-                error: 'project is busy',
-                reason: busyReason,
-                hint: 'Wait for the running job/loop to finish, or pass allowWhileBusy:true only after explicit user confirmation.',
-            });
-            return;
-        }
-        const resolvedCwd = path_1.default.resolve(c.project.path, typeof cwd === 'string' && cwd.trim() ? cwd : '.');
-        const root = path_1.default.resolve(c.project.path);
-        if (resolvedCwd !== root && !resolvedCwd.startsWith(root + path_1.default.sep)) {
-            res.status(400).json({ error: 'cwd must stay within the project' });
-            return;
-        }
-        try {
-            const process = (0, transient_children_1.startBackgroundProcess)(command.trim(), resolvedCwd, chatId.trim(), c.project.id, {
-                onStarted: (process) => c.broadcast({
-                    type: 'background_process.started',
-                    process,
-                    projectId: process.projectId,
-                    timestamp: new Date().toISOString(),
-                }),
-                onExited: (process) => c.broadcast({
-                    type: 'background_process.exited',
-                    process,
-                    projectId: process.projectId,
-                    timestamp: new Date().toISOString(),
-                }),
-            });
-            res.status(202).json({ ok: true, process });
-        }
-        catch (err) {
-            res.status(500).json({ error: err instanceof Error ? err.message : 'background process failed to start' });
-        }
-    });
-    router.delete('/:projectId/background-processes/:pid', (req, res) => {
-        const c = ctx(req);
-        const pid = Number(req.params.pid);
-        const chatId = typeof req.query.chatId === 'string' ? req.query.chatId : '';
-        if (!Number.isFinite(pid)) {
-            res.status(400).json({ error: 'pid must be numeric' });
-            return;
-        }
-        if (!chatId.trim()) {
-            res.status(400).json({ error: 'chatId is required' });
-            return;
-        }
-        if (!(0, transient_children_1.killOwnedBackgroundProcess)(pid, { projectId: c.project.id, chatId: chatId.trim() })) {
-            res.status(404).json({ error: 'background process not found for project/chat' });
-            return;
-        }
-        res.json({ ok: true, pid, status: 'killing' });
-    });
+    (0, project_router_background_processes_1.registerBackgroundProcessRoutes)(deps);
     // Returns the resolved default model for Add Spec + the full provider
     // allow-list so the modal can render its picker without maintaining its
     // own copy of the model lists. Source of truth is `server/spec-models.ts`.