specrails-desktop 2.4.0 → 2.5.0

package/server/dist/chat-manager.js

@@ -391,13 +391,23 @@ class ChatManager {
      */
     _buildLightweightSystemPrompt(scope) {
         const name = this._projectName ?? 'this project';
-        const base = `You are a fast, focused assistant for the "${name}" specrails project. ` +
+        // High tier = the user opted into MCP/connectors (Max/Desktop presets). At
+        // that tier the agent also has Bash (gh + repo inspection) and MCP tools, so
+        // its stance flips from "be minimal" to "verify against the real code before
+        // recommending" — this is deterministic per scope, so the prompt stays
+        // byte-stable for prompt caching within a given scope.
+        const highTier = !!(scope && scope.full && (scope.mcp || scope.userMcp));
+        const intro = `You are a focused assistant for the "${name}" specrails project. ` +
             `You have explicit permission to read and write .specrails/local-tickets.json — ` +
             `this is the project's local ticket store managed by Specrails. It is NOT sensitive. ` +
-            `When creating or updating tickets, write directly to this JSON file.\n\n` +
-            `IMPORTANT: Be efficient. Minimize tool calls. Only read files that are directly relevant. ` +
-            `Do not explore broadly — focus on the specific task.`;
-        const scopedBase = `${base}\n\n` +
+            `When creating or updating tickets, write directly to this JSON file.`;
+        const stance = highTier
+            ? `IMPORTANT: You have read/search tools (Read, Grep, Glob), the GitHub CLI (\`gh\`, already authenticated for this machine — use it to inspect issues, PRs, and CI), and any MCP servers the user enabled. ` +
+                `Before recommending a spec, doing gap analysis, or claiming a feature is missing, you MUST INVESTIGATE THE ACTUAL CODEBASE first — grep and read the relevant source (and check \`gh\`/MCP where useful) to confirm the real implementation status. ` +
+                `NEVER recommend a spec for something that is already implemented: if the backlog or another spec references a feature, verify it in code before proposing it. Reading code thoroughly is expected and encouraged at this tier — do not guess from ticket titles alone.`
+            : `IMPORTANT: Be efficient. Minimize tool calls. Only read files that are directly relevant. ` +
+                `Do not explore broadly — focus on the specific task.`;
+        const scopedBase = `${intro}\n\n${stance}\n\n` +
             `When "Specrails Tickets" or "OpenSpec Specs" sections are present below, treat them as authoritative project context. ` +
             `For roadmap-style requests like "suggest the next best spec", ground the answer in that context, avoid duplicates, and propose one concrete next spec instead of generic directions.`;
         if (!scope || !this._cwd)
@@ -495,8 +505,10 @@ class ChatManager {
                 : 'chat-turn';
             // Translate the per-conversation Explore scope into provider-native
             // tool-gating flags. `toolFlagsForScope` emits claude-shape argv
-            // (`--disallowedTools …`); codex's `exec` would reject those with an
-            // "unexpected argument" error and crash the turn. The scope's tool
+            // (`--tools …` to restrict the read-only tiers, or `--disallowedTools …` at
+            // the high MCP tier where Bash + MCP tools must stay callable); codex's
+            // `exec` would reject those with an "unexpected argument" error and crash
+            // the turn. The scope's tool
             // gating is therefore claude-only today — codex inherits its sandbox
             // and approval policy from the project's `.codex/config.toml` (or the
             // `-c sandbox_mode=` override the adapter already attaches on resume).

package/server/dist/context-scope.js

@@ -262,16 +262,37 @@ function buildScopedSystemPromptPrefix(scope, projectPath) {
     return sections.join('\n\n');
 }
 // Compute the claude CLI tool flags for the given scope.
-// We use `--tools` (whitelist) instead of `--disallowedTools` because
-// `--dangerously-skip-permissions` can bypass disallow filters in some CLI
-// versions; an explicit whitelist is the most reliable lockdown.
 //
-// - full=true   → --tools Read,Grep,Glob (Bash is NEVER auto-allowed)
-// - full=false  → --tools __none__ (a non-existent tool name; effectively
-//                 disables all tools because Commander.js requires a non-empty
-//                 value, and the empty string `""` is silently dropped by some
-//                 CLI versions, falling back to the default tool set).
+// The base read-only Explore tiers use `--tools Read,Grep,Glob` (a built-in
+// toolkit RESTRICTION — NOT a permission allow-list). This is the most reliable
+// read-only lockdown because `--dangerously-skip-permissions` (in COMMON_FLAGS)
+// can bypass `--disallowedTools` filters. Verified against claude 2.1.177:
+//   - `--tools Read,Grep,Glob` removes Bash AND MCP tools from the toolkit, so
+//     `gh` and any `mcp__*` tools are uncallable (the "only local read access"
+//     symptom users hit when they enable approved MCPs at this tier).
+//
+// HIGH TIER (full AND an MCP toggle on — the Max/Desktop presets, i.e. the user
+// explicitly opted into MCP/connectors): we cannot enumerate Claude.ai connector
+// servers to put them in an allow-list, so we keep the full `--tools default`
+// toolkit + skip-permissions (which makes ALL MCP servers — file, plugin, and
+// connector — callable) and merely DISALLOW the GUI file-writers. This is a
+// deliberate capability bump: it also exposes Bash (so the agent can run `gh`
+// with the user's local auth, and inspect the repo via shell). Bash can write
+// to disk, so this tier is NOT a hard read-only sandbox — the Explore system
+// prompt carries the non-destructive stance, and the tier is opt-in.
+//
+// - full && (mcp || userMcp) → --disallowedTools Write,Edit,NotebookEdit
+//                              (default toolkit: Read/Grep/Glob/Bash/WebFetch +
+//                               all loaded MCP tools; file-writer tools removed)
+// - full (no MCP toggle)     → --tools Read,Grep,Glob (read-only, no Bash/MCP)
+// - !full                    → --tools __none__ (a non-existent tool name; the
+//                              empty string `""` is silently dropped by some CLI
+//                              versions and falls back to the default set, so we
+//                              use a sentinel to disable all tools).
 function toolFlagsForScope(scope) {
+    if (scope.full && (scope.mcp || scope.userMcp)) {
+        return { args: ['--disallowedTools', 'Write,Edit,NotebookEdit'] };
+    }
     if (scope.full) {
         return { args: ['--tools', 'Read,Grep,Glob'] };
     }

package/server/dist/db.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_ULTRACODE_PRE_PROMPT = void 0;
 exports.initDb = initDb;
 exports.createJob = createJob;
+exports.accumulateInteractiveTurn = accumulateInteractiveTurn;
+exports.finalizeInteractiveJob = finalizeInteractiveJob;
 exports.finishJob = finishJob;
 exports.appendEvent = appendEvent;
 exports.upsertPhase = upsertPhase;
@@ -639,6 +641,18 @@ const MIGRATIONS = [
             // Column may already exist on a partially-migrated DB — no-op.
         }
     },
+    // Migration 32: jobs.interactive — 1 when the job is an interactive persistent
+    // ultracode session (the user sends multiple prompts across turns; the job
+    // stays 'running' until an explicit finalize, at which point every turn's real
+    // tokens/cost/num_turns are already summed into the row and status flips to
+    // 'completed'); 0 (default) for standard autonomous jobs. Additive + idempotent
+    // (guarded by PRAGMA table_info, mirroring migrations 18–26).
+    (db) => {
+        const cols = db.prepare(`PRAGMA table_info(jobs)`).all().map((r) => r.name);
+        if (!cols.includes('interactive')) {
+            db.exec(`ALTER TABLE jobs ADD COLUMN interactive INTEGER NOT NULL DEFAULT 0`);
+        }
+    },
 ];
 function applyMigrations(db) {
     // Ensure the migrations table exists (migration 1 creates it, but we need
@@ -700,8 +714,39 @@ function initDb(dbPath) {
 function createJob(db, job) {
     // INSERT OR IGNORE handles the case where the job row already exists (restored from DB
     // after server restart). The UPDATE that follows always sets status and started_at.
-    db.prepare('INSERT OR IGNORE INTO jobs (id, command, started_at, status, priority, depends_on_job_id, pipeline_id) VALUES (?, ?, ?, ?, ?, ?, ?)').run(job.id, job.command, job.started_at, 'running', job.priority ?? 'normal', job.depends_on_job_id ?? null, job.pipeline_id ?? null);
-    db.prepare('UPDATE jobs SET status = ?, started_at = ? WHERE id = ?').run('running', job.started_at, job.id);
+    db.prepare('INSERT OR IGNORE INTO jobs (id, command, started_at, status, priority, depends_on_job_id, pipeline_id, interactive) VALUES (?, ?, ?, ?, ?, ?, ?, ?)').run(job.id, job.command, job.started_at, 'running', job.priority ?? 'normal', job.depends_on_job_id ?? null, job.pipeline_id ?? null, job.interactive ? 1 : 0);
+    db.prepare('UPDATE jobs SET status = ?, started_at = ?, interactive = ? WHERE id = ?').run('running', job.started_at, job.interactive ? 1 : 0, job.id);
+}
+/**
+ * Add one completed interactive turn's REAL usage into the job row. Token/cost/
+ * turn columns accumulate (COALESCE so the first turn starts from a clean base);
+ * model + session_id are stamped from the first turn that reports them. The job
+ * stays 'running' — only finalizeInteractiveJob flips the terminal status. This
+ * keeps the live Job Detail totals honest (sum of completed turns, never an
+ * estimate) between turns.
+ */
+function accumulateInteractiveTurn(db, jobId, turn) {
+    db.prepare(`
+    UPDATE jobs SET
+      tokens_in           = COALESCE(tokens_in, 0) + ?,
+      tokens_out          = COALESCE(tokens_out, 0) + ?,
+      tokens_cache_read   = COALESCE(tokens_cache_read, 0) + ?,
+      tokens_cache_create = COALESCE(tokens_cache_create, 0) + ?,
+      total_cost_usd      = COALESCE(total_cost_usd, 0) + ?,
+      num_turns           = COALESCE(num_turns, 0) + ?,
+      total_cost_usd_estimated = 0,
+      model               = COALESCE(model, ?),
+      session_id          = COALESCE(?, session_id)
+    WHERE id = ?
+  `).run(turn.tokens_in, turn.tokens_out, turn.tokens_cache_read, turn.tokens_cache_create, turn.total_cost_usd, turn.num_turns, turn.model ?? null, turn.session_id ?? null, jobId);
+}
+/**
+ * Flip an interactive job to its terminal status (completed on finalize, failed
+ * on crash) and stamp finished_at. Token/cost/turn columns are left untouched —
+ * they were already accumulated turn-by-turn via accumulateInteractiveTurn.
+ */
+function finalizeInteractiveJob(db, jobId, status) {
+    db.prepare('UPDATE jobs SET status = ?, finished_at = ? WHERE id = ?').run(status, new Date().toISOString(), jobId);
 }
 function finishJob(db, jobId, result) {
     db.prepare(`

package/server/dist/feature-flags.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCodeExplorerEnabled = isCodeExplorerEnabled;
 exports.isBrowserCaptureEnabled = isBrowserCaptureEnabled;
 exports.isJiraEnabled = isJiraEnabled;
+exports.isInteractiveJobsEnabled = isInteractiveJobsEnabled;
 function isCodeExplorerEnabled() {
     return process.env.SPECRAILS_CODE_EXPLORER !== 'false';
 }
@@ -26,3 +27,17 @@ function isBrowserCaptureEnabled() {
 function isJiraEnabled() {
     return process.env.SPECRAILS_JIRA_SECTION !== 'false';
 }
+/**
+ * Interactive ultracode jobs: when launched with the rail's "Interactive"
+ * toggle, an ultracode (Claude-only) job becomes a persistent chat session —
+ * the user sends multiple prompts across turns, the job stays resident until an
+ * explicit "Finalize Job" action, and every turn's real token spend is summed
+ * into the single job row. Server-side default ON; set
+ * SPECRAILS_INTERACTIVE_JOBS="false" to reject the toggle + the per-job
+ * message/finalize routes (emergency rollback). Inert unless a launch actually
+ * sets interactive=true, so default-on is safe. The client gates separately on
+ * VITE_FEATURE_INTERACTIVE_JOBS.
+ */
+function isInteractiveJobsEnabled() {
+    return process.env.SPECRAILS_INTERACTIVE_JOBS !== 'false';
+}

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

@@ -0,0 +1,363 @@
+"use strict";
+// Interactive ultracode job sessions (resident persistent-stdin transport).
+//
+// A standard ultracode job spawns `claude -p <prompt>` once and settles when the
+// child closes. An INTERACTIVE ultracode job instead keeps ONE `claude -p
+// --input-format stream-json` child resident across many user turns (the same
+// transport ExploreStdinSessions uses for Explore chat): each user prompt is a
+// newline-delimited stream-json message written to stdin, the agent works, and
+// the turn ends on a `result` event WITHOUT killing the child. The session stays
+// alive until the user finalizes (SIGTERM) — at which point QueueManager flips
+// the job to a terminal status. Every turn's REAL token usage is summed into the
+// job row as it completes, so the live Job Detail totals are honest (never an
+// estimate) and the finalized job carries the full conversation's spend.
+//
+// This module owns the transport + per-turn streaming/persistence/accounting.
+// QueueManager owns spawn-arg construction and the terminal settle (slot release,
+// rail/ticket completion, ai_invocations) via the onSettle callback.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InteractiveJobSession = void 0;
+const node_readline_1 = require("node:readline");
+const cli_prompt_1 = require("./util/cli-prompt");
+const explore_stdin_session_1 = require("./explore-stdin-session");
+const result_event_1 = require("./result-event");
+const db_1 = require("./db");
+const stream_display_1 = require("./util/stream-display");
+function zeroUsage() {
+    return {
+        tokens_in: 0,
+        tokens_out: 0,
+        tokens_cache_read: 0,
+        tokens_cache_create: 0,
+        total_cost_usd: 0,
+        num_turns: 0,
+    };
+}
+/** SIGTERM → SIGKILL escalation window on finalize (ms). */
+const FINALIZE_KILL_GRACE_MS = 2000;
+class InteractiveJobSession {
+    _jobId;
+    _projectId;
+    _db;
+    _adapter;
+    _broadcast;
+    _onSettle;
+    _spawn;
+    _child = null;
+    _stdoutReader = null;
+    _stderrReader = null;
+    _eventSeq = 0;
+    _streaming = false;
+    /** True between writing a turn to stdin and receiving its `result` event.
+     *  Guards _onTurnResult against double-counting a duplicate `result` frame. */
+    _awaitingResult = false;
+    _pending = [];
+    _turnEvents = [];
+    _accum = zeroUsage();
+    _model = null;
+    _sessionId = null;
+    _finalizing = false;
+    _settled = false;
+    _disposed = false;
+    _killTimer = null;
+    constructor(deps) {
+        this._jobId = deps.jobId;
+        this._projectId = deps.projectId;
+        this._db = deps.db;
+        this._adapter = deps.adapter;
+        this._broadcast = deps.broadcast;
+        this._onSettle = deps.onSettle;
+        this._spawn = deps.spawn ?? cli_prompt_1.spawnAiCli;
+    }
+    /** Spawn the resident child and run the first turn (the ultracode 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,
+        });
+        this._child = child;
+        // Absorb spawn 'error' (e.g. ENOENT) so it does not crash the process; the
+        // 'close' that follows settles the job as crashed through _handleClose.
+        child.on('error', (err) => {
+            console.error(`[interactive-job] spawn failed for ${this._jobId}: ${err.message}`);
+        });
+        if (child.stdout) {
+            this._stdoutReader = (0, node_readline_1.createInterface)({ input: child.stdout, crlfDelay: Infinity });
+            this._stdoutReader.on('line', (line) => this._handleStdoutLine(line));
+        }
+        if (child.stderr) {
+            this._stderrReader = (0, node_readline_1.createInterface)({ input: child.stderr, crlfDelay: Infinity });
+            this._stderrReader.on('line', (line) => this._handleStderrLine(line));
+        }
+        child.on('close', (code) => this._handleClose(code));
+        this.send(firstPrompt);
+    }
+    /** Accept a user prompt. Echoed immediately to the in-job chat; written to the
+     *  child now if idle, else queued and fed when the active turn's `result`
+     *  fires. Returns false if the session is gone. */
+    send(text) {
+        if (this._disposed || this._finalizing || !this._child)
+            return false;
+        const queued = this._streaming;
+        // Surface the user turn in the transcript via the existing `log` channel so
+        // it both renders live (the client's 'log' handler) and survives a reload
+        // (persisted as a log event, picked up by GET /jobs/:id). The 🧑 prefix marks
+        // it as the user's prompt amid the agent's streamed work.
+        const line = `🧑 ${text}`;
+        this._persistLog('stdout', line);
+        this._emitLog('stdout', line);
+        // Control signal for the in-job chat UI (streaming-state / queued hint).
+        this._broadcast({
+            type: 'job.turn_user',
+            projectId: this._projectId,
+            jobId: this._jobId,
+            text,
+            queued,
+            timestamp: new Date().toISOString(),
+        });
+        if (queued) {
+            this._pending.push(text);
+        }
+        else {
+            this._writeTurn(text);
+        }
+        return true;
+    }
+    isStreaming() {
+        return this._streaming;
+    }
+    getTotals() {
+        return { ...this._accum };
+    }
+    /** User-initiated end: SIGTERM the child (SIGKILL after a grace window). The
+     *  subsequent 'close' settles the job as 'finalized'. Idempotent. */
+    finalize() {
+        if (this._finalizing || this._settled)
+            return;
+        this._finalizing = true;
+        const child = this._child;
+        if (!child || child.killed || !child.pid) {
+            this._settle('finalized');
+            return;
+        }
+        try {
+            child.kill('SIGTERM');
+        }
+        catch { /* already gone */ }
+        this._killTimer = setTimeout(() => {
+            try {
+                if (this._child && !this._child.killed)
+                    this._child.kill('SIGKILL');
+            }
+            catch { /* gone */ }
+        }, FINALIZE_KILL_GRACE_MS);
+    }
+    /** Teardown without settling (project removal / shutdown). */
+    dispose() {
+        if (this._disposed)
+            return;
+        this._disposed = true;
+        this._clearKillTimer();
+        this._closeReaders();
+        try {
+            if (this._child && !this._child.killed)
+                this._child.kill('SIGTERM');
+        }
+        catch { /* gone */ }
+        this._child = null;
+    }
+    // ─── internals ─────────────────────────────────────────────────────────────
+    _writeTurn(text) {
+        this._streaming = true;
+        this._awaitingResult = true;
+        this._turnEvents = [];
+        const child = this._child;
+        if (!child || !child.stdin || child.stdin.destroyed)
+            return;
+        try {
+            child.stdin.write((0, explore_stdin_session_1.frameStreamJsonUserMessage)(text));
+        }
+        catch (err) {
+            console.error('[interactive-job] stdin write failed:', err);
+        }
+    }
+    _handleStdoutLine(line) {
+        let parsed = null;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch { /* plain text */ }
+        const adapterEv = this._adapter.parseStreamLine(line);
+        if (adapterEv)
+            this._turnEvents.push(adapterEv);
+        if (parsed) {
+            const eventType = parsed.type ?? 'unknown';
+            this._persistEvent(eventType, line);
+            this._broadcast({
+                type: 'event',
+                jobId: this._jobId,
+                event_type: eventType,
+                source: 'stdout',
+                payload: line,
+                timestamp: new Date().toISOString(),
+                seq: this._eventSeq - 1,
+            });
+            if (eventType === 'result') {
+                this._onTurnResult(parsed);
+            }
+            const displayText = (0, stream_display_1.extractDisplayText)(parsed);
+            if (displayText !== null) {
+                this._persistLog('stdout', displayText);
+                this._emitLog('stdout', displayText);
+            }
+        }
+        else {
+            this._persistLog('stdout', line);
+            if (adapterEv?.kind === 'text-delta') {
+                this._emitLog('stdout', adapterEv.text);
+            }
+            else {
+                this._emitLog('stdout', line);
+            }
+        }
+    }
+    _handleStderrLine(line) {
+        this._persistLog('stderr', line);
+        this._emitLog('stderr', line);
+    }
+    _onTurnResult(_parsed) {
+        // Guard against a duplicate `result` frame for the same turn — without it a
+        // second result would double-count this turn's tokens into _accum + the row.
+        if (!this._awaitingResult)
+            return;
+        this._awaitingResult = false;
+        this._streaming = false;
+        const { result: normalised } = (0, result_event_1.finaliseInvocationResult)(this._adapter, this._turnEvents, {});
+        this._accum.tokens_in += normalised.tokens_in ?? 0;
+        this._accum.tokens_out += normalised.tokens_out ?? 0;
+        this._accum.tokens_cache_read += normalised.tokens_cache_read ?? 0;
+        this._accum.tokens_cache_create += normalised.tokens_cache_create ?? 0;
+        this._accum.total_cost_usd += normalised.total_cost_usd ?? 0;
+        this._accum.num_turns += normalised.num_turns ?? 1;
+        if (!this._model && normalised.model)
+            this._model = normalised.model;
+        if (normalised.session_id)
+            this._sessionId = normalised.session_id;
+        if (this._db) {
+            try {
+                (0, db_1.accumulateInteractiveTurn)(this._db, this._jobId, {
+                    tokens_in: normalised.tokens_in ?? 0,
+                    tokens_out: normalised.tokens_out ?? 0,
+                    tokens_cache_read: normalised.tokens_cache_read ?? 0,
+                    tokens_cache_create: normalised.tokens_cache_create ?? 0,
+                    total_cost_usd: normalised.total_cost_usd ?? 0,
+                    num_turns: normalised.num_turns ?? 1,
+                    model: normalised.model,
+                    session_id: normalised.session_id,
+                });
+            }
+            catch (err) {
+                console.error('[interactive-job] accumulate turn failed:', err);
+            }
+        }
+        this._broadcast({
+            type: 'job.turn_done',
+            projectId: this._projectId,
+            jobId: this._jobId,
+            totals: { ...this._accum },
+            timestamp: new Date().toISOString(),
+        });
+        // Feed the next queued prompt (if any) now that the turn is idle.
+        if (!this._finalizing && this._pending.length > 0) {
+            const next = this._pending.shift();
+            this._writeTurn(next);
+        }
+    }
+    _persistEvent(eventType, payload) {
+        if (!this._db)
+            return;
+        try {
+            (0, db_1.appendEvent)(this._db, this._jobId, this._eventSeq++, {
+                event_type: eventType,
+                source: 'stdout',
+                payload,
+            });
+        }
+        catch (err) {
+            console.error('[interactive-job] persist event failed:', err);
+        }
+    }
+    _persistLog(source, line) {
+        if (!this._db)
+            return;
+        try {
+            (0, db_1.appendEvent)(this._db, this._jobId, this._eventSeq++, {
+                event_type: 'log',
+                source,
+                payload: JSON.stringify({ line }),
+            });
+        }
+        catch (err) {
+            console.error('[interactive-job] persist log failed:', err);
+        }
+    }
+    _emitLog(source, line) {
+        this._broadcast({
+            type: 'log',
+            source,
+            line,
+            timestamp: new Date().toISOString(),
+            processId: this._jobId,
+        });
+    }
+    _handleClose(_code) {
+        if (this._disposed || this._settled)
+            return;
+        this._settle(this._finalizing ? 'finalized' : 'crashed');
+    }
+    _settle(reason) {
+        if (this._settled)
+            return;
+        this._settled = true;
+        this._streaming = false;
+        this._awaitingResult = false;
+        this._clearKillTimer();
+        this._closeReaders();
+        // The child is gone — any prompts still queued (turn died without a `result`,
+        // or the user finalized mid-turn) can never run. Surface them in the
+        // transcript instead of dropping them silently.
+        if (this._pending.length > 0) {
+            const note = `⚠️ ${this._pending.length} queued prompt(s) were not sent — the session ended.`;
+            this._persistLog('stderr', note);
+            this._emitLog('stderr', note);
+            this._pending = [];
+        }
+        this._onSettle({
+            reason,
+            totals: { ...this._accum },
+            model: this._model,
+            sessionId: this._sessionId,
+        });
+    }
+    _clearKillTimer() {
+        if (this._killTimer !== null) {
+            clearTimeout(this._killTimer);
+            this._killTimer = null;
+        }
+    }
+    _closeReaders() {
+        try {
+            this._stdoutReader?.close();
+        }
+        catch { /* best-effort */ }
+        try {
+            this._stderrReader?.close();
+        }
+        catch { /* best-effort */ }
+        this._stdoutReader = null;
+        this._stderrReader = null;
+    }
+}
+exports.InteractiveJobSession = InteractiveJobSession;

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)) {