specrails-desktop 2.31.2 → 2.33.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/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
@@ -182,7 +186,9 @@ function createLoopExecutors(opts = {}) {
                 buildOpts,
                 cwd,
                 env: (0, runtime_1.buildProviderEnv)(adapter, buildOpts, stepEnv),
-                timeoutMs: aiStepTimeoutMs ?? AI_STEP_TIMEOUT_MS,
+                // 0 ⇒ watchdog disabled (factory loops run untimed; the loop's
+                // maxIterations / cost cap remain the runaway guards).
+                timeoutMs: (aiStepTimeoutMs ?? AI_STEP_TIMEOUT_MS) > 0 ? (aiStepTimeoutMs ?? AI_STEP_TIMEOUT_MS) : undefined,
                 onSpawn,
                 // Two complementary streams, mirroring QueueManager's contract:
                 //  • RAW JSONL via onStdoutLine → engine emits parsed `event`s that drive
@@ -319,7 +325,8 @@ function createLoopExecutors(opts = {}) {
             return {
                 adapter,
                 spec: { binary: adapter.binary, args, cwd, env: (0, runtime_1.buildProviderEnv)(adapter, buildOpts, stepEnv) },
-                // The loop's ai-step timeout bounds the WHOLE step, interactive included.
+                // The loop's ai-step timeout bounds the WHOLE step, interactive
+                // included. 0 ⇒ unbounded (the engine skips arming the step timer).
                 stepTimeoutMs: aiStepTimeoutMs ?? AI_STEP_TIMEOUT_MS,
             };
         },

package/server/dist/loop-factory.js

@@ -8,12 +8,14 @@ exports.factoryLoopForMode = factoryLoopForMode;
 const loop_templates_1 = require("./loop-templates");
 const GREEN_GOAL = 'Stop only when the latest verification step reports {{const:VERIFICATION_PASS}} and the history proves the spec is implemented with all required tests/build checks passing.';
 // Factory loops run the WHOLE architect→developer→reviewer pipeline inside a
-// single AI step (`/specrails:implement` etc.), so they need far more headroom
-// than the engine defaults (loop 30 min / step 15 min): a real implement can run
-// for a long time. 360 min loop deadline, 60 min per AI step.
+// single AI step (`/specrails:implement` etc.), so no fixed wall-clock budget is
+// honest — a legit implement outran the old 60-min step cap and got killed
+// mid-run. Built-in loops therefore run UNTIMED (0 = no timeout, both the run
+// deadline and the per-step watchdog); maxIterations and the optional cost cap
+// remain the runaway guards.
 const FACTORY_MAX_ITERATIONS = 12;
-const FACTORY_LOOP_TIMEOUT_MIN = 360;
-const FACTORY_AI_STEP_TIMEOUT_MIN = 60;
+const FACTORY_LOOP_TIMEOUT_MIN = 0;
+const FACTORY_AI_STEP_TIMEOUT_MIN = 0;
 const SDD_QUICK_OPENSPEC_FACTORY = {
     id: 'factory:sdd-quick-openspec',
     name: 'SDD Quick (OpenSpec)',

package/server/dist/loop-graph.js

@@ -27,7 +27,7 @@ function emptyLoopGraph() {
  *  - at least one `end` node (the explicit exit),
  *  - every edge references existing nodes (no dangling edges),
  *  - every node is reachable from `start` (no orphan / disconnected nodes),
- *  - a sane config (maxIterations ≥ 1, timeoutMinutes ≥ 1).
+ *  - a sane config (maxIterations ≥ 1, timeoutMinutes ≥ 0 — 0 = no timeout).
  *
  * Returns all errors found (not just the first) so the builder can highlight
  * every problem at once.
@@ -60,10 +60,11 @@ function validateLoopGraph(graph) {
         !Number.isInteger(cfg.maxIterations) ||
         cfg.maxIterations < 1 ||
         typeof cfg.timeoutMinutes !== 'number' ||
-        cfg.timeoutMinutes < 1) {
+        !Number.isFinite(cfg.timeoutMinutes) ||
+        cfg.timeoutMinutes < 0) {
         errors.push({
             code: 'INVALID_CONFIG',
-            message: 'maxIterations and timeoutMinutes must both be ≥ 1.',
+            message: 'maxIterations must be ≥ 1 and timeoutMinutes ≥ 0 (0 = no timeout).',
         });
     }
     // ── Dangling edges ────────────────────────────────────────────────────────────

package/server/dist/loop-run-manager.js

@@ -502,9 +502,13 @@ class LoopRunManager {
         const neverAfterDispose = () => new Promise(() => { });
         const runId = req.runId ?? (0, ids_1.newId)();
         const maxIterations = req.graph.config.maxIterations;
-        const timeoutMs = req.graph.config.timeoutMinutes * 60_000;
-        const deadline = this.now() + timeoutMs;
-        // Per-step AI timeout (ms) — undefined falls back to the executor default.
+        // 0 ⇒ no whole-run deadline (built-in pipeline loops opt out of the wall
+        // clock; maxIterations / maxCostUsd remain the runaway guards).
+        const deadline = req.graph.config.timeoutMinutes > 0
+            ? this.now() + req.graph.config.timeoutMinutes * 60_000
+            : Infinity;
+        // Per-step AI timeout (ms) — undefined falls back to the executor default,
+        // 0 disables the per-step watchdog entirely.
         const aiStepTimeoutMs = req.graph.config.aiStepTimeoutMinutes != null
             ? req.graph.config.aiStepTimeoutMinutes * 60_000
             : undefined;

package/server/dist/loop-templates.js

@@ -170,9 +170,10 @@ function opsxLifecycleGraph() {
             { id: 'e-stop', source: 'decide', target: 'archive', branch: 'stop' },
             { id: 'e-archive', source: 'archive', target: 'done' },
         ],
-        // Conservative bounds so a never-satisfied verify can't spin: at most 3 full
-        // lifecycle passes; per-step cap raised (apply can implement a whole change).
-        config: { maxIterations: 3, timeoutMinutes: 180, aiStepTimeoutMinutes: 45 },
+        // At most 3 full lifecycle passes guard a never-satisfied verify. Like the
+        // other built-in loops the run is UNTIMED (0 = no timeout) — apply can
+        // implement a whole change and must never be killed mid-flight.
+        config: { maxIterations: 3, timeoutMinutes: 0, aiStepTimeoutMinutes: 0 },
     };
 }
 exports.LOOP_TEMPLATES = [

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/profiles-router.js

@@ -282,7 +282,30 @@ function createProfilesRouter() {
                 throw err;
             }
             broadcast({ type: 'profile.changed', projectId: project.id, name: 'default' });
-            res.status(201).json({ profile });
+            // Companion `fast` profile (claude only, best-effort): same chain, but
+            // the flanking pipeline stages (architect plan / reviewer gate) run on
+            // haiku while the developer keeps its migrated model — a one-click way
+            // to cut implement wall-clock when the spec doesn't need heavyweight
+            // design/review. Skipped silently when 'fast' already exists.
+            let fastProfile = null;
+            if (isClaude && (0, providers_1.isModelAvailableForAdapter)(adapter, 'haiku')) {
+                const candidate = {
+                    ...profile,
+                    name: 'fast',
+                    description: 'Speed-first: haiku architect/reviewer, your developer model unchanged. Pick per rail when the spec is routine.',
+                    agents: profile.agents.map((a) => (a.id === 'sr-architect' || a.id === 'sr-reviewer' ? { ...a, model: 'haiku' } : a)),
+                };
+                try {
+                    (0, profile_manager_1.createProfile)(specRoot(project), candidate, provider);
+                    fastProfile = candidate;
+                    broadcast({ type: 'profile.changed', projectId: project.id, name: 'fast' });
+                }
+                catch (err) {
+                    if (!(err instanceof profile_manager_1.ProfileConflictError))
+                        throw err;
+                }
+            }
+            res.status(201).json({ profile, ...(fastProfile ? { fastProfile } : {}) });
         }
         catch (err) {
             handleError(res, err);

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).

package/server/dist/queue-manager.js

@@ -15,6 +15,7 @@ const win_spawn_1 = require("./util/win-spawn");
 const types_1 = require("./types");
 const command_resolver_1 = require("./command-resolver");
 const rail_isolation_1 = require("./rail-isolation");
+const repo_map_1 = require("./repo-map");
 const cli_prompt_1 = require("./util/cli-prompt");
 const stream_display_1 = require("./util/stream-display");
 const hooks_1 = require("./hooks");
@@ -2368,6 +2369,9 @@ class QueueManager {
         if (profileSnapshotPath) {
             spawnEnv = { ...spawnEnv, SPECRAILS_PROFILE_PATH: profileSnapshotPath };
         }
+        // Deterministic repo map (zero-AI, best-effort) — orients the pipeline's
+        // exploration phase so it doesn't spend its first turns on `ls`/`find`.
+        spawnEnv = (0, repo_map_1.injectRepoMapEnv)(spawnEnv, execution.repoDir);
         // ─── Plugin resolution + snapshot ──────────────────────────────────────
         // Active = installed + verify ok; degraded = installed but verify failed
         // or timed out. Degraded does NOT block spawn — rail proceeds, UI gets

package/server/dist/rail-isolated-launch.js

@@ -78,6 +78,7 @@ const agent_chat_registry_1 = require("./agent-chat-registry");
 const rail_merge_orchestrator_1 = require("./rail-merge-orchestrator");
 const loop_executors_1 = require("./loop-executors");
 const worktree_overlay_1 = require("./worktree-overlay");
+const worktree_node_modules_1 = require("./worktree-node-modules");
 const workspace_resolution_1 = require("./workspace-resolution");
 const feature_flags_1 = require("./feature-flags");
 const file_provenance_1 = require("./file-provenance");
@@ -690,6 +691,20 @@ async function launchIsolatedRail(input, io = {}) {
                             // and future edits — the spawn proceeds regardless.
                             notifyOverlayDegraded(unit.ticketId, [err instanceof Error ? err.message : String(err)]);
                         }
+                        // Warm-dependency reuse: link the base checkout's node_modules trees
+                        // into the fresh worktree (best-effort; a failure just leaves the run
+                        // on the legacy cold start). Linked paths join the overlay exclusion
+                        // list so they inherit the commit-time guarantees.
+                        try {
+                            const nm = (io.linkNodeModules ?? worktree_node_modules_1.linkNodeModulesIntoWorktree)(baseRepo, handle.worktreePath);
+                            if (nm.linked.length > 0)
+                                overlayExcludes = overlayExcludes.concat(nm.linked);
+                            if (nm.warnings.length > 0)
+                                notifyOverlayDegraded(unit.ticketId, nm.warnings);
+                        }
+                        catch (err) {
+                            notifyOverlayDegraded(unit.ticketId, [err instanceof Error ? err.message : String(err)]);
+                        }
                         // Code-Explorer provenance: freeze the worktree's pre-run state (HEAD sha
                         // + the overlay's untracked set) so the settle diff attributes exactly
                         // the run's own writes. Best-effort — a snapshot failure only loses

package/server/dist/rail-pr-decision.js

@@ -73,6 +73,7 @@ const rail_pr_delivery_1 = require("./rail-pr-delivery");
 const rail_worktree_release_1 = require("./rail-worktree-release");
 const pr_naming_1 = require("./pr-naming");
 const pr_body_1 = require("./pr-body");
+const ai_invocations_1 = require("./ai-invocations");
 const jira_db_1 = require("./jira/jira-db");
 const rail_pr_store_1 = require("./rail-pr-store");
 const rail_worktrees_store_1 = require("./rail-worktrees-store");
@@ -1292,12 +1293,21 @@ async function runCreatePr(deps, row) {
     catch {
         changes = null;
     }
+    // Cost footer is best-effort: a lookup failure omits the line, never blocks.
+    let costUsd = null;
+    try {
+        costUsd = (0, ai_invocations_1.sumInvocationCostForRuns)(deps.db, snap.runIds);
+    }
+    catch {
+        costUsd = null;
+    }
     const title = (0, pr_naming_1.buildPrTitle)(ticketData, { loopName: row.loop_name });
     const body = (0, pr_body_1.buildCanonicalPrBody)({
         loopName: row.loop_name,
         baseBranch: row.base_branch,
         tickets: ticketData.map((t) => ({ ...t, branch: branchFor(t.ticketId) })),
         changes,
+        costUsd,
     });
     let next;
     // Underlying git/gh failure detail for a degraded or failed delivery —