specrails-desktop 2.32.0 → 2.34.0

package/server/dist/job-phase-breakdown.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeJobPhaseBreakdown = computeJobPhaseBreakdown;
+const pricing_1 = require("./pricing");
+function computeJobPhaseBreakdown(events, providerId = 'claude') {
+    const phases = new Map();
+    /** tool_use id → root phase id, for transitive nested-Task attribution. */
+    const rootOf = new Map();
+    const orchestrator = emptyTotals();
+    const unattributed = emptyTotals();
+    let sawUsage = false;
+    const totalsFor = (parentId) => {
+        if (!parentId)
+            return orchestrator;
+        const rootId = rootOf.get(parentId);
+        if (!rootId)
+            return unattributed;
+        return phases.get(rootId) ?? unattributed;
+    };
+    for (const ev of events) {
+        let parsed;
+        try {
+            parsed = JSON.parse(ev.payload);
+        }
+        catch {
+            continue;
+        }
+        const parentId = typeof parsed.parent_tool_use_id === 'string' ? parsed.parent_tool_use_id : null;
+        const message = parsed.message;
+        if (parsed.type === 'assistant' && message) {
+            // Register Task spawns FIRST so a same-event usage envelope can't
+            // attribute to a phase this very event opens.
+            for (const block of contentBlocks(message)) {
+                if (block.type !== 'tool_use' || block.name !== 'Task' || typeof block.id !== 'string')
+                    continue;
+                const input = (block.input ?? {});
+                const rootId = parentId ? (rootOf.get(parentId) ?? null) : null;
+                if (rootId) {
+                    // Nested Task: its events roll up into the ancestor phase.
+                    rootOf.set(block.id, rootId);
+                }
+                else {
+                    rootOf.set(block.id, block.id);
+                    phases.set(block.id, {
+                        ...emptyTotals(),
+                        agent: typeof input.subagent_type === 'string' ? input.subagent_type : 'subagent',
+                        toolUseId: block.id,
+                        description: typeof input.description === 'string' ? input.description : null,
+                        startedAt: ev.timestamp,
+                        endedAt: null,
+                        durationMs: null,
+                    });
+                }
+            }
+            const usage = message.usage;
+            if (usage && typeof usage === 'object') {
+                sawUsage = true;
+                const target = totalsFor(parentId);
+                const tokensIn = num(usage.input_tokens);
+                const tokensOut = num(usage.output_tokens);
+                const cacheRead = num(usage.cache_read_input_tokens);
+                const cacheCreate = num(usage.cache_creation_input_tokens);
+                target.tokensIn += tokensIn;
+                target.tokensOut += tokensOut;
+                target.tokensCacheRead += cacheRead;
+                target.tokensCacheCreate += cacheCreate;
+                target.assistantEvents += 1;
+                const cost = (0, pricing_1.estimateCostUsd)(providerId, str(message.model), {
+                    tokens_in: tokensIn,
+                    tokens_out: tokensOut,
+                    tokens_cache_read: cacheRead,
+                    tokens_cache_create: cacheCreate,
+                });
+                if (cost !== null) {
+                    target.estimatedCostUsd = (target.estimatedCostUsd ?? 0) + cost;
+                }
+            }
+            continue;
+        }
+        if (parsed.type === 'user' && message) {
+            // A tool_result closing a root Task block ends that phase.
+            for (const block of contentBlocks(message)) {
+                if (block.type !== 'tool_result' || typeof block.tool_use_id !== 'string')
+                    continue;
+                const phase = phases.get(block.tool_use_id);
+                if (phase && phase.endedAt === null) {
+                    phase.endedAt = ev.timestamp;
+                    phase.durationMs = spanMs(phase.startedAt, ev.timestamp);
+                }
+            }
+        }
+    }
+    if (!sawUsage)
+        return null;
+    const hasUnattributed = unattributed.assistantEvents > 0 || unattributed.tokensIn > 0 || unattributed.tokensOut > 0;
+    return {
+        phases: [...phases.values()],
+        orchestrator,
+        unattributed: hasUnattributed ? unattributed : null,
+        estimated: true,
+    };
+}
+// ─── Internals ────────────────────────────────────────────────────────────────
+function emptyTotals() {
+    return {
+        tokensIn: 0,
+        tokensOut: 0,
+        tokensCacheRead: 0,
+        tokensCacheCreate: 0,
+        assistantEvents: 0,
+        estimatedCostUsd: null,
+    };
+}
+function contentBlocks(message) {
+    const content = message.content;
+    return Array.isArray(content) ? content : [];
+}
+function num(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : 0;
+}
+function str(value) {
+    return typeof value === 'string' ? value : null;
+}
+function spanMs(start, end) {
+    if (!start || !end)
+        return null;
+    const a = Date.parse(start);
+    const b = Date.parse(end);
+    if (Number.isNaN(a) || Number.isNaN(b) || b < a)
+        return null;
+    return b - a;
+}

