specrails-desktop 2.36.0 → 2.42.2

package/server/dist/mcp/tools/watch.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.watchTool = watchTool;
 const zod_1 = require("zod");
 const types_1 = require("./types");
-// Event `type` suffixes/strings that mean an async operation has settled.
-const TERMINAL_PATTERNS = [
+// Exact event types that mean an async operation has settled.
+const TERMINAL_PATTERNS = new Set([
     'job.finalized',
     'rail.job_completed',
     'rail.job_stopped',
@@ -16,6 +16,7 @@ const TERMINAL_PATTERNS = [
     'ticket_ai_edit_error',
     'agent_refine_ready',
     'agent_refine_error',
+    'agent_refine_cancelled',
     'smash.completed',
     'smash.failed',
     'smash.undone',
@@ -24,31 +25,51 @@ const TERMINAL_PATTERNS = [
     'explore.contract_refine_failed',
     'file.summary_updated',
     'file.summary_failed',
+    'file.summary_skipped',
     'setup_install_done',
     'setup_error',
     'plugin.installed',
     'plugin.degraded',
-];
+]);
 // Job statuses that mean a polled job has settled (see project-router-jobs.ts).
-const TERMINAL_JOB_STATUSES = new Set(['completed', 'failed', 'canceled']);
+const TERMINAL_JOB_STATUSES = new Set(['completed', 'failed', 'canceled', 'skipped', 'zombie_terminated']);
 // Jobs are identified by UUIDs (server/ids.ts newId → randomUUID). When the ref
 // looks like one, the wait loop also polls the job read as a fallback for jobs
 // that never emit a watch-terminal event (e.g. rail-bypass `spawn` jobs).
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const JOB_POLL_INTERVAL_MS = 5000;
-const TIMEOUT_SUGGESTION = 'timeout ≠ failure — the operation may still be running. Re-watch with the same ref, or poll specrails_jobs(get)/specrails_specs(get) for current state.';
+const TIMEOUT_SUGGESTION = 'timeout ≠ failure — the operation may still be running. Re-watch with the same ref and kind, or poll specrails_jobs(get)/specrails_loops(run_get)/specrails_specs(get) for current state.';
 function isTerminal(type) {
-    return TERMINAL_PATTERNS.some((p) => type === p || type.endsWith(p));
+    return TERMINAL_PATTERNS.has(type);
 }
 function mentionsRef(msg, ref) {
-    // Heuristic: the reference (jobId / requestId / loopRunId) appears somewhere
-    // in the message payload. Cheap and robust across the heterogeneous WS union.
-    try {
-        return JSON.stringify(msg).includes(ref);
-    }
-    catch {
-        return false;
-    }
+    // Identity must match exactly: arbitrary log/output text can mention another
+    // operation, and "job-1" must never settle when "job-10" finishes.
+    const record = msg;
+    if (['jobId', 'processId', 'requestId', 'conversationId', 'loopRunId', 'refineId', 'runId', 'sessionId']
+        .some((key) => record[key] === ref))
+        return true;
+    if (msg.type.startsWith('plugin.'))
+        return record.name === ref;
+    if (msg.type.startsWith('file.'))
+        return record.path === ref;
+    if (msg.type.startsWith('setup_'))
+        return record.projectId === ref;
+    if (msg.type === 'smash.undone')
+        return String(record.ticketId) === ref;
+    return false;
+}
+const MAX_EVENT_BYTES = 16_000;
+const MAX_BUFFER_BYTES = 256_000;
+function boundedEvent(msg) {
+    const json = JSON.stringify(msg);
+    if (json.length <= MAX_EVENT_BYTES)
+        return { event: msg, bytes: json.length };
+    const record = msg;
+    const identity = Object.fromEntries(Object.entries(record).filter(([key, value]) => ['type', 'projectId', 'jobId', 'processId', 'requestId', 'conversationId', 'loopRunId', 'refineId', 'runId', 'sessionId', 'status', 'name', 'path'].includes(key)
+        && typeof value === 'string').map(([key, value]) => [key, value.slice(0, 1024)]));
+    const event = { ...identity, truncated: true, originalLength: json.length, preview: json.slice(0, 6000) };
+    return { event, bytes: JSON.stringify(event).length };
 }
 function watchTool() {
     return {
@@ -58,95 +79,167 @@ function watchTool() {
             'and return its events. Pass the reference (jobId / requestId / conversationId / loopRunId) returned by the action; projectId is optional ' +
             '(defaults to the active project; app-level operations need none). ' +
             'Resolves when a terminal event for that reference is seen, or after untilMs. ' +
-            'When the ref is a jobId (or kind:"job" is passed), the job status is also polled every 5s so jobs settle even without a watch-terminal event. ' +
+            'Use kind:"job" or kind:"loop_run" for durable recovery: reads current state immediately, then every 5s, including operations that finished before this call. UUID refs auto-detect jobs/loop runs. ' +
             'Default untilMs 120000 is often shorter than a rail run (max 600000). ' +
-            'settled:false means TIMEOUT, not failure — re-watch or poll the domain read (specrails_jobs(get) / specrails_specs(get) / specrails_plugins(health)).',
+            'settled means terminal, NOT necessarily successful; inspect terminalEvent.status/outcome. Events are bounded/truncated to protect context; other operation kinds only observe future events. ' +
+            'settled:false with reason:"timeout" means TIMEOUT, not failure — re-watch or poll the domain read. Cancellation stops waiting without stopping the operation. ' +
+            'A new message in the owning mission ends only this wait immediately with reason:"user_update" so the agent can incorporate it; the underlying job/rail keeps running.',
         tier: 'read',
         inputSchema: {
             projectId: zod_1.z
                 .string()
                 .optional()
                 .describe('Project id the operation runs in (defaults to the active project; omit for app-level operations)'),
-            ref: zod_1.z.string().describe('jobId / requestId / conversationId / loopRunId returned by the async action'),
+            ref: zod_1.z.string().min(1).describe('Exact jobId / requestId / conversationId / loopRunId returned by the async action'),
             untilMs: zod_1.z.number().int().min(1000).max(600000).default(120000).describe('Max time to wait (ms)'),
             kind: zod_1.z
-                .enum(['job'])
+                .enum(['job', 'loop_run'])
                 .optional()
-                .describe('Force the ref to be treated as a jobId (enables the 5s job-status poll fallback even for non-UUID ids)'),
+                .describe('Durable result type: job or loop_run. Reads immediately and every 5s, even for non-UUID ids. Omit to auto-detect UUID jobs/loops or listen for other event kinds.'),
         },
         handler: (ctx, args) => {
             // Optional + active-project resolution: an explicit projectId wins, else
-            // the active project. When neither exists, project filtering is skipped —
-            // the ref-substring match is discriminating enough, and app-level agent
-            // operations carry no projectId at all.
+            // the active project. App-level operations can have neither; exact
+            // operation identity still filters their events.
             const projectId = args.projectId ?? (0, types_1.getActiveProject)(ctx) ?? undefined;
             const ref = args.ref;
             const untilMs = args.untilMs ?? 120000;
-            const pollAsJob = args.kind === 'job' || UUID_RE.test(ref);
+            const kind = args.kind;
+            if (kind && !projectId)
+                throw new Error('Watching a job or loop_run requires projectId or an active project. Select the project or pass projectId.');
+            const shouldPoll = kind !== undefined || UUID_RE.test(ref);
             return new Promise((resolve) => {
+                const readController = new AbortController();
+                const readCtx = { ...ctx, signal: ctx.signal
+                        ? AbortSignal.any([ctx.signal, readController.signal])
+                        : readController.signal };
                 const events = [];
+                let eventCount = 0;
+                let bufferBytes = 0;
                 let done = false;
+                let poller;
+                let timer;
+                let unsub = () => { };
+                let unsubMission = () => { };
+                const addEvent = (msg) => {
+                    if (done)
+                        return;
+                    const entry = boundedEvent(msg);
+                    events.push(entry);
+                    eventCount++;
+                    bufferBytes += entry.bytes;
+                    while (events.length > 50 || bufferBytes > MAX_BUFFER_BYTES) {
+                        bufferBytes -= events.shift().bytes;
+                    }
+                };
+                const aborted = () => finish(false, 'canceled');
                 const finish = (settled, reason) => {
                     if (done)
                         return;
                     done = true;
+                    readController.abort();
                     clearTimeout(timer);
                     if (poller)
                         clearInterval(poller);
                     unsub();
+                    unsubMission();
+                    ctx.signal?.removeEventListener('abort', aborted);
                     resolve({
                         settled,
                         reason,
                         ref,
                         projectId: projectId ?? null,
-                        eventCount: events.length,
-                        terminalEvent: settled ? events[events.length - 1] : null,
-                        events: events.slice(-50),
-                        ...(settled ? {} : { suggestion: TIMEOUT_SUGGESTION }),
+                        eventCount,
+                        terminalEvent: settled ? events[events.length - 1]?.event ?? null : null,
+                        events: events.map((entry) => entry.event),
+                        ...(reason === 'user_update' ? { operationStopped: false } : {}),
+                        ...(settled ? {} : { suggestion: reason === 'user_update'
+                                ? 'Waiting ended because the user updated this mission; the operation was NOT stopped and may still be running. Incorporate the user instructions received through the active mission input channel, then decide the next action from current state.'
+                                : reason === 'canceled'
+                                    ? 'Waiting was canceled; the operation was not stopped. Read its current state before deciding the next action.'
+                                    : TIMEOUT_SUGGESTION }),
                     });
                 };
-                const unsub = ctx.eventBus.onMessage((msg) => {
+                if (ctx.signal?.aborted) {
+                    aborted();
+                    return;
+                }
+                ctx.signal?.addEventListener('abort', aborted, { once: true });
+                unsub = ctx.eventBus.onMessage((msg) => {
+                    if (done)
+                        return;
                     const msgProjectId = msg.projectId;
                     if (projectId && msgProjectId && msgProjectId !== projectId)
                         return;
                     if (!mentionsRef(msg, ref))
                         return;
-                    events.push(msg);
+                    addEvent(msg);
                     const type = msg.type ?? '';
+                    // A loop's final job accounting may precede its durable loop outcome.
+                    // Explicit kinds must wait for their own lifecycle, even if ids match.
+                    if (kind === 'loop_run' && !type.startsWith('loop.run_'))
+                        return;
+                    if (kind === 'job' && type !== 'job.finalized' && !type.startsWith('rail.job_'))
+                        return;
                     if (isTerminal(type))
                         finish(true, `terminal:${type}`);
                 });
-                // Job-status poll fallback: some jobs (rail-bypass spawn) never emit a
-                // watch-terminal event; poll the job read every 5s and settle when its
-                // status is terminal. Polling needs a resolvable project; errors (e.g.
-                // the ref is not a job in this project) are ignored and the wait
-                // continues on the event path.
-                let poller;
-                if (pollAsJob && projectId) {
+                if (ctx.onMissionInput) {
+                    unsubMission = ctx.onMissionInput(() => finish(false, 'user_update'));
+                    // Registration can synchronously report an already-pending input.
+                    // finish then ran before its disposer was assigned; release it now.
+                    if (done) {
+                        unsubMission();
+                        return;
+                    }
+                }
+                // Subscribe BEFORE reading durable state, closing the fast-completion
+                // race. Never overlap reads or let a late response resurrect this wait.
+                if (shouldPoll && projectId) {
                     let polling = false;
-                    poller = setInterval(() => {
+                    const poll = async () => {
                         if (done || polling)
                             return;
                         polling = true;
-                        (0, types_1.apiCall)(ctx, 'GET', `/projects/${encodeURIComponent(projectId)}/jobs/${encodeURIComponent(ref)}`)
-                            .then((r) => {
-                            const status = r?.job?.status;
-                            if (typeof status === 'string' && TERMINAL_JOB_STATUSES.has(status)) {
-                                events.push({ type: 'job.poll_settled', projectId, jobId: ref, status });
-                                finish(true, `poll:job:${status}`);
+                        try {
+                            const base = `/projects/${encodeURIComponent(projectId)}`;
+                            if (kind !== 'loop_run') {
+                                const result = await (0, types_1.apiCall)(readCtx, 'GET', `${base}/jobs/${encodeURIComponent(ref)}`).catch(() => null);
+                                if (done)
+                                    return;
+                                const job = result?.job;
+                                if (job) {
+                                    if (typeof job.status === 'string' && TERMINAL_JOB_STATUSES.has(job.status)) {
+                                        addEvent({ type: 'job.poll_settled', projectId, jobId: ref, status: job.status });
+                                        finish(true, `poll:job:${job.status}`);
+                                    }
+                                    return;
+                                }
+                            }
+                            if (kind === 'job')
+                                return;
+                            const result = await (0, types_1.apiCall)(readCtx, 'GET', `${base}/loop-runs/${encodeURIComponent(ref)}`);
+                            if (done)
+                                return;
+                            const run = result?.loopRun;
+                            if (run?.status === 'completed') {
+                                addEvent({ type: 'loop.poll_settled', projectId, loopRunId: ref, status: run.status, outcome: run.final_outcome ?? null });
+                                finish(true, `poll:loop_run:${run.final_outcome ?? run.status}`);
                             }
-                        })
-                            .catch(() => {
-                            /* not a job / transient error — keep waiting on events */
-                        })
-                            .finally(() => {
+                        }
+                        catch {
+                            // Unknown ref / transient read failure: stay subscribed, retry.
+                        }
+                        finally {
                             polling = false;
-                        });
-                    }, JOB_POLL_INTERVAL_MS);
+                        }
+                    };
+                    poller = setInterval(() => { void poll(); }, JOB_POLL_INTERVAL_MS);
                     if (typeof poller.unref === 'function')
                         poller.unref();
+                    void poll();
                 }
-                const timer = setTimeout(() => finish(false, 'timeout'), untilMs);
+                timer = setTimeout(() => finish(false, 'timeout'), untilMs);
                 // Do not keep the event loop alive solely for this watch.
                 if (typeof timer.unref === 'function')
                     timer.unref();

package/server/dist/milestone-chain-store.js

@@ -0,0 +1,164 @@
+"use strict";
+// Durable milestone launch chains (premium-milestone-progress, migration 58).
+//
+// One row per "Launch Milestone" in sequential mode: the chunk plan, the
+// chunk currently in flight (rail / runs / delivery), the branch the next
+// chunk stacks on, and a compare-and-set status so a settle is never advanced
+// twice. Replaces the browser-local localStorage plan that died with the
+// window and never stacked chunks.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTIVE_CHAIN_STATUSES = void 0;
+exports.isActiveChainStatus = isActiveChainStatus;
+exports.createChain = createChain;
+exports.getChain = getChain;
+exports.listActiveChains = listActiveChains;
+exports.listChains = listChains;
+exports.parseChunks = parseChunks;
+exports.parseLaunched = parseLaunched;
+exports.parseRunIds = parseRunIds;
+exports.listChainsTouchingDelivery = listChainsTouchingDelivery;
+exports.updateChain = updateChain;
+exports.toChainSnapshot = toChainSnapshot;
+exports.pauseChainsForDiscardedHead = pauseChainsForDiscardedHead;
+exports.ACTIVE_CHAIN_STATUSES = new Set(['running', 'waiting', 'paused', 'awaiting_approval']);
+function isActiveChainStatus(status) {
+    return exports.ACTIVE_CHAIN_STATUSES.has(status);
+}
+function iso(nowMs) {
+    return new Date(nowMs ?? Date.now()).toISOString();
+}
+function createChain(db, input) {
+    const ts = iso(input.nowMs);
+    db.prepare(`
+    INSERT INTO milestone_launch_chains
+      (id, milestone_n, milestone_id, mode, chunks, next_chunk, current_run_ids, integration_branch, status, launched, auto_advance, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, 0, '[]', ?, ?, '[]', ?, ?, ?)
+  `).run(input.id, input.milestoneN, input.milestoneId, input.mode, JSON.stringify(input.chunks), input.integrationBranch, input.status ?? 'running', input.autoAdvance === false ? 0 : 1, ts, ts);
+    return getChain(db, input.id);
+}
+function getChain(db, id) {
+    return db.prepare('SELECT * FROM milestone_launch_chains WHERE id = ?').get(id);
+}
+/** Non-terminal chains (running / waiting / paused / awaiting_approval), oldest first. */
+function listActiveChains(db) {
+    return db.prepare(`
+    SELECT * FROM milestone_launch_chains
+     WHERE status IN ('running','waiting','paused','awaiting_approval')
+     ORDER BY created_at ASC, rowid ASC
+  `).all();
+}
+/** Every chain, newest first (progress projection picks the newest per milestone). */
+function listChains(db) {
+    return db.prepare('SELECT * FROM milestone_launch_chains ORDER BY created_at DESC, rowid DESC').all();
+}
+function parseChunks(row) {
+    try {
+        const parsed = JSON.parse(row.chunks);
+        return Array.isArray(parsed) ? parsed.filter((c) => Array.isArray(c)) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseLaunched(row) {
+    try {
+        const parsed = JSON.parse(row.launched);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseRunIds(row) {
+    try {
+        const parsed = JSON.parse(row.current_run_ids);
+        return Array.isArray(parsed) ? parsed.filter((v) => typeof v === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Chains whose launched chunks include this delivery (any status). */
+function listChainsTouchingDelivery(db, deliveryId) {
+    return listChains(db).filter((row) => parseLaunched(row).some((l) => l.deliveryId === deliveryId));
+}
+const PATCH_COLUMNS = {
+    nextChunk: 'next_chunk',
+    currentRailIndex: 'current_rail_index',
+    currentRunIds: 'current_run_ids',
+    currentDeliveryId: 'current_delivery_id',
+    headBranch: 'head_branch',
+    status: 'status',
+    pauseReason: 'pause_reason',
+    launched: 'launched',
+    lastRunOutcome: 'last_run_outcome',
+    autoAdvance: 'auto_advance',
+    retryChunk: 'retry_chunk',
+};
+function patchValue(key, patch) {
+    const raw = patch[key];
+    if (key === 'currentRunIds' || key === 'launched')
+        return JSON.stringify(raw ?? []);
+    if (key === 'autoAdvance')
+        return raw ? 1 : 0;
+    return raw ?? null;
+}
+/**
+ * Compare-and-set update: applies only while the row's status is one of
+ * `expected` (a string or a list). Returns true when a row changed.
+ */
+function updateChain(db, id, expected, patch, nowMs) {
+    const keys = Object.keys(patch).filter((k) => patch[k] !== undefined);
+    const setClause = keys.map((k) => `${PATCH_COLUMNS[k]} = ?`).concat('updated_at = ?').join(', ');
+    const values = keys.map((k) => patchValue(k, patch));
+    const expectedList = Array.isArray(expected) ? expected : [expected];
+    const placeholders = expectedList.map(() => '?').join(', ');
+    return db.prepare(`UPDATE milestone_launch_chains SET ${setClause} WHERE id = ? AND status IN (${placeholders})`)
+        .run(...values, iso(nowMs), id, ...expectedList).changes > 0;
+}
+function toChainSnapshot(row) {
+    return {
+        id: row.id,
+        milestoneN: row.milestone_n,
+        mode: row.mode,
+        status: row.status,
+        pauseReason: row.pause_reason,
+        autoAdvance: row.auto_advance !== 0,
+        nextChunk: row.next_chunk,
+        totalChunks: parseChunks(row).length,
+        currentRailIndex: row.current_rail_index,
+        headBranch: row.head_branch,
+        launched: parseLaunched(row),
+        updatedAt: row.updated_at,
+    };
+}
+/**
+ * A delivery that a chain's later chunks build on was discarded by the user:
+ * pause every active chain whose launched chunks include it, and rewind the
+ * head to the previous launched chunk's delivery (`resolveBranch`), else null
+ * (= the integration branch). Returns the rows it paused.
+ */
+function pauseChainsForDiscardedHead(db, deliveryId, resolveBranch, nowMs) {
+    const paused = [];
+    for (const row of listActiveChains(db)) {
+        const launched = parseLaunched(row);
+        const idx = launched.findIndex((l) => l.deliveryId === deliveryId);
+        if (idx < 0)
+            continue;
+        let previous = null;
+        for (let i = idx - 1; i >= 0; i--) {
+            const id = launched[i].deliveryId;
+            if (!id)
+                continue;
+            previous = resolveBranch(id);
+            if (previous)
+                break;
+        }
+        if (updateChain(db, row.id, row.status, { status: 'paused', pauseReason: 'head_discarded', headBranch: previous }, nowMs)) {
+            const fresh = getChain(db, row.id);
+            if (fresh)
+                paused.push(fresh);
+        }
+    }
+    return paused;
+}