specrails-desktop 2.58.0 → 2.59.0

package/server/dist/modules/subscription-usage/adapters/codex.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodexReader = createCodexReader;
+const node_string_decoder_1 = require("node:string_decoder");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const win_spawn_1 = require("../../../util/win-spawn");
+const domain_1 = require("../domain");
+const errors_1 = require("./errors");
+const local_auth_1 = require("./local-auth");
+async function stopProbe(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    await new Promise(resolve => {
+        const done = () => { clearTimeout(timer); child.off('close', done); resolve(); };
+        const timer = setTimeout(() => {
+            if (child.pid)
+                (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGKILL', () => done());
+            else {
+                child.kill('SIGKILL');
+                done();
+            }
+        }, 500);
+        child.once('close', done);
+        child.stdin?.end();
+        if (child.pid)
+            (0, win_spawn_1.treeKillSafe)(child.pid, 'SIGTERM');
+        else
+            child.kill('SIGTERM');
+    });
+}
+function createCodexReader(options = {}) {
+    const home = options.home ?? process.env.CODEX_HOME ?? node_path_1.default.join((0, node_os_1.homedir)(), '.codex');
+    return {
+        async context() {
+            if (!node_path_1.default.isAbsolute(home))
+                throw new errors_1.UsageError('unsupported-platform');
+            return (0, local_auth_1.fingerprint)(`${home}:${await (options.readFile ?? local_auth_1.readAuthFile)(node_path_1.default.join(home, 'auth.json')) ?? 'keychain-or-none'}`);
+        },
+        read(signal) {
+            if (signal.aborted)
+                return Promise.reject(new errors_1.UsageError('aborted'));
+            return new Promise((resolve, reject) => {
+                let child;
+                try {
+                    child = options.spawn ? options.spawn() : (0, win_spawn_1.spawnCli)('codex', ['app-server', '--listen', 'stdio://'], {
+                        cwd: (0, node_os_1.homedir)(), env: { ...process.env, CODEX_HOME: home }, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true,
+                    });
+                }
+                catch {
+                    reject(new errors_1.UsageError('unsupported-cli'));
+                    return;
+                }
+                let buffer = '', finished = false, plan = null, identity;
+                const decoder = new node_string_decoder_1.StringDecoder('utf8');
+                const timer = setTimeout(() => finish(new errors_1.UsageError('probe-timeout', true)), options.timeoutMs ?? 25_000);
+                function cleanup() {
+                    clearTimeout(timer);
+                    signal.removeEventListener('abort', abort);
+                    child.stdout?.off('data', data);
+                    child.stderr?.off('data', drain);
+                    child.off('error', failure);
+                    child.off('close', closed);
+                    child.stdin?.off('error', failure);
+                }
+                function finish(error, result) {
+                    if (finished)
+                        return;
+                    finished = true;
+                    cleanup();
+                    // Continue draining without retaining provider diagnostics during termination.
+                    child.stdout?.resume();
+                    child.stderr?.resume();
+                    void (options.stop ?? stopProbe)(child).then(() => error ? reject(error) : resolve(result), () => reject(new errors_1.UsageError('cleanup-failed', true)));
+                }
+                const abort = () => finish(new errors_1.UsageError('aborted'));
+                const failure = () => finish(new errors_1.UsageError('unsupported-cli'));
+                const closed = () => finish(new errors_1.UsageError('probe-exited', true));
+                const drain = () => { };
+                function send(id, method, params = {}) {
+                    try {
+                        child.stdin?.write(`${JSON.stringify({ id, method, params })}\n`);
+                    }
+                    catch {
+                        failure();
+                    }
+                }
+                function data(chunk) {
+                    buffer += decoder.write(chunk);
+                    if (Buffer.byteLength(buffer) > 1024 * 1024) {
+                        finish(new errors_1.UsageError('invalid-response', true));
+                        return;
+                    }
+                    let newline;
+                    while (!finished && (newline = buffer.indexOf('\n')) >= 0) {
+                        const line = buffer.slice(0, newline);
+                        buffer = buffer.slice(newline + 1);
+                        let message;
+                        try {
+                            message = (0, domain_1.record)(JSON.parse(line));
+                        }
+                        catch {
+                            finish(new errors_1.UsageError('invalid-response', true));
+                            return;
+                        }
+                        if (typeof message.id !== 'number')
+                            continue;
+                        if (message.error) {
+                            const code = (0, domain_1.record)(message.error).code;
+                            finish(new errors_1.UsageError(code === -32601 ? 'unsupported-cli' : 'provider-error', code !== -32601));
+                            return;
+                        }
+                        if (message.id === 1) {
+                            try {
+                                child.stdin?.write(`${JSON.stringify({ method: 'initialized', params: {} })}\n`);
+                            }
+                            catch {
+                                failure();
+                                return;
+                            }
+                            send(2, 'account/read', { refreshToken: false });
+                        }
+                        else if (message.id === 2) {
+                            const account = (0, domain_1.record)((0, domain_1.record)(message.result).account);
+                            if (!Object.keys(account).length) {
+                                finish(undefined, { availability: 'signed-out', windows: [], plan: null, source: null });
+                                return;
+                            }
+                            if (account.type !== 'chatgpt') {
+                                finish(undefined, { availability: 'unsupported-auth', windows: [], plan: null, source: null });
+                                return;
+                            }
+                            plan = typeof account.planType === 'string' ? account.planType.slice(0, 80) : null;
+                            // Never export an email; only an internal fingerprint for identity checks.
+                            if (typeof account.email === 'string')
+                                identity = (0, local_auth_1.fingerprint)(account.email);
+                            send(3, 'account/rateLimits/read');
+                        }
+                        else if (message.id === 3) {
+                            const payload = (0, domain_1.record)(message.result), windows = (0, domain_1.normalizeCodex)(payload);
+                            if (typeof payload.accountId === 'string')
+                                identity = (0, local_auth_1.fingerprint)(payload.accountId);
+                            if (!windows.length) {
+                                finish(new errors_1.UsageError('usage-unavailable'));
+                                return;
+                            }
+                            finish(undefined, { availability: 'available', windows, plan, source: 'app-server', identity });
+                        }
+                    }
+                }
+                signal.addEventListener('abort', abort, { once: true });
+                child.on('error', failure);
+                child.on('close', closed);
+                child.stdin?.on('error', failure);
+                child.stdout?.on('data', data);
+                child.stderr?.on('data', drain);
+                send(1, 'initialize', { clientInfo: { name: 'specrails-subscription-usage', title: 'Specrails', version: '1.0.0' } });
+            });
+        },
+    };
+}

package/server/dist/modules/subscription-usage/adapters/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsageError = void 0;
+class UsageError extends Error {
+    code;
+    retryable;
+    retryMs;
+    constructor(code, retryable = false, retryMs) {
+        super(code);
+        this.code = code;
+        this.retryable = retryable;
+        this.retryMs = retryMs;
+    }
+}
+exports.UsageError = UsageError;

package/server/dist/modules/subscription-usage/adapters/http.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerUsageRoutes = registerUsageRoutes;
+const domain_1 = require("../domain");
+function registerUsageRoutes(router, service) {
+    router.get('/subscription-usage', (_req, res) => res.json(service.snapshot()));
+    router.post('/subscription-usage/refresh', (req, res) => {
+        const body = req.body ?? {};
+        if (typeof body !== 'object' || body === null || Array.isArray(body) || Object.keys(body).some(key => key !== 'providerId' && key !== 'automatic')) {
+            res.status(400).json({ error: 'Invalid usage refresh request' });
+            return;
+        }
+        const { providerId, automatic } = body;
+        if ((providerId !== undefined && !domain_1.USAGE_PROVIDERS.includes(providerId)) || (automatic !== undefined && typeof automatic !== 'boolean')) {
+            res.status(400).json({ error: 'Invalid usage refresh request' });
+            return;
+        }
+        res.status(202).json(service.refresh(providerId, automatic === true));
+    });
+}

package/server/dist/modules/subscription-usage/adapters/local-auth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fingerprint = void 0;
+exports.readAuthFile = readAuthFile;
+exports.limitedJson = limitedJson;
+const promises_1 = require("node:fs/promises");
+const node_crypto_1 = require("node:crypto");
+const errors_1 = require("./errors");
+const fingerprint = (value) => (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
+exports.fingerprint = fingerprint;
+/** Bounded read; never expose auth bytes or paths in errors. */
+async function readAuthFile(file) {
+    let handle;
+    try {
+        handle = await (0, promises_1.open)(file, 'r');
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > 1024 * 1024)
+            throw new errors_1.UsageError('credentials-unreadable');
+        const buffer = Buffer.alloc(1024 * 1024 + 1);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead > 1024 * 1024)
+            throw new errors_1.UsageError('credentials-unreadable');
+        return buffer.toString('utf8', 0, bytesRead);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new errors_1.UsageError('credentials-unreadable');
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function limitedJson(response) {
+    const reader = response.body?.getReader();
+    if (!reader)
+        throw new errors_1.UsageError('invalid-response', true);
+    let size = 0;
+    const chunks = [];
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > 1024 * 1024)
+                throw new errors_1.UsageError('invalid-response', true);
+            chunks.push(value);
+        }
+        try {
+            return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        }
+        catch {
+            throw new errors_1.UsageError('invalid-response', true);
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}

package/server/dist/modules/subscription-usage/application.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFreshness = withFreshness;
+exports.backoff = backoff;
+function withFreshness(row, now) {
+    if (!row.observedAt)
+        return { ...row, freshness: 'unknown' };
+    const expired = now - Date.parse(row.observedAt) >= 300_000 || row.windows.some(w => w.resetsAt && Date.parse(w.resetsAt) <= now);
+    return { ...row, freshness: expired || row.refreshState === 'error' ? 'stale' : 'fresh' };
+}
+function backoff(failures) { return Math.min(300_000, 30_000 * 2 ** Math.min(4, Math.max(0, failures - 1))); }

package/server/dist/modules/subscription-usage/domain.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.duration = exports.percentage = exports.record = exports.USAGE_PROVIDERS = void 0;
+exports.timestamp = timestamp;
+exports.windowLabel = windowLabel;
+exports.normalizeClaude = normalizeClaude;
+exports.normalizeCodex = normalizeCodex;
+exports.initialUsage = initialUsage;
+exports.USAGE_PROVIDERS = ['claude', 'codex'];
+const record = (value) => value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {};
+exports.record = record;
+const percentage = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100 ? value : null;
+exports.percentage = percentage;
+const duration = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
+exports.duration = duration;
+function timestamp(value, seconds = false) {
+    const time = typeof value === 'number' && Number.isFinite(value) ? value * (seconds ? 1000 : 1) : typeof value === 'string' ? Date.parse(value) : NaN;
+    return Number.isFinite(time) && time > 0 && time <= 8.64e15 ? new Date(time).toISOString() : null;
+}
+function windowLabel(minutes) {
+    return minutes === 300 ? 'session' : minutes === 10080 ? 'weekly' : minutes === 43200 ? 'monthly' : 'window';
+}
+function normalizeClaude(payload) {
+    const data = (0, exports.record)(payload);
+    const windows = [];
+    for (const [key, raw] of Object.entries(data)) {
+        if (!/^(five_hour|seven_day(?:_[a-z0-9_]+)?|fable_(weekly|seven_day))$/.test(key) || raw === null)
+            continue;
+        const value = (0, exports.record)(raw);
+        if (!['utilization', 'used_percentage', 'resets_at'].some(field => Object.hasOwn(value, field)))
+            continue;
+        const minutes = key === 'five_hour' ? 300 : 10080;
+        const model = key.startsWith('seven_day_') ? key.slice(10) : key.startsWith('fable_') ? 'fable' : null;
+        windows.push({ id: key, label: windowLabel(minutes), scope: model ? 'model' : 'account', model,
+            usedPercent: (0, exports.percentage)(value.utilization ?? value.used_percentage), durationMinutes: minutes, resetsAt: timestamp(value.resets_at, typeof value.resets_at === 'number') });
+    }
+    if (Array.isArray(data.limits))
+        for (const raw of data.limits.slice(0, 32)) {
+            const value = (0, exports.record)(raw), model = (0, exports.record)((0, exports.record)(value.scope).model).display_name;
+            if (value.kind !== 'weekly_scoped' || typeof model !== 'string' || !model.trim())
+                continue;
+            const name = model.trim().slice(0, 80);
+            if (windows.some(w => w.model?.toLowerCase() === name.toLowerCase()))
+                continue;
+            windows.push({ id: `model:${name}`, label: 'weekly', scope: 'model', model: name,
+                usedPercent: (0, exports.percentage)(value.percent), durationMinutes: 10080, resetsAt: timestamp(value.resets_at, true) });
+        }
+    return windows;
+}
+function normalizeCodex(payload) {
+    const data = (0, exports.record)(payload), groups = (0, exports.record)(data.rateLimitsByLimitId);
+    const entries = Object.keys(groups).length ? Object.entries(groups) : [['codex', data.rateLimits]];
+    const windows = [];
+    for (const [group, raw] of entries.slice(0, 32)) {
+        const bucket = (0, exports.record)(raw);
+        for (const slot of ['primary', 'secondary']) {
+            if (!bucket[slot] || typeof bucket[slot] !== 'object')
+                continue;
+            const value = (0, exports.record)(bucket[slot]), minutes = (0, exports.duration)(value.windowDurationMins);
+            windows.push({ id: `${group}:${slot}`, label: windowLabel(minutes), scope: group === 'codex' ? 'account' : 'model',
+                model: group === 'codex' ? null : (typeof bucket.limitName === 'string' ? bucket.limitName : group).slice(0, 80),
+                usedPercent: (0, exports.percentage)(value.usedPercent), durationMinutes: minutes, resetsAt: timestamp(value.resetsAt, true) });
+        }
+    }
+    return windows;
+}
+function initialUsage(providerId, generation) {
+    return { providerId, installed: null, generation, availability: 'unavailable', refreshState: 'idle', freshness: 'unknown', plan: null,
+        windows: [], source: null, observedAt: null, attemptedAt: null, retryAt: null, issue: null };
+}

package/server/dist/modules/subscription-usage/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/dist/modules/subscription-usage/ports.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/dist/modules/subscription-usage/runtime/composition.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDesktopUsageService = createDesktopUsageService;
+const provider_detection_1 = require("../../../provider-detection");
+const claude_1 = require("../adapters/claude");
+const codex_1 = require("../adapters/codex");
+const usage_service_1 = require("./usage-service");
+function createDesktopUsageService() {
+    return (0, usage_service_1.createUsageService)({
+        installed: async (id) => {
+            const provider = (await (0, provider_detection_1.getDetectionSnapshot)()).providers[id];
+            return !!provider?.installed;
+        },
+        eligible: async (id) => {
+            const provider = (await (0, provider_detection_1.getDetectionSnapshot)()).providers[id];
+            return !!provider?.executable && provider.meetsMinimum !== false && !provider.vetoed;
+        },
+        readers: { claude: (0, claude_1.createClaudeReader)(), codex: (0, codex_1.createCodexReader)() },
+    });
+}

package/server/dist/modules/subscription-usage/runtime/usage-service.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUsageService = createUsageService;
+const node_crypto_1 = require("node:crypto");
+const domain_1 = require("../domain");
+const application_1 = require("../application");
+const errors_1 = require("../adapters/errors");
+function createUsageService(deps) {
+    const now = deps.now ?? Date.now;
+    const instanceId = (0, node_crypto_1.randomUUID)();
+    const rows = new Map(domain_1.USAGE_PROVIDERS.map(id => [id, (0, domain_1.initialUsage)(id, (0, node_crypto_1.randomUUID)())]));
+    const contexts = new Map(), identities = new Map();
+    const failures = new Map(), running = new Map();
+    const controllers = new Map();
+    let revision = 0, disposed = false;
+    function snapshot() { return { scope: 'machine', instanceId, revision, providers: domain_1.USAGE_PROVIDERS.map(id => (0, application_1.withFreshness)(rows.get(id), now())) }; }
+    function clear(id) {
+        const previous = rows.get(id);
+        rows.set(id, { ...(0, domain_1.initialUsage)(id, (0, node_crypto_1.randomUUID)()), installed: previous.installed, attemptedAt: previous.attemptedAt, refreshState: previous.refreshState });
+        identities.delete(id);
+        revision++;
+    }
+    async function collect(id, signal) {
+        const reader = deps.readers[id];
+        try {
+            const installed = await deps.installed(id);
+            if (signal.aborted)
+                return;
+            rows.set(id, { ...rows.get(id), installed });
+            if (!installed) {
+                clear(id);
+                rows.set(id, { ...rows.get(id), refreshState: 'idle', retryAt: new Date(now() + 30_000).toISOString(), issue: { code: 'cli-missing', retryable: false } });
+                return;
+            }
+            if (deps.eligible && !await deps.eligible(id))
+                throw new errors_1.UsageError('unsupported-cli');
+            if (signal.aborted)
+                return;
+            const before = await reader.context(signal);
+            if (signal.aborted)
+                return;
+            if (contexts.get(id) !== before) {
+                clear(id);
+                contexts.set(id, before);
+            }
+            const result = await reader.read(signal);
+            const after = await reader.context(signal);
+            if (signal.aborted)
+                return;
+            if (before !== after) {
+                clear(id);
+                contexts.set(id, after);
+                throw new errors_1.UsageError('account-changed', true);
+            }
+            if (result.identity && identities.get(id) && identities.get(id) !== result.identity)
+                clear(id);
+            if (result.identity)
+                identities.set(id, result.identity);
+            const available = result.availability === 'available';
+            if (!available)
+                clear(id);
+            rows.set(id, { ...rows.get(id), availability: result.availability, plan: result.plan, source: result.source, windows: available ? result.windows : [],
+                // Identity is internal: explicitly select fields instead of returning adapter metadata.
+                providerId: id, installed: true, refreshState: 'idle', freshness: available ? 'fresh' : 'unknown',
+                observedAt: available ? new Date(now()).toISOString() : null, retryAt: new Date(now() + 30_000).toISOString(),
+                issue: available ? null : { code: result.availability, retryable: false } });
+            failures.delete(id);
+        }
+        catch (error) {
+            if (signal.aborted)
+                return;
+            const issue = error instanceof errors_1.UsageError ? error : new errors_1.UsageError('collection-failed', true);
+            const count = (failures.get(id) ?? 0) + 1;
+            failures.set(id, count);
+            if (!issue.retryable)
+                clear(id);
+            const row = rows.get(id);
+            rows.set(id, { ...row, refreshState: 'error', availability: row.observedAt ? 'available' : (['signed-out', 'unsupported-cli', 'unsupported-platform', 'unsupported-auth'].includes(issue.code) ? issue.code : 'unavailable'),
+                issue: { code: issue.code, retryable: issue.retryable }, retryAt: new Date(now() + (issue.retryMs ?? (0, application_1.backoff)(count))).toISOString() });
+        }
+        finally {
+            revision++;
+        }
+    }
+    function refresh(providerId, automatic = false) {
+        let scheduled = false;
+        if (!disposed)
+            for (const id of providerId ? [providerId] : domain_1.USAGE_PROVIDERS) {
+                const row = rows.get(id);
+                if (running.has(id)) {
+                    scheduled = true;
+                    continue;
+                }
+                if (row.retryAt && Date.parse(row.retryAt) > now())
+                    continue;
+                if (automatic && row.issue && !row.issue.retryable)
+                    continue;
+                const controller = new AbortController();
+                controllers.set(id, controller);
+                rows.set(id, { ...row, attemptedAt: new Date(now()).toISOString(), refreshState: 'refreshing' });
+                revision++;
+                scheduled = true;
+                const task = collect(id, controller.signal).finally(() => { running.delete(id); controllers.delete(id); });
+                running.set(id, task);
+            }
+        const view = snapshot();
+        return { snapshot: view, scheduled, retryAt: view.providers.filter(p => !providerId || p.providerId === providerId).map(p => p.retryAt).filter((s) => !!s).sort()[0] ?? null };
+    }
+    async function dispose() { disposed = true; controllers.forEach(c => c.abort()); await Promise.allSettled(running.values()); }
+    return { snapshot, refresh, dispose, settled: () => Promise.allSettled(running.values()) };
+}

package/server/dist/project-registry.js

@@ -494,6 +494,15 @@ class ProjectRegistry {
                 delete input.path;
             }
         }
