specrails-desktop 2.4.0 → 2.6.0

package/server/dist/mobile/mobile-webrtc-peer.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileWebrtcGateway = void 0;
+const werift_1 = require("werift");
+const auth_1 = require("../auth");
+const mobile_datachannel_1 = require("./mobile-datachannel");
+class MobileWebrtcGateway {
+    _deps;
+    _pending = null;
+    _active = new Set();
+    constructor(_deps) {
+        this._deps = _deps;
+    }
+    /** Drop the open (un-answered) offer. */
+    clearOffer() {
+        const p = this._pending;
+        this._pending = null;
+        if (p)
+            this._close(p.pc);
+    }
+    /** Create a fresh pairing offer (peer + DataChannel + gathered offer SDP).
+     *  Replaces any previously-open offer. Returns the SDP to embed in the QR. */
+    async createOffer(secret) {
+        this.clearOffer();
+        const pc = new werift_1.RTCPeerConnection({ iceServers: [] });
+        const dc = pc.createDataChannel('mobile');
+        // The companion peer activates when the channel opens. It validates `hello`
+        // against THIS connection's offer secret (captured in this closure) — not a
+        // global pending secret, which is already null by the time hello arrives.
+        new mobile_datachannel_1.DataChannelPeer(toChannelLike(dc), {
+            registerDevice: async (input) => input.secret && (0, auth_1.safeEqual)(input.secret, secret)
+                ? this._deps.registerDevice({ deviceName: input.deviceName, platform: input.platform, token: input.token })
+                : { ok: false },
+            rpcDispatch: this._deps.rpcDispatch,
+            bridge: this._deps.bridge,
+        });
+        pc.connectionStateChange.subscribe((s) => {
+            console.log('[webrtc] pc connectionState:', s);
+            if (s === 'failed' || s === 'closed' || s === 'disconnected') {
+                this._active.delete(pc);
+                if (this._pending?.pc === pc)
+                    this._pending = null;
+            }
+        });
+        const offer = await pc.createOffer();
+        await pc.setLocalDescription(offer);
+        await waitIceComplete(pc);
+        const sdp = pc.localDescription?.sdp;
+        if (!sdp) {
+            this._close(pc);
+            throw new Error('no local description after ICE gathering');
+        }
+        console.log(`[webrtc] offer ready: ${(sdp.match(/a=candidate/g) ?? []).length} ICE candidates`);
+        this._pending = { pc, secret };
+        return { sdp };
+    }
+    /** Apply the companion's scanned answer SDP to the open offer and keep the
+     *  connection alive for the session. */
+    async acceptAnswer(sdp) {
+        const p = this._pending;
+        if (!p)
+            return { ok: false };
+        try {
+            console.log(`[webrtc] applying answer: ${(sdp.match(/a=candidate/g) ?? []).length} ICE candidates`);
+            await p.pc.setRemoteDescription({ type: 'answer', sdp });
+            this._active.add(p.pc);
+            this._pending = null;
+            return { ok: true };
+        }
+        catch {
+            return { ok: false };
+        }
+    }
+    /** Tear down every peer (gateway stopping / disabled). */
+    stop() {
+        this.clearOffer();
+        for (const pc of this._active)
+            this._close(pc);
+        this._active.clear();
+    }
+    _close(pc) {
+        try {
+            void pc.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+exports.MobileWebrtcGateway = MobileWebrtcGateway;
+function toChannelLike(dc) {
+    dc.stateChanged.subscribe((s) => console.log('[webrtc] datachannel state:', s));
+    return {
+        get readyState() {
+            return dc.readyState;
+        },
+        send: (data) => dc.send(data),
+        onMessage: (cb) => {
+            dc.onMessage.subscribe((d) => cb(typeof d === 'string' ? d : d.toString('utf8')));
+        },
+        onClose: (cb) => {
+            dc.stateChanged.subscribe((s) => {
+                if (s === 'closed')
+                    cb();
+            });
+        },
+    };
+}
+/** Vanilla ICE: resolve once gathering completes so the offer SDP carries all
+ *  candidates (there's no trickle channel — the SDP travels by QR). */
+function waitIceComplete(pc) {
+    if (pc.iceGatheringState === 'complete')
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = () => {
+            if (!done) {
+                done = true;
+                resolve();
+            }
+        };
+        pc.iceGatheringStateChange.subscribe((s) => {
+            if (s === 'complete')
+                finish();
+        });
+        const t = setTimeout(finish, 3000);
+        t.unref?.();
+    });
+}

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

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRegisterDevice = buildRegisterDevice;
+exports.buildRpcDispatch = buildRpcDispatch;
+exports.createLoopbackFetch = createLoopbackFetch;
+const https_1 = __importDefault(require("https"));
+const crypto_1 = require("crypto");
+const mobile_devices_1 = require("./mobile-devices");
+// Glue for the serverless WebRTC companion, kept dependency-injected so the
+// security-relevant bits (secret check, device creation, /v1 dispatch) are
+// unit-tested without a real WebRTC peer, the DB driver, or HTTP. The werift
+// runtime peer lives in ./mobile-webrtc-peer.ts and consumes these.
+function toPlatform(p) {
+    return p === 'android' ? 'android' : p === 'ios' ? 'ios' : 'web';
+}
+/** Persists a paired device + issues its token. The single-use pairing-secret
+ *  check is done per-connection by [MobileWebrtcGateway] (which holds each
+ *  offer's secret for the life of that connection — the secret must NOT live on
+ *  the global "pending offer", which is cleared the moment the answer is
+ *  accepted, well before the companion's `hello` arrives). Approval is implicit:
+ *  the desktop user actively scanned the phone's answer QR. */
+function buildRegisterDevice(deps) {
+    const genToken = deps.genToken ?? (() => (0, crypto_1.randomBytes)(32).toString('hex'));
+    return async (input) => {
+        // Reconnect: a known, non-revoked device token → reuse that device (no new
+        // row, no growing the paired-devices list on every reconnect).
+        if (input.token) {
+            const existing = (0, mobile_devices_1.getActiveDeviceByTokenHash)(deps.db, (0, mobile_devices_1.hashToken)(input.token));
+            if (existing) {
+                return {
+                    ok: true,
+                    deviceId: existing.id,
+                    token: input.token,
+                    hubName: deps.desktopName(),
+                    hubInstanceId: deps.desktopInstanceId(),
+                };
+            }
+        }
+        const token = genToken();
+        const row = (0, mobile_devices_1.createDevice)(deps.db, {
+            name: (input.deviceName || 'Web companion').slice(0, 80),
+            platform: toPlatform(input.platform),
+            tokenHash: (0, mobile_devices_1.hashToken)(token),
+            certFingerprint: deps.currentFingerprint(),
+        });
+        return {
+            ok: true,
+            deviceId: row.id,
+            token,
+            hubName: deps.desktopName(),
+            hubInstanceId: deps.desktopInstanceId(),
+        };
+    };
+}
+/** Builds the `rpcDispatch` used by [DataChannelPeer] on `rpc`. A thin proxy to
+ *  the EXISTING `/v1` allow-list (which already validates params, forwards to the
+ *  internal API, and redacts), authenticated with the device's bearer token. */
+function buildRpcDispatch(deps) {
+    return async (input) => {
+        // Only the /v1 surface is reachable; the gateway enforces the allow-list.
+        if (input.path !== '/v1' && !input.path.startsWith('/v1/')) {
+            return { status: 404, json: { error: 'not found' } };
+        }
+        const method = input.method.toUpperCase();
+        const headers = { Authorization: `Bearer ${input.token}` };
+        let body;
+        if (input.body !== undefined && method !== 'GET' && method !== 'DELETE') {
+            headers['Content-Type'] = 'application/json';
+            body = JSON.stringify(input.body);
+        }
+        try {
+            const res = await deps.doFetch(deps.gatewayBase + input.path, { method, headers, body });
+            const text = await res.text();
+            let json = {};
+            try {
+                json = text ? JSON.parse(text) : {};
+            }
+            catch {
+                json = {};
+            }
+            return { status: res.status, json };
+        }
+        catch {
+            return { status: 502, json: { error: 'gateway unreachable' } };
+        }
+    };
+}
+/** A loopback `fetch` for the local /v1 gateway. It deliberately ignores the
+ *  gateway's self-signed cert — the connection never leaves 127.0.0.1, and the
+ *  device bearer token (not the TLS cert) is the auth boundary. */
+function createLoopbackFetch() {
+    return (url, init) => new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const req = https_1.default.request({
+            hostname: u.hostname,
+            port: u.port,
+            path: u.pathname + u.search,
+            method: init.method,
+            headers: init.headers,
+            rejectUnauthorized: false,
+        }, (res) => {
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', (c) => {
+                data += c;
+            });
+            res.on('end', () => resolve({ status: res.statusCode ?? 0, text: async () => data }));
+        });
+        req.on('error', reject);
+        if (init.body)
+            req.write(init.body);
+        req.end();
+    });
+}

