specrails-desktop 2.36.0 → 2.42.2

package/server/dist/milestone-progress.js

@@ -0,0 +1,348 @@
+"use strict";
+// Server-derived milestone progress (premium-milestone-progress).
+//
+// The Builder sidebar used to count `status === 'done'` on a board it fetched
+// only when its flyout opened — so a delivered M1 read `0/8` forever (every
+// ask-first delivery parks its specs at `on_review`; `done` arrives only after a
+// merge) and nothing ever updated live. This module is the ONE progress model:
+// derived on the server from durable rows only (ticket store, rail_pr_deliveries,
+// live rail runs, the launch chain), returned by `GET /:projectId/blueprint`
+// and broadcast as `blueprint.milestone_progress` on every relevant mutation.
+//
+// Honesty contract: every count is a fact from a row. `failed` means "this
+// spec is back at todo and its NEWEST delivery unit failed" — never a guess.
+// The derived `state` is what surfaces render; the blueprint's stored status is
+// a record (persisted `done` once, never auto-reverted).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MilestoneProgressBroadcaster = exports.MILESTONE_PROGRESS_DEBOUNCE_MS = exports.MILESTONE_PROGRESS_TRIGGERS = void 0;
+exports.milestoneLabelFor = milestoneLabelFor;
+exports.deriveMilestoneProgress = deriveMilestoneProgress;
+exports.resolveBlueprintWorkspace = resolveBlueprintWorkspace;
+exports.readMilestoneProgress = readMilestoneProgress;
+exports.markMilestoneDone = markMilestoneDone;
+const blueprint_render_1 = require("./blueprint-render");
+const ticket_store_1 = require("./ticket-store");
+const rail_pr_store_1 = require("./rail-pr-store");
+const rails_store_1 = require("./rails-store");
+const loop_runs_store_1 = require("./loop-runs-store");
+const workspace_resolution_1 = require("./workspace-resolution");
+const workspace_manager_1 = require("./workspace-manager");
+function milestoneLabelFor(n) {
+    return `M${n}`;
+}
+function deliveryFailedForTicket(d, ticketId) {
+    if (d.decision === 'implementation_failed')
+        return true;
+    const unit = d.units.find((u) => u.ticketId === ticketId);
+    if (!unit)
+        return d.implementationOutcome === 'failed';
+    if (unit.implementationOutcome === 'failed')
+        return true;
+    if (unit.deliveryOutcome === 'blocked')
+        return true;
+    return unit.implementationOutcome == null && unit.succeeded === false;
+}
+/** Pure derivation — see the module header for the semantics. */
+function deriveMilestoneProgress(input) {
+    const deliveries = [...input.deliveries].sort((a, b) => a.createdAt < b.createdAt ? 1 : a.createdAt > b.createdAt ? -1 : 0);
+    const railNames = new Map(input.rails.map((r) => [r.railIndex, r.name]));
+    return input.blueprint.milestones.map((m, index) => {
+        const n = index + 1;
+        const label = milestoneLabelFor(n);
+        const mine = input.tickets.filter((t) => Array.isArray(t.labels) && t.labels.includes(label));
+        const ids = new Set(mine.map((t) => t.id));
+        const count = (status) => mine.filter((t) => t.status === status).length;
+        const counts = {
+            total: mine.length,
+            done: count('done'),
+            onReview: count('on_review'),
+            inProgress: count('in_progress'),
+            todo: count('todo'),
+            failed: 0,
+        };
+        for (const t of mine) {
+            if (t.status !== 'todo')
+                continue;
+            const newest = deliveries.find((d) => d.ticketIds.includes(t.id));
+            if (newest && deliveryFailedForTicket(newest, t.id))
+                counts.failed += 1;
+        }
+        const chain = input.chains.find((c) => c.milestoneN === n) ?? null;
+        const chunkByRail = new Map();
+        for (const l of chain?.launched ?? [])
+            chunkByRail.set(l.railIndex, l.chunk);
+        const rails = new Map();
+        for (const run of input.activeRuns) {
+            const carried = run.ticketIds.filter((id) => ids.has(id));
+            if (carried.length === 0)
+                continue;
+            rails.set(run.railIndex, {
+                railIndex: run.railIndex,
+                name: railNames.get(run.railIndex) ?? null,
+                ticketIds: carried,
+                active: true,
+                runId: run.runId,
+                startedAt: run.startedAt,
+                delivery: null,
+                chunkIndex: chunkByRail.get(run.railIndex) ?? null,
+            });
+        }
+        for (const d of deliveries) {
+            if ((0, rail_pr_store_1.isTerminalPrDecision)(d.decision))
+                continue;
+            const carried = d.ticketIds.filter((id) => ids.has(id));
+            if (carried.length === 0)
+                continue;
+            const existing = rails.get(d.railIndex);
+            if (existing) {
+                if (!existing.delivery)
+                    existing.delivery = d;
+                continue;
+            }
+            rails.set(d.railIndex, {
+                railIndex: d.railIndex,
+                name: railNames.get(d.railIndex) ?? null,
+                ticketIds: carried,
+                active: false,
+                runId: null,
+                startedAt: d.createdAt,
+                delivery: d,
+                chunkIndex: chunkByRail.get(d.railIndex) ?? null,
+            });
+        }
+        const railList = [...rails.values()].sort((a, b) => {
+            const ca = a.chunkIndex ?? Number.MAX_SAFE_INTEGER;
+            const cb = b.chunkIndex ?? Number.MAX_SAFE_INTEGER;
+            return ca !== cb ? ca - cb : a.railIndex - b.railIndex;
+        });
+        const chainLive = chain !== null && (chain.status === 'running' || chain.status === 'waiting');
+        const state = counts.total > 0 && counts.done === counts.total ? 'done'
+            : counts.total > 0 && counts.todo + counts.inProgress === 0 && counts.onReview > 0 ? 'delivered'
+                : counts.inProgress > 0 || chainLive ? 'running'
+                    : counts.total > 0 ? 'committed'
+                        : m.status;
+        return {
+            id: m.id,
+            n,
+            title: m.title,
+            storedStatus: m.status,
+            state,
+            counts,
+            rails: railList,
+            chain,
+        };
+    });
+}
+// ─── Reading the durable sources ─────────────────────────────────────────────
+/** The workspace holding the blueprint pair (same resolution as the route). */
+function resolveBlueprintWorkspace(project) {
+    const exec = (0, workspace_resolution_1.resolveProjectExecution)({ slug: project.slug, path: project.path });
+    if (exec.relocated && exec.workspaceDir)
+        return exec.workspaceDir;
+    return project.slug ? (0, workspace_manager_1.workspacePathFor)(project.slug) : null;
+}
+function parseTicketIds(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.filter((v) => typeof v === 'number') : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Read every durable source and derive; null when the project has no blueprint. */
+function readMilestoneProgress(src) {
+    const workspace = src.workspaceDir();
+    const blueprint = workspace ? (0, blueprint_render_1.readBlueprint)(workspace) : null;
+    if (!blueprint)
+        return null;
+    let tickets = [];
+    try {
+        const store = (0, ticket_store_1.readStore)(src.ticketsPath());
+        tickets = Object.values(store.tickets).map((t) => ({ id: t.id, status: t.status, labels: t.labels ?? [] }));
+    }
+    catch {
+        tickets = [];
+    }
+    let deliveries = [];
+    try {
+        deliveries = [...(0, rail_pr_store_1.listActivePrDeliveries)(src.db), ...(0, rail_pr_store_1.listTerminalPrDeliveries)(src.db)].map(rail_pr_store_1.toPrDeliverySnapshot);
+    }
+    catch {
+        deliveries = [];
+    }
+    const activeRuns = [];
+    const seenRuns = new Set();
+    for (const [runId, meta] of src.railLoopRuns?.entries() ?? []) {
+        seenRuns.add(runId);
+        let startedAt = null;
+        try {
+            startedAt = (0, loop_runs_store_1.getLoopRun)(src.db, runId)?.started_at ?? null;
+        }
+        catch { /* fall through */ }
+        activeRuns.push({ runId, railIndex: meta.railIndex, ticketIds: meta.ticketIds, startedAt });
+    }
+    try {
+        for (const run of (0, loop_runs_store_1.listActiveLoopRuns)(src.db, src.projectId)) {
+            if (run.rail_index == null || seenRuns.has(run.id))
+                continue;
+            seenRuns.add(run.id);
+            const ids = parseTicketIds(run.ticket_ids_json);
+            activeRuns.push({
+                runId: run.id,
+                railIndex: run.rail_index,
+                ticketIds: ids.length > 0 ? ids : run.ticket_id != null ? [run.ticket_id] : [],
+                startedAt: run.started_at ?? null,
+            });
+        }
+    }
+    catch { /* DB unavailable ⇒ in-memory maps only */ }
+    for (const [jobId, meta] of src.railJobs?.entries() ?? []) {
+        if (seenRuns.has(jobId))
+            continue;
+        activeRuns.push({ runId: jobId, railIndex: meta.railIndex, ticketIds: meta.ticketIds, startedAt: null });
+    }
+    let rails = [];
+    try {
+        rails = (0, rails_store_1.getRails)(src.db).map((r) => ({ railIndex: r.railIndex, name: r.name ?? null }));
+    }
+    catch {
+        rails = [];
+    }
+    let chains = [];
+    try {
+        chains = src.chains?.() ?? [];
+    }
+    catch {
+        chains = [];
+    }
+    return { blueprint, progress: deriveMilestoneProgress({ blueprint, tickets, deliveries, activeRuns, rails, chains }) };
+}
+/** Persist `status: 'done'` on one milestone (idempotent). Returns the
+ *  updated blueprint, or null when nothing was written. */
+function markMilestoneDone(workspaceDir, milestoneId) {
+    if (!workspaceDir)
+        return null;
+    const blueprint = (0, blueprint_render_1.readBlueprint)(workspaceDir);
+    if (!blueprint)
+        return null;
+    const milestone = blueprint.milestones.find((m) => m.id === milestoneId);
+    if (!milestone || milestone.status === 'done')
+        return null;
+    milestone.status = 'done';
+    (0, blueprint_render_1.writeBlueprintPair)(workspaceDir, blueprint);
+    return blueprint;
+}
+// ─── Broadcaster ─────────────────────────────────────────────────────────────
+/** WS message types whose arrival means the milestone progress may have
+ *  changed. Everything else (log frames, queue ticks…) is ignored. */
+exports.MILESTONE_PROGRESS_TRIGGERS = new Set([
+    'ticket_created',
+    'ticket_updated',
+    'ticket_deleted',
+    'rail.pr_state',
+    'rail.updated',
+    'rail.removed',
+    'rail.job_started',
+    'rail.job_completed',
+    'rail.job_stopped',
+    'loop.run_completed',
+    'loop.run_stopped',
+    'milestone.chain_changed',
+]);
+exports.MILESTONE_PROGRESS_DEBOUNCE_MS = 150;
+/**
+ * Per-project debounced progress broadcaster. `observe(msg)` is the ONE tap
+ * (wired inside the project's bound broadcast): any trigger schedules a flush;
+ * a flush re-reads the durable sources, persists newly-completed milestones,
+ * and emits `blueprint.milestone_progress` (+ `blueprint.milestone_completed`).
+ * A project with no blueprint is remembered as absent so the tap costs nothing
+ * on ordinary projects until `invalidate()` (a blueprint commit) resets it.
+ */
+class MilestoneProgressBroadcaster {
+    deps;
+    timer = null;
+    knownAbsent = false;
+    disposed = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    observe(msg) {
+        if (this.disposed)
+            return;
+        if (!exports.MILESTONE_PROGRESS_TRIGGERS.has(msg.type))
+            return;
+        this.schedule();
+    }
+    schedule() {
+        if (this.disposed || this.knownAbsent)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => { this.timer = null; this.flush(); }, this.deps.debounceMs ?? exports.MILESTONE_PROGRESS_DEBOUNCE_MS);
+        this.timer.unref?.();
+    }
+    /** Forget the "no blueprint" memo (call after a blueprint lands). */
+    invalidate() {
+        this.knownAbsent = false;
+    }
+    /** Synchronous read + broadcast. Returns the snapshot (null = no blueprint). */
+    flush() {
+        if (this.disposed)
+            return null;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        let snapshot;
+        try {
+            snapshot = this.deps.read();
+        }
+        catch (err) {
+            console.error('[milestone-progress] read failed:', err);
+            return null;
+        }
+        if (!snapshot) {
+            this.knownAbsent = true;
+            return null;
+        }
+        const completed = [];
+        for (const m of snapshot.progress) {
+            if (m.state !== 'done' || m.storedStatus === 'done')
+                continue;
+            let written = false;
+            try {
+                written = this.deps.persistDone(m.id);
+            }
+            catch (err) {
+                console.error('[milestone-progress] persist done failed:', err);
+            }
+            if (written) {
+                m.storedStatus = 'done';
+                completed.push(m);
+            }
+        }
+        const timestamp = new Date(this.deps.now?.() ?? Date.now()).toISOString();
+        try {
+            this.deps.broadcast({ type: 'blueprint.milestone_progress', projectId: this.deps.projectId, progress: snapshot.progress, timestamp });
+        }
+        catch { /* durable rows are authoritative */ }
+        for (const m of completed) {
+            try {
+                this.deps.broadcast({ type: 'blueprint.milestone_completed', projectId: this.deps.projectId, milestoneId: m.id, n: m.n, title: m.title, timestamp });
+            }
+            catch { /* ignore */ }
+        }
+        return snapshot;
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+    }
+}
+exports.MilestoneProgressBroadcaster = MilestoneProgressBroadcaster;

