specrails-desktop 2.36.0 → 2.42.2

package/server/dist/index.js

@@ -44,12 +44,16 @@ const framework_manager_1 = require("./framework-manager");
 const artifact_registry_1 = require("./artifact-registry");
 const path_resolver_1 = require("./path-resolver");
 const dev_ports_1 = require("./dev-ports");
+const api_not_found_1 = require("./api-not-found");
 const process_admission_1 = require("./process-admission");
+const host_control_1 = require("./host-control");
+const transient_children_1 = require("./transient-children");
 // Side-effect import: registers every bundled ProviderAdapter (claude, codex,
 // future providers) so `getAdapter`/`hasAdapter`/`listAdapters` are populated
 // before any manager constructs a project context. See
 // openspec/changes/add-multi-provider-support/specs/multi-provider-architecture/spec.md.
 require("./providers");
+const hostControlToken = (0, host_control_1.consumeHostControlToken)();
 const inheritedPathBeforeResolve = (process.env.PATH ?? '').split(process.platform === 'win32' ? ';' : ':').filter(Boolean).length;
 // Backfill SystemRoot/ComSpec/etc into process.env BEFORE anything spawns, so a
 // stripped GUI-launch sidecar env never breaks cmd.exe-mediated spawns (PTY,
@@ -155,6 +159,7 @@ function corsMiddleware(req, res, next) {
     next();
 }
 app.use(corsMiddleware);
+app.use('/api/host', (0, host_control_1.createHostControlRouter)({ token: hostControlToken, onShutdown: shutdown }));
 // Provider traffic uses the desktop listener as a stable relay. Mount before
 // every body parser so large/streaming request bodies and Codex event streams
 // pass through byte-for-byte; the relay verifies the connected Headroom backend
@@ -504,9 +509,17 @@ function applyPtyWsRateLimiting(ws) {
 // ─── Super-mode bootstrap ─────────────────────────────────────────────────────
 {
     const registry = new project_registry_1.ProjectRegistry(broadcast, undefined, port);
+    try {
+        (0, transient_children_1.initializeBackgroundProcessPersistence)(path_1.default.join(path_1.default.dirname(registry.desktopDb.name), 'background-processes.sqlite'));
+    }
+    catch (error) {
+        // A log-store failure must not take mission chat or the project catalog
+        // offline. New background launches report the persistence error directly.
+        console.error('[background-process] persistent history unavailable:', error);
+    }
     registry.loadAll();
     _registry = registry;
-    _getProjectCount = () => registry.listContexts().length;
+    _getProjectCount = () => registry.listProjects().length;
     // ─── Bundled framework update channel (Phase 6) ─────────────────────────────
     // After the registry + projects have loaded, run a single framework
     // version-check. On FIRST run it materializes the bundled framework to
@@ -606,6 +619,15 @@ function applyPtyWsRateLimiting(ws) {
         broadcast,
     }));
     if (mcpManager.isEnabledSetting()) {
+        // MCP is on by default, so mint + persist the scoped token at boot: the
+        // stdio bridge reads ~/.specrails/mcp.token locally, and on a fresh install
+        // nothing else would have written it until Settings ▸ MCP was opened.
+        try {
+            (0, mcp_1.getMcpToken)();
+        }
+        catch (err) {
+            console.warn('[mcp] could not prepare the scoped token at boot:', err);
+        }
         mcpManager.start().catch((err) => console.error('[mcp] boot start failed:', err));
     }
     // ─── App-global agent chat (drives the app via its own MCP) ────────────────
@@ -660,7 +682,7 @@ function applyPtyWsRateLimiting(ws) {
                 state.subscribedProjectId = frame.projectId;
         });
         // Send app state init
