specrails-desktop 2.32.0 → 2.34.0

package/server/dist/desktop-router.js

@@ -16,6 +16,9 @@ const core_update_manager_1 = require("./core-update-manager");
 const specrails_tech_client_1 = require("./specrails-tech-client");
 const core_compat_1 = require("./core-compat");
 const providers_1 = require("./providers");
+const provider_detection_1 = require("./provider-detection");
+const workspace_manager_1 = require("./workspace-manager");
+const workspace_resolution_1 = require("./workspace-resolution");
 const desktop_analytics_1 = require("./desktop-analytics");
 const setup_prerequisites_1 = require("./setup-prerequisites");
 const path_resolver_1 = require("./path-resolver");
@@ -44,24 +47,9 @@ function allocateSlug(name, existing) {
         n += 1;
     return `${base}-${n}`;
 }
-// Emergency rollback for the codex provider: SPECRAILS_CODEX_BETA=0 forces
-// codex back to "unavailable" without redeploying. The pre-rebrand
-// SPECRAILS_HUB_CODEX_BETA name is read as a legacy fallback when the new
-// var is unset (legacy fallback — do not remove while old installs exist).
-function isCodexBetaDisabled() {
-    const v = process.env.SPECRAILS_CODEX_BETA ?? process.env.SPECRAILS_HUB_CODEX_BETA;
-    return v === '0';
-}
-// Gemini is enabled by DEFAULT now that its stream-json schema and the full rails
-// pipeline (architect→developer→reviewer delegation, headless agent loading, the
-// MAX_TURNS resume + reviewer gate) are validated against the live binary
-// (0.46/0.47). Emergency rollback: SPECRAILS_GEMINI_BETA=0 forces it back to
-// "unavailable" without redeploying — parity with codex's SPECRAILS_CODEX_BETA.
-// The adapter is always registered (pricing/getAdapter work); only project
-// selection is gated.
-function isGeminiBetaDisabled() {
-    return process.env.SPECRAILS_GEMINI_BETA === '0';
-}
+// Beta kill switches live with the app-level detection singleton now
+// (provider-detection.ts) so detection and route gating can never disagree.
+// Re-imported here under the original names.
 // Theme allow-list. Mirror of THEME_IDS in `client/src/lib/themes.ts` —
 // kept duplicated to avoid pulling client code into the server bundle.
 const THEME_ID_ALLOWLIST = new Set(['dracula', 'aurora-light', 'obsidian-dark', 'code-rain', 'specrails', 'galaxy']);
@@ -332,25 +320,64 @@ function createDesktopRouter(registry, broadcast) {
         db: registry.desktopDb,
         isLoopRunning: (loopId) => registry.listContexts().some((c) => (0, loop_runs_store_1.countRunningForLoop)(c.db, loopId) > 0),
     });