package/server/dist/mobile/mobile-devices.js

@@ -51,24 +51,27 @@ function _resetAclColumnCacheForTests() {
     _aclColumnReady = false;
 }
 /** The set of project ids this device may access, or `null` when unrestricted
- *  (all projects). A malformed/empty stored value is treated as unrestricted to
- *  preserve legacy behaviour — restriction is opt-in. */
+ *  (all projects). Only the legacy NULL/unset value grants all projects;
+ *  malformed persisted restrictions fail closed. */
 function getAllowedProjects(db, deviceId) {
     ensureAclColumn(db);
     const row = db
         .prepare('SELECT allowed_projects FROM mobile_devices WHERE id = ?')
         .get(deviceId);
-    if (!row || row.allowed_projects == null || row.allowed_projects === '')
+    if (!row)
+        return new Set();
+    if (row.allowed_projects == null || row.allowed_projects === '')
         return null;
     try {
         const parsed = JSON.parse(row.allowed_projects);
         if (!Array.isArray(parsed))
-            return null;
-        const ids = parsed.filter((x) => typeof x === 'string');
-        return ids.length > 0 ? new Set(ids) : null;
+            return new Set();
+        if (parsed.some(x => typeof x !== 'string'))
+            return new Set();
+        return new Set(parsed);
     }
     catch {
-        return null;
+        return new Set();
     }
 }
 /** Restrict a device to a specific set of project ids. An empty array clears the

package/server/dist/mobile/mobile-gateway.js

@@ -16,6 +16,7 @@ const mobile_devices_1 = require("./mobile-devices");
 const mobile_webrtc_peer_1 = require("./mobile-webrtc-peer");
 const mobile_signal_reconnect_1 = require("./mobile-signal-reconnect");
 const mobile_webrtc_1 = require("./mobile-webrtc");
+const agent_store_1 = require("../agent-store");
 // Lifecycle owner of the second HTTPS+WSS listener (default :4202), hard-isolated
 // from the main server. Off by default; started on enable or boot-if-enabled.
 const DEFAULT_PORT = 4202;
@@ -144,6 +145,7 @@ class MobileGateway {
         // projects (null ⇒ unrestricted/all-projects, the default for paired devices).
         const bridge = new mobile_ws_1.MobileWsBridge({
             allowedProjectsFor: (deviceId) => (0, mobile_devices_1.getAllowedProjects)(this._db, deviceId),
+            missionProjectFor: (conversationId) => (0, agent_store_1.getAgentConversation)(this._db, conversationId)?.pinned_project_id ?? null,
         });
         bridge.start();
         const port = this.configuredPort();

package/server/dist/mobile/mobile-missions.js

@@ -0,0 +1,214 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MISSION_ACCESS_REASON = exports.MOBILE_PROTOCOL_VERSION = void 0;
+exports.mobileCapabilities = mobileCapabilities;
+exports.missionSnapshot = missionSnapshot;
+exports.createMobileMissionsRouter = createMobileMissionsRouter;
+const node_string_decoder_1 = require("node:string_decoder");
+const express_1 = require("express");
+const agent_store_1 = require("../agent-store");
+const desktop_db_1 = require("../desktop-db");
+const mobile_devices_1 = require("./mobile-devices");
+const mobile_redact_1 = require("./mobile-redact");
+const ID = /^[A-Za-z0-9_-]{1,160}$/;
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+const pick = (value, keys) => Object.fromEntries(Object.entries(record(value)).filter(([key]) => keys.includes(key)));
+exports.MOBILE_PROTOCOL_VERSION = 2;
+exports.MISSION_ACCESS_REASON = 'Mission agents can access more than their pinned project. Missions require an all-projects device grant; your permitted Specs and Rails remain available.';
+function mobileCapabilities(db, deviceId) {
+    const missions = process.env.SPECRAILS_AGENT_CHAT !== 'false' && (0, mobile_devices_1.getAllowedProjects)(db, deviceId) === null;
+    return { protocolVersion: exports.MOBILE_PROTOCOL_VERSION, features: { missions, missionControl: missions, missionQueue: missions, missionProcesses: missions, repositories: true },
+        ...(!missions ? { missionsUnavailableReason: process.env.SPECRAILS_AGENT_CHAT === 'false' ? 'Missions are disabled on Desktop.' : exports.MISSION_ACCESS_REASON } : {}) };
+}
+function conversationView(value) {
+    return pick(value, ['id', 'title', 'provider', 'model', 'pinned_project_id', 'tier_level', 'reasoning_effort', 'created_at', 'updated_at']);
+}
+/** Explicit mobile DTO: provider session IDs, attachment paths, tool inputs and
+ * arbitrary context metadata never enter the mission wire contract. */
+function missionSnapshot(value) {
+    const data = record(value);
+    const messages = Array.isArray(data.messages) ? data.messages : [];
+    // Shared UTF-8 budget for all text, with pending inputs and the current
+    // response reserved first. Metadata is bounded separately by row counts.
+    let remaining = 480_000;
+    let truncated = messages.length > 200;
+    const take = (raw, maximum) => {
+        const bytes = Buffer.from(raw);
+        const budget = Math.min(remaining, maximum);
+        const text = bytes.length <= budget ? raw : new node_string_decoder_1.StringDecoder('utf8').write(bytes.subarray(0, budget));
+        remaining -= Buffer.byteLength(text);
+        if (text.length < raw.length)
+            truncated = true;
+        return text;
+    };
+    const live = record(data.live), liveRaw = String(live.streamingText ?? '');
+    const streamingText = take(liveRaw, 80_000);
+    const pending = Array.isArray(data.pendingMessages) ? data.pendingMessages : [];
+    const pendingMessages = pending.slice(0, 50).map(value => {
+        const raw = String(record(value).text ?? ''), text = take(raw, 4_000);
+        return { ...pick(value, ['queueId', 'deliveryMode', 'timestamp']), text, textTruncated: text.length < raw.length };
+    });
+    const bounded = [];
+    for (const message of messages.slice(-200).reverse()) {
+        const raw = String(record(message).content ?? '');
+        let card;
+        if (record(message).role === 'system') {
+            try {
+                const parsed = record(JSON.parse(raw));
+                if (parsed.kind === 'pr_decision')
+                    card = { ...pick(parsed, ['kind', 'railIndex', 'ticketIds', 'decision', 'implementationOutcome', 'deliveryOutcome', 'prNumber']), repositoryDeliveries: (Array.isArray(parsed.repositoryDeliveries) ? parsed.repositoryDeliveries : []).slice(0, 30).map(value => pick(value, ['repositoryId', 'repositoryName', 'decision'])) };
+            }
+            catch { /* Non-card system rows do not expose internal provider payloads. */ }
+        }
+        if (remaining === 0) {
+            truncated = true;
+            break;
+        }
+        const content = record(message).role === 'system' ? '' : take(raw, 40_000);
+        bounded.unshift({ ...pick(message, ['id', 'role', 'created_at', 'delivery_status', 'delivery_receipt']), content, ...(card ? { card } : {}) });
+    }
+    return { conversation: conversationView(data.conversation), messages: bounded, truncated,
+        pendingMessages, pendingTruncated: pending.length > 50,
+        live: { ...pick(live, ['isStreaming', 'startedAt']), streamingText, textTruncated: streamingText.length < liveRaw.length } };
+}
+function createMobileMissionsRouter({ db, upstream }) {
+    const router = (0, express_1.Router)();
+    const segment = (value) => typeof value === 'string' ? value : '';
+    const send = async (res, method, path, body, shape) => {
+        try {
+            const result = await upstream(method, path, body);
+            res.status(result.status).json((0, mobile_redact_1.redact)(result.status >= 200 && result.status < 300 && shape ? shape(result.json) : result.json));
+        }
+        catch {
+            res.status(502).json({ error: 'Desktop is unreachable. Retry when connected.' });
+        }
+    };
+    router.get('/capabilities', (req, res) => res.json(mobileCapabilities(db, req.mobileDevice.id)));
+    router.get('/mission-models', (req, res) => {
+        const provider = segment(req.query.provider);
+        if (!/^[a-z0-9_-]{1,40}$/.test(provider)) {
+            res.status(400).json({ error: 'A valid provider is required' });
+            return;
+        }
+        void send(res, 'GET', `/api/agent/models?provider=${encodeURIComponent(provider)}`);
+    });
+    router.get('/projects/:pid/repositories', (req, res) => {
+        const pid = segment(req.params.pid);
+        if (!(0, desktop_db_1.getProject)(db, pid)) {
+            res.status(404).json({ error: 'Unknown project' });
+            return;
+        }
+        res.json({ repositories: (0, desktop_db_1.listProjectRepositories)(db, pid).map(repository => pick(repository, ['id', 'name', 'isPrimary', 'kind', 'integrationBranch'])) });
+    });
+    router.use('/projects/:pid/missions', (req, res, next) => {
+        const device = req.mobileDevice;
+        // A conversation pin is an execution default, not an agent sandbox. Deny
+        // restricted devices rather than leaking repinned history or escalating tools.
+        if (!mobileCapabilities(db, device.id).features.missions) {
+            res.status(403).json({ error: exports.MISSION_ACCESS_REASON });
+            return;
+        }
+        if (!(0, desktop_db_1.getProject)(db, segment(req.params.pid))) {
+            res.status(404).json({ error: 'Unknown project' });
+            return;
+        }
+        next();
+    });
+    const identity = (req, res) => {
+        const pid = segment(req.params.pid), cid = segment(req.params.cid);
+        if (!ID.test(pid) || !ID.test(cid)) {
+            res.status(400).json({ error: 'Invalid mission identity' });
+            return null;
+        }
+        const conversation = (0, agent_store_1.getAgentConversation)(db, cid);
+        if (!conversation || conversation.pinned_project_id !== pid) {
+            res.status(404).json({ error: 'Mission not found in this project' });
+            return null;
+        }
+        return { pid, cid, base: `/api/agent/conversations/${encodeURIComponent(cid)}` };
+    };
+    router.get('/projects/:pid/missions', async (req, res) => {
+        const pid = segment(req.params.pid);
+        const rawLimit = req.query.limit === undefined ? 100 : Number(req.query.limit);
+        if (!Number.isSafeInteger(rawLimit) || rawLimit < 1 || rawLimit > 200) {
+            res.status(400).json({ error: 'limit must be 1–200' });
+            return;
+        }
+        // Query the project before applying the limit: active projects must not
+        // disappear behind another project's most recent conversations.
+        const rows = db.prepare('SELECT id FROM agent_conversations WHERE pinned_project_id = ? ORDER BY updated_at DESC, id DESC LIMIT ?').all(pid, rawLimit + 1);
+        try {
+            const active = await upstream('GET', '/api/agent/active-turns');
+            if (active.status !== 200) {
+                res.status(active.status).json((0, mobile_redact_1.redact)(active.json));
+                return;
+            }
+            const activeIds = new Set((Array.isArray(record(active.json).turns) ? record(active.json).turns : []).map(value => record(value).conversationId));
+            res.json((0, mobile_redact_1.redact)({ conversations: rows.slice(0, rawLimit).map(row => ({ ...conversationView((0, agent_store_1.getAgentConversation)(db, row.id)), isStreaming: activeIds.has(row.id) })), truncated: rows.length > rawLimit }));
+        }
+        catch {
+            res.status(502).json({ error: 'Desktop is unreachable' });
+        }
+    });
+    router.post('/projects/:pid/missions', (req, res) => {
+        const b = record(req.body);
+        const body = { ...pick(b, ['provider', 'model', 'reasoningEffort']), pinnedProjectId: segment(req.params.pid), tierLevel: Number.isInteger(b.tierLevel) && Number(b.tierLevel) >= 0 && Number(b.tierLevel) <= 3 ? b.tierLevel : 0 };
+        void send(res, 'POST', '/api/agent/conversations', body, data => ({ conversation: conversationView(record(data).conversation) }));
+    });
+    router.get('/projects/:pid/missions/:cid', (req, res) => {
+        const id = identity(req, res);
+        if (id)
+            void send(res, 'GET', id.base, undefined, missionSnapshot);
+    });
+    router.post('/projects/:pid/missions/:cid/send', (req, res) => {
+        const id = identity(req, res);
+        if (!id)
+            return;
+        const b = record(req.body);
+        if (typeof b.text !== 'string' || !b.text.trim() || b.text.length > 40_000 || !ID.test(segment(b.queueId))) {
+            res.status(400).json({ error: 'A message and stable queueId are required (maximum 40000 characters)' });
+            return;
+        }
+        if (b.deliveryMode !== undefined && b.deliveryMode !== 'queue' && b.deliveryMode !== 'steer') {
+            res.status(400).json({ error: 'deliveryMode must be queue or steer' });
+            return;
+        }
+        void send(res, 'POST', `${id.base}/send`, { text: b.text, queueId: b.queueId, deliveryMode: b.deliveryMode ?? 'queue' }, data => pick(data, ['accepted', 'queued', 'duplicate', 'removed', 'deliveryMode']));
+    });
+    router.post('/projects/:pid/missions/:cid/abort', (req, res) => { const id = identity(req, res); if (id)
+        void send(res, 'POST', `${id.base}/abort`, {}); });
+    for (const action of ['edit', 'steer', 'remove']) {
+        const route = `/projects/:pid/missions/:cid/queue/:queueId${action === 'steer' ? '/steer' : ''}`;
+        const method = action === 'edit' ? 'patch' : action === 'steer' ? 'post' : 'delete';
+        router[method](route, (req, res) => {
+            const id = identity(req, res);
+            if (!id)
+                return;
+            const queueId = segment(req.params.queueId), text = record(req.body).text;
+            if (!ID.test(queueId) || (action === 'edit' && (typeof text !== 'string' || !text.trim() || text.length > 40_000))) {
+                res.status(400).json({ error: 'Invalid queued message' });
+                return;
+            }
+            void send(res, method.toUpperCase(), `${id.base}/queue/${encodeURIComponent(queueId)}${action === 'steer' ? '/steer' : ''}`, action === 'edit' ? { text } : undefined);
+        });
+    }
+    router.get('/projects/:pid/missions/:cid/processes', (req, res) => {
+        const id = identity(req, res);
+        if (id)
+            void send(res, 'GET', `/api/projects/${encodeURIComponent(id.pid)}/background-processes?chatId=${encodeURIComponent(id.cid)}&includeFinished=true`);
+    });
+    for (const method of ['get', 'delete'])
+        router[method](`/projects/:pid/missions/:cid/processes/:processId${method === 'get' ? '/logs' : ''}`, (req, res) => {
+            const id = identity(req, res);
+            if (!id)
+                return;
+            const processId = segment(req.params.processId), osPid = Number(req.query.pid);
+            if (!ID.test(processId) || !Number.isSafeInteger(osPid) || osPid < 1) {
+                res.status(400).json({ error: 'Execution identity and numeric pid are required' });
+                return;
+            }
+            const query = new URLSearchParams({ chatId: id.cid, processId, ...(method === 'get' ? { limit: '1000' } : {}) });
+            void send(res, method.toUpperCase(), `/api/projects/${encodeURIComponent(id.pid)}/background-processes/${osPid}${method === 'get' ? '/logs' : ''}?${query}`);
+        });
+    return router;
+}