+        if (input.workspacePath !== undefined || input.workspacePaths !== undefined) {
+            const context = this._contexts.get(projectId);
+            if (!context)
+                throw new project_repositories_1.RepositoryValidationError('Load this project before changing its workspace', 'project_unavailable', 503);
+            const references = (0, multi_repo_execution_store_1.getRepositoryExecutionReferences)(context.db, repositoryId);
+            const unfinished = context.db.prepare("SELECT id FROM loop_runs WHERE status <> 'completed' LIMIT 1").get();
+            if (unfinished || references.runIds.length || references.deliveryIds.length)
+                throw new project_repositories_1.RepositoryValidationError('Workspace is referenced by runs or pending deliveries', 'repository_in_use', 409, references);
+        }
         if (input.path !== undefined)
             this._assertRepositoryUnreferenced(projectId, repositoryId);
         const repository = (0, desktop_db_1.updateProjectRepository)(this._desktopDb, projectId, repositoryId, input);
@@ -1108,7 +1117,8 @@ class ProjectRegistry {
         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 }),
             // A project registered as a package of a larger checkout scopes Core to that package in isolated worktrees.
-            sourcePath: () => project.path,
+            sourcePath: () => (0, project_repositories_1.resolveProjectRepository)(project).path,
+            workspacePaths: () => { const primary = (0, project_repositories_1.resolveProjectRepository)(project); return primary.workspacePaths ?? (primary.workspacePath ? [primary.workspacePath] : undefined); },
             env: () => (0, workspace_resolution_1.resolveLoopBaseEnv)({ slug: project.slug, path: project.path }, undefined, (0, project_env_1.applyWorktreeEnvPassthrough)(db, process.env)),
             // Named rail profiles and global per-agent defaults ride the same
             // SPECRAILS_PROFILE_PATH snapshot in both AI transports. An explicit null