-    // GET /api/projects — list all registered projects
+    // Lazy per-provider workspace assembly (provider-auto-detection spec): when
+    // the usable set gains a provider, every RELOCATED project whose workspace
+    // lacks that provider's surface assembles it in the background — installing
+    // codex on Tuesday makes it usable everywhere without user action.
+    function assembleNewlyDetected(detected) {
+        for (const ctx of registry.listContexts()) {
+            try {
+                const workspace = (0, workspace_manager_1.workspacePathFor)(ctx.project.slug);
+                if (!(0, workspace_resolution_1.isWorkspacePopulated)(workspace))
+                    continue; // legacy → migration owns it
+                const missing = detected.filter((p) => {
+                    try {
+                        return (0, providers_1.hasAdapter)(p) && !fs_1.default.existsSync(path_1.default.join(workspace, (0, providers_1.getAdapter)(p).projectDirName));
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+                if (missing.length === 0)
+                    continue;
+                ctx.setupManager.startSilentAssemble(ctx.project.id, ctx.project.path, ctx.project.slug, missing);
+            }
+            catch (err) {
+                console.warn(`[desktop] lazy assemble check failed for ${ctx.project.id} (non-fatal):`, err);
+            }
+        }
+    }
+    // GET /api/projects — list all registered projects. The old wizard-restore
+    // `setupProjectIds` field is retired (silent-project-add): kept as an empty
+    // array for wire compat with clients that still destructure it.
     router.get('/projects', (_req, res) => {
-        const projects = (0, desktop_db_1.listProjects)(registry.desktopDb);
-        // Detect projects that are currently in the setup wizard so the client
-        // can restore the wizard after a page refresh.
-        const setupProjectIds = [];
-        for (const p of projects) {
-            const ctx = registry.getContext(p.id);
-            if (!ctx)
-                continue;
-            const installing = ctx.setupManager.isInstalling(p.id);
-            const settingUp = ctx.setupManager.isSettingUp(p.id);
-            const hasSession = !!(0, desktop_db_1.getProjectSetupSession)(registry.desktopDb, p.id);
-            const specrailsInstalled = hasSpecrails(p.path);
-            if (installing || settingUp || (hasSession && !specrailsInstalled)) {
-                setupProjectIds.push(p.id);
+        res.json({ projects: (0, desktop_db_1.listProjects)(registry.desktopDb), setupProjectIds: [] });
+    });
+    // GET /api/providers/detected — the app-level detection snapshot (machine
+    // property, not project property). `?refresh=1` bypasses the 60s cache; a
+    // changed usable set broadcasts `providers.detected_changed` app-globally.
+    router.get('/providers/detected', async (req, res) => {
+        try {
+            if (req.query.refresh === '1') {
+                const { snapshot, changed } = await (0, provider_detection_1.refreshDetection)();
+                if (changed) {
+                    broadcast({
+                        type: 'providers.detected_changed',
+                        detected: snapshot.detected,
+                        providers: snapshot.providers,
+                        timestamp: new Date().toISOString(),
+                    });
+                    assembleNewlyDetected(snapshot.detected);
+                }
+                res.json(snapshot);
+                return;
             }
+            res.json(await (0, provider_detection_1.getDetectionSnapshot)());
+        }
+        catch (err) {
+            console.error('[provider-detection] snapshot error:', err);
+            res.status(500).json({ error: 'provider detection failed' });
         }
-        res.json({ projects, setupProjectIds });
     });
     // GET /api/available-providers — which AI CLIs are installed, plus supported install tiers
     //
@@ -364,11 +391,11 @@ function createDesktopRouter(registry, broadcast) {
         // provider surfaces here with no edit. Apply per-provider beta gates: codex
         // is forced unavailable when SPECRAILS_CODEX_BETA=0 (emergency rollback).
         const gated = { ...providers };
-        if (isCodexBetaDisabled())
+        if ((0, provider_detection_1.isCodexBetaDisabled)())
             gated.codex = false;
         // Gemini: enabled by default; forced unavailable only when
         // SPECRAILS_GEMINI_BETA=0 (emergency rollback, parity with codex).
-        if (isGeminiBetaDisabled())
+        if ((0, provider_detection_1.isGeminiBetaDisabled)())
             gated.gemini = false;
         const providerIssues = {};
         if (gated.kimi) {
@@ -429,10 +456,28 @@ function createDesktopRouter(registry, broadcast) {
             res.status(400).json({ error: 'path is required' });
             return;
         }
-        // Normalise to a providers list. New multi-provider clients send
-        // `providers: ['claude','codex']`; legacy clients send a single
-        // `provider`; omitting both defaults to ['claude']. The first entry is the
-        // primary/default provider.
+        // Project registration is a detection refresh trigger (spec:
+        // provider-auto-detection). The refresh runs in the BACKGROUND so
+        // registration latency never pays for CLI probes; the defaulting below uses
+        // the last cached snapshot (null before the first startup detection).
+        (0, provider_detection_1.refreshDetection)()
+            .then(({ snapshot, changed }) => {
+            if (!changed)
+                return;
+            broadcast({
+                type: 'providers.detected_changed',
+                detected: snapshot.detected,
+                providers: snapshot.providers,
+                timestamp: new Date().toISOString(),
+            });
+            assembleNewlyDetected(snapshot.detected);
+        })
+            .catch(() => { });
+        const detectedNow = (0, provider_detection_1.getDetectedIdsSync)() ?? [];
+        // Normalise to a providers list. Wire compat: `providers`/`provider` are
+        // still accepted and recorded, but the DETECTED set is authoritative for
+        // what the project offers (delta spec: multi-provider-architecture).
+        // Omitting both registers with the detected set.
         let providers;
         if (Array.isArray(providersRaw) && providersRaw.length > 0) {
             providers = providersRaw;
@@ -441,7 +486,7 @@ function createDesktopRouter(registry, broadcast) {
             providers = [provider];
         }
         else {
-            providers = ['claude'];
+            providers = detectedNow.length > 0 ? [...detectedNow] : ['claude'];
         }
         // De-duplicate while preserving order (primary stays first).
         providers = providers.filter((p, i) => providers.indexOf(p) === i);
@@ -458,13 +503,13 @@ function createDesktopRouter(registry, broadcast) {
         }
         // Beta-gate parity: if codex beta is forced off via env, refuse codex
         // selections too (consistency with /available-providers).
-        if (providers.includes('codex') && isCodexBetaDisabled()) {
+        if (providers.includes('codex') && (0, provider_detection_1.isCodexBetaDisabled)()) {
             res.status(400).json({
                 error: 'Codex provider is currently disabled (SPECRAILS_CODEX_BETA=0). Unset or set to 1 to enable.',
             });
             return;
         }
-        if (providers.includes('gemini') && isGeminiBetaDisabled()) {
+        if (providers.includes('gemini') && (0, provider_detection_1.isGeminiBetaDisabled)()) {
             res.status(400).json({
                 error: 'Gemini provider is currently disabled (SPECRAILS_GEMINI_BETA=0). Unset or set to 1 to enable.',
             });
@@ -527,6 +572,20 @@ function createDesktopRouter(registry, broadcast) {
                 project: ctx.project,
                 timestamp: new Date().toISOString(),
             });
+            // Silent add (global-core-zero-friction): registration is already done —
+            // assemble the relocated workspace in the BACKGROUND for every detected
+            // provider. Never blocks or rolls back registration. Skipped when the
+            // workspace is already populated (re-register of a relocated repo).
+            try {
+                const workspace = (0, workspace_manager_1.workspacePathFor)(slug);
+                const effectiveProviders = detectedNow.length > 0 ? detectedNow : providers;
+                if (!(0, workspace_resolution_1.isWorkspacePopulated)(workspace)) {
+                    ctx.setupManager.startSilentAssemble(id, canonicalPath, slug, effectiveProviders);
+                }
+            }
+            catch (err) {
+                console.warn('[desktop] silent assemble launch failed (non-fatal):', err);
+            }
             res.status(201).json({ project: ctx.project, has_specrails: specrailsInstalled });
         }
         catch (err) {
@@ -541,6 +600,36 @@ function createDesktopRouter(registry, broadcast) {
             }
         }
     });
+    // POST /api/projects/:id/assemble-retry — re-run the silent workspace
+    // assemble for the providers that failed (or every detected provider when
+    // nothing is recorded as failed). 202; progress rides project.assemble_progress.
+    router.post('/projects/:id/assemble-retry', async (req, res) => {
+        const ctx = registry.getContext(req.params.id);
+        if (!ctx) {
+            res.status(404).json({ error: 'unknown project' });
+            return;
+        }
+        const state = ctx.setupManager.silentAssembleState(ctx.project.id);
+        if (state.running) {
+            res.status(202).json({ alreadyRunning: true });
+            return;
+        }
+        let providers = state.failed;
+        if (providers.length === 0) {
+            try {
+                providers = (await (0, provider_detection_1.getDetectionSnapshot)()).detected;
+            }
+            catch {
+                providers = [];
+            }
+        }
+        if (providers.length === 0) {
+            res.status(409).json({ error: 'no providers detected to assemble' });
+            return;
+        }
+        ctx.setupManager.startSilentAssemble(ctx.project.id, ctx.project.path, ctx.project.slug, providers);
+        res.status(202).json({ retrying: providers });
+    });
     // DELETE /api/projects/:id — unregister a project
     router.delete('/projects/:id', (req, res) => {
         const { id } = req.params;

package/server/dist/framework-reseed.js

@@ -0,0 +1,144 @@
+"use strict";
+// Post-swap workspace re-seed (global-core-zero-friction / framework-auto-update).
+//
+// A `current` swap updates every SYMLINKED workspace surface for free, but the
+// COPIED files (instruction files with the project name, Windows copy-fallback
+// subtrees, Kimi per-child skill links) stay frozen at the old version. This
+// pass re-runs the offline assemble for every relocated workspace whose
+// recorded framework version differs from `current` — which also repairs
+// machines that were off during a swap (missed-swap scenario).
+//
+// `.mcp.json` guarantee: the framework owns NO mcp keys today, so the surgical
+// "update only framework-owned keys" contract degenerates to full preservation
+// — the file is snapshotted before the assemble and restored byte-identically
+// if the assemble touched it (plugin/user keys can never be clobbered).
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFrameworkAutoswapEnabled = isFrameworkAutoswapEnabled;
+exports.readWorkspaceFrameworkVersion = readWorkspaceFrameworkVersion;
+exports.reseedStaleWorkspaces = reseedStaleWorkspaces;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const providers_1 = require("./providers");
+const workspace_manager_1 = require("./workspace-manager");
+const workspace_resolution_1 = require("./workspace-resolution");
+const offline_assemble_1 = require("./offline-assemble");
+function isFrameworkAutoswapEnabled() {
+    const v = (process.env.SPECRAILS_FRAMEWORK_AUTOSWAP ?? '').toLowerCase();
+    return v !== 'false' && v !== '0' && v !== 'off';
+}
+/** The framework version this workspace was last assembled against. */
+function readWorkspaceFrameworkVersion(slug) {
+    try {
+        const v = fs.readFileSync(path.join((0, workspace_manager_1.workspacePathFor)(slug), '.specrails', 'specrails-version'), 'utf-8').trim();
+        return v.length > 0 ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Providers whose surface exists in this workspace (assembled at some point). */
+function workspaceProviders(workspace) {
+    return (0, providers_1.listAdapters)()
+        .filter((a) => fs.existsSync(path.join(workspace, a.projectDirName)))
+        .map((a) => a.id);
+}
+/**
+ * Re-seed every relocated workspace whose recorded framework version differs
+ * from `currentVersion`. Idempotent (an up-to-date workspace is skipped);
+ * serialized; never throws — per-project failures are reported and logged.
+ */
+async function reseedStaleWorkspaces(projects, currentVersion, io) {
+    const results = [];
+    if (!currentVersion)
+        return results;
+    const assemble = io?.assemble
+        ?? (async (p, providers) => {
+            await (0, offline_assemble_1.assembleProjectOffline)({
+                projectPath: p.path,
+                slug: p.slug,
+                desktopProjectId: p.id,
+                providers,
+                continueOnError: true,
+            });
+        });
+    for (const project of projects) {
+        const workspace = (0, workspace_manager_1.workspacePathFor)(project.slug);
+        if (!(0, workspace_resolution_1.isWorkspacePopulated)(workspace)) {
+            results.push({ projectId: project.id, reseeded: false, skippedReason: 'not-relocated' });
+            continue;
+        }
+        const recorded = readWorkspaceFrameworkVersion(project.slug);
+        if (recorded === currentVersion) {
+            results.push({ projectId: project.id, reseeded: false, skippedReason: 'up-to-date' });
+            continue;
+        }
+        const providers = workspaceProviders(workspace);
+        if (providers.length === 0) {
+            results.push({ projectId: project.id, reseeded: false, skippedReason: 'not-relocated' });
+            continue;
+        }
+        // `.mcp.json` preservation snapshot (see module header).
+        const mcpPath = path.join(workspace, '.mcp.json');
+        let mcpBefore = null;
+        try {
+            mcpBefore = fs.readFileSync(mcpPath, 'utf-8');
+        }
+        catch { /* absent */ }
+        try {
+            await assemble(project, providers);
+            if (mcpBefore !== null) {
+                let mcpAfter = null;
+                try {
+                    mcpAfter = fs.readFileSync(mcpPath, 'utf-8');
+                }
+                catch { /* deleted by assemble */ }
+                if (mcpAfter !== mcpBefore)
+                    fs.writeFileSync(mcpPath, mcpBefore, 'utf-8');
+            }
+            results.push({ projectId: project.id, reseeded: true });
+            console.log(`[framework-reseed] ${project.slug}: ${recorded ?? '(none)'} → ${currentVersion}`);
+        }
+        catch (err) {
+            results.push({
+                projectId: project.id,
+                reseeded: false,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            console.warn(`[framework-reseed] ${project.slug} failed (non-fatal):`, err);
+        }
+    }
+    return results;
+}

package/server/dist/index.js

@@ -15,6 +15,11 @@ const express_1 = __importDefault(require("express"));
 const ws_1 = require("ws");
 const project_registry_1 = require("./project-registry");
 const desktop_router_1 = require("./desktop-router");
+const provider_detection_1 = require("./provider-detection");
+const provider_selection_1 = require("./provider-selection");
+const desktop_db_1 = require("./desktop-db");
+const legacy_migration_1 = require("./legacy-migration");
+const framework_reseed_1 = require("./framework-reseed");
 const project_router_1 = require("./project-router");
 const docs_router_1 = require("./docs-router");
 const auth_1 = require("./auth");
@@ -522,9 +527,20 @@ function applyPtyWsRateLimiting(ws) {
             // WsMessage union; cast at this single boundary.
             broadcast: (msg) => broadcast(msg),
         });
-        if (framework.isAvailable()) {
+        // Kill switch (framework-auto-update spec): SPECRAILS_FRAMEWORK_AUTOSWAP=false
+        // restores the manual-only flow (GlobalSettings "check now").
+        if (framework.isAvailable() && (0, framework_reseed_1.isFrameworkAutoswapEnabled)()) {
             const providers = registry.installedProvidersUnion();
-            (0, artifact_registry_1.withFileLock)(undefined, () => framework.versionCheck(providers));
+            const check = (0, artifact_registry_1.withFileLock)(undefined, () => framework.versionCheck(providers));
+            // Post-swap re-seed: refresh COPIED workspace files (instruction files,
+            // Windows copy-fallback, Kimi skill links) for every workspace whose
+            // recorded framework version ≠ current — also repairs missed swaps.
+            const reseedProjects = registry.listContexts().map((c) => ({
+                id: c.project.id,
+                slug: c.project.slug,
+                path: c.project.path,
+            }));
+            void (0, framework_reseed_1.reseedStaleWorkspaces)(reseedProjects, check.version);
         }
     }
     catch (err) {
@@ -542,6 +558,29 @@ function applyPtyWsRateLimiting(ws) {
     (0, telemetry_compactor_1.runCompactionForAll)(registry).catch((err) => {
         console.error('[telemetry-compactor] startup compaction error:', err);
     });
+    // ─── App-level provider detection (global-core-zero-friction) ───────────────
+    // Providers are a machine property: one detection snapshot feeds
+    // provider-selection (per-invocation validation) and desktop-db's project-row
+    // mirror (`providers` reads as the detected set). Startup is a refresh
+    // trigger; window-focus and project-add refreshes ride the REST route.
+    (0, provider_selection_1.setDetectedProvidersSupplier)(provider_detection_1.getDetectedIdsSync);
+    (0, desktop_db_1.setProjectProvidersMirror)(provider_detection_1.getDetectedIdsSync);
+    (0, provider_detection_1.refreshDetection)()
+        .then(({ snapshot }) => {
+        // ─── Forced legacy migration (global-core-zero-friction) ────────────────
+        // After the first detection lands, migrate repo-resident core installs to
+        // the relocated workspace in the background — serialized, fail-open,
+        // journaled. Kill switch: SPECRAILS_LEGACY_MIGRATION=false.
+        const projects = registry.listContexts().map((c) => ({
+            id: c.project.id,
+            slug: c.project.slug,
+            path: c.project.path,
+        }));
+        void (0, legacy_migration_1.runLegacyMigrationSweep)(projects, { providers: snapshot.detected });
+    })
+        .catch((err) => {
+        console.error('[provider-detection] startup detection failed (non-fatal):', err);
+    });
     // ─── Mobile companion gateway (off by default; boot if previously enabled) ──
     // Second HTTPS+WSS listener in THIS process; the main server stays loopback.
     // The control plane is desktop-only: loopback + (via /api below) requireAuth.

package/server/dist/jira/jira-sync-manager.js

@@ -687,6 +687,49 @@ class JiraSyncManager {
      * reconciles it to the issue's real status (protected meanwhile by the
      * pending-transition frozen guard).
      */
+    /**
+     * Manual "move to <Jira status>" from the spec detail's status selector
+     * (global-core-zero-friction follow-up): enqueue an explicit-target
+     * transition to the NAMED raw Jira status. The logical state is derived by
+     * reverse statusMap lookup (falling back to `in_progress` — the resolver
+     * honours the explicit target regardless), and the local cache is
+     * optimistically flipped so the board reflects the move immediately; the
+     * inbound poll reconciles to the issue's real status afterwards.
+     */
+    moveSpecToStatus(localId, targetStatus) {
+        if (!this.isActive())
+            return { ok: false, reason: 'not-active' };
+        const link = (0, jira_db_1.getLinkByLocalId)(this.db, localId);
+        if (!link || link.tombstoned)
+            return { ok: false, reason: 'no-link' };
+        const conn = (0, jira_db_1.getConnection)(this.db, this.projectId);
+        const map = conn?.statusMap ?? null;
+        let logical = 'in_progress';
+        if (map) {
+            for (const [state, name] of Object.entries(map)) {
+                if (typeof name === 'string' && name.toLowerCase() === targetStatus.toLowerCase()) {
+                    logical = state;
+                    break;
+                }
+            }
+        }
+        const nonce = Date.now().toString(36);
+        (0, jira_db_1.enqueueMany)(this.db, [{
+                jiraIssueId: link.jiraIssueId,
+                opType: 'transition',
+                idempotencyKey: `manual-move:${localId}:${nonce}`,
+                payload: { localId, jiraIssueId: link.jiraIssueId, logicalState: logical, targetStatus },
+            }]);
+        const localStatus = logical === 'todo' ? 'todo'
+            : logical === 'done' ? 'done'
+                : logical === 'cancelled' ? 'cancelled'
+                    : logical === 'on_review' ? 'on_review'
+                        : 'in_progress';
+        this.writeLocalStatus([localId], localStatus, targetStatus);
+        this.broadcastOutboxState();
+        void this.drainOnce().catch(() => undefined);
+        return { ok: true };
+    }
     discardSpec(localId, comment) {
         if (!this.isActive())
             return { ok: false, reason: 'not-active' };
@@ -1156,7 +1199,7 @@ class JiraSyncManager {
         void this.drainOnce().catch(() => undefined);
     }
     // ─── Local cache helpers ───────────────────────────────────────────────────
-    writeLocalStatus(localIds, status) {
+    writeLocalStatus(localIds, status, rawJiraStatus) {
         if (localIds.length === 0)
             return;
         try {
@@ -1166,8 +1209,12 @@ class JiraSyncManager {
             const store = (0, ticket_store_1.mutateStore)(file, (s) => {
                 for (const id of ids) {
                     const t = s.tickets[id];
-                    if (t && t.status !== status) {
+                    if (t && (t.status !== status || (rawJiraStatus !== undefined && t.jira_status !== rawJiraStatus))) {
                         t.status = status;
+                        // Manual move-to-status: reflect the RAW target immediately so the
+                        // Jira-status filter dimension updates without waiting for the poll.
+                        if (rawJiraStatus !== undefined)
+                            t.jira_status = rawJiraStatus;
                         t.updated_at = now;
                     }
                 }

package/server/dist/jira-router.js

@@ -245,6 +245,27 @@ function createJiraRouter() {
         }
         res.status(201).json({ localId: result.localId, jiraKey: result.jiraKey });
     });
+    // POST /specs/:localId/move-to-status — manual transition to a NAMED raw Jira
+    // status from the spec detail's status selector. Body: { status: string }.
+    router.post('/specs/:localId/move-to-status', (req, res) => {
+        const c = ctx(req);
+        const localId = parseInt(req.params.localId, 10);
+        if (Number.isNaN(localId)) {
+            res.status(400).json({ error: 'Invalid spec id' });
+            return;
+        }
+        const status = req.body?.status;
+        if (!isNonEmptyString(status)) {
+            res.status(400).json({ error: 'status is required' });
+            return;
+        }
+        const result = c.jiraSyncManager.moveSpecToStatus(localId, status.trim());
+        if (!result.ok) {
+            res.status(result.reason === 'no-link' ? 404 : 409).json({ error: result.reason });
+            return;
+        }
+        res.status(202).json({ ok: true });
+    });
     // POST /specs/:localId/discard — "Move to <discard status>": transition the
     // linked issue to the configured discard status (+ optional reason comment)
     // instead of a destructive delete. Body: { comment?: string }.