openmausbot 0.1.82 → 0.1.83

package/dist-server/server/config.js

@@ -7,7 +7,8 @@ import { join } from "node:path";
 import { z } from "zod";
 import { normalizeImageGenerationUrl } from "../shared/image-generation.js";
 import { writeFileAtomic } from "./atomic.js";
-import { EFFORT_LEVELS, isModelVariant } from "./contracts.js";
+import { EFFORT_LEVELS } from "../shared/wire.js";
+import { isModelVariant } from "./contracts.js";
 import { isRemoteMcpServer, parseStoredMcpServer } from "./mcp-registry.js";
 import { parseJson, schemaIssue } from "./schema.js";
 const optionalText = z.string().optional();
@@ -17,6 +18,9 @@ const BROWSER_PROFILE_ID = /^[a-z0-9_-]{1,40}$/;
 export const DEFAULT_ROOM_TURN_TIMEOUT_MINUTES = 5;
 export const MIN_ROOM_TURN_TIMEOUT_MINUTES = 1;
 export const MAX_ROOM_TURN_TIMEOUT_MINUTES = 1_440;
+export const DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES = 30;
+export const DEFAULT_ROOM_HANDOFF_MIN_RUNWAY_MINUTES = 10;
+export const DEFAULT_ROOM_HANDOFF_HARD_CAP_MINUTES = 240;
 export const DEFAULT_MAX_CONCURRENT_BOT_THREADS = 3;
 export const MAX_CONCURRENT_BOT_THREADS = 10;
 /** Bounds for threads.eventLogMaxBytes: the floor keeps the kept tail large
@@ -57,7 +61,15 @@ const roomConfigSchema = z.object({
         .int()
         .min(MIN_ROOM_TURN_TIMEOUT_MINUTES)
         .max(MAX_ROOM_TURN_TIMEOUT_MINUTES),
-});
+    /** Room handoff tree lifetime. Active execution pauses this clock; the
+     * hard cap is wall-clock and bounds trees that never stop executing. */
+    handoffLifetimeMinutes: z.number().int().min(1).max(MAX_ROOM_TURN_TIMEOUT_MINUTES).optional(),
+    handoffMinRunwayMinutes: z.number().int().min(1).max(MAX_ROOM_TURN_TIMEOUT_MINUTES).optional(),
+    handoffHardCapMinutes: z.number().int().min(1).max(7 * MAX_ROOM_TURN_TIMEOUT_MINUTES).optional(),
+}).refine((rooms) => (rooms.handoffMinRunwayMinutes ?? DEFAULT_ROOM_HANDOFF_MIN_RUNWAY_MINUTES) <=
+    (rooms.handoffLifetimeMinutes ?? DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES) &&
+    (rooms.handoffLifetimeMinutes ?? DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES) <=
+        (rooms.handoffHardCapMinutes ?? DEFAULT_ROOM_HANDOFF_HARD_CAP_MINUTES), { message: "rooms handoff bounds must satisfy handoffMinRunwayMinutes <= handoffLifetimeMinutes <= handoffHardCapMinutes" });
 const localVmConfigSchema = z.object({
     mode: z.enum(["shared", "per-bot"]).optional(),
     maxInstances: z
@@ -349,6 +361,9 @@ const appConfigSchema = z.object({
         /** Cap each per-thread events/ and native/ NDJSON log at this many
          * bytes; absent (the default) keeps today's unbounded growth (#1280). */
         eventLogMaxBytes: z.number().int().min(MIN_THREAD_EVENT_LOG_BYTES).max(MAX_THREAD_EVENT_LOG_BYTES).optional(),
+        /** Days a closed or archived thread's event logs survive (#1280).
+         * Absent keeps them forever. */
+        eventLogRetentionDays: z.number().int().min(1).max(3650).optional(),
     }).strict().optional(),
     localVm: localVmConfigSchema.optional(),
     features: featureConfigSchema.optional(),
@@ -447,6 +462,16 @@ export function vpsSshAlias(cfg) {
 export function roomTurnTimeoutMinutes(cfg) {
     return cfg.rooms?.turnTimeoutMinutes ?? DEFAULT_ROOM_TURN_TIMEOUT_MINUTES;
 }
+/** Room handoff tree budgets in milliseconds. The tree lifetime pauses
+ * while a node is actively executing; the hard cap is wall-clock and bounds
+ * trees that never stop. Read when the server starts. */
+export function roomHandoffLimits(cfg) {
+    return {
+        lifetimeMs: (cfg.rooms?.handoffLifetimeMinutes ?? DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES) * 60_000,
+        minRunwayMs: (cfg.rooms?.handoffMinRunwayMinutes ?? DEFAULT_ROOM_HANDOFF_MIN_RUNWAY_MINUTES) * 60_000,
+        hardCapMs: (cfg.rooms?.handoffHardCapMinutes ?? DEFAULT_ROOM_HANDOFF_HARD_CAP_MINUTES) * 60_000,
+    };
+}
 export function maxConcurrentBotThreads(cfg) {
     return cfg.threads?.maxConcurrentPerBot ?? DEFAULT_MAX_CONCURRENT_BOT_THREADS;
 }
@@ -456,6 +481,12 @@ export function threadEventLogMaxBytes(cfg) {
     const cap = cfg.threads?.eventLogMaxBytes;
     return typeof cap === "number" && Number.isFinite(cap) && cap > 0 ? cap : null;
 }
+/** Days a closed or archived bot thread's event logs survive before the
+ * retention sweep removes them (#1280). Null — the default — keeps them
+ * forever. */
+export function threadEventLogRetentionDays(cfg) {
+    return cfg.threads?.eventLogRetentionDays ?? null;
+}
 export function localVmMode(cfg) {
     return cfg.localVm?.mode ?? DEFAULT_LOCAL_VM_MODE;
 }

package/dist-server/server/contracts.js

@@ -12,13 +12,6 @@ export class ProviderError extends Error {
         this.code = code;
     }
 }
-/** Reasoning-effort levels, ascending. A union of everything any engine
- * accepts; each driver declares the subset its CLI will take. */
-export const EFFORT_LEVELS = ["none", "low", "medium", "high", "xhigh", "max"];
-/** Narrow untrusted API/config input before it becomes a model selection. */
-export function isEffortLevel(value) {
-    return typeof value === "string" && EFFORT_LEVELS.includes(value);
-}
 /** Variants are opaque provider IDs, not the cross-engine effort enum. */
 export function isModelVariant(value) {
     return typeof value === "string" && value.length > 0 && value.length <= 256 &&

package/dist-server/server/drivers/acp/gemini.js

@@ -64,6 +64,16 @@ export function geminiIsAuthenticated(env) {
         nonBlank(env.GOOGLE_API_KEY) ||
         (existsSync(join(homedir(), ".gemini", "oauth_creds.json")) && liveOauthCredential()));
 }
+/** Gemini CLI's approval modes, passed through: `--approval-mode auto_edit`
+ * approves file edits, `--yolo` approves everything; Gemini has no
+ * automatic reviewer, so Auto stays Ask. Ask sends nothing. */
+export function geminiApprovalArgs(fullAuto, approvalMode) {
+    if (fullAuto)
+        return ["--yolo"];
+    if (approvalMode === "edits")
+        return ["--approval-mode", "auto_edit"];
+    return [];
+}
 const support = {
     driverKind: "geminiAgent",
     displayName: "Gemini",
@@ -79,7 +89,7 @@ const support = {
     loginNote: "Gemini CLI needs a GEMINI_API_KEY, a Vertex AI setup, or an enterprise Code Assist login — consumer Google logins stopped working on 2026-06-18 (use the Antigravity engine for those accounts)",
     // --acp is the stable Gemini CLI surface. --experimental-acp remains an
     // alias for older releases, but using it now emits a deprecation warning.
-    spawnArgs: (_config, turn) => ["--acp", ...(turn.model ? ["-m", turn.model] : [])],
+    spawnArgs: (config, turn) => ["--acp", ...geminiApprovalArgs(config.fullAuto, turn.approvalMode), ...(turn.model ? ["-m", turn.model] : [])],
     credentialEnv: ["GEMINI_API_KEY", "GOOGLE_API_KEY"],
     pickAuthMethod: (methods) => {
         const ids = methods.map((m) => m.id).filter((id) => typeof id === "string");

package/dist-server/server/drivers/acp/qwen.js

@@ -205,6 +205,21 @@ export function resolveQwenTurnModel(model, env) {
         throw new Error("This Qwen model is no longer configured. Refresh models and select it again.");
     return matches[0].id;
 }
+/** Qwen Code's own approval ladder, passed through (qwen --help, 0.24):
+ * `--approval-mode default` asks, `auto-edit` approves file edits, `auto`
+ * runs Qwen's LLM classifier that approves safe actions and blocks risky
+ * ones, and `--yolo` approves everything. Ask sends nothing, so an older
+ * CLI without the flag keeps working at the level it always had; the ACP
+ * client still answers residual permission asks itself under Full. */
+export function qwenApprovalArgs(fullAuto, approvalMode) {
+    if (fullAuto)
+        return ["--yolo"];
+    if (approvalMode === "auto")
+        return ["--approval-mode", "auto"];
+    if (approvalMode === "edits")
+        return ["--approval-mode", "auto-edit"];
+    return [];
+}
 const support = {
     driverKind: "qwenAgent",
     displayName: "Qwen",
@@ -225,7 +240,7 @@ const support = {
     },
     // A raw -m only changes the model within the saved provider. ACP switches
     // the complete route and confirms it before any prompt leaves OMB.
-    spawnArgs: () => ["--acp"],
+    spawnArgs: (config, turn) => ["--acp", ...qwenApprovalArgs(config.fullAuto, turn.approvalMode)],
     selectModel: { configId: "model" },
     pickAuthMethod: () => null,
     authFailure: "continue",

package/dist-server/server/drivers/agents-proxy.js

@@ -390,10 +390,10 @@ const TOOLS = [
     },
     {
         name: "coordinate_bots",
-        description: "Ask existing OpenMausBot teammates for advice or assign concrete work. From normal chat every assignment you send a teammate continues your one standing conversation with that teammate, so they keep the context of what you asked before; from a room it defaults to this room. Use group_id from list_room_targets for a specific room. Name 1-4 bot_ids: they receive only your brief and use their own model, tools and permissions. Busy bots queue. They can consult their specialists; all results return here and resume you automatically. Include exact file paths, constraints and what must be verified. After sending all assignments, END your turn; do not poll or wait. On return, resolve tradeoffs, verify the requested outcome and request concrete corrections if necessary before giving one final answer. Do not send acknowledgements as new work.",
+        description: "Ask existing OpenMausBot teammates for advice or assign concrete work. From normal chat every assignment you send a teammate continues your one standing conversation with that teammate, so they keep the context of what you asked before; from a room it defaults to this room. Use group_id from list_room_targets for a specific room. Give 1-4 bot_ids — teammate ids as list_bots or your roster prints them; a unique teammate name also resolves: they receive only your brief and use their own model, tools and permissions. Busy bots queue. They can consult their specialists; all results return here and resume you automatically. Include exact file paths, constraints and what must be verified. After sending all assignments, END your turn; do not poll or wait. On return, resolve tradeoffs, verify the requested outcome and request concrete corrections if necessary before giving one final answer. Do not send acknowledgements as new work.",
         inputSchema: { type: "object", additionalProperties: false, properties: {
                 group_id: { type: "string", description: "Optional destination room. Omit for this room, or your standing conversation with each teammate when chatting directly." },
-                bot_ids: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 4, uniqueItems: true },
+                bot_ids: { type: "array", items: { type: "string", description: "A teammate's id exactly as list_bots or your roster prints it ([id: …]). A teammate's unique display name also resolves; a name shared by two reachable teammates is refused." }, minItems: 1, maxItems: 4, uniqueItems: true },
                 message: { type: "string", minLength: 1, maxLength: 4000, description: "Self-contained question or task for these teammates. Send separate requests when responsibilities differ." },
                 request_key: { type: "string", description: "A short unique assignment key. Reuse for an identical retry." },
                 rework: { type: "boolean", description: "True only for concrete additional work from someone who already completed a request." },
@@ -416,7 +416,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
-                bot_id: { type: "string", description: "The target bot's id (from list_bots)." },
+                bot_id: { type: "string", description: "The target bot's id (from list_bots or your roster); a unique teammate name also resolves." },
                 message: { type: "string", description: "What to say / ask the bot." },
             },
             required: ["bot_id", "message"],
@@ -428,7 +428,7 @@ const TOOLS = [
         inputSchema: {
             type: "object",
             properties: {
-                bot_id: { type: "string", description: "The target bot's id (from list_bots)." },
+                bot_id: { type: "string", description: "The target bot's id (from list_bots or your roster); a unique teammate name also resolves." },
                 message: { type: "string", description: "What the peer should do / answer." },
                 reason: { type: "string", description: "Optional one-line reason for the delegation (shown to the user as a chip)." },
             },

package/dist-server/server/drivers/claude.js

@@ -1754,12 +1754,13 @@ export const ClaudeDriver = {
             return { turnId };
         };
         /** A user message into the running turn: the CLI delivers it before its
-         * next model call. False when nothing is running here to steer. */
+         * next model call. "refused" when nothing is running here to steer or
+         * the stdin write provably failed; the caller queues those words. */
         const steer = async (threadId, text) => {
             const s = sessions.get(threadId);
             if (!s || !s.turn || s.turn.settled || s.closing || s.child.exitCode !== null)
-                return false;
-            return writeUser(s, threadId, claudeUserMessage(text, undefined));
+                return "refused";
+            return (await writeUser(s, threadId, claudeUserMessage(text, undefined))) ? "steered" : "refused";
         };
         // Sign in from Settings: the unmodified CLI's own login, driven over pipes
         // (server/drivers/claude-login-auth.ts). Same environment as every turn.

package/dist-server/server/drivers/codex.js

@@ -703,9 +703,33 @@ export const CodexDriver = {
                     return stopped;
                 });
                 let completeStoppedTurn;
+                // Stop asks the app-server to end the turn itself before any process
+                // signal. Killing first surfaced routine stops as "codex exited null
+                // (signal SIGTERM) before turn/completed"; the protocol interrupt keeps
+                // the session the authority, and the kill below is only escalation for
+                // a server that will not answer. settle() runs with state.settled
+                // already true, so ordinary completion still tears down immediately.
+                let interruptRequested = false;
                 const stop = async () => {
                     stopRequested = true;
                     stopSignal.abort();
+                    if (!state.settled && !interruptRequested && codexThreadId && codexTurnId &&
+                        child.exitCode === null && child.signalCode === null) {
+                        interruptRequested = true;
+                        const graceMs = Math.max(1, Number(process.env.FAKE_CODEX_INTERRUPT_GRACE_MS ?? 750) || 750);
+                        try {
+                            await request("turn/interrupt", { threadId: codexThreadId, turnId: codexTurnId }, graceMs);
+                        }
+                        catch {
+                            // Old CLI without the method, or a wedged server: escalate below.
+                        }
+                        const deadline = Date.now() + graceMs;
+                        while (!state.settled && Date.now() < deadline) {
+                            await new Promise((wake) => setTimeout(wake, 15));
+                        }
+                        if (state.settled)
+                            return true;
+                    }
                     const stopped = await terminate();
                     if (stopped)
                         completeStoppedTurn?.();
@@ -731,6 +755,35 @@ export const CodexDriver = {
                         emit({ ...base(threadId, turnId), type: "runtime.error", message: "codex did not shut down after termination was requested" });
                     }
                 };
+                // Live steering folds new input into the running turn without ending
+                // it. expectedTurnId is the protocol's precondition: a turn that moved
+                // on (or a CLI without turn/steer) answers with an explicit RPC error,
+                // which becomes "refused" here so the caller queues for the next turn —
+                // the child is never killed to steer. A timeout after delivery, a dead
+                // transport, or a turn that settles while the answer is in flight is
+                // "indeterminate": the words may already be running, so the caller must
+                // not re-queue them.
+                const steerActiveTurn = async (text) => {
+                    if (state.settled || abandoned || stopRequested || !codexThreadId || !codexTurnId)
+                        return "refused";
+                    if (child.exitCode !== null || child.signalCode !== null)
+                        return "refused";
+                    try {
+                        const steerTimeoutMs = Math.max(1, Number(process.env.FAKE_CODEX_STEER_TIMEOUT_MS ?? 10_000) || 10_000);
+                        await request("turn/steer", {
+                            threadId: codexThreadId,
+                            input: [{ type: "text", text }],
+                            expectedTurnId: codexTurnId,
+                        }, steerTimeoutMs);
+                        return "steered";
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        if (state.settled || message.includes("timed out"))
+                            return "indeterminate";
+                        return "refused";
+                    }
+                };
                 // server→client approval request → canonical request.opened
                 // Host-scope tagging mirrors claude.ts: when this turn mounts the real
                 // Mac (not a VM), every card carries approvalScope so the harness's
@@ -1134,6 +1187,13 @@ export const CodexDriver = {
                         void stop();
                         return;
                     }
+                    // An intentional stop killed (or outlived) the child before the
+                    // turn acknowledged its own end. That is the stop doing its job, not
+                    // a crash: settle quietly so Stop never reports the raw signal.
+                    if (stopRequested) {
+                        void settle(false, "interrupted");
+                        return;
+                    }
                     // The child died before the turn completed. Attribute the exit
                     // honestly: name the signal when it was killed, and only quote
                     // stderr that arrived after the last protocol message. A stale
@@ -1194,7 +1254,7 @@ export const CodexDriver = {
                     });
                     void settle(false, "exit_before_result");
                 });
-                active.set(threadId, { stop, turnId, asks });
+                active.set(threadId, { stop, turnId, asks, steer: steerActiveTurn });
                 // Relaunching the app-server is still the same logical turn. Keep the
                 // active process current on every attempt, but announce the turn once.
                 if (attempt === 0)
@@ -1441,6 +1501,7 @@ export const CodexDriver = {
                 provider: DRIVER_KIND,
                 capabilities: {
                     sessionModelSwitch: "unsupported",
+                    queueing: true,
                     computerMcp: true,
                     localComputerMcp: true,
                     composioMcp: true,
@@ -1456,6 +1517,10 @@ export const CodexDriver = {
                 interruptTurn: async (threadId) => {
                     await active.get(threadId)?.stop();
                 },
+                steer: async (threadId, text) => {
+                    const turn = active.get(threadId);
+                    return turn?.steer ? await turn.steer(text) : "refused";
+                },
                 respondToRequest: async (threadId, requestId, decision) => {
                     const turn = active.get(threadId);
                     const finish = turn?.asks.get(requestId);

package/dist-server/server/drivers/pi.js

@@ -28,7 +28,8 @@ import { augmentedPath } from "../env-path.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../procs.js";
 import { SPAWNED_PROXIES } from "../proxy-paths.js";
 import { commandSummary, toolDetailPreview } from "../tool-summary.js";
-import { EFFORT_LEVELS, newEventId, newId } from "../contracts.js";
+import { EFFORT_LEVELS } from "../../shared/wire.js";
+import { newEventId, newId } from "../contracts.js";
 import { decodeInjectId, encodeInjectId, hostApiKey, localHost, mergeLocalInject, } from "./local-inject.js";
 import { appendNative } from "./native.js";
 const DRIVER_KIND = "piAgent";

package/dist-server/server/env-path.js

@@ -252,7 +252,12 @@ function parseCmdShim(shim, env) {
         return null;
     }
     const dir = dirname(shim);
-    const targets = [...text.matchAll(/"%~?dp0%?\\?([^"]+)"/g)]
+    // npm's own npm.cmd / npx.cmd, installed beside node.exe, name their entry
+    // in a variable next to a helper script that is not the CLI:
+    // SET "NPX_CLI_JS=%~dp0\node_modules\npm\bin\npx-cli.js". The launcher's
+    // switch to a globally upgraded npm is not followed; this node's npm runs.
+    const npmEntry = /^SET "NP[MX]_CLI_JS=%~dp0\\([^"]+)"/im.exec(text);
+    const targets = [...(npmEntry ? [npmEntry] : []), ...text.matchAll(/"%~?dp0%?\\?([^"]+)"/g)]
         .map((m) => join(dir, m[1]))
         .filter((p) => isFile(p) && basename(p).toLowerCase() !== "node.exe");
     const script = targets.find((p) => /\.[cm]?js$/i.test(p));