remcodex 0.1.0-beta.1 → 0.1.0-beta.11

package/README.md

@@ -6,38 +6,6 @@ RemCodex is a local-first web UI for running, reviewing, approving, and resuming
 
 It is built for the real workflow: long-running sessions, mobile check-ins, approval prompts, imported rollout history, and timeline-style execution flow.
 
-```mermaid
-flowchart LR
-  subgraph D[Your devices]
-    P[Phone]
-    B[Browser]
-  end
-
-  subgraph M[Your work machine]
-    subgraph R[RemCodex]
-      UI[Web UI]
-      S[Server]
-      T[Timeline + approvals + sync]
-    end
-
-    subgraph C[Local Codex runtime]
-      X[Codex CLI / app-server]
-      F[Workspace files]
-      H[~/.codex sessions]
-    end
-  end
-
-  P --> UI
-  B --> UI
-  UI --> S
-  S --> T
-  S --> X
-  X --> F
-  X --> H
-  H --> S
-  T --> UI
-```
-
 - Watch live Codex runs without staying in the terminal
 - Approve sensitive actions from a cleaner UI
 - Pick up the same session again after refresh, sleep, or reconnect
@@ -46,10 +14,6 @@ flowchart LR
 
 This project is currently a **beta / developer preview**.
 
-MIT licensed — free for personal and commercial use.
-
-Cloud version coming soon.
-
 It is already usable for local and internal workflows, but it is not yet packaged as a one-click desktop app.
 
 ## Why People Use It
@@ -134,7 +98,7 @@ RemCodex turns Codex's event stream into a browser-based workspace that is easie
 
 Before running this project, you should have:
 
-- Node.js installed
+- Node.js 20.x installed
 - Codex CLI installed and already working locally
 - A machine where this app can access your local Codex data and working directories
 
@@ -151,6 +115,8 @@ npm link
 remcodex start
 ```
 
+If you switch Node.js versions later, reinstall dependencies and relink or reinstall `remcodex`.
+
 Then open:
 
 ```text
@@ -177,11 +143,16 @@ node dist/server/src/cli.js start --no-open
 node dist/server/src/cli.js version
 ```
 
+Published package note:
+
+- the npm package currently expects Node.js 20.x
+- if `better-sqlite3` or `node-pty` reports a native module / `NODE_MODULE_VERSION` error, reinstall `remcodex` under the same Node.js version you will use to run it
+
 Use a specific database:
 
 ```bash
-node dist/server/src/cli.js start --db ~/.remcodex/remcodex-alt.db --no-open
-node dist/server/src/cli.js doctor --db ~/.remcodex/remcodex-alt.db
+node dist/server/src/cli.js start --db ~/.remcodex/remcodex-demo.db --no-open
+node dist/server/src/cli.js doctor --db ~/.remcodex/remcodex-demo.db
 ```
 
 Planned install target after the npm package is published:
@@ -197,6 +168,18 @@ npm install
 npm run dev
 ```
 
+Smoke-test the published-package shape locally:
+
+```bash
+npm run smoke:tarball
+```
+
+Smoke-test a real isolated startup and `/health` check:
+
+```bash
+npm run smoke:start
+```
+
 ## How It Works
 
 The app uses `codex app-server` as the primary runtime path.
@@ -249,6 +232,12 @@ Supported environment variables:
 - `PROJECT_ROOTS`
 - `CODEX_COMMAND`
 - `CODEX_MODE`
+
+For launch screenshots or demo data, you can rebuild a clean demo database with:
+
+```bash
+DATABASE_PATH="$HOME/.remcodex/remcodex-demo.db" ~/.nvm/versions/node/v20.19.5/bin/node scripts/seed-launch-demo-data.js --clean
+```
 - `REMOTE_HOSTS`
 - `ACTIVE_REMOTE_HOST`
 
@@ -278,6 +267,8 @@ web/
   app.js
 scripts/
   fix-node-pty-helper.js