-        const projects = registry.listContexts().map((ctx) => ctx.project);
+        const projects = registry.listProjects();
         ws.send(JSON.stringify({
             type: 'desktop.projects',
             projects,
@@ -680,6 +702,7 @@ app.use((err, _req, res, _next) => {
     }
 });
 // ─── Serve built React client (production) ────────────────────────────────────
+app.use(['/api', '/hooks'], api_not_found_1.apiNotFound);
 const clientDist = path_1.default.resolve(__dirname, '../../client/dist');
 if (fs_1.default.existsSync(clientDist)) {
     app.use(express_1.default.static(clientDist));
@@ -699,6 +722,13 @@ server.on('error', (err) => {
 server.listen(port, '127.0.0.1', () => {
     console.log(`specrails web manager running on http://127.0.0.1:${port}`);
     writePidFile();
+    // Milestone launch chains launch chunks over loopback REST, so a chain whose
+    // chunk settled while the server was down can only replay once we listen.
+    for (const ctx of _registry?.listContexts() ?? []) {
+        void ctx.milestoneChains?.recoverOnStartup().catch((err) => {
+            console.error(`[milestone-chain] startup recovery failed for ${ctx.project.id}:`, err);
+        });
+    }
     // Sweep stale shell-integration shim directories left behind by previous runs.
     try {
         const removed = (0, terminal_shell_integration_1.cleanupStaleShimDirs)();
@@ -744,6 +774,17 @@ async function shutdown() {
         Promise.resolve().then(() => _agentChatManager?.shutdown()),
         Promise.resolve().then(() => _blueprintChatManager?.shutdown()),
     ]);
+    // The shell can exit before its application descendants. Keep the event
+    // loop alive for the owned-group escalation before server.close exits us.
+    const remainingBackground = await (0, transient_children_1.awaitBackgroundProcessesStopped)(6000);
+    if (remainingBackground.length)
+        console.error('[shutdown] background applications still alive after stop deadline:', remainingBackground.map(({ pid, processId, error }) => ({ pid, processId, error })));
+    try {
+        (0, transient_children_1.closeBackgroundProcessPersistence)();
+    }
+    catch (error) {
+        console.error('[shutdown] background process history could not be flushed:', error);
+    }
     try {
         await _headroomManager?.shutdown();
     }

package/server/dist/interactive-job-session.js

@@ -40,6 +40,9 @@ const result_event_1 = require("./result-event");
 const db_1 = require("./db");
 const stream_display_1 = require("./util/stream-display");
 const runtime_1 = require("./providers/runtime");
+const terminal_result_1 = require("./providers/terminal-result");
+const claude_background_tasks_1 = require("./providers/claude-background-tasks");
+const loop_constants_1 = require("./loop-constants");
 /** Claude's stream-json result frames do not carry a turn id. Hash a canonical
  * representation of the real frame instead: an exact/semantic retransmission
  * remains identifiable even after the next stdin turn has been armed, while a
@@ -58,6 +61,11 @@ function canonicalJson(value) {
 function resultFrameSignature(frame) {
     return (0, node_crypto_1.createHash)('sha256').update(canonicalJson(frame)).digest('hex');
 }
+/** Bound unproductive reply/continue cycles for the same unfinished workers.
+ * A blocking collection can take as long as the owner's ordinary step budget;
+ * repeatedly returning without joining the workers cannot spin forever. */
+const MAX_BACKGROUND_HANDOFFS = 3;
+const MAX_TOTAL_BACKGROUND_HANDOFFS = 12;
 /** The claude CLI's synthetic no-op marker: the result text of a frame emitted
  *  for a command the CLI could not resolve (nothing was sent to the model). */
 exports.UNKNOWN_COMMAND_RE = /^Unknown command:/;
@@ -120,6 +128,7 @@ class InteractiveJobSession {
     _onSettle;
     _settleMode;
     _zombieTimeoutMs;
+    _onZombieTimeoutHook;
     _quiescentEofGraceMs;
     /** Armed by the quiescent graceful teardown: SIGTERM escalation if the child
      *  ignores the stdin EOF. Cleared on close/settle/dispose. */
@@ -158,11 +167,16 @@ class InteractiveJobSession {
     _sessionId = null;
     /** Last completed turn's `result` payload (output chaining — see SettleInfo). */
     _resultText = null;
+    _resultIsError = false;
     /** True once ANY assistant-derived event was observed across the whole
      *  session life (isModelWorkEvent). Feeds the zero-work settle predicate:
      *  real turns always emit assistant events; the synthetic `Unknown command:`
      *  frame never does. */
     _sawModelWork = false;
+    /** Authoritative live roster, never a reason to complete an automatic step. */
+    _liveBackgroundTasks = [];
+    _backgroundHandoffs = 0;
+    _totalBackgroundHandoffs = 0;
     /** Previous turn's CUMULATIVE `total_cost_usd` / `num_turns` reading. The
      *  persistent stream-json transport reports both cumulatively per turn, so we
      *  accumulate deltas against these baselines (HIGH-2). Reset to 0 when the
@@ -199,6 +213,7 @@ class InteractiveJobSession {
         this._onSettle = deps.onSettle;
         this._settleMode = deps.settleMode ?? 'finalize';
         this._zombieTimeoutMs = deps.zombieTimeoutMs ?? 0;
+        this._onZombieTimeoutHook = deps.onZombieTimeout;
         this._quiescentEofGraceMs = deps.quiescentEofGraceMs ?? 5000;
         this._nextEventSeq = deps.nextEventSeq ?? null;
         this._persistTurnUsage = deps.persistTurnUsage ?? null;
@@ -208,12 +223,37 @@ class InteractiveJobSession {
     }
     /** Spawn the resident child and run the first turn (the freestyle prompt). */
     start(spec, firstPrompt) {
-        const child = this._spawn(spec.binary, spec.args, {
-            env: spec.env ?? process.env,
-            // stdin MUST be piped — it is the per-turn transport.
-            stdio: ['pipe', 'pipe', 'pipe'],
-            cwd: spec.cwd,
-        });
+        // Keep slash-command expansion intact: the lifecycle rule belongs in the
+        // system context, not in the command's argument string. Preserve any
+        // existing appended system prompt supplied by the queue/loop owner.
+        const args = [...spec.args];
+        if (this._adapter.id === 'claude' && this._settleMode === 'auto') {
+            const index = args.indexOf('--append-system-prompt');
+            if (index >= 0)
+                args[index + 1] = `${args[index + 1] ?? ''}\n\n${loop_constants_1.FOREGROUND_RULE}`;
+            else
+                args.push('--append-system-prompt', loop_constants_1.FOREGROUND_RULE);
+        }
+        let child;
+        try {
+            child = this._spawn(spec.binary, args, {
+                env: spec.env ?? process.env,
+                // stdin MUST be piped — it is the per-turn transport.
+                stdio: ['pipe', 'pipe', 'pipe'],
+                cwd: spec.cwd,
+            });
+        }
+        catch (error) {
+            // Local preparation (including managed skills) can fail synchronously,
+            // before there is a child to emit error/close. Settle through the normal
+            // owner callback so no interactive slot or step timer leaks.
+            this._resultText = `Could not start ${this._adapter.id}: ${error instanceof Error ? error.message : String(error)}`;
+            this._resultIsError = true;
+            this._persistLog('stderr', this._resultText);
+            this._emitLog('stderr', this._resultText);
+            this._settle('crashed');
+            return;
+        }
         this._child = child;
         this._childClosed = false;
         this._stdinFailed = false;
@@ -272,7 +312,7 @@ class InteractiveJobSession {
      *  an immediate prompt only after a confirmed stdin write. Returns false if the
      *  session is gone OR the write could not be delivered (stdin destroyed/EPIPE). */
     send(text) {
-        if (this._disposed || this._finalizing || !this._child)
+        if (this._disposed || this._settled || this._finalizing || !this._child)
             return false;
         const queued = this._streaming;
         if (queued) {
@@ -392,6 +432,8 @@ class InteractiveJobSession {
      *  write; false when stdin is gone/destroyed or the write throws (EPIPE) — the
      *  caller must NOT treat an unconfirmed turn as accepted. */
     _writeTurn(text) {
+        if (this._disposed || this._settled || this._finalizing || this._terminationStarted)
+            return false;
         const child = this._child;
         if (!child || !child.stdin || child.stdin.destroyed || this._stdinFailed)
             return false;
@@ -431,20 +473,39 @@ class InteractiveJobSession {
             parsed = JSON.parse(line);
         }
         catch { /* plain text */ }
+        // Keep the live roster current before deciding whether a result completes
+        // the step or needs the parent to join its unfinished workers.
+        this._trackBackgroundTasks(parsed);
+        // parseStreamEvents is pure, so classifying the frame through the adapter
+        // BEFORE the drop logic is safe — and it is the adapter that knows a claude
+        // `result` frame carrying `origin.kind === 'task-notification'` is a
+        // CLI-internal notification turn, not this turn's terminal result.
+        const adapterEvents = (0, runtime_1.parseStreamEvents)(this._adapter, line);
         // A late retransmission can arrive after the next queued prompt has already
-        // been written. Drop it BEFORE adapter parsing and event persistence: adding
-        // it to the next turn's event buffer corrupts live totals, while persisting
-        // it beyond the prior checkpoint would make crash recovery count it again.
+        // been written. Drop it BEFORE event persistence: adding it to the next
+        // turn's event buffer corrupts live totals, while persisting it beyond the
+        // prior checkpoint would make crash recovery count it again.
         if (parsed?.type === 'result') {
             // A terminal frame with no active turn is causally unassignable. Drop it
-            // before adapter parsing/persistence so raw recovery cannot count it.
+            // before persistence so raw recovery cannot count it.
             if (!this._awaitingResult)
                 return;
+            if (!adapterEvents.some((ev) => ev.kind === 'result')) {
+                // Notification turn (loop run 5c958db2): the CLI answered its OWN
+                // orphaned-background-task notice, not the prompt we wrote — the real
+                // turn is still coming. Closing the turn here auto-settled the session
+                // and tore the child down mid-thought as a zero-work failure. Leave the
+                // turn armed, and do not persist the frame as a `result` row either
+                // (crash recovery counts persisted result rows as completed turns).
+                const note = `↷ ${this._adapter.id} reported a background-task notification (not this turn's result) — continuing.`;
+                this._persistLog('stdout', note);
+                this._emitLog('stdout', note);
+                return;
+            }
             const signature = resultFrameSignature(parsed);
             if (this._acceptedResultSignatures.has(signature))
                 return;
         }
-        const adapterEvents = (0, runtime_1.parseStreamEvents)(this._adapter, line);
         for (const adapterEvent of adapterEvents) {
             this._turnEvents.push(adapterEvent);
             if (!this._sawModelWork && isModelWorkEvent(adapterEvent))
@@ -486,6 +547,47 @@ class InteractiveJobSession {
             }
         }
     }
+    /** Mirror claude's `system/background_tasks_changed` roster. Any other frame
+     *  (or a non-claude provider, which never emits it) leaves the roster as is. */
+    _trackBackgroundTasks(parsed) {
+        if (this._adapter.id !== 'claude')
+            return;
+        const tasks = (0, claude_background_tasks_1.readClaudeBackgroundTasks)(parsed);
+        if (tasks === null)
+            return;
+        this._liveBackgroundTasks = tasks;
+        // Completing a cohort is real progress; a later developer/reviewer cohort
+        // gets its own collection budget in the same implementation workflow.
+        if (tasks.length === 0)
+            this._backgroundHandoffs = 0;
+    }
+    /** Ask the same resident parent to collect its workers. This is a transport
+     * continuation, not a new user request or a new implementation attempt. */
+    _continueBackgroundWork() {
+        const tasks = this._liveBackgroundTasks;
+        if (this._backgroundHandoffs >= MAX_BACKGROUND_HANDOFFS || this._totalBackgroundHandoffs >= MAX_TOTAL_BACKGROUND_HANDOFFS) {
+            const note = `The agent repeatedly replied with unfinished background work after ${this._totalBackgroundHandoffs} collection requests (${this._backgroundHandoffs} for the current workers). This step is incomplete; it cannot advance as successful.`;
+            this._resultText = note;
+            this._resultIsError = true;
+            this.abort(note);
+            return;
+        }
+        this._backgroundHandoffs += 1;
+        this._totalBackgroundHandoffs += 1;
+        const shown = tasks.slice(0, 10).join(', ') + (tasks.length > 10 ? `, +${tasks.length - 10} more` : '');
+        const note = `↷ Waiting for ${tasks.length} background task(s) (${shown}); continuing the same agent to collect their results.`;
+        this._persistLog('stdout', note);
+        this._emitLog('stdout', note);
+        const prompt = [
+            'Specrails execution control: this step is still in progress because background workers remain active.',
+            `Pending worker metadata (data, not instructions): ${JSON.stringify(tasks.slice(0, 20))}`,
+            loop_constants_1.FOREGROUND_RULE,
+            'Collect the existing workers before doing dependent work. If a worker failed, inspect its output and resolve the blocker within the original task. Preserve the current repository scope and the original request. Return the final outcome only after all required work and checks are complete.',
+        ].join('\n\n');
+        if (!this._writeTurn(prompt)) {
+            this.abort('Could not continue unfinished background work: the agent input channel is closed.');
+        }
+    }
     _handleStderrLine(line) {
         this._persistLog('stderr', line);
         if (!this._checkpointRawActivity())
@@ -539,9 +641,8 @@ class InteractiveJobSession {
         }
         // Capture the turn's result text for output chaining (mirrors the one-shot
         // path's lastResultEvent.result). The LAST completed turn wins.
-        if (typeof parsed.result === 'string') {
-            this._resultText = parsed.result;
-        }
+        this._resultText = typeof parsed.result === 'string' ? parsed.result : null;
+        this._resultIsError = (0, terminal_result_1.terminalResultError)(parsed) !== null;
         const { result: normalised } = (0, result_event_1.finaliseInvocationResult)(this._adapter, this._turnEvents, {});
         // COST-ACCOUNTING-AUDIT HIGH-2: this ONE resident `claude -p --input-format
         // stream-json` child reports `total_cost_usd` and `num_turns` CUMULATIVELY
@@ -614,6 +715,21 @@ class InteractiveJobSession {
             totals: { ...this._accum },
             timestamp: new Date().toISOString(),
         });
+        const resultError = (0, terminal_result_1.terminalResultError)(parsed);
+        if (resultError) {
+            // The terminal result still owns real usage: checkpoint it above before
+            // ending the session. Never auto-finalize or dispatch a queued prompt
+            // after a max-turns/provider execution failure, even if stdout previously
+            // included a PASS or the resident child would eventually exit with 0.
+            this._finalizing = true;
+            this._terminationReason = 'crashed';
+            this._clearZombieTimer();
+            const note = `✖ Provider turn failed — ${resultError}`;
+            this._persistLog('stderr', note);
+            this._emitLog('stderr', note);
+            this._terminateChildTree('crashed');
+            return;
+        }
         // Feed the next queued prompt (if any) now that the turn is idle. Deferred to a
         // microtask so any stray/duplicate result for THIS just-settled turn that is
         // sitting in the same synchronous stdout batch is processed (and rejected by
@@ -645,7 +761,10 @@ class InteractiveJobSession {
                     return;
                 if (this._streaming || this._pending.length > 0)
                     return;
-                this._finalizeQuiescent();
+                if (this._liveBackgroundTasks.length > 0)
+                    this._continueBackgroundWork();
+                else
+                    this._finalizeQuiescent();
             });
         }
     }
@@ -815,11 +934,19 @@ class InteractiveJobSession {
         const timeoutSec = Math.round(this._zombieTimeoutMs / 1000);
         const note = `[zombie-detection] Interactive job ${this._jobId} produced no output for ${timeoutSec}s — auto-terminating`;
         console.error(note);
+        try {
+            this._onZombieTimeoutHook?.();
+        }
+        catch { /* owner hook must never block teardown */ }
         this.abort(note);
     }
     _settle(reason) {
         if (this._settled)
             return;
+        // A terminal error received during graceful teardown overrides an earlier
+        // finalize request, including a teardown timer armed before the error.
+        if (this._terminationReason === 'crashed')
+            reason = 'crashed';
         this._settled = true;
         // Fold any unfinished turn BEFORE snapshotting totals so a mid-turn
         // finalize/crash keeps that turn's spend (CRIT-4).
@@ -867,6 +994,7 @@ class InteractiveJobSession {
             estimated: this._inflightEstimated,
             activeDurationMs: this._activeDurationMs,
             resultText: this._resultText,
+            resultIsError: this._resultIsError,
             zeroWork,
         });
     }
@@ -882,6 +1010,11 @@ class InteractiveJobSession {
      * settles because its owner already flushed/reconciles the job separately.
      */
     _terminateChildTree(reason) {
+        // Close admission synchronously, before SIGTERM. A child may take seconds
+        // to exit; neither a queued user prompt nor an auto-collection microtask
+        // may start another turn in that window (including a late result frame).
+        this._finalizing = true;
+        this._clearZombieTimer();
         if (reason !== null && this._terminationReason === null)
             this._terminationReason = reason;
         const child = this._child;

package/server/dist/internal-api.js

@@ -0,0 +1,48 @@
+"use strict";
+// Loopback client for the app's OWN REST API, authenticated with the master
+// token held server-side. Precedent: the MCP domain tools (`apiCall`), which
+// reuse every router's validation instead of re-implementing it. The milestone
+// launch chain uses it to launch chunks through the ordinary rails launch
+// route — the single authority for its ~15 guards — so a chunk launch behaves
+// byte-identically to a dashboard launch and every 4xx becomes a typed reason.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInternalApi = createInternalApi;
+exports.internalApiError = internalApiError;
+const auth_1 = require("./auth");
+function createInternalApi(deps) {
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const token = deps.token ?? auth_1.loadOrGenerateToken;
+    return {
+        async call(method, path, body) {
+            const res = await fetchImpl(`http://127.0.0.1:${deps.port}/api${path}`, {
+                method,
+                headers: {
+                    Authorization: `Bearer ${token()}`,
+                    ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
+                },
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+            });
+            const text = await res.text();
+            let data;
+            try {
+                data = text ? JSON.parse(text) : null;
+            }
+            catch {
+                data = text;
+            }
+            return { ok: res.ok, status: res.status, body: data };
+        },
+    };
+}
+/** Extract the router's `{ error, detail }` from a failed response body. */
+function internalApiError(res) {
+    const body = res.body;
+    if (body && typeof body === 'object') {
+        const obj = body;
+        return {
+            error: typeof obj.error === 'string' ? obj.error : `http_${res.status}`,
+            ...(typeof obj.detail === 'string' ? { detail: obj.detail } : {}),
+        };
+    }
+    return { error: `http_${res.status}`, ...(typeof body === 'string' && body ? { detail: body.slice(0, 200) } : {}) };
+}

package/server/dist/jira/jira-materializer.js

@@ -131,6 +131,7 @@ function mapIssueToTicket(issue, localId, conn, existing) {
         labels: issue.fields.labels ?? [],
         assignee: issue.fields.assignee?.displayName ?? issue.fields.assignee?.emailAddress ?? null,
         prerequisites: existing?.prerequisites ?? [],
+        ...(existing?.repositoryIds ? { repositoryIds: [...existing.repositoryIds] } : {}),
         metadata: existing?.metadata ?? {},
         comments: existing?.comments ?? [],
         attachments: existing?.attachments,

package/server/dist/json-tolerant.js

@@ -0,0 +1,174 @@
+"use strict";
+// ─── Tolerant JSON parsing for model-emitted payloads ─────────────────────────
+//
+// A model writing a ~20 KB JSON snapshot by hand makes small, predictable
+// mistakes: a raw newline inside a string, an unescaped inner quote, a
+// trailing comma, a nested ```json fence, a stray comment. `JSON.parse`
+// rejects all of them and the whole snapshot used to be dropped silently.
+//
+// `parseJsonTolerant` first tries strict `JSON.parse`; only when that fails
+// does it run ONE deterministic repair pass (a small string-aware state
+// machine — never a regex over the whole text, so repairs inside string
+// literals can't corrupt structure) and parses again. The result says whether
+// a repair was needed and which kinds were applied, so callers can log/badge
+// it. It never throws.
+//
+// Client mirror: client/src/lib/json-tolerant.ts — keep the two in sync.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repairJsonText = repairJsonText;
+exports.parseJsonTolerant = parseJsonTolerant;
+const VALID_ESCAPES = '"\\/bfnrtu';
+function isJsonWhitespace(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\r' || ch === '\n';
+}
+/** One string-aware pass over `source` fixing the common model mistakes. */
+function repairJsonText(source) {
+    const repairs = new Set();
+    let text = source.trim();
+    // A nested code fence around the payload (```json … ``` inside the
+    // blueprint-draft block). Leading and trailing fences are stripped
+    // independently: the outer lazy fence regex may already have eaten one.
+    const leadingFence = /^```[A-Za-z0-9_-]*[ \t]*\r?\n/.exec(text);
+    if (leadingFence) {
+        text = text.slice(leadingFence[0].length);
+        repairs.add('nested_fence');
+    }
+    const trailingFence = /\r?\n[ \t]*```[ \t]*$/.exec(text);
+    if (trailingFence) {
+        text = text.slice(0, trailingFence.index);
+        repairs.add('nested_fence');
+    }
+    // Prose before/after the object ("Here is the snapshot: {...} Done.").
+    const first = text.indexOf('{');
+    const last = text.lastIndexOf('}');
+    if (first !== -1 && last > first && (first > 0 || last < text.length - 1)) {
+        text = text.slice(first, last + 1);
+        repairs.add('trimmed_wrapper');
+    }
+    let out = '';
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (inString) {
+            if (ch === '\\') {
+                const next = text[i + 1];
+                if (next === undefined) {
+                    repairs.add('dangling_escape');
+                    break;
+                }
+                if (VALID_ESCAPES.includes(next)) {
+                    out += ch + next;
+                    i += 1;
+                    continue;
+                }
+                // `\'` and friends are not JSON escapes — keep the character, drop the
+                // backslash (a raw newline after a backslash becomes a real escape).
+                out += next === '\n' ? '\\n' : next;
+                i += 1;
+                repairs.add('invalid_escape');
+                continue;
+            }
+            if (ch === '"') {
+                // Terminator, or a stray inner quote? A real terminator is followed
+                // (after whitespace) by a structural character or the end of input.
+                let j = i + 1;
+                while (j < text.length && isJsonWhitespace(text[j]))
+                    j += 1;
+                const after = text[j];
+                if (after === undefined || after === ',' || after === '}' || after === ']' || after === ':') {
+                    inString = false;
+                    out += ch;
+                    continue;
+                }
+                out += '\\"';
+                repairs.add('inner_quote');
+                continue;
+            }
+            if (ch === '\n') {
+                out += '\\n';
+                repairs.add('raw_newline');
+                continue;
+            }
+            if (ch === '\r') {
+                repairs.add('raw_newline');
+                continue;
+            }
+            if (ch === '\t') {
+                out += '\\t';
+                repairs.add('raw_control');
+                continue;
+            }
+            const code = ch.charCodeAt(0);
+            if (code < 0x20) {
+                out += '\\u' + code.toString(16).padStart(4, '0');
+                repairs.add('raw_control');
+                continue;
+            }
+            out += ch;
+            continue;
+        }
+        // Outside a string literal.
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === ',') {
+            let j = i + 1;
+            while (j < text.length && isJsonWhitespace(text[j]))
+                j += 1;
+            if (text[j] === '}' || text[j] === ']') {
+                repairs.add('trailing_comma');
+                continue;
+            }
+            out += ch;
+            continue;
+        }
+        if (ch === '/' && text[i + 1] === '/') {
+            const end = text.indexOf('\n', i);
+            i = end === -1 ? text.length : end;
+            repairs.add('comment');
+            continue;
+        }
+        if (ch === '/' && text[i + 1] === '*') {
+            const end = text.indexOf('*/', i + 2);
+            i = end === -1 ? text.length : end + 1;
+            repairs.add('comment');
+            continue;
+        }
+        out += ch;
+    }
+    return { text: out, repairs: [...repairs] };
+}
+function describeParseError(err, text) {
+    const message = err instanceof Error ? err.message : String(err);
+    const match = /position (\d+)/i.exec(message);
+    const position = match ? Number(match[1]) : null;
+    let excerpt = null;
+    if (position !== null && Number.isFinite(position)) {
+        const start = Math.max(0, position - 40);
+        const end = Math.min(text.length, position + 40);
+        excerpt = text.slice(start, end).replace(/\s+/g, ' ');
+    }
+    return { error: message, position, excerpt };
+}
+/**
+ * Strict `JSON.parse` first; on failure ONE repair pass, then parse again.
+ * `repaired` is true only when the strict parse failed AND the repaired text
+ * parsed. Never throws.
+ */
+function parseJsonTolerant(source) {
+    try {
+        return { ok: true, value: JSON.parse(source), repaired: false, repairs: [] };
+    }
+    catch (strictErr) {
+        const { text, repairs } = repairJsonText(source);
+        try {
+            const value = JSON.parse(text);
+            return { ok: true, value, repaired: true, repairs };
+        }
+        catch {
+            return { ok: false, ...describeParseError(strictErr, source) };
+        }
+    }
+}

package/server/dist/legacy-migration.js

@@ -227,8 +227,10 @@ function moveOverwriting(src, dest) {
         fs.renameSync(src, dest);
     }
     catch {
-        // Cross-device fallback.
-        fs.cpSync(src, dest, { recursive: true });
+        // Cross-device fallback. JS traversal avoids Node 22's native Unicode copy
+        // failure on Windows (nodejs/node#61878). The destination is cleared before
+        // this copy; remove the source state only after copying succeeds.
+        fs.cpSync(src, dest, { recursive: true, filter: () => true, mode: fs.constants.COPYFILE_FICLONE });
         fs.rmSync(src, { recursive: true, force: true });
     }
 }