specrails-desktop 2.57.0 → 2.58.0

package/server/dist/modules/delivery/runtime/rail-launch-parser.js

@@ -22,7 +22,7 @@ const json_tolerant_1 = require("../../../json-tolerant");
 const pr_follow_up_scope_1 = require("./pr-follow-up-scope");
 exports.RAIL_LAUNCH_FENCE = 'rail-launch';
 exports.RAIL_LAUNCH_PROPOSAL_VERSION = 1;
-exports.RAIL_LAUNCH_MODES = ['implement', 'batch-implement', 'freestyle', 'loop'];
+exports.RAIL_LAUNCH_MODES = ['implement', 'freestyle', 'loop'];
 const FENCE_RE = /```rail-launch[^\S\n]*\n([\s\S]*?)\n[^\S\n]*```/g;
 const OPEN_FENCE = '```rail-launch';
 const EXCERPT_MAX = 160;
@@ -71,7 +71,8 @@ function coerceRailLaunchProposal(value) {
     if (ticketIds.length === 0)
         return { ok: false, reason: 'no_tickets' };
     const modeRaw = optString(value.mode)?.toLowerCase().replace(/_/g, '-') ?? 'implement';
-    const mode = modeRaw === 'batch' ? 'batch-implement' : modeRaw;
+    // The removed Batch mode folds into implement (one aggregate run per rail).
+    const mode = modeRaw === 'batch' || modeRaw === 'batch-implement' ? 'implement' : modeRaw;
     if (!exports.RAIL_LAUNCH_MODES.includes(mode))
         return { ok: false, reason: 'invalid_mode' };
     const newRailRaw = value.newRail;

package/server/dist/modules/delivery/runtime/rail-pr-store.js

@@ -322,11 +322,16 @@ function reconcileFailedBuildingPrDeliveries(db, opts = {}) {
         const uniqueRunIds = [...new Set(runIds)];
         const placeholders = uniqueRunIds.map(() => '?').join(',');
         const runs = db
-            .prepare(`SELECT id, status, final_outcome FROM loop_runs WHERE id IN (${placeholders})`)
+            .prepare(`SELECT id, status, final_outcome, engine_version, restart_reason FROM loop_runs WHERE id IN (${placeholders})`)
             .all(...uniqueRunIds);
         if (runs.length !== uniqueRunIds.length || runs.some((run) => run.status !== 'completed')) {
             if (!opts.startup)
                 continue;
+            if (runs.length === uniqueRunIds.length && runs.some(run => run.engine_version === 2 && run.status === 'paused' && run.restart_reason === 'restart') && runs.every(run => run.status === 'completed' || run.engine_version === 2 && run.status === 'paused' && run.restart_reason === 'restart')) {
+                db.prepare("UPDATE rail_pr_deliveries SET status_code='restart_pending', status_detail=? WHERE id=? AND decision='building'")
+                    .run('The retained Core execution awaits recovery or delivery settlement after restart.', row.id);
+                continue;
+            }
             if (transitionDecision(db, row.id, 'building', 'pr_failed', {
                 implementationOutcome: 'unknown',
                 deliveryOutcome: 'blocked',

package/server/dist/modules/delivery/runtime/rails-router.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeRailMode = normalizeRailMode;
 exports.prDeliveryRevisionAllowed = prDeliveryRevisionAllowed;
 exports.createRailsRouter = createRailsRouter;
 const pr_follow_up_1 = require("./pr-follow-up");
@@ -25,7 +26,9 @@ const agent_defaults_1 = require("../../agents/runtime/agent-defaults");
 const profile_manager_1 = require("../../agents/runtime/profile-manager");
 const spec_models_1 = require("../../specs/runtime/spec-models");
 const workspace_resolution_1 = require("../../../workspace-resolution");
+const agent_runtime_loader_1 = require("../../agent-runtime/runtime/agent-runtime-loader");
 const loop_factory_1 = require("../../loops/runtime/loop-factory");
+const builtin_loops_1 = require("../../loops/runtime/builtin-loops");
 const loop_constants_1 = require("../../loops/runtime/loop-constants");
 const loop_command_catalog_1 = require("../../loops/runtime/loop-command-catalog");
 const loop_graph_1 = require("../../loops/runtime/loop-graph");
@@ -34,6 +37,7 @@ const rail_pr_store_1 = require("./rail-pr-store");
 const loop_effect_1 = require("../../loops/runtime/loop-effect");
 const review_packet_1 = require("./review-packet");
 const delivery_evidence_1 = require("./delivery-evidence");
+const loop_definition_recovery_1 = require("../../loops/runtime/loop-definition-recovery");
 const accept_ladder_1 = require("../../execution/runtime/accept-ladder");
 const rail_pr_decision_1 = require("./rail-pr-decision");
 const active_pr_continuation_1 = require("./active-pr-continuation");
@@ -56,7 +60,14 @@ const agent_runtime_controls_router_1 = require("../../agent-runtime/runtime/age
 const ticket_store_1 = require("../../specs/runtime/ticket-store");
 const spec_addenda_1 = require("../../specs/runtime/spec-addenda");
 const process_admission_1 = require("../../../process-admission");
-const VALID_MODES = new Set(['implement', 'batch-implement', 'freestyle', 'loop']);
+const VALID_MODES = new Set(['implement', 'freestyle', 'loop']);
+/** Input aliases of the removed Batch mode. `implement` already runs every rail
+ *  ticket in one aggregate run, so stored/agent/mobile `batch-implement` (or
+ *  `batch`) requests are normalized to it at the HTTP boundary. */
+const REMOVED_BATCH_MODES = new Set(['batch-implement', 'batch']);
+function normalizeRailMode(mode) {
+    return typeof mode === 'string' && REMOVED_BATCH_MODES.has(mode) ? 'implement' : mode;
+}
 function prDeliveryContinuesTickets(delivery, ticketIds) {
     if (delivery.decision !== 'pr_draft' && delivery.decision !== 'pr_ready')
         return false;
@@ -136,6 +147,20 @@ function onReviewTicketIds(c) {
         return new Set();
     }
 }
+/** Map an engine-availability refusal to the launch's 409 body; rethrow others. */
+async function engineSupportRejection(manager, graph, loopId) {
+    try {
+        await manager.assertEngineSupport?.(graph);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = /^(legacy_engine_unavailable|engine_unsupported):/.exec(message)?.[1];
+        if (!code)
+            throw error;
+        return { error: code, loopId, detail: message.slice(code.length + 1).trim() };
+    }
+    return undefined;
+}
 function createRailsRouter() {
     const router = (0, express_1.Router)({ mergeParams: true });
     function ctx(req) {
@@ -318,7 +343,12 @@ function createRailsRouter() {
             // per-rail profile. Preserve them (an explicit body value still wins).
             const current = (0, rails_store_1.getRail)(c.db, railIndex);
             const body = req.body ?? {};
-            const mode = typeof body.mode === 'string' ? body.mode : current.mode;
+            const requestedMode = normalizeRailMode(body.mode);
+            if (requestedMode !== undefined && (typeof requestedMode !== 'string' || !VALID_MODES.has(requestedMode))) {
+                res.status(400).json({ error: 'mode must be "implement", "freestyle" or "loop"' });
+                return;
+            }
+            const mode = typeof requestedMode === 'string' ? requestedMode : String(normalizeRailMode(current.mode));
             const profileName = 'profileName' in body ? body.profileName : current.profileName;
             // Preserve the rail's AI engine across ticket reassignment (undefined →
             // setRailTickets re-reads the current value), so it isn't silently wiped.
@@ -478,7 +508,8 @@ function createRailsRouter() {
             res.status(400).json({ error: 'invalid_runtime_provider_override' });
             return;
         }
-        let { mode = 'implement' } = req.body ?? {};
+        // Non-string values fail the VALID_MODES check below.
+        let mode = normalizeRailMode(req.body?.mode ?? 'implement');
         const { repositoryIds: rawRepositoryIds, baseDeliveryIds, profileName, aiEngine, model, loopId: rawLoopId, reasoning_effort, originConversationId, originSurface, targetPrNumber, revisionOfDeliveryId, revisionNote, baseBranch: rawBaseBranch, followUp: rawFollowUp } = req.body ?? {};
         // PR review follow-up (pr-follow-up-fixes): a typed, bounded, FROZEN scope
         // for "resolve these review comments". It rides the delivery row and every
@@ -566,7 +597,7 @@ function createRailsRouter() {
             mode = fmode;
         }
         if (!VALID_MODES.has(mode)) {
-            res.status(400).json({ error: 'mode must be "implement", "batch-implement", "freestyle" or "loop"' });
+            res.status(400).json({ error: 'mode must be "implement", "freestyle" or "loop"' });
             return;
         }
         // A bare legacy mode (MCP tools, mobile, direct REST — no loopId) must run
@@ -795,11 +826,31 @@ function createRailsRouter() {
                 let loopGraph;
                 let loopName;
                 if ((0, loop_factory_1.isFactoryLoopId)(loopId)) {
-                    const f = (0, loop_factory_1.getFactoryLoop)(loopId);
+                    let capabilities;
+                    try {
+                        capabilities = (await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).api?.capabilities;
+                    }
+                    catch { /* Existing Core remains supported through the legacy factory. */ }
+                    // Editable built-ins: an edited row runs its Published graph (or the
+                    // last Published snapshot while an edit is Draft); otherwise the
+                    // current code default for this Core.
+                    const f = (0, builtin_loops_1.resolveBuiltinLoop)(c.desktopDb, loopId, capabilities);
                     if (!f) {
                         res.status(404).json({ error: 'Factory loop not found' });
                         return;
                     }
+                    if (f.source !== 'default') {
+                        const validation = (0, loop_graph_1.validateLoopGraph)(f.graph);
+                        if (!validation.valid) {
+                            res.status(422).json({ error: 'Loop graph is invalid', errors: validation.errors });
+                            return;
+                        }
+                        const rejection = await engineSupportRejection(c.loopRunManager, f.graph, loopId);
+                        if (rejection) {
+                            res.status(409).json(rejection);
+                            return;
+                        }
+                    }
                     loopGraph = f.graph;
                     loopName = f.name;
                 }
@@ -826,6 +877,11 @@ function createRailsRouter() {
                         res.status(400).json({ error: 'This loop runs standalone — launch it from the Loops page, not a rail.' });
                         return;
                     }
+                    const rejection = await engineSupportRejection(c.loopRunManager, loop.graph, loopId);
+                    if (rejection) {
+                        res.status(409).json(rejection);
+                        return;
+                    }
                     loopGraph = loop.graph;
                     loopName = loop.name;
                 }
@@ -1311,11 +1367,10 @@ function createRailsRouter() {
                 res.status(202).json({ jobId, jobIds, railIndex, mode });
                 return;
             }
-            // Implement / batch-implement create a single job with all ticket IDs.
-            // /specrails:implement handles multiple specs in parallel internally.
+            // Implement creates a single job with all ticket IDs (the removed Batch
+            // mode is normalized to implement above).
             const issueArgs = rail.ticketIds.map((id) => `#${id}`).join(' ');
-            const commandName = mode === 'batch-implement' ? 'batch-implement' : 'implement';
-            const command = `/specrails:${commandName} ${issueArgs} --yes`;
+            const command = `/specrails:implement ${issueArgs} --yes`;
             const job = c.queueManager.enqueue(command, 'normal', { profileName: resolvedProfile, provider: railProvider });
             jobId = job.id;
             c.railJobs.set(jobId, { railIndex, mode, ticketIds: [...rail.ticketIds] });
@@ -1470,7 +1525,8 @@ function createRailsRouter() {
                 const existing = (0, delivery_evidence_1.readSettleEvidence)(row.settle_evidence);
                 if (existing) {
                     const pipelineDir = path_1.default.join((0, workspace_resolution_1.resolveProjectExecution)({ slug: c.project.slug, path: c.project.path }).specrailsDir, 'pipeline');
-                    const healed = (0, delivery_evidence_1.healRuntimeEvidence)(existing, pipelineDir);
+                    const definitionStatuses = await (0, loop_definition_recovery_1.probeDefinitionRuns)({ db: c.db, cwd: c.project.path, env: process.env }, existing.units.filter(unit => !unit.runtime && unit.runId && (0, loop_runs_store_1.getLoopRun)(c.db, unit.runId)?.engine_version === 2).map(unit => unit.runId), true);
+                    const healed = (0, delivery_evidence_1.healRuntimeEvidence)(existing, pipelineDir, {}, definitionStatuses);
                     if (healed) {
                         (0, rail_pr_store_1.updatePrDeliverySettleEvidence)(c.db, row.id, healed);
                         row = { ...row, settle_evidence: JSON.stringify(healed) };

package/server/dist/modules/execution/runtime/queue-manager.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueManager = exports.FREESTYLE_COMMAND_RE = exports.InvalidJobDependencyError = exports.JobAlreadyTerminalError = exports.JobNotFoundError = exports.CodexNotFoundError = exports.ClaudeNotFoundError = exports.DEFAULT_ZOMBIE_TIMEOUT_MS = exports.distributeIntEvenly = exports.projectSupportsProfiles = exports.buildTelemetryEnv = void 0;
 const budget_storage_1 = require("../adapters/budget-storage");
+const legacy_launch_telemetry_1 = require("../../loops/runtime/legacy-launch-telemetry");
 const __1 = require("..");
 const usage_reader_1 = require("../adapters/usage-reader");
 const __2 = require("..");
@@ -649,6 +650,11 @@ class QueueManager {
         if (this._disposed)
             throw new Error('Queue manager is shutting down');
     }
+    _recordLegacySlashLaunch(job) {
+        if (this._db && this._projectId && (0, legacy_launch_telemetry_1.isLegacySlashCommand)(job.command)) {
+            (0, legacy_launch_telemetry_1.recordLegacyLaunch)(this._db, { kind: 'queue_manager_slash', projectId: this._projectId, runId: job.id });
+        }
+    }
     enqueue(command, priorityOrOpts, opts, durableAdmission) {
         this._assertMutable();
         if (this._restoreBlocked) {
@@ -1692,6 +1698,7 @@ class QueueManager {
             });
         }
         this._consumePendingSelections(jobId);
+        this._recordLegacySlashLaunch(job);
         const session = new interactive_job_session_1.InteractiveJobSession({
             jobId,
             projectId: this._projectId ?? '',
@@ -2053,8 +2060,9 @@ class QueueManager {
                     '- Skip any instructions that say "wait for user", "present for review", or "ask the user".\n' +
                     '- The pipeline must complete fully from start to finish in a single uninterrupted run.';
         }
-        // Local ticket store: implement/batch-implement jobs must read specs from
+        // Local ticket store: implement jobs must read specs from
         // .specrails/local-tickets.json — never from external trackers like Jira/Linear.
+        // (`batch-implement` stays matched only for historical/replayed commands.)
         if (/\/(specrails|sr):(implement|batch-implement)\b/.test(commandToRun)) {
             systemAppend += '\n\nIMPORTANT: The ticket/spec data for this project is stored locally in .specrails/local-tickets.json. ' +
                 'You MUST read specs from this file. Do NOT attempt to fetch tickets from Jira, Linear, GitHub Issues, or any other external tracker. ' +
@@ -2081,7 +2089,7 @@ class QueueManager {
         //    `$skill_name` to invoke a skill from `.codex/skills/<name>/SKILL.md`.
         //    Translate `/specrails:<name>` → `$<name>` so codex picks up the
         //    matching skill natively (which our scaffold writes for every
-        //    claude slash command — propose-spec, implement, batch-implement,
+        //    claude slash command — propose-spec, implement,
         //    explore-spec, retry, …). This is the rail equivalent of the
         //    user typing `$implement #1 --yes` themselves in `codex`.
         // Freestyle (capability-gated; currently Claude and Kimi): skip the slash
@@ -2460,6 +2468,7 @@ class QueueManager {
         }
         this._consumePendingSelections(jobId);
         // spawnAiCli reroutes multi-line argv values through stdin on Windows.
+        this._recordLegacySlashLaunch(job);
         const child = (0, cli_prompt_1.spawnAiCli)(binary, args, {
             env: (0, runtime_1.buildProviderEnv)(adapter, railSpawnOptions, spawnEnv),
             stdio: ['ignore', 'pipe', 'pipe'],

package/server/dist/modules/loops/runtime/builtin-loops.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EDITABLE_BUILTIN_LOOP_IDS = void 0;
+exports.probeCoreCapabilities = probeCoreCapabilities;
+exports.builtinLoopDefaults = builtinLoopDefaults;
+exports.ensureBuiltinLoops = ensureBuiltinLoops;
+exports.resolveBuiltinLoop = resolveBuiltinLoop;
+exports.restoreBuiltin = restoreBuiltin;
+const registry_1 = require("../../../providers/registry");
+const agent_runtime_loader_1 = require("../../agent-runtime/runtime/agent-runtime-loader");
+const loop_factory_1 = require("./loop-factory");
+const loops_store_1 = require("./loops-store");
+/** Built-ins that exist as editable rows. Batch is an alias, never seeded. */
+exports.EDITABLE_BUILTIN_LOOP_IDS = ['factory:implement', 'factory:freestyle', 'factory:sdd-quick-openspec'];
+async function defaultCapabilities() {
+    return (await (0, agent_runtime_loader_1.loadCoreAgentRuntime)()).api?.capabilities;
+}
+function defaultFreestyleAvailable() {
+    return (0, registry_1.listAdapters)().some(adapter => adapter.capabilities.freestyle === true);
+}
+async function probeCoreCapabilities(env = {}) {
+    try {
+        return { capabilities: await (env.loadCapabilities ?? defaultCapabilities)(), known: true };
+    }
+    catch {
+        return { capabilities: undefined, known: false };
+    }
+}
+function toDefault(factory) {
+    return { id: factory.id, name: factory.name, description: factory.description, graph: factory.graph };
+}
+/** Current defaults of the seeded built-ins for these capabilities. */
+function builtinLoopDefaults(capabilities, freestyleAvailable) {
+    return (0, loop_factory_1.factoryLoopsForCapabilities)(capabilities)
+        .filter(factory => exports.EDITABLE_BUILTIN_LOOP_IDS.includes(factory.id))
+        .filter(factory => factory.requiredCapability !== 'freestyle' || freestyleAvailable)
+        .map(toDefault);
+}
+/** Idempotent, concurrency-safe seeding/refresh. Returns the capability probe. */
+async function ensureBuiltinLoops(db, env = {}) {
+    const probe = await probeCoreCapabilities(env);
+    const defaults = builtinLoopDefaults(probe.capabilities, (env.freestyleAvailable ?? defaultFreestyleAvailable)());
+    return { ...probe, ...(0, loops_store_1.seedBuiltinLoops)(db, defaults, { refresh: probe.known }) };
+}
+/** Resolve a `factory:*` id to the graph a launch must run. Read-only. */
+function resolveBuiltinLoop(db, loopId, capabilities) {
+    const factory = (0, loop_factory_1.getFactoryLoop)(loopId, capabilities);
+    if (!factory)
+        return undefined;
+    const base = { id: factory.id, name: factory.name, description: factory.description, mode: factory.mode, graph: factory.graph, source: 'default' };
+    const row = db ? (0, loops_store_1.getBuiltinLoop)(db, factory.id) : undefined;
+    if (!row)
+        return base;
+    const named = { ...base, name: row.name, description: row.description ?? factory.description, row };
+    if (!row.builtinModified)
+        return named;
+    if (row.status === 'published')
+        return { ...named, graph: row.graph, source: 'edited' };
+    const snapshot = (0, loops_store_1.readPublishedLoopGraph)(db, row.id);
+    return snapshot ? { ...named, graph: snapshot, source: 'published-snapshot' } : named;
+}
+/** Reset a built-in row to its current default variant (Published). */
+async function restoreBuiltin(db, id, env = {}) {
+    const row = (0, loops_store_1.getBuiltinLoop)(db, id);
+    if (!row)
+        return undefined;
+    const probe = await probeCoreCapabilities(env);
+    const factory = (0, loop_factory_1.getFactoryLoop)(id, probe.capabilities);
+    return factory ? (0, loops_store_1.restoreBuiltinLoop)(db, toDefault(factory)) : undefined;
+}

package/server/dist/modules/loops/runtime/definition-cancellation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.finishDefinitionCancellation = finishDefinitionCancellation;
+/** Acknowledgement is not settlement. Wait for Core to release its writer lease
+ * before Desktop replays terminal events and closes the original delivery. */
+async function finishDefinitionCancellation(ports, timeoutMs = 90_000) {
+    const deadline = ports.now() + timeoutMs;
+    for (;;) {
+        if (ports.stopped())
+            return; // Startup recovery retains the durable Core intent.
+        const state = await ports.inspect();
+        if (ports.stopped())
+            return;
+        if (state.status === 'unavailable')
+            throw new Error('Cancellation was accepted, but retained Core status is unavailable');
+        if (!state.lease?.active) {
+            if (!['cancelled', 'succeeded'].includes(state.status) && !state.completion) {
+                // A writer can disappear after inbox admission. Core owns converting
+                // its expired lease and durable cancel request into terminal truth.
+                await ports.cancel();
+            }
+            else {
+                await ports.settle();
+                return;
+            }
+        }
+        if (ports.now() >= deadline)
+            throw new Error('Cancellation is durable; Core has not released its execution lease yet');
+        await ports.wait(Math.min(1000, Math.max(1, deadline - ports.now())));
+    }
+}

package/server/dist/modules/loops/runtime/legacy-launch-telemetry.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_LAUNCH_KINDS = void 0;
+exports.isLegacySlashCommand = isLegacySlashCommand;
+exports.recordLegacyLaunch = recordLegacyLaunch;
+exports.readLegacyLaunchSummary = readLegacyLaunchSummary;
+/**
+ * Legacy-launch telemetry — the D8 retirement counter.
+ *
+ * Every launch that still runs through a pre-Core path appends one row to the
+ * per-project `legacy_launch_events` table (migration 66): the node-by-node
+ * loop traversal in LoopRunManager, the QueueManager slash command a bare rail
+ * mode enqueues, and the isolated-rail merge-back. The analytics page reads the
+ * summary so two releases can prove the counter stays at zero before D8.3–D8.5
+ * remove those paths. Nothing here changes how a launch runs.
+ *
+ * Append-only. A run-scoped event is idempotent per (kind, runId) so restart
+ * replay and retries never inflate the count; events without a run id count
+ * every call. Pure SQLite helpers; no Express, no process access.
+ */
+const node_crypto_1 = require("node:crypto");
+exports.LEGACY_LAUNCH_KINDS = ['legacy_loop_traversal', 'queue_manager_slash', 'merge_back'];
+/** Raw queue prompts support slash commands and Codex's $skill spelling. */
+function isLegacySlashCommand(command) {
+    return /^\s*\/(?:[a-z0-9-]+:)?[a-z][a-z0-9-]*(?=\s|$)/i.test(command) ||
+        /^\s*\$[a-z][a-z0-9-]*(?=\s|$)/.test(command);
+}
+function assertIso(value, field) {
+    if (typeof value !== 'string' || !value.trim() || Number.isNaN(Date.parse(value))) {
+        throw new RangeError(`legacy launch telemetry: ${field} must be an ISO-8601 timestamp`);
+    }
+    return new Date(value).toISOString();
+}
+/** Record one legacy launch. Throws only on malformed input; callers that must
+ *  never block a launch wrap the call. */
+function recordLegacyLaunch(db, event) {
+    if (!exports.LEGACY_LAUNCH_KINDS.includes(event?.kind)) {
+        throw new TypeError(`legacy launch telemetry: unknown kind ${JSON.stringify(event?.kind)}`);
+    }
+    if (typeof event.projectId !== 'string' || !event.projectId.trim()) {
+        throw new TypeError('legacy launch telemetry: projectId is required');
+    }
+    if (event.runId !== undefined && (typeof event.runId !== 'string' || !event.runId.trim())) {
+        throw new TypeError('legacy launch telemetry: runId must be a non-empty string when present');
+    }
+    const at = event.at === undefined ? new Date().toISOString() : assertIso(event.at, 'at');
+    // The partial unique index on (kind, run_id) makes the run-scoped insert a
+    // no-op on replay; rows without a run id never collide.
+    db.prepare(`
+    INSERT OR IGNORE INTO legacy_launch_events (id, kind, project_id, run_id, at)
+    VALUES (?, ?, ?, ?, ?)
+  `).run((0, node_crypto_1.randomUUID)(), event.kind, event.projectId, event.runId ?? null, at);
+}
+/** Aggregate the counter, optionally from an ISO lower bound (inclusive). The
+ *  bound is compared lexicographically, so a date-only `YYYY-MM-DD` works. */
+function readLegacyLaunchSummary(db, since) {
+    const params = [];
+    let where = '';
+    if (since !== undefined) {
+        where = 'WHERE at >= ?';
+        params.push(assertIso(since, 'since'));
+    }
+    const rows = db.prepare(`
+    SELECT kind, COUNT(*) AS count, MAX(at) AS last_at
+      FROM legacy_launch_events ${where}
+     GROUP BY kind
+  `).all(...params);
+    const byKind = Object.fromEntries(exports.LEGACY_LAUNCH_KINDS.map((kind) => [kind, 0]));
+    let total = 0;
+    let lastAt = null;
+    for (const row of rows) {
+        byKind[row.kind] = (byKind[row.kind] ?? 0) + row.count;
+        total += row.count;
+        if (row.last_at && (lastAt === null || row.last_at > lastAt))
+            lastAt = row.last_at;
+    }
+    return { total, byKind, lastAt };
+}

package/server/dist/modules/loops/runtime/loop-command-catalog.js

@@ -13,7 +13,7 @@
  *    autonomous prompt.
  *
  * Each command declares its TICKET SCOPE:
- *  - `all`        → one run over ALL the rail's tickets (`#1 #2 #3`). implement, batch.
+ *  - `all`        → one run over ALL the rail's tickets (`#1 #2 #3`). implement.
  *  - `per-ticket` → one run per ticket. Freestyle (and the default).
  *
  * Expansion order in the engine: `expandCommands()` FIRST (injects the ticket ids),
@@ -72,13 +72,6 @@ exports.LOOP_COMMANDS = [
         coreCommand: 'implement',
         ticketScope: 'all',
     },
-    {
-        name: 'batch',
-        label: 'batch',
-        description: "Run all selected tickets as one frozen candidate through Core’s programmatic agent workflow.",
-        coreCommand: 'batch-implement',
-        ticketScope: 'all',
-    },
     {
         name: 'freestyle',
         label: 'Freestyle',
@@ -226,7 +219,7 @@ exports.LOOP_COMMANDS = [
     // native opsx command fall back to the `template` prompt. Archive is invoked via
     // the `openspec` CLI in a shell node (provider-independent) and has no command.
     // NOTE: opsx commands are confirmed on claude today; codex/gemini lean on the
-    // fallback until OpenSpec ships their native commands (see opsx-lifecycle loop).
+    // fallback until OpenSpec ships their native commands (see the legacy Quick SDD graph).
     {
         name: 'opsx:ff', label: 'opsx:ff', ticketScope: 'per-ticket',
         description: 'OpenSpec fast-forward: create (or continue) a change and generate all its artifacts (proposal, specs, design, tasks). Native /opsx:ff (claude/gemini) or $opsx:ff (codex).',
@@ -310,7 +303,17 @@ exports.LOOP_COMMANDS = [
         ].join('\n'),
     },
 ];
-const COMMANDS_BY_NAME = new Map(exports.LOOP_COMMANDS.map((c) => [c.name, c]));
+/** Hidden, unlisted aliases kept so saved loops keep working. `{{cmd:batch}}`
+ *  belonged to the removed Batch mode; it now expands exactly like
+ *  `{{cmd:implement}}` (one aggregate run over all the rail's tickets). */
+const LOOP_COMMAND_ALIASES = { batch: 'implement' };
+const COMMANDS_BY_NAME = new Map([
+    ...exports.LOOP_COMMANDS.map((c) => [c.name, c]),
+    ...Object.entries(LOOP_COMMAND_ALIASES).flatMap(([alias, target]) => {
+        const cmd = exports.LOOP_COMMANDS.find((c) => c.name === target);
+        return cmd ? [[alias, cmd]] : [];
+    }),
+]);
 function getLoopCommand(name) {
     return COMMANDS_BY_NAME.get(name);
 }
@@ -321,8 +324,6 @@ const CMD_TOKEN_RE = /\{\{\s*cmd:([\w:-]+)\s*\}\}/g;
  *  identical in shape to the rail's `/specrails:implement #1 #2 --yes`. Codex has
  *  no `/namespace:cmd` parser, so it invokes the equivalent `$<name>` skill. */
 function nativeInvocation(coreCommand, provider, ids) {
-    if (provider === 'codex' && coreCommand === 'implement' && ids.length > 1)
-        coreCommand = 'batch-implement';
     const head = provider === 'codex'
         ? `$${coreCommand}`
         : provider === 'kimi'