@@ -1363,6 +1373,11 @@ class ProjectRegistry {
                         : typeof data.jobId === 'string' ? [data.jobId] : [];
                 return { ok: true, loopRunIds: ids.filter((v) => typeof v === 'string') };
             },
+            integrateDelivery: async (delivery) => {
+                const action = delivery.decision === 'no_changes' ? 'acknowledge-no-changes' : 'merge-local';
+                const r = await internalApi.call('POST', `${railsBase}/pr-decision`, { prDeliveryId: delivery.id, expectedDecision: delivery.decision, action });
+                return r.ok ? { ok: true } : { ok: false, status: r.status, ...(0, internal_api_1.internalApiError)(r) };
+            },
             activeDeliveryForRail: (railIndex) => {
                 const row = (0, rail_pr_store_1.getActivePrDeliveryByRail)(db, railIndex);
                 return row ? (0, rail_pr_store_1.toPrDeliverySnapshot)(row) : null;

package/server/dist/project-repositories.js

@@ -15,6 +15,7 @@ exports.inspectRepositoryPath = inspectRepositoryPath;
 exports.assertDistinctRepositories = assertDistinctRepositories;
 exports.isRepositoryPathWithin = isRepositoryPathWithin;
 exports.resolveRepositoryProject = resolveRepositoryProject;
+exports.validateWorkspaceSelection = validateWorkspaceSelection;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
@@ -117,6 +118,33 @@ function inspectRepositoryPath(input, requireAvailable = true) {
     const canonical = canonicalRepositoryPath(input.path);
     if (requireAvailable && !repositoryAvailable(canonical))
         throw new RepositoryValidationError(`Repository directory is unavailable: ${canonical}`, 'repository_unavailable');
+    if (input.workspacePath != null && input.workspacePaths != null)
+        throw new RepositoryValidationError('Use workspacePaths or workspacePath, not both', 'invalid_workspace_path');
+    let workspacePaths;
+    if (input.workspacePaths !== undefined && input.workspacePaths !== null) {
+        if (!Array.isArray(input.workspacePaths) || !input.workspacePaths.length || input.workspacePaths.some(item => typeof item !== 'string' || !item.trim()))
+            throw new RepositoryValidationError('workspacePaths must be a nonempty array of workspace directories');
+        workspacePaths = input.workspacePaths.map(item => inspectRepositoryPath({ path: canonical, workspacePath: item }, requireAvailable).workspacePath);
+        if (new Set(workspacePaths.map(repositoryPathKey)).size !== workspacePaths.length || workspacePaths.some((root, index) => workspacePaths.some((other, otherIndex) => index !== otherIndex && isRepositoryPathWithin(root, other))))
+            throw new RepositoryValidationError('Code workspaces must have distinct non-overlapping directories', 'invalid_workspace_path');
+    }
+    let workspacePath;
+    if (input.workspacePath !== undefined && input.workspacePath !== null) {
+        if (typeof input.workspacePath !== 'string' || !input.workspacePath.trim())
+            throw new RepositoryValidationError('Workspace path must not be empty');
+        workspacePath = canonicalRepositoryPath(path_1.default.resolve(canonical, input.workspacePath));
+        if (!isRepositoryPathWithin(canonical, workspacePath))
+            throw new RepositoryValidationError('Workspace must be inside its registered repository', 'invalid_workspace_path');
+        if (requireAvailable && !repositoryAvailable(workspacePath))
+            throw new RepositoryValidationError(`Workspace directory is unavailable: ${workspacePath}`, 'workspace_unavailable');
+        // A nested independent Git checkout needs its own membership and delivery.
+        if (workspacePath !== canonical) {
+            for (let current = workspacePath; current !== canonical; current = path_1.default.dirname(current)) {
+                if (fs_1.default.existsSync(path_1.default.join(current, '.git')))
+                    throw new RepositoryValidationError('A nested Git repository must be registered as a separate workspace', 'invalid_workspace_path');
+            }
+        }
+    }
     let gitIdentity = null;
     if (repositoryAvailable(canonical)) {
         try {
@@ -125,14 +153,15 @@ function inspectRepositoryPath(input, requireAvailable = true) {
         }
         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' };
+    return { ...input, workspacePath, workspacePaths, 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)) {
+            const container = (a.kind === 'folder' && b.kind === 'git' && isRepositoryPathWithin(a.canonicalKey, b.canonicalKey)) || (b.kind === 'folder' && a.kind === 'git' && isRepositoryPathWithin(b.canonicalKey, a.canonicalKey));
+            if ((overlapping && !container) || (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);
             }
         }
@@ -155,3 +184,23 @@ function resolveRepositoryProject(projects, inputPath, projectId) {
     }
     return selected.sort((a, b) => b.path.length - a.path.length)[0];
 }
+/** A launch may narrow registered code workspaces, never invent new targets. */
+function validateWorkspaceSelection(project, value, repositoryIds) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value) || !Object.keys(value).length)
+        throw new RepositoryValidationError('workspaceSelection must map repository IDs to nonempty workspace path arrays', 'invalid_workspace_selection');
+    const entries = Object.entries(value).map(([id, paths]) => {
+        if (!repositoryIds.includes(id))
+            throw new RepositoryValidationError('Workspace selection refers to an unselected repository', 'invalid_workspace_selection');
+        const repository = resolveProjectRepository(project, id);
+        if (!Array.isArray(paths) || !paths.length || paths.some(item => typeof item !== 'string' || !item.trim()))
+            throw new RepositoryValidationError('Select at least one code workspace per repository', 'invalid_workspace_selection');
+        const allowed = repository.workspacePaths ?? (repository.workspacePath ? [repository.workspacePath] : [repository.path]);
+        const selected = paths.map(item => canonicalRepositoryPath(path_1.default.resolve(repository.path, item)));
+        if (new Set(selected.map(repositoryPathKey)).size !== selected.length || selected.some(item => !allowed.some(root => repositoryPathKey(root) === repositoryPathKey(item))))
+            throw new RepositoryValidationError('Select only registered code workspace paths', 'invalid_workspace_selection');
+        return [id, selected];
+    });
+    return Object.fromEntries(entries);
+}

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