package/server/dist/legacy-migration.js

@@ -0,0 +1,395 @@
+"use strict";
+// Forced migration of legacy repo-resident specrails-core installs
+// (global-core-zero-friction / legacy-install-migration spec).
+//
+// A "legacy" project has core installed INSIDE the user's repo (the pre-
+// relocation layout): `<repo>/.specrails/specrails-version` exists and the
+// relocated workspace is not populated. Migration, per project and serialized:
+//   1. assemble the relocated workspace from the bundled framework,
+//   2. MOVE per-project state from `<repo>/.specrails/` (and provider
+//      `agent-memory/`) into the workspace,
+//   3. CLEAN the repo with a manifest — exact framework listing (from
+//      `~/.specrails/framework/current`) UNION narrow historical patterns
+//      (`sr-*` agents, `commands/{sr,specrails,opsx}`, `sr-*`/`specrails-*`
+//      skills) that older core versions installed,
+//   4. journal every action write-ahead to
+//      `~/.specrails/projects/<slug>/migration-log.json` (fail-open, resumable).
+//
+// NEVER touched: `openspec/**`, `<providerDir>/worktrees/**`, `custom-*` files,
+// user instruction files (CLAUDE.md/AGENTS.md/GEMINI.md), user settings, and
+// `.mcp.json` keys we do not own (surgical key removal only).
+//
+// Kill switch: SPECRAILS_LEGACY_MIGRATION=false disables the whole sweep.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLegacyMigrationEnabled = isLegacyMigrationEnabled;
+exports.isLegacyProject = isLegacyProject;
+exports.journalPathFor = journalPathFor;
+exports.buildCleanupManifest = buildCleanupManifest;
+exports.isProtectedPath = isProtectedPath;
+exports.readJournal = readJournal;
+exports.migrateProject = migrateProject;
+exports.runLegacyMigrationSweep = runLegacyMigrationSweep;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const providers_1 = require("./providers");
+const artifact_registry_1 = require("./artifact-registry");
+const workspace_manager_1 = require("./workspace-manager");
+const workspace_resolution_1 = require("./workspace-resolution");
+const offline_assemble_1 = require("./offline-assemble");
+const plugin_manager_1 = require("./plugin-manager");
+const plugins_1 = require("./plugins");
+function isLegacyMigrationEnabled() {
+    const v = (process.env.SPECRAILS_LEGACY_MIGRATION ?? '').toLowerCase();
+    return v !== 'false' && v !== '0' && v !== 'off';
+}
+/** True when the project still runs from a repo-resident core install. */
+function isLegacyProject(project) {
+    if (!fs.existsSync(path.join(project.path, '.specrails', 'specrails-version')))
+        return false;
+    return !(0, workspace_resolution_1.isWorkspacePopulated)((0, workspace_manager_1.workspacePathFor)(project.slug));
+}
+function journalPathFor(slug) {
+    return path.join((0, artifact_registry_1.resolveHome)(), 'projects', slug, 'migration-log.json');
+}
+// ─── Manifest ────────────────────────────────────────────────────────────────
+/** Legacy command namespaces older cores installed (deprecated `sr` included). */
+const HISTORICAL_COMMAND_DIRS = ['sr', 'specrails', 'opsx'];
+function isFrameworkOwnedName(name) {
+    // Framework naming conventions ONLY — `custom-*`, `openspec-*` and any other
+    // user/third-party name can never match.
+    return name.startsWith('sr-') || name.startsWith('specrails-');
+}
+function listFrameworkRelPaths(providerDir, home) {
+    // Exact relative paths (under the provider dir) from the CURRENT framework
+    // version — covers files the historical patterns don't (e.g. rules).
+    const root = path.join(home, 'framework', 'current', providerDir);
+    const out = [];
+    const walk = (dir, rel) => {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const childRel = rel ? `${rel}/${e.name}` : e.name;
+            if (e.isDirectory())
+                walk(path.join(dir, e.name), childRel);
+            else
+                out.push(childRel);
+        }
+    };
+    walk(root, '');
+    return out;
+}
+/**
+ * The repo paths (absolute) migration is allowed to delete. Exact framework
+ * listing ∪ narrow historical patterns. Only existing paths are returned.
+ */
+function buildCleanupManifest(repoPath, home = (0, artifact_registry_1.resolveHome)()) {
+    const out = [];
+    const seen = new Set();
+    const add = (abs, reason) => {
+        if (seen.has(abs))
+            return;
+        if (!fs.existsSync(abs))
+            return;
+        if (isProtectedPath(repoPath, abs))
+            return;
+        seen.add(abs);
+        out.push({ path: abs, reason });
+    };
+    for (const adapter of (0, providers_1.listAdapters)()) {
+        const pd = path.join(repoPath, adapter.projectDirName);
+        if (!fs.existsSync(pd))
+            continue;
+        // Historical pattern: framework agents.
+        const agentsDir = path.join(pd, 'agents');
+        try {
+            for (const f of fs.readdirSync(agentsDir)) {
+                if (isFrameworkOwnedName(f) && f.endsWith('.md')) {
+                    add(path.join(agentsDir, f), 'framework agent (sr-*)');
+                }
+            }
+        }
+        catch { /* no agents dir */ }
+        // Historical pattern: framework command namespaces (whole dirs).
+        for (const ns of HISTORICAL_COMMAND_DIRS) {
+            add(path.join(pd, 'commands', ns), `framework command namespace (${ns})`);
+        }
+        // Historical pattern: framework skills (per-child, never openspec-*/custom-*).
+        const skillsDir = path.join(pd, 'skills');
+        try {
+            for (const child of fs.readdirSync(skillsDir)) {
+                if (isFrameworkOwnedName(child)) {
+                    add(path.join(skillsDir, child), 'framework skill (sr-*/specrails-*)');
+                }
+            }
+        }
+        catch { /* no skills dir */ }
+        // Exact current-framework listing (covers rules and anything pattern-less).
+        for (const rel of listFrameworkRelPaths(adapter.projectDirName, home)) {
+            add(path.join(pd, rel), 'exact framework listing match');
+        }
+    }
+    return out;
+}
+/** Hard exclusions — checked even though the manifest never generates them. */
+function isProtectedPath(repoPath, abs) {
+    const rel = path.relative(repoPath, abs);
+    if (rel.startsWith('..'))
+        return true; // outside the repo — never
+    const parts = rel.split(path.sep);
+    if (parts[0] === 'openspec')
+        return true;
+    if (parts.includes('worktrees'))
+        return true;
+    const base = path.basename(abs);
+    if (base.startsWith('custom-'))
+        return true;
+    if (base.startsWith('openspec'))
+        return true;
+    if (['CLAUDE.md', 'AGENTS.md', 'GEMINI.md'].includes(base))
+        return true;
+    if (base === 'settings.json' || base === 'settings.local.json')
+        return true;
+    if (base === '.mcp.json')
+        return true; // handled surgically, never deleted
+    return false;
+}
+// ─── State move ──────────────────────────────────────────────────────────────
+const STATE_ENTRIES = [
+    'profiles',
+    'local-tickets.json',
+    'backlog-config.json',
+    'state',
+    'file-summaries',
+    'plugins',
+];
+function planStateMoves(repoPath, workspace) {
+    const moves = [];
+    const repoSpecrails = path.join(repoPath, '.specrails');
+    for (const entry of STATE_ENTRIES) {
+        const src = path.join(repoSpecrails, entry);
+        if (fs.existsSync(src)) {
+            moves.push({ src, dest: path.join(workspace, '.specrails', entry), reason: `per-project state (${entry})` });
+        }
+    }
+    // Provider agent-memory (real per-project state, never framework).
+    for (const adapter of (0, providers_1.listAdapters)()) {
+        const src = path.join(repoPath, adapter.projectDirName, 'agent-memory');
+        if (fs.existsSync(src)) {
+            moves.push({ src, dest: path.join(workspace, adapter.projectDirName, 'agent-memory'), reason: 'agent memory' });
+        }
+    }
+    return moves;
+}
+function moveOverwriting(src, dest) {
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    // Repo state is the REAL user data — it wins over freshly-seeded workspace
+    // defaults (e.g. the seeded default profile).
+    fs.rmSync(dest, { recursive: true, force: true });
+    try {
+        fs.renameSync(src, dest);
+    }
+    catch {
+        // Cross-device fallback.
+        fs.cpSync(src, dest, { recursive: true });
+        fs.rmSync(src, { recursive: true, force: true });
+    }
+}
+// ─── Journal ─────────────────────────────────────────────────────────────────
+function writeJournal(journalPath, journal) {
+    fs.mkdirSync(path.dirname(journalPath), { recursive: true });
+    const tmp = `${journalPath}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(journal, null, 2), 'utf-8');
+    fs.renameSync(tmp, journalPath);
+}
+function readJournal(journalPath) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(journalPath, 'utf-8'));
+        return parsed && parsed.schemaVersion === 1 && Array.isArray(parsed.entries) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Per-project migration ───────────────────────────────────────────────────
+async function migrateProject(project, io) {
+    const journalPath = journalPathFor(project.slug);
+    // Resume path: a prior crash left unexecuted entries — re-attempt those only.
+    const prior = readJournal(journalPath);
+    const resuming = prior !== null && !prior.finishedAt && prior.entries.some((e) => !e.executed);
+    if (!resuming && !isLegacyProject(project)) {
+        return { projectId: project.id, migrated: false, skippedReason: 'not-legacy' };
+    }
+    const workspace = (0, workspace_manager_1.workspacePathFor)(project.slug);
+    // 1. Ensure the relocated workspace exists (idempotent, continue-on-error —
+    //    the state move below is what flips the activation gate).
+    if (!(0, workspace_resolution_1.isWorkspacePopulated)(workspace)) {
+        const providers = io?.providers ?? (0, providers_1.listAdapters)().map((a) => a.id);
+        const assemble = io?.assemble
+            ?? (async (p, provs) => {
+                await (0, offline_assemble_1.assembleProjectOffline)({
+                    projectPath: p.path,
+                    slug: p.slug,
+                    desktopProjectId: p.id,
+                    providers: provs,
+                    continueOnError: true,
+                });
+            });
+        try {
+            await assemble(project, providers);
+        }
+        catch (err) {
+            return {
+                projectId: project.id,
+                migrated: false,
+                error: `workspace assemble failed: ${err instanceof Error ? err.message : String(err)}`,
+            };
+        }
+    }
+    // 2+3. Plan (write-ahead) then execute.
+    const journal = resuming
+        ? prior
+        : {
+            schemaVersion: 1,
+            projectId: project.id,
+            repoPath: project.path,
+            startedAt: new Date().toISOString(),
+            entries: [],
+        };
+    if (!resuming) {
+        for (const m of planStateMoves(project.path, workspace)) {
+            journal.entries.push({ action: 'move', src: m.src, dest: m.dest, reason: m.reason, executed: false });
+        }
+        for (const d of buildCleanupManifest(project.path)) {
+            journal.entries.push({ action: 'delete', src: d.path, reason: d.reason, executed: false });
+        }
+        // The now-empty app-owned `.specrails/` residue (version marker etc.) —
+        // fully ours by the reserved-paths contract.
+        journal.entries.push({
+            action: 'delete',
+            src: path.join(project.path, '.specrails'),
+            reason: 'app-owned .specrails residue',
+            executed: false,
+        });
+        // Surgical .mcp.json cleanup: only bundled-plugin-owned keys.
+        const ownedKeys = plugins_1.BUNDLED_PLUGINS.flatMap((p) => p.manifest.owns.mcpServers ?? []);
+        if (ownedKeys.length > 0 && fs.existsSync(path.join(project.path, '.mcp.json'))) {
+            journal.entries.push({
+                action: 'mcp-key-remove',
+                src: path.join(project.path, '.mcp.json'),
+                reason: `plugin-owned mcp keys (${ownedKeys.join(', ')})`,
+                executed: false,
+            });
+        }
+        writeJournal(journalPath, journal); // write-ahead: plan on disk BEFORE deleting
+    }
+    const removeMcpKeys = io?.removeMcpKeys
+        ?? (async (repoPath, keys) => {
+            await plugin_manager_1.PluginManager.removeMcpServers(repoPath, keys, 'claude');
+        });
+    for (const entry of journal.entries) {
+        if (entry.executed)
+            continue;
+        try {
+            if (entry.action === 'move' && entry.dest) {
+                if (fs.existsSync(entry.src))
+                    moveOverwriting(entry.src, entry.dest);
+            }
+            else if (entry.action === 'delete') {
+                if (isProtectedPath(project.path, entry.src))
+                    throw new Error(`protected path: ${entry.src}`);
+                fs.rmSync(entry.src, { recursive: true, force: true });
+            }
+            else if (entry.action === 'mcp-key-remove') {
+                const ownedKeys = plugins_1.BUNDLED_PLUGINS.flatMap((p) => p.manifest.owns.mcpServers ?? []);
+                await removeMcpKeys(project.path, ownedKeys);
+            }
+            entry.executed = true;
+            writeJournal(journalPath, journal);
+        }
+        catch (err) {
+            // Fail-open: abort the remaining cleanup for this project. State already
+            // moved keeps working (the activation gate prefers the workspace).
+            entry.error = err instanceof Error ? err.message : String(err);
+            writeJournal(journalPath, journal);
+            return {
+                projectId: project.id,
+                migrated: false,
+                error: `migration halted at ${entry.action} ${entry.src}: ${entry.error}`,
+                journalPath,
+            };
+        }
+    }
+    journal.finishedAt = new Date().toISOString();
+    writeJournal(journalPath, journal);
+    return { projectId: project.id, migrated: true, journalPath };
+}
+// ─── Startup sweep ───────────────────────────────────────────────────────────
+/**
+ * Serialized background sweep over registered projects. Never throws; each
+ * project's outcome is logged, failures surface once as a console warning
+ * (non-blocking by design — the project keeps working either way).
+ */
+async function runLegacyMigrationSweep(projects, io) {
+    if (!isLegacyMigrationEnabled())
+        return [];
+    const results = [];
+    for (const project of projects) {
+        try {
+            const result = await migrateProject(project, io);
+            results.push(result);
+            if (result.migrated) {
+                console.log(`[legacy-migration] migrated ${project.slug} (journal: ${result.journalPath})`);
+            }
+            else if (result.error) {
+                console.warn(`[legacy-migration] ${project.slug}: ${result.error}`);
+            }
+        }
+        catch (err) {
+            results.push({
+                projectId: project.id,
+                migrated: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            console.warn(`[legacy-migration] ${project.slug} threw:`, err);
+        }
+    }
+    return results;
+}

package/server/dist/loop-executors.js

@@ -22,6 +22,7 @@ const spawn_lifecycle_1 = require("./spawn-lifecycle");
 const result_event_1 = require("./result-event");
 const loop_decider_1 = require("./loop-decider");
 const rail_isolation_1 = require("./rail-isolation");
+const repo_map_1 = require("./repo-map");
 const feature_flags_1 = require("./feature-flags");
 const runtime_1 = require("./providers/runtime");
 // Per-step wall-clock caps so a single hung step can't block the engine's
@@ -95,7 +96,10 @@ function runShellCommand(command, cwd, env, timeoutMs, onLine, onSpawn) {
  */
 function aiStepEnv(env, repoDir) {
     const base = repoDir ? { ...env, SPECRAILS_REPO_DIR: repoDir } : env;
-    return (0, rail_isolation_1.isRailPrDeliveryEnabled)() ? { ...base, SPECRAILS_GIT_AUTO: 'false' } : base;
+    // Deterministic repo map (zero-AI) so the pipeline's exploration phase
+    // starts oriented instead of spending its first turns on `ls`/`find`.
+    const withMap = (0, repo_map_1.injectRepoMapEnv)(base, repoDir);
+    return (0, rail_isolation_1.isRailPrDeliveryEnabled)() ? { ...withMap, SPECRAILS_GIT_AUTO: 'false' } : withMap;
 }
 /**
  * Relocated cwd is the workspace; the source repo is reached via the

package/server/dist/offline-assemble.js

@@ -144,7 +144,8 @@ function defaultModelForProvider(opts, provider) {
  * from the npx fallback in development/runtimes-less builds: registry mirror
  * → framework materialize (idempotent) → one `init` per provider. Throws on
  * any failure — the caller surfaces it as a failed step; nothing here registers
- * the project.
+ * the project. With `continueOnError` it instead reports per-provider results
+ * (silent-add mode).
  */
 async function assembleProjectOffline(opts) {
     const { projectPath, slug, desktopProjectId, providers } = opts;
@@ -183,7 +184,8 @@ async function assembleProjectOffline(opts) {
     materialize(providers);
     const spawnInit = opts.io?.spawnInit ?? (useBundled ? spawnBundledCoreInit : spawnNpxCoreInit);
     const coreLabel = useBundled ? 'bundled core' : 'npx core';
-    for (const provider of providers) {
+    const results = [];
+    const assembleOne = async (provider) => {
         const configPath = (0, install_config_path_1.installConfigPathForProvider)({ slug, path: projectPath }, provider);
         (0, fs_1.mkdirSync)((0, path_1.dirname)(configPath), { recursive: true });
         (0, fs_1.writeFileSync)(configPath, buildQuickInstallConfigYaml(provider, defaultModelForProvider(opts, provider)), 'utf-8');
@@ -204,12 +206,38 @@ async function assembleProjectOffline(opts) {
             const tail = stderrChunks.join('').split('\n').filter(Boolean).slice(-5).join(' ').slice(0, 500);
             throw new Error(`${coreLabel} init failed for ${provider} (exit ${code})${tail ? `: ${tail}` : ''}`);
         }
+    };
+    for (const provider of providers) {
+        opts.onProviderStart?.(provider);
+        try {
+            await assembleOne(provider);
+            const result = { provider, ok: true };
+            results.push(result);
+            opts.onProviderResult?.(result);
+        }
+        catch (err) {
+            const result = {
+                provider,
+                ok: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+            results.push(result);
+            opts.onProviderResult?.(result);
+            if (!opts.continueOnError)
+                throw err;
+        }
     }
     // The activation gate (workspace-resolution) requires a populated workspace;
     // verify assemble actually produced one so a silent core no-op cannot leave
-    // a half-created project that would spawn from a repo cwd.
+    // a half-created project that would spawn from a repo cwd. In
+    // continueOnError mode this only applies when at least one provider
+    // succeeded (an all-failed run already carries its per-provider errors).
     const workspace = (0, workspace_manager_1.workspacePathFor)(slug);
-    if (!(0, fs_1.existsSync)(workspace)) {
+    if (!(0, fs_1.existsSync)(workspace) && results.some((r) => r.ok)) {
+        throw new Error(`assemble completed but workspace was not created at ${workspace}`);
+    }
+    if (!opts.continueOnError && !(0, fs_1.existsSync)(workspace)) {
         throw new Error(`assemble completed but workspace was not created at ${workspace}`);
     }
+    return results;
 }

package/server/dist/pr-body.js

@@ -79,8 +79,21 @@ function buildCanonicalPrBody(input) {
     const changesSection = buildChangesSection(input.changes ?? null);
     if (changesSection)
         parts.push(changesSection);
+    const costLine = buildCostFooter(input.costUsd ?? null);
+    if (costLine)
+        parts.push(costLine);
     return parts.join('\n\n');
 }
+/** `> Specrails cost: $X.XX` — the transparency footer that keeps AI spend
+ *  visible at the exact place the work is reviewed. `~` marks a total that
+ *  includes rate-card estimates (providers without native cost, kill-path
+ *  reconstructions). */
+function buildCostFooter(cost) {
+    if (!cost || !Number.isFinite(cost.totalUsd) || cost.totalUsd <= 0)
+        return null;
+    const prefix = cost.estimated ? '~' : '';
+    return `> Specrails cost: ${prefix}$${cost.totalUsd.toFixed(2)}`;
+}
 function summaryParagraph(input) {
     const n = input.tickets.length;
     const refs = input.tickets.map((t) => displayRef(t)).join(', ');

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

@@ -10,6 +10,7 @@ const db_1 = require("./db");
 const queue_manager_1 = require("./queue-manager");
 const feature_flags_1 = require("./feature-flags");
 const types_1 = require("./types");
+const job_phase_breakdown_1 = require("./job-phase-breakdown");
 const providers_1 = require("./providers");
 const hooks_1 = require("./hooks");
 const explore_smash_1 = require("./explore-smash");
@@ -589,6 +590,21 @@ function registerJobsRoutes(deps) {
             res.json({ jobs });
         }
     });
+    // Per-phase cost/usage attribution, computed post-hoc from the persisted
+    // raw stream events (claude Task/parent_tool_use_id envelope). Costs are
+    // rate-card ESTIMATES and flagged as such; providers whose stream carries
+    // no per-event usage (codex/gemini/kimi) return breakdown: null.
+    router.get('/:projectId/jobs/:id/phase-breakdown', (req, res) => {
+        const { db } = ctx(req);
+        const job = db.prepare('SELECT id FROM jobs WHERE id = ?').get(req.params.id);
+        if (!job) {
+            res.status(404).json({ error: 'Job not found' });
+            return;
+        }
+        const events = db.prepare("SELECT event_type, payload, timestamp FROM events WHERE job_id = ? AND event_type IN ('assistant', 'user') ORDER BY seq ASC").all(req.params.id);
+        const breakdown = (0, job_phase_breakdown_1.computeJobPhaseBreakdown)(events);
+        res.json({ jobId: req.params.id, breakdown });
+    });
     // Must be registered BEFORE /:projectId/jobs/:id, otherwise Express matches
     // the parameterized route first with id='compare' and this never runs (the
     // Job Comparison feature would always 404).