+  import-codex-rollout.js
+  reset-semantic-demo-data.js
 ```
 
 ## Main Endpoints

package/dist/server/src/app.js

@@ -3,12 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePackageRoot = resolvePackageRoot;
-exports.resolveDefaultDatabasePath = resolveDefaultDatabasePath;
 exports.startRemCodexServer = startRemCodexServer;
 const node_fs_1 = require("node:fs");
 const node_http_1 = __importDefault(require("node:http"));
-const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
 const express_1 = __importDefault(require("express"));
 const codex_options_controller_1 = require("./controllers/codex-options.controller");
@@ -23,35 +20,15 @@ const codex_rollout_sync_1 = require("./services/codex-rollout-sync");
 const project_manager_1 = require("./services/project-manager");
 const session_manager_1 = require("./services/session-manager");
 const session_timeline_service_1 = require("./services/session-timeline-service");
+const runtime_paths_1 = require("./utils/runtime-paths");
 const command_1 = require("./utils/command");
 const errors_1 = require("./utils/errors");
-function isPackageRoot(root) {
-    return ((0, node_fs_1.existsSync)(node_path_1.default.join(root, "package.json")) &&
-        (0, node_fs_1.existsSync)(node_path_1.default.join(root, "web", "index.html")));
-}
-function resolvePackageRoot(startDir = __dirname) {
-    let current = node_path_1.default.resolve(startDir);
-    while (true) {
-        if (isPackageRoot(current)) {
-            return current;
-        }
-        const parent = node_path_1.default.dirname(current);
-        if (parent === current) {
-            break;
-        }
-        current = parent;
-    }
-    return process.cwd();
-}
-function resolveDefaultDatabasePath() {
-    return node_path_1.default.join((0, node_os_1.homedir)(), ".remcodex", "remcodex.db");
-}
 function buildRemCodexServer(options = {}) {
-    const repoRoot = options.repoRoot ? node_path_1.default.resolve(options.repoRoot) : resolvePackageRoot();
+    const repoRoot = options.repoRoot ? node_path_1.default.resolve(options.repoRoot) : (0, runtime_paths_1.resolvePackageRoot)();
     const port = options.port ?? Number.parseInt(process.env.PORT ?? "3000", 10);
     const databasePath = options.databasePath ??
         process.env.DATABASE_PATH ??
-        resolveDefaultDatabasePath();
+        (0, runtime_paths_1.resolveDefaultDatabasePath)();
     const codexCommand = (0, command_1.resolveExecutable)(options.codexCommand ?? process.env.CODEX_COMMAND ?? "codex");
     const codexMode = options.codexMode ?? (process.env.CODEX_MODE === "exec-json" ? "exec-json" : "app-server");
     const projectRootsEnv = options.projectRootsEnv ?? process.env.PROJECT_ROOTS;

package/dist/server/src/cli.js

@@ -1,5 +1,38 @@
 #!/usr/bin/env node
 "use strict";
+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;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -8,7 +41,7 @@ const node_fs_1 = require("node:fs");
 const node_child_process_1 = require("node:child_process");
 const node_os_1 = require("node:os");
 const node_path_1 = __importDefault(require("node:path"));
-const app_1 = require("./app");
+const runtime_paths_1 = require("./utils/runtime-paths");
 const command_1 = require("./utils/command");
 function print(message = "") {
     process.stdout.write(`${message}\n`);
@@ -18,7 +51,7 @@ function printError(message = "") {
 }
 function readPackageVersion() {
     try {
-        const packageRoot = (0, app_1.resolvePackageRoot)();
+        const packageRoot = (0, runtime_paths_1.resolvePackageRoot)();
         const packageJson = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(packageRoot, "package.json"), "utf8"));
         return typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
     }
@@ -123,12 +156,24 @@ function usage() {
     print("  --db <path>             Use a specific SQLite database path");
     print("  --no-open               Do not open a browser automatically");
 }
+function formatNativeModuleError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("NODE_MODULE_VERSION")) {
+        return null;
+    }
+    return [
+        "Native module failed to load. This usually means RemCodex was installed with a different Node.js version.",
+        `Current Node: ${process.version}`,
+        "Reinstall remcodex with the same Node.js version you will use to run it.",
+        "If you use nvm/fnm/asdf, switch to the target Node version first, then reinstall.",
+    ].join("\n");
+}
 async function runDoctor(flags) {
     const version = readPackageVersion();
     const rawCodexCommand = process.env.CODEX_COMMAND ?? "codex";
     const codex = commandExists(rawCodexCommand);
-    const packageRoot = (0, app_1.resolvePackageRoot)();
-    const databasePath = flags.databasePath ?? process.env.DATABASE_PATH ?? (0, app_1.resolveDefaultDatabasePath)();
+    const packageRoot = (0, runtime_paths_1.resolvePackageRoot)();
+    const databasePath = flags.databasePath ?? process.env.DATABASE_PATH ?? (0, runtime_paths_1.resolveDefaultDatabasePath)();
     const databaseDir = node_path_1.default.dirname(databasePath);
     const databaseDirExists = (0, node_fs_1.existsSync)(databaseDir);
     const databaseDirWritable = databaseDirExists && (() => {
@@ -161,6 +206,18 @@ async function runDoctor(flags) {
     return 0;
 }
 async function runStart(flags) {
+    let startRemCodexServer;
+    try {
+        ({ startRemCodexServer } = await Promise.resolve().then(() => __importStar(require("./app"))));
+    }
+    catch (error) {
+        const nativeModuleMessage = formatNativeModuleError(error);
+        if (nativeModuleMessage) {
+            printError(nativeModuleMessage);
+            return 1;
+        }
+        throw error;
+    }
     const version = readPackageVersion();
     const rawCodexCommand = process.env.CODEX_COMMAND ?? "codex";
     const codex = commandExists(rawCodexCommand);
@@ -176,7 +233,7 @@ async function runStart(flags) {
     for (let offset = 0; offset < 20; offset += 1) {
         const candidate = preferredPort + offset;
         try {
-            started = await (0, app_1.startRemCodexServer)({
+            started = await startRemCodexServer({
                 port: candidate,
                 databasePath: flags.databasePath,
                 codexCommand: rawCodexCommand,
@@ -242,8 +299,9 @@ async function main() {
         usage();
         return;
     }
-    const command = argv[0] && !argv[0].startsWith("-") ? argv[0] : "start";
-    const flagArgs = command === "start" ? argv.slice(1) : argv;
+    const hasExplicitCommand = Boolean(argv[0] && !argv[0].startsWith("-"));
+    const command = hasExplicitCommand ? argv[0] : "start";
+    const flagArgs = hasExplicitCommand ? argv.slice(1) : argv;
     const flags = parseFlags(flagArgs);
     switch (command) {
         case "start":

package/dist/server/src/controllers/session.controller.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createSessionRouter = createSessionRouter;
 const express_1 = require("express");
+const codex_launch_1 = require("../utils/codex-launch");
 function createSessionRouter(sessionManager, eventStore, projectManager, codexRolloutSync, sessionTimeline) {
     const router = (0, express_1.Router)();
     router.get("/", (_request, response) => {
@@ -171,5 +172,16 @@ function createSessionRouter(sessionManager, eventStore, projectManager, codexRo
             next(error);
         }
     });
+    router.post("/:sessionId/approvals/:requestId/retry", (request, response, next) => {
+        try {
+            const body = request.body;
+            const launch = (0, codex_launch_1.normalizeCodexExecLaunchInput)(body.codex);
+            const result = sessionManager.retryApprovalRequest(request.params.sessionId, request.params.requestId, launch);
+            response.json(result);
+        }
+        catch (error) {
+            next(error);
+        }
+    });
     return router;
 }

package/dist/server/src/db/migrations.js

@@ -6,6 +6,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.runMigrations = runMigrations;
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
+function isPackageRoot(root) {
+    return (0, node_fs_1.existsSync)(node_path_1.default.join(root, "package.json")) && (0, node_fs_1.existsSync)(node_path_1.default.join(root, "web", "index.html"));
+}
+function resolvePackageRoot(startDir = __dirname) {
+    let current = node_path_1.default.resolve(startDir);
+    while (true) {
+        if (isPackageRoot(current)) {
+            return current;
+        }
+        const parent = node_path_1.default.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return process.cwd();
+}
+function resolveSchemaFile() {
+    const packageRoot = resolvePackageRoot();
+    const candidates = [
+        node_path_1.default.join(packageRoot, "server", "src", "db", "schema.sql"),
+        node_path_1.default.join(packageRoot, "dist", "server", "src", "db", "schema.sql"),
+    ];
+    const resolved = candidates.find((candidate) => (0, node_fs_1.existsSync)(candidate));
+    if (!resolved) {
+        throw new Error(`Database schema file not found. Tried: ${candidates.join(", ")}`);
+    }
+    return resolved;
+}
 function ensureColumn(db, table, column, definition) {
     const rows = db.prepare(`PRAGMA table_info(${table})`).all();
     if (rows.some((row) => row.name === column)) {
@@ -14,7 +43,7 @@ function ensureColumn(db, table, column, definition) {
     db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
 }
 function runMigrations(db) {
-    const schemaFile = node_path_1.default.join(process.cwd(), "server", "src", "db", "schema.sql");
+    const schemaFile = resolveSchemaFile();
     const schema = (0, node_fs_1.readFileSync)(schemaFile, "utf8");
     db.exec(schema);
     ensureColumn(db, "sessions", "source_kind", "TEXT NOT NULL DEFAULT 'native'");

package/dist/server/src/db/schema.sql

@@ -0,0 +1,48 @@
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  path TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  title TEXT,
+  project_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  pid INTEGER,
+  codex_thread_id TEXT,
+  source_kind TEXT NOT NULL DEFAULT 'native',
+  source_rollout_path TEXT,
+  source_thread_id TEXT,
+  source_sync_cursor INTEGER,
+  source_last_synced_at TEXT,
+  source_rollout_has_open_turn INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  FOREIGN KEY (project_id) REFERENCES projects(id)
+);
+
+CREATE TABLE IF NOT EXISTS session_events (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL,
+  turn_id TEXT,
+  seq INTEGER NOT NULL,
+  event_type TEXT NOT NULL,
+  message_id TEXT,
+  call_id TEXT,
+  request_id TEXT,
+  phase TEXT,
+  stream TEXT,
+  payload_json TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+  FOREIGN KEY (session_id) REFERENCES sessions(id),
+  UNIQUE (session_id, seq)
+);
+
+CREATE INDEX IF NOT EXISTS idx_sessions_project_id ON sessions(project_id);
+CREATE INDEX IF NOT EXISTS idx_session_events_session_seq ON session_events(session_id, seq);
+CREATE INDEX IF NOT EXISTS idx_session_events_type_seq ON session_events(session_id, event_type, seq);
+CREATE INDEX IF NOT EXISTS idx_session_events_message_id ON session_events(session_id, message_id, seq);
+CREATE INDEX IF NOT EXISTS idx_session_events_call_id ON session_events(session_id, call_id, seq);
+CREATE INDEX IF NOT EXISTS idx_session_events_request_id ON session_events(session_id, request_id, seq);

package/dist/server/src/services/codex-rollout-sync.js

@@ -9,6 +9,7 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const errors_1 = require("../utils/errors");
 const ids_1 = require("../utils/ids");
+const output_limits_1 = require("../utils/output-limits");
 function computeSourceRolloutHasOpenTurnFromRecords(records) {
     const openTurnIds = new Set();
     for (const record of records) {
@@ -571,22 +572,7 @@ function translateRolloutRecords(records, emitFromRecordIndex = 0) {
                     : `call_${index}`;
                 const started = commandStarts.get(callId) || null;
                 const parsed = parseExecOutput(payload.output);
-                if (parsed.outputText) {
-                    appendSemantic(index, {
-                        type: "command.output.delta",
-                        turnId: currentTurnId,
-                        messageId: null,
-                        callId,
-                        requestId: null,
-                        phase: null,
-                        stream: "stdout",
-                        payload: {
-                            stream: "stdout",
-                            textDelta: parsed.outputText,
-                        },
-                        timestamp,
-                    });
-                }
+                const cappedOutput = parsed.outputText ? (0, output_limits_1.capTextValue)(parsed.outputText) : null;
                 appendSemantic(index, {
                     type: "command.end",
                     turnId: currentTurnId,
@@ -598,6 +584,9 @@ function translateRolloutRecords(records, emitFromRecordIndex = 0) {
                     payload: {
                         command: parsed.commandLine || started?.commandPayload.command || null,
                         cwd: started?.commandPayload.cwd || null,
+                        stdout: cappedOutput?.text || null,
+                        aggregatedOutput: cappedOutput?.text || null,
+                        stdoutTruncated: cappedOutput?.truncated || undefined,
                         status: parsed.exitCode == null
                             ? "completed"
                             : parsed.exitCode === 0

package/dist/server/src/services/event-store.js

@@ -55,9 +55,24 @@ class EventStore {
         `)
             .get(id);
         const event = this.toPayload(row);