@@ -347,7 +347,7 @@ function formatDescriptionWithCriteria(body, criteria) {
  * Order:
  *   1. `models.defaults.model` from the install-config.yaml (per-project HOME
  *      dir), if it parses AND is in the provider allow-list.
- *   2. Provider default from `PROVIDER_DEFAULT_MODEL` (`sonnet` / `gpt-5.5`).
+ *   2. Provider default from `PROVIDER_DEFAULT_MODEL` (`sonnet` / `gpt-6.1-sol`).
  *
  * Logs a warning when the configured value exists but is not valid for the
  * project's provider.

package/server/dist/project-router-loop-runs.js

@@ -352,9 +352,11 @@ function registerLoopRunRoutes(deps) {
             effort = globalAgentDefaults.pipelineEffort;
         }
         let repositoryIds;
+        let workspaceSelection;
         const primary = (0, project_repositories_1.getProjectRepositories)(c.project).find((repository) => repository.isPrimary);
         try {
             repositoryIds = (0, project_repositories_1.validateTicketRepositoryIds)(c.project, body.repositoryIds) ?? [primary.id];
+            workspaceSelection = (0, project_repositories_1.validateWorkspaceSelection)(c.project, body.workspaceSelection, repositoryIds);
             (0, loop_graph_1.assertLoopShellRepositoryScope)(loop.graph, repositoryIds);
             (0, process_admission_1.assertProcessAdmission)(c.project.id);
         }
@@ -386,7 +388,7 @@ function registerLoopRunRoutes(deps) {
             try {
                 let prDeliveryId;
                 const ids = await (0, multi_repo_execution_1.launchMultiRepositoryRail)({
-                    ctx: c, railIndex: rail.railIndex, ticketIds: [], repositoryIds, scope: 'all',
+                    ctx: c, railIndex: rail.railIndex, ticketIds: [], repositoryIds, workspaceSelection, scope: 'all',
                     loopId, loopName: loop.name, loopGraph: loop.graph, provider, model, effort,
                     onPrDeliveryCreated: (id) => { prDeliveryId = id; },
                 });
@@ -418,6 +420,7 @@ function registerLoopRunRoutes(deps) {
             graph: loop.graph,
             projectId: c.project.id,
             repositoryId: primary.id,
+            workspacePaths: workspaceSelection?.[primary.id],
             cwd: exec.cwd,
             repoDir: exec.relocated ? exec.repoDir : undefined,
             railIndex: null,