package/server/dist/project-router-jobs.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerJobsRoutes = registerJobsRoutes;
 const db_1 = require("./db");
 const queue_manager_1 = require("./queue-manager");
+const feature_flags_1 = require("./feature-flags");
 const types_1 = require("./types");
 const hooks_1 = require("./hooks");
 const explore_smash_1 = require("./explore-smash");
@@ -118,6 +119,47 @@ function registerJobsRoutes(deps) {
             }
         }
     });
+    // ─── Interactive ultracode jobs ────────────────────────────────────────────
+    // Send one more user prompt to a running interactive job (queued behind the
+    // active turn — see InteractiveJobSession). 202 = accepted; 409 = the job is
+    // not an active interactive session (unknown / non-interactive / finalized).
+    router.post('/:projectId/jobs/:id/messages', (req, res) => {
+        if (!(0, feature_flags_1.isInteractiveJobsEnabled)()) {
+            res.status(403).json({ error: 'Interactive jobs are disabled on this server' });
+            return;
+        }
+        const { text } = req.body ?? {};
+        if (!text || typeof text !== 'string' || !text.trim()) {
+            res.status(400).json({ error: 'text is required' });
+            return;
+        }
+        const { queueManager } = ctx(req);
+        const jobId = req.params.id;
+        const accepted = queueManager.sendInteractiveTurn(jobId, text);
+        if (!accepted) {
+            res.status(409).json({ error: 'Job is not an active interactive session' });
+            return;
+        }
+        res.status(202).json({ ok: true });
+    });
+    // Finalize a running interactive job: SIGTERM the resident child; the summed
+    // token/cost totals + 'completed' status are stamped asynchronously when the
+    // child closes (the client also learns the final state via the job.finalized
+    // WS broadcast). 202 = finalize scheduled; 409 = not an active interactive job.
+    router.post('/:projectId/jobs/:id/finalize', (req, res) => {
+        if (!(0, feature_flags_1.isInteractiveJobsEnabled)()) {
+            res.status(403).json({ error: 'Interactive jobs are disabled on this server' });
+            return;
+        }
+        const { db, queueManager } = ctx(req);
+        const jobId = req.params.id;
+        const scheduled = queueManager.finalizeInteractive(jobId);
+        if (!scheduled) {
+            res.status(409).json({ error: 'Job is not an active interactive session' });
+            return;
+        }
+        res.status(202).json({ ok: true, job: (0, db_1.getJob)(db, jobId) ?? null });
+    });
     router.patch('/:projectId/jobs/:id/priority', (req, res) => {
         const { priority } = req.body ?? {};
         if (!priority || !types_1.VALID_PRIORITIES.has(priority)) {

package/server/dist/queue-manager.js

@@ -14,6 +14,7 @@ const tree_kill_1 = __importDefault(require("tree-kill"));
 const types_1 = require("./types");
 const command_resolver_1 = require("./command-resolver");
 const cli_prompt_1 = require("./util/cli-prompt");
+const stream_display_1 = require("./util/stream-display");
 const hooks_1 = require("./hooks");
 const ai_invocations_1 = require("./ai-invocations");
 const feature_flags_1 = require("./feature-flags");
@@ -23,6 +24,7 @@ const crypto_1 = require("crypto");
 const providers_1 = require("./providers");
 const codex_otel_bridge_1 = require("./codex-otel-bridge");
 const db_1 = require("./db");
+const interactive_job_session_1 = require("./interactive-job-session");
 const attachment_manager_1 = require("./attachment-manager");
 const ticket_store_1 = require("./ticket-store");
 const binary_probe_1 = require("./binary-probe");
@@ -104,59 +106,6 @@ class JobAlreadyTerminalError extends Error {
 }
 exports.JobAlreadyTerminalError = JobAlreadyTerminalError;
 // ─── Helpers ──────────────────────────────────────────────────────────────────
-function extractDisplayText(event) {
-    const type = event.type;
-    // ── Claude `--output-format stream-json` ───────────────────────────────
-    if (type === 'assistant') {
-        const content = event.message;
-        const texts = (content?.content ?? [])
-            .filter((c) => c.type === 'text')
-            .map((c) => c.text ?? '');
-        return texts.join('') || null;
-    }
-    if (type === 'tool_use') {
-        const name = event.name;
-        const input = JSON.stringify(event.input ?? {});
-        return `[tool: ${name}] ${input.slice(0, 120)}`;
-    }
-    if (type === 'tool_result' || type === 'system_prompt' || type === 'user' || type === 'system' || type === 'result') {
-        return null;
-    }
-    // ── Codex `exec --json` event types ───────────────────────────────────
-    // Codex shape differs from claude: items are nested under `item` with a
-    // discriminator at `item.type`. Without explicit handling the Job Detail
-    // log shows only the spawn preamble and exit notice — exactly the
-    // "2 / 2 lines" symptom that masks 200k+ tokens of real work.
-    if (type === 'item.completed' || type === 'item.started') {
-        const item = event.item;
-        if (!item)
-            return null;
-        const itemType = item.type;
-        if (itemType === 'agent_message') {
-            const text = item.text?.trim();
-            return text && text.length > 0 ? text : null;
-        }
-        if (itemType === 'command_execution') {
-            // Only surface the completed line so the log isn't doubled with the
-            // matching `item.started` placeholder.
-            if (type !== 'item.completed')
-                return null;
-            const cmd = item.command ?? '';
-            const exitCode = item.exit_code;
-            const exitStr = typeof exitCode === 'number' ? ` → exit ${exitCode}` : '';
-            return `[exec]${exitStr} ${cmd.slice(0, 200)}`;
-        }
-        if (itemType === 'agent_reasoning') {
-            const text = item.text?.trim();
-            return text && text.length > 0 ? `[reasoning] ${text.slice(0, 200)}` : null;
-        }
-        return null;
-    }
-    if (type === 'thread.started' || type === 'turn.started' || type === 'turn.completed') {
-        return null;
-    }
-    return null;
-}
 const TERMINAL_STATUSES = new Set(['completed', 'failed', 'canceled', 'zombie_terminated', 'skipped']);
 /** Match an Ultracode rail command: `/specrails:ultracode #5 …` (or `/sr:…`). */
 exports.ULTRACODE_COMMAND_RE = /^\/(specrails|sr):ultracode\b/;
@@ -207,6 +156,12 @@ class QueueManager {
     /** Pre-spawn working-tree snapshot refs keyed by jobId — read at exit time
      *  by the Code-Explorer provenance hook. Cleared on job exit. */
     _snapshotRefs;
+    /** Pending per-job interactive flag keyed by jobId — read at spawn time.
+     *  In-memory only (mirrors _jobModelSelection). */
+    _jobInteractiveSelection;
+    /** Live interactive job sessions keyed by jobId (the resident persistent-stdin
+     *  child + per-turn accounting). Present only while an interactive job runs. */
+    _interactiveSessions;
     constructor(broadcast, db, commands, cwd, options) {
         this._queue = [];
         this._jobs = new Map();
@@ -235,6 +190,8 @@ class QueueManager {
         this._jobProviderSelection = new Map();
         this._jobModelSelection = new Map();
         this._snapshotRefs = new Map();
+        this._jobInteractiveSelection = new Map();
+        this._interactiveSessions = new Map();
         const envTimeout = process.env.WM_ZOMBIE_TIMEOUT_MS !== undefined
             ? parseInt(process.env.WM_ZOMBIE_TIMEOUT_MS, 10)
             : null;
@@ -293,6 +250,15 @@ class QueueManager {
         }
         this._activeProcess = null;
         this._activeJobId = null;
+        // Tear down any resident interactive sessions (SIGTERM their children) so
+        // teardown orphans no persistent claude process. dispose() does not settle.
+        for (const session of this._interactiveSessions.values()) {
+            try {
+                session.dispose();
+            }
+            catch { /* best-effort */ }
+        }
+        this._interactiveSessions.clear();
         // Release any per-job provenance snapshots so teardown leaves no map entries.
         this._snapshotRefs.clear();
         // Drop the DB reference last so any in-flight 'close' callback sees null
@@ -357,6 +323,11 @@ class QueueManager {
         if (resolvedOpts?.model) {
             this._jobModelSelection.set(id, resolvedOpts.model);
         }
+        // Record per-job interactive flag (ultracode + claude only — enforced at
+        // spawn time against the resolved adapter's persistent-stdin capability).
+        if (resolvedOpts?.interactive) {
+            this._jobInteractiveSelection.set(id, true);
+        }
         // Insert at the correct position based on priority (higher priority first, FIFO within same level)
         const weight = types_1.PRIORITY_WEIGHT[priority];
         let insertIdx = this._queue.length;
@@ -395,6 +366,7 @@ class QueueManager {
             this._jobProviderSelection.delete(jobId);
             this._jobModelSelection.delete(jobId);
             this._jobProfileSelection.delete(jobId);
+            this._jobInteractiveSelection.delete(jobId);
             this._skipDependents(jobId, `Parent job ${jobId} was canceled`);
             this._recomputePositions();
             this._persistJob(job);
@@ -415,6 +387,15 @@ class QueueManager {
             return 'canceled';
         }
         // job.status === 'running'
+        // Interactive jobs own a resident child via the session (not _activeProcess),
+        // so route their cancel through the session: SIGTERM → settle sees the
+        // canceling flag and stamps 'canceled'.
+        const interactiveSession = this._interactiveSessions.get(jobId);
+        if (interactiveSession) {
+            this._cancelingJobs.add(jobId);
+            interactiveSession.finalize();
+            return 'canceling';
+        }
         this._kill(jobId);
         return 'canceling';
     }
@@ -490,6 +471,29 @@ class QueueManager {
     getLogBuffer() {
         return [...this._logBuffer];
     }
+    /** True while an interactive ultracode session is resident for this job. */
+    isInteractiveJob(jobId) {
+        return this._interactiveSessions.has(jobId);
+    }
+    /** Feed one more user prompt to a running interactive job (queued behind the
+     *  active turn). Returns false when the job isn't an active interactive
+     *  session (unknown / already finalized / not interactive). */
+    sendInteractiveTurn(jobId, text) {
+        const session = this._interactiveSessions.get(jobId);
+        if (!session)
+            return false;
+        return session.send(text);
+    }
+    /** User-initiated finalize for an interactive job: SIGTERM the resident child;
+     *  the settle path stamps the summed totals + 'completed' status. Returns false
+     *  when the job isn't an active interactive session. */
+    finalizeInteractive(jobId) {
+        const session = this._interactiveSessions.get(jobId);
+        if (!session)
+            return false;
+        session.finalize();
+        return true;
+    }
     // ─── Private methods ────────────────────────────────────────────────────────
     phasesForCommand(command) {
         return this._phasesForCommand(command);
@@ -630,6 +634,143 @@ class QueueManager {
         }
         return this._adapter;
     }
+    /**
+     * Spawn an interactive ultracode session. The job row is created with the
+     * `interactive` flag set; the resident child runs the first turn (the
+     * ultracode prompt) and stays alive for follow-up turns until finalize/crash.
+     * No zombie timer is armed (the child idles between turns by design) and
+     * `_activeProcess` is left null — the session owns the child; the active SLOT
+     * (`_activeJobId`, reserved by _drainQueue) is held until settle.
+     */
+    _startInteractiveJob(jobId, job, adapter, spec, firstPrompt) {
+        if (this._db) {
+            try {
+                (0, db_1.createJob)(this._db, {
+                    id: jobId,
+                    command: job.command,
+                    started_at: job.startedAt,
+                    priority: job.priority,
+                    depends_on_job_id: job.dependsOnJobId,
+                    pipeline_id: job.pipelineId,
+                    interactive: true,
+                });
+            }
+            catch (err) {
+                console.error('[queue-manager] createJob (interactive) failed:', err);
+            }
+        }
+        const session = new interactive_job_session_1.InteractiveJobSession({
+            jobId,
+            projectId: this._projectId ?? '',
+            db: this._db,
+            adapter,
+            broadcast: this._broadcast,
+            onSettle: (info) => this._settleInteractiveJob(jobId, info),
+        });
+        this._interactiveSessions.set(jobId, session);
+        session.start(spec, firstPrompt);
+        this._broadcastQueueState();
+    }
+    /**
+     * Terminal bookkeeping for an interactive job (called once by the session's
+     * onSettle). Releases the active slot, stamps the job's terminal status +
+     * finished_at (token/cost totals were already accumulated per turn), writes a
+     * single ai_invocations row with the summed usage, fires the rail/ticket
+     * completion callback, and drains the queue.
+     */
+    _settleInteractiveJob(jobId, info) {
+        this._interactiveSessions.delete(jobId);
+        if (this._activeJobId === jobId) {
+            this._activeProcess = null;
+            this._activeJobId = null;
+        }
+        // Interactive jobs skip provenance, but a defensive delete keeps the map
+        // clean if a snapshot was ever recorded for this id.
+        this._snapshotRefs.delete(jobId);
+        if (this._disposed)
+            return;
+        const job = this._jobs.get(jobId);
+        if (!job) {
+            this._drainQueue();
+            return;
+        }
+        const wasCanceling = this._cancelingJobs.has(jobId);
+        this._cancelingJobs.delete(jobId);
+        const finalStatus = wasCanceling
+            ? 'canceled'
+            : info.reason === 'finalized'
+                ? 'completed'
+                : 'failed';
+        job.status = finalStatus;
+        job.finishedAt = new Date().toISOString();
+        job.exitCode = info.reason === 'finalized' ? 0 : 1;
+        const totals = info.totals;
+        if (this._db) {
+            try {
+                (0, db_1.finalizeInteractiveJob)(this._db, jobId, finalStatus);
+            }
+            catch (err) {
+                console.error('[queue-manager] finalizeInteractiveJob failed:', err);
+            }
+            if (this._projectId) {
+                try {
+                    const invStatus = finalStatus === 'completed'
+                        ? 'success'
+                        : finalStatus === 'canceled'
+                            ? 'aborted'
+                            : 'failed';
+                    const ticketIds = this._extractTicketIds(job.command);
+                    const durationMs = job.startedAt
+                        ? new Date(job.finishedAt).getTime() - new Date(job.startedAt).getTime()
+                        : undefined;
+                    (0, ai_invocations_1.recordInvocation)(this._db, {
+                        id: (0, crypto_1.randomUUID)(),
+                        project_id: this._projectId,
+                        provider: 'claude',
+                        surface: 'job',
+                        surface_ref_id: jobId,
+                        ticket_id: ticketIds[0] ?? null,
+                        status: invStatus,
+                        started_at: job.startedAt ?? new Date().toISOString(),
+                        finished_at: job.finishedAt,
+                        total_cost_usd_estimated: false,
+                        tokens_in: totals.tokens_in,
+                        tokens_out: totals.tokens_out,
+                        tokens_cache_read: totals.tokens_cache_read,
+                        tokens_cache_create: totals.tokens_cache_create,
+                        total_cost_usd: totals.total_cost_usd,
+                        num_turns: totals.num_turns,
+                        model: info.model ?? undefined,
+                        session_id: info.sessionId ?? undefined,
+                        duration_ms: durationMs,
+                    });
+                    this._broadcast({ type: 'spending.invalidated', projectId: this._projectId });
+                }
+                catch (err) {
+                    console.error('[queue-manager] recordInvocation (interactive) failed:', err);
+                }
+            }
+        }
+        this._persistJob(job);
+        this._broadcast({
+            type: 'job.finalized',
+            projectId: this._projectId ?? '',
+            jobId,
+            status: finalStatus,
+            totals,
+            timestamp: new Date().toISOString(),
+        });
+        this._broadcastQueueState();
+        if (this._onJobFinished) {
+            try {
+                this._onJobFinished(jobId, finalStatus, totals.total_cost_usd);
+            }
+            catch (err) {
+                console.error(`[QueueManager] onJobFinished failed for ${jobId}: ${err.message}`);
+            }
+        }
+        this._drainQueue();
+    }
     async _startJob(jobId) {
         const job = this._jobs.get(jobId);
         if (!job) {
@@ -859,6 +1000,25 @@ class QueueManager {
                 };
             }
         }
+        // ─── Interactive ultracode branch ──────────────────────────────────────
+        // When the launch requested interactive mode AND the command is ultracode
+        // AND the adapter supports persistent stdin (claude), hand off to a resident
+        // session instead of the one-shot spawn below. The session keeps the child
+        // alive across turns and settles only on finalize/crash. Code-Explorer
+        // provenance is intentionally skipped for interactive jobs (v1 — deferred).
+        const wantsInteractive = this._jobInteractiveSelection.get(jobId) === true;
+        this._jobInteractiveSelection.delete(jobId);
+        if (wantsInteractive && isUltracode && adapter.capabilities.persistentStdin) {
+            const interactiveArgs = adapter.buildArgs('chat-stream', {
+                // chat-stream feeds the prompt over stdin per-turn, so the argv `prompt`
+                // is unused — pass empty to satisfy the shared SpawnOptions shape.
+                prompt: '',
+                systemPrompt: systemAppend || undefined,
+                model: railModel,
+            });
+            this._startInteractiveJob(jobId, job, adapter, { binary, args: interactiveArgs, cwd: this._cwd, env: spawnEnv }, railPrompt);
+            return;
+        }
         // Code-Explorer pre-spawn snapshot. Captures the working-tree state via
         // `git stash create --include-untracked` so the post-exit hook can diff
         // against it. Gated by SPECRAILS_CODE_EXPLORER — when off, no-op.
@@ -996,7 +1156,7 @@ class QueueManager {
                 if (eventType === 'result') {
                     lastResultEvent = parsed;
                 }
-                const displayText = extractDisplayText(parsed);
+                const displayText = (0, stream_display_1.extractDisplayText)(parsed);
                 if (displayText !== null) {
                     if (this._db) {
                         (0, db_1.appendEvent)(this._db, jobId, eventSeq++, {