-        this.captureLatestQuota(sessionId, event);
-        this.emitter.emit(this.channel(sessionId), event);
-        return event;
+        return this.publish(event);
+    }
+    publishTransient(sessionId, input, seq) {
+        const event = {
+            id: input.id?.trim() || (0, ids_1.createId)("evt"),
+            sessionId,
+            type: input.type,
+            seq,
+            timestamp: input.timestamp?.trim() || new Date().toISOString(),
+            turnId: input.turnId ?? null,
+            messageId: input.messageId ?? null,
+            callId: input.callId ?? null,
+            requestId: input.requestId ?? null,
+            phase: input.phase ?? null,
+            stream: this.normalizeStream(input.stream),
+            payload: input.payload ?? {},
+        };
+        return this.publish(event);
     }
     list(sessionId, options = {}) {
         const safeLimit = Math.max(1, Math.min(options.limit ?? 200, 200));
@@ -241,7 +256,7 @@ class EventStore {
             this.emitter.off(channel, listener);
         };
     }
-    nextSeq(sessionId) {
+    latestSeq(sessionId) {
         const row = this.db
             .prepare(`
           SELECT COALESCE(MAX(seq), 0) AS current_seq
@@ -249,7 +264,15 @@ class EventStore {
           WHERE session_id = ?
         `)
             .get(sessionId);
-        return row.current_seq + 1;
+        return row.current_seq;
+    }
+    nextSeq(sessionId) {
+        return this.latestSeq(sessionId) + 1;
+    }
+    publish(event) {
+        this.captureLatestQuota(event.sessionId, event);
+        this.emitter.emit(this.channel(event.sessionId), event);
+        return event;
     }
     toPayload(row) {
         return {

package/dist/server/src/services/session-manager.js

@@ -9,11 +9,13 @@ const node_os_1 = __importDefault(require("node:os"));
 const node_path_1 = __importDefault(require("node:path"));
 const errors_1 = require("../utils/errors");
 const ids_1 = require("../utils/ids");
+const output_limits_1 = require("../utils/output-limits");
 const codex_runner_1 = require("./codex-runner");
 const codex_stream_events_1 = require("./codex-stream-events");
 function nowIso() {
     return new Date().toISOString();
 }
+const TRANSIENT_SEQ_STEP = 0.00001;
 function shouldAutotitleSession(title) {
     const normalized = String(title || "").trim();
     return (!normalized ||
@@ -277,6 +279,30 @@ class SessionManager {
             seq: event.seq,
         };
     }
+    retryApprovalRequest(sessionId, requestId, codexLaunch) {
+        const session = this.getSessionOrThrow(sessionId);
+        const project = this.options.projectManager.getProject(session.project_id);
+        if (!project) {
+            throw new errors_1.AppError(404, "Project not found for session.");
+        }
+        const currentRunner = this.runners.get(sessionId);
+        const busyStatuses = ["starting", "running", "stopping"];
+        if (currentRunner?.runner.isAlive() && busyStatuses.includes(session.status)) {
+            throw new errors_1.AppError(409, "Session already has an active task.");
+        }
+        const pending = this.pendingApprovals.get(sessionId)?.get(requestId) ??
+            this.restorePendingApprovalFromEvents(sessionId, requestId);
+        if (!pending) {
+            throw new errors_1.AppError(404, "Approval request not found.");
+        }
+        const turnId = (0, ids_1.createId)("turn");
+        const runtimePrompt = normalizeDemoPrompt(project.path, this.buildApprovalRetryRuntimePrompt(pending));
+        this.startRunner(sessionId, project.path, runtimePrompt, turnId, this.resolveResumeThreadId(session), codexLaunch);
+        return {
+            accepted: true,
+            turnId,
+        };
+    }
     stopSession(sessionId) {
         const runtime = this.runners.get(sessionId);
         if (!runtime || !runtime.runner.isAlive()) {
@@ -322,6 +348,7 @@ class SessionManager {
         const runtime = {
             runner,
             stopRequested: false,
+            transientSeqCursor: this.options.eventStore.latestSeq(sessionId),
             turnId,
             appTurnId: null,
             turnStarted: false,
@@ -921,6 +948,8 @@ class SessionManager {
             cwd: payload.cwd || null,
             stdout: "",
             stderr: "",
+            stdoutTruncated: false,
+            stderrTruncated: false,
             started: true,
             completed: false,
         });
@@ -947,14 +976,15 @@ class SessionManager {
         if (!current) {
             return;
         }
-        if (stream === "stderr") {
-            current.stderr += textDelta;
-        }
-        else {
-            current.stdout += textDelta;
+        const targetKey = stream === "stderr" ? "stderr" : "stdout";
+        const truncatedKey = stream === "stderr" ? "stderrTruncated" : "stdoutTruncated";
+        const capped = (0, output_limits_1.appendCappedText)(current[targetKey], textDelta);
+        current[targetKey] = capped.nextText;
+        if (capped.truncated) {
+            current[truncatedKey] = true;
         }
         runtime.activeCommandCallId = callId;
-        this.appendEvent(sessionId, {
+        this.publishTransientEvent(sessionId, runtime, {
             type: "command.output.delta",
             turnId: runtime.turnId,
             messageId: null,
@@ -989,6 +1019,11 @@ class SessionManager {
             payload: {
                 command: payload.command || current.command,
                 cwd: payload.cwd || current.cwd,
+                stdout: current.stdout || null,
+                stderr: current.stderr || null,
+                aggregatedOutput: current.stdout || current.stderr || null,
+                stdoutTruncated: current.stdoutTruncated || undefined,
+                stderrTruncated: current.stderrTruncated || undefined,
                 status: payload.status || (payload.exitCode === 0 ? "completed" : "failed"),
                 exitCode: payload.exitCode ?? null,
                 durationMs: payload.durationMs ?? null,
@@ -1194,9 +1229,18 @@ class SessionManager {
     }
     appendEvent(sessionId, input) {
         const event = this.options.eventStore.append(sessionId, input);
+        const runtime = this.runners.get(sessionId);
+        if (runtime) {
+            runtime.transientSeqCursor = Math.max(runtime.transientSeqCursor, Number(event.seq || 0));
+        }
         this.touchSession(sessionId);
         return event;
     }
+    publishTransientEvent(sessionId, runtime, input) {
+        runtime.transientSeqCursor =
+            Math.round((runtime.transientSeqCursor + TRANSIENT_SEQ_STEP) * 100000) / 100000;
+        return this.options.eventStore.publishTransient(sessionId, input, runtime.transientSeqCursor);
+    }
     touchSession(sessionId) {
         this.options.db
             .prepare(`
@@ -1368,6 +1412,35 @@ class SessionManager {
         }
         return null;
     }
+    buildApprovalRetryRuntimePrompt(approval) {
+        const commandText = this.extractApprovalCommand(approval.method, approval.params);
+        const reason = typeof approval.params.reason === "string" && approval.params.reason.trim()
+            ? approval.params.reason.trim()
+            : "";
+        if (commandText) {
+            return [
+                "Re-run the exact operation that previously requested approval.",
+                "Do not do extra exploration.",
+                "As soon as the approval prompt appears again, stop and wait for the user decision.",
+                "",
+                commandText,
+            ].join("\n");
+        }
+        if (reason) {
+            return [
+                "Re-run the exact step that previously requested approval.",
+                "Do not do extra exploration.",
+                "As soon as the approval prompt appears again, stop and wait for the user decision.",
+                "",
+                `Original approval reason: ${reason}`,
+            ].join("\n");
+        }
+        return [
+            "Re-run the exact step that previously requested approval.",
+            "Do not do extra exploration.",
+            "As soon as the approval prompt appears again, stop and wait for the user decision.",
+        ].join("\n");
+    }
     describeApprovalTitle(method) {
         if (method === "item/commandExecution/requestApproval" || method === "execCommandApproval") {
             return "Command execution requires approval";