package/server/dist/mobile/mobile-redact.js

@@ -19,7 +19,8 @@ const os_1 = __importDefault(require("os"));
 //      key allow-list (rule 1) stays as defence-in-depth.
 //
 // Applied to EVERY proxied REST JSON body and EVERY outbound WS payload.
-const SENSITIVE_KEYS = new Set(['path', 'db_path', 'dbPath', 'absolutePath', 'cwd', 'filePath', 'projectPath']);
+const SENSITIVE_KEYS = new Set(['path', 'db_path', 'dbPath', 'absolutePath', 'cwd', 'filePath', 'projectPath',
+    'token', 'token_hash', 'session_id', 'authorization', 'apiKey', 'api_key', 'password', 'secret', 'privateKey', 'private_key', 'env', 'environment']);
 const ABS_PATH_PLACEHOLDER = '[path]';
 // Absolute-path tokens to scrub AFTER the $HOME→`~` rewrite. A token is a run of
 // non-whitespace characters; we match those that look like an absolute path:
@@ -33,6 +34,11 @@ const ABS_PATH_PLACEHOLDER = '[path]';
 //     paths are already collapsed by stripHome and never reach here.
 // The leading boundary keeps embedded `://` URLs and mid-word slashes intact.
 const ABS_PATH_RE = /(^|[\s"'`(=:,])([A-Za-z]:[\\/][^\s"'`)]*|\\\\[^\s"'`)]+|\/[^\s"'`)/]+\/[^\s"'`)]*)/g;
+// Quotes bound the complete path, including a final filename with spaces.
+// Without quotes, spaces are reliable only inside components followed by a
+// separator; leave trailing prose intact rather than guessing its endpoint.
+const QUOTED_WINDOWS_PATH_RE = /(["'`])((?:[A-Za-z]:[\\/]|\\\\)[^\r\n]*?)\1/g;
+const WINDOWS_COMPONENT_PATH_RE = /(^|[\s"'`(=:,])((?:[A-Za-z]:[\\/]|\\\\)(?:[^\\/\r\n"'`()<>|:;,!?]*[\\/])*[^\s\\/"'`()<>|:;,!?]*)/g;
 function homeDir() {
     try {
         return os_1.default.homedir();
@@ -47,7 +53,12 @@ function stripHome(s) {
     const home = homeDir();
     if (!home)
         return s;
-    return s.split(home).join('~');
+    const windowsHome = /^[A-Za-z]:[\\/]|^\\\\/.test(home);
+    const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = windowsHome ? home.split(/[\\/]/).map(escape).join('[\\\\/]') : escape(home);
+    // A different account whose name merely starts with ours is not our HOME.
+    const boundary = '(?=$|[\\\\/\\s"\'`),;:])';
+    return s.replace(new RegExp(pattern + boundary, windowsHome || process.platform === 'win32' ? 'gi' : 'g'), '~');
 }
 /** Replace absolute-path tokens (POSIX `/…`, Windows `X:\…`, UNC `\\…`) with a
  *  placeholder. Runs AFTER stripHome so `~`-rooted paths are already collapsed and
@@ -55,7 +66,10 @@ function stripHome(s) {
 function scrubAbsolutePaths(s) {
     // Keep the matched leading delimiter, replace the path token with the
     // placeholder. URLs (`://`) are excluded by the path-branch char classes.
-    return s.replace(ABS_PATH_RE, (_m, lead) => `${lead}${ABS_PATH_PLACEHOLDER}`);
+    return s
+        .replace(QUOTED_WINDOWS_PATH_RE, (_match, quote) => `${quote}${ABS_PATH_PLACEHOLDER}${quote}`)
+        .replace(WINDOWS_COMPONENT_PATH_RE, (_match, lead) => `${lead}${ABS_PATH_PLACEHOLDER}`)
+        .replace(ABS_PATH_RE, (_match, lead) => `${lead}${ABS_PATH_PLACEHOLDER}`);
 }
 function scrubString(s) {
     return scrubAbsolutePaths(stripHome(s));