openmausbot 0.1.69 → 0.1.70

package/dist-server/server/routines.js

@@ -449,6 +449,7 @@ export class RoutineManager {
                         timeoutMinutes: loadTimeoutMinutes(routine.timeoutMinutes),
                         attachments: loadAttachments(routine.attachments),
                         sourceThreadId: persistedSourceThreadId.parse(routine.sourceThreadId),
+                        resultsThreadId: persistedSourceThreadId.parse(routine.resultsThreadId),
                     };
                     if (loaded.timeoutMinutes === undefined)
                         delete loaded.timeoutMinutes;
@@ -467,6 +468,7 @@ export class RoutineManager {
                         timeoutMinutes: loadTimeoutMinutes(run.timeoutMinutes),
                         attachments: loadAttachments(run.attachments),
                         sourceThreadId: persistedSourceThreadId.parse(run.sourceThreadId),
+                        resultsThreadId: persistedSourceThreadId.parse(run.resultsThreadId),
                     };
                     if (loaded.timeoutMinutes === undefined)
                         delete loaded.timeoutMinutes;
@@ -619,11 +621,12 @@ export class RoutineManager {
             createdAt: at,
             updatedAt: at,
         };
+        const discardResults = this.applyResultsInput(routine, input.resultsThreadId);
         this.commitMutation(() => {
             this.routines.unshift(routine);
             if (request)
                 this.rememberRoutineRequest(request, routine.id, at);
-        });
+        }, discardResults);
         this.emitRoutine(routine);
         return cloneRoutine(routine);
     }
@@ -664,9 +667,14 @@ export class RoutineManager {
         if (clean.schedule.type === "interval" && clean.enabled && nextRunAt === null) {
             throw new Error("This interval has no future runs. Choose a later end date or turn it off.");
         }
+        const destination = { ...routine, ...clean };
+        if (destination.botId !== routine.botId)
+            delete destination.resultsThreadId;
+        const discardResults = this.applyResultsInput(destination, patch.resultsThreadId);
         const cancelledRuns = [];
         this.commitMutation(() => {
             Object.assign(routine, clean, {
+                resultsThreadId: destination.resultsThreadId,
                 nextRunAt,
                 // `updatedAt` doubles as the optimistic revision on durable routine
                 // confirmation cards. Keep it monotonic even for two writes in one ms.
@@ -692,7 +700,7 @@ export class RoutineManager {
             }
             if (request)
                 this.rememberRoutineRequest(request, routine.id, now);
-        });
+        }, discardResults);
         for (const run of cancelledRuns)
             this.emitRun(run);
         this.emitRoutine(routine);
@@ -803,15 +811,19 @@ export class RoutineManager {
         if (!routine)
             return null;
         let run;
+        const allocations = [];
+        const previousDestination = routine.resultsThreadId;
         this.commitMutation(() => {
-            run = this.newRun(routine, this.now(), true);
-            // A chat-confirmed "run now" reports back to the conversation that
-            // invoked this one run. It must not silently rebind future schedules.
+            run = this.newRun(routine, this.now(), true, allocations, request?.threadId ?? routine.sourceThreadId);
+            // Preserve the invoking chat as provenance/fallback for this run.
+            // An explicitly configured results destination continues to win.
             if (request)
                 run.sourceThreadId = request.threadId;
             if (request)
                 this.rememberRoutineRequest(request, run.id, this.now());
-        });
+        }, () => this.discardResultsThreads(allocations));
+        if (routine.resultsThreadId !== previousDestination)
+            this.emitRoutine(routine);
         this.emitRun(run);
         queueMicrotask(() => void this.tick());
         return cloneRun(run);
@@ -978,55 +990,57 @@ export class RoutineManager {
                     await this.options.interruptTurn?.(run.botId, threadId, run.runOn ?? "maus").catch(() => { });
                 }
             }
-            let changed = false;
-            const missedRuns = [];
-            for (const routine of this.routines) {
-                if (!routine.enabled || routine.nextRunAt == null || routine.nextRunAt > now)
-                    continue;
-                const pendingAt = routine.nextRunAt;
-                const late = now - pendingAt;
-                const scheduledFor = routine.schedule.type === "interval" && late <= CATCH_UP_MS
-                    ? latestIntervalOccurrence(routine.schedule, now) ?? pendingAt
-                    : pendingAt;
-                // One slow interval run must not build an unbounded queue of stale
-                // copies behind it. The series still advances on its original phase.
-                const overlapping = routine.schedule.type === "interval" && this.runs.some((run) => run.routineId === routine.id && ["queued", "running", "waiting"].includes(run.status));
-                if (!overlapping) {
-                    if (late > CATCH_UP_MS) {
-                        const missed = this.newRun(routine, scheduledFor, false);
-                        missed.status = "missed";
-                        missed.finishedAt = now;
-                        missed.error = "This computer was offline for more than 12 hours after the scheduled time";
-                        this.emitRun(missed);
-                        missedRuns.push(cloneRun(missed));
-                    }
-                    else {
-                        const run = this.newRun(routine, scheduledFor, false);
-                        this.emitRun(run);
+            const dueRoutines = this.routines.filter((routine) => routine.enabled && routine.nextRunAt != null && routine.nextRunAt <= now);
+            const scheduledRuns = [];
+            const allocations = [];
+            if (dueRoutines.length > 0) {
+                this.commitMutation(() => {
+                    for (const routine of dueRoutines) {
+                        const pendingAt = routine.nextRunAt;
+                        const late = now - pendingAt;
+                        const scheduledFor = routine.schedule.type === "interval" && late <= CATCH_UP_MS
+                            ? latestIntervalOccurrence(routine.schedule, now) ?? pendingAt
+                            : pendingAt;
+                        // One slow interval run must not build an unbounded queue of stale
+                        // copies behind it. The series still advances on its original phase.
+                        const overlapping = routine.schedule.type === "interval" && this.runs.some((run) => run.routineId === routine.id && ["queued", "running", "waiting"].includes(run.status));
+                        if (!overlapping) {
+                            const run = this.newRun(routine, scheduledFor, false, allocations);
+                            if (late > CATCH_UP_MS) {
+                                run.status = "missed";
+                                run.finishedAt = now;
+                                run.error = "This computer was offline for more than 12 hours after the scheduled time";
+                            }
+                            scheduledRuns.push(run);
+                        }
+                        routine.nextRunAt =
+                            routine.schedule.type === "once" ? null : nextOccurrence(routine.schedule, Math.max(now, scheduledFor));
+                        // `updatedAt` is the optimistic definition revision carried by
+                        // routine confirmation cards. Moving the scheduler cursor is runtime
+                        // progress, not a definition edit, so recurring ticks must not make a
+                        // still-accurate pending confirmation stale. A one-time routine does
+                        // mutate its definition by auto-disabling after its occurrence.
+                        if (routine.schedule.type === "once") {
+                            routine.enabled = false;
+                            routine.updatedAt = Math.max(now, routine.updatedAt + 1);
+                        }
+                        else if (routine.schedule.type === "interval" && routine.nextRunAt === null) {
+                            routine.enabled = false;
+                            routine.updatedAt = Math.max(now, routine.updatedAt + 1);
+                        }
                     }
-                }
-                routine.nextRunAt =
-                    routine.schedule.type === "once" ? null : nextOccurrence(routine.schedule, Math.max(now, scheduledFor));
-                // `updatedAt` is the optimistic definition revision carried by
-                // routine confirmation cards. Moving the scheduler cursor is runtime
-                // progress, not a definition edit, so recurring ticks must not make a
-                // still-accurate pending confirmation stale. A one-time routine does
-                // mutate its definition by auto-disabling after its occurrence.
-                if (routine.schedule.type === "once") {
-                    routine.enabled = false;
-                    routine.updatedAt = Math.max(now, routine.updatedAt + 1);
-                }
-                else if (routine.schedule.type === "interval" && routine.nextRunAt === null) {
-                    routine.enabled = false;
-                    routine.updatedAt = Math.max(now, routine.updatedAt + 1);
-                }
+                }, () => this.discardResultsThreads(allocations));
+            }
+            // Reporting may persist transcript cards, so publish only after the
+            // scheduler batch (including each destination) is durable.
+            for (const routine of dueRoutines)
                 this.emitRoutine(routine);
-                changed = true;
+            for (const run of scheduledRuns)
+                this.emitRun(run);
+            for (const run of scheduledRuns) {
+                if (run.status === "missed")
+                    this.options.onRunFailed?.(cloneRun(run));
             }
-            if (changed)
-                this.save();
-            for (const missed of missedRuns)
-                this.options.onRunFailed?.(missed);
             // Oldest queued requests have priority. New manual/webhook arrivals
             // must not continually overtake work that has already waited. Snapshot
             // the queue because each dispatch can asynchronously add/cancel work.
@@ -1262,7 +1276,16 @@ export class RoutineManager {
             return schedule.at;
         return nextOccurrence(schedule, now);
     }
-    newRun(routine, scheduledFor, manual) {
+    newRun(routine, scheduledFor, manual, allocations, sourceThreadId = routine.sourceThreadId) {
+        if (routine.target === "bot" && this.options.resolveResultsThread) {
+            const destination = this.options.resolveResultsThread({ ...routine, sourceThreadId }, false);
+            if (destination !== routine.resultsThreadId) {
+                if (destination)
+                    allocations.push({ botId: routine.botId, threadId: destination });
+                routine.resultsThreadId = destination;
+                routine.updatedAt = Math.max(this.now(), routine.updatedAt + 1);
+            }
+        }
         const run = {
             id: randomUUID(),
             routineId: routine.id,
@@ -1279,12 +1302,44 @@ export class RoutineManager {
             status: "queued",
             manual,
             triggerSource: manual ? "manual" : "schedule",
-            sourceThreadId: routine.sourceThreadId,
+            sourceThreadId,
+            resultsThreadId: routine.resultsThreadId,
             createdAt: this.now(),
         };
         this.runs.push(run);
         return run;
     }
+    discardResultsThreads(allocations) {
+        for (const { botId, threadId } of allocations) {
+            try {
+                this.options.discardResultsThread?.(botId, threadId);
+            }
+            catch (error) {
+                console.error("routine: could not discard uncommitted results thread", error);
+            }
+        }
+    }
+    applyResultsInput(routine, value) {
+        if (routine.target !== "bot") {
+            if (value != null)
+                throw Object.assign(new Error("Results threads are only available for bot routines"), { status: 400 });
+            delete routine.resultsThreadId;
+            return;
+        }
+        if (value === undefined)
+            return;
+        if (value === null) {
+            const destination = this.options.resolveResultsThread?.(routine, true);
+            if (!destination)
+                throw new Error("Could not create a results thread for this routine");
+            routine.resultsThreadId = destination;
+            return () => this.options.discardResultsThread?.(routine.botId, destination);
+        }
+        if (typeof value !== "string" || !value.trim() || !this.options.isResultsThread?.(routine.botId, value.trim())) {
+            throw Object.assign(new Error("Choose a visible results thread belonging to this bot"), { status: 400 });
+        }
+        routine.resultsThreadId = value.trim();
+    }
     emitRoutine(routine) {
         this.options.emit?.({ kind: "routine", routine: cloneRoutine(routine) });
     }
@@ -1331,7 +1386,7 @@ export class RoutineManager {
      * state if writing or renaming that file fails so a retry cannot mistake an
      * uncommitted action for a durable one.
      */
-    commitMutation(mutate) {
+    commitMutation(mutate, rollback) {
         const before = {
             routines: this.routines.map(cloneRoutine),
             runs: this.runs.map(cloneRun),
@@ -1345,6 +1400,12 @@ export class RoutineManager {
             this.routines = before.routines;
             this.runs = before.runs;
             this.routineRequestReceipts = before.receipts;
+            try {
+                rollback?.();
+            }
+            catch (cleanupError) {
+                console.error("routine: could not discard uncommitted results thread", cleanupError);
+            }
             throw error;
         }
     }

package/dist-server/server/steer-queue.js

@@ -57,11 +57,27 @@ export function queueSteeredMessage(botId, threadId, text, options = {}) {
         replyToId: options.replyToId,
         sendId: options.sendId,
         reason: options.reason,
+        unattended: options.unattended,
     });
     queues.set(threadId, entry);
     changed();
     return { id };
 }
+/** Where a thread stands among this bot's threads waiting for a free slot:
+ * 1 for the next to start. The drain visits queues in insertion order, so
+ * insertion order is the line. Null when nothing of this bot's is waiting
+ * on that thread. */
+export function queuedThreadPosition(botId, threadId) {
+    let position = 0;
+    for (const [candidate, entry] of queues) {
+        if (entry.botId !== botId || !entry.items.some((item) => item.reason === "capacity"))
+            continue;
+        position += 1;
+        if (candidate === threadId)
+            return position;
+    }
+    return null;
+}
 /** Drain every queue whose task is idle: append the held lines (leaf is now
  * the finished turn's last item), then one run per thread whose prompt is
  * the texts separated by a blank line. `userMessage` is the last appended line
@@ -108,7 +124,10 @@ export function drainSteeredMessages(store, run, isBlocked) {
         // message into one HTML block, which makes that attachment stop being a
         // native image when the combined follow-up is dispatched.
         const prompt = entry.items.map((item) => item.prompt).join("\n\n");
-        void run(entry.botId, threadId, prompt, last, appended.map((message) => message.id));
+        void run(entry.botId, threadId, prompt, last, appended.map((message) => message.id), 
+        // one unattended line makes the whole drained turn unattended: a
+        // person's words in the same queue cannot re-attend a bot's own
+        entry.items.some((item) => item.unattended === true));
     }
 }
 /** Find the receipt for a retry whose message is still waiting to drain. */

package/dist-server/server/store.js

@@ -26,6 +26,7 @@ export function isProjectEmoji(value) {
 const TASK_PATCH_FIELDS = [
     "title", "projectId", "modelSelection", "approvalMode", "autoApprove", "alwaysAllow",
     "unread", "rewound", "pinnedMessageId", "resumeCursors", "lastInstanceId", "cwd",
+    "routineRunId",
 ];
 /** Everything the BOT authored is scrubbed of content-shaped secrets before
  * it is stored: its reply text, a tool title (an ACP engine's title can be
@@ -1444,7 +1445,7 @@ export class Store {
     }
     /** A fresh context on the same bot: new thread, new session, same
      * persona/tools/computer. Becomes the active task. */
-    createTask(botId, title, activate = true, projectId) {
+    createTask(botId, title, activate = true, projectId, openedBy) {
         const bot = this.bot(botId);
         if (!bot)
             return null;
@@ -1455,6 +1456,7 @@ export class Store {
             title: title?.trim().slice(0, 80) || UNTITLED_THREAD,
             createdAt: Date.now(),
             ...(projectId ? { projectId } : {}),
+            ...(openedBy ? { openedBy: structuredClone(openedBy) } : {}),
             resumeCursors: {},
             modelSelection: structuredClone(bot.modelSelection),
             approvalMode: approvalModeFor(bot),
@@ -1472,6 +1474,20 @@ export class Store {
         this.emit({ type: "bot", botId });
         return task;
     }
+    /** Attach (or complete) the opener record after the thread exists — the
+     * handoff id is only known once the thread it targets has an id, so a
+     * peer-opened thread is created first and stamped second. Never reachable
+     * from the HTTP task PATCH: openedBy is not a TASK_PATCH_FIELD. */
+    setTaskOpenedBy(botId, threadId, openedBy) {
+        const bot = this.bot(botId);
+        const task = this.taskByThread(botId, threadId);
+        if (!bot || !task)
+            return null;
+        task.openedBy = structuredClone(openedBy);
+        this.saveBots();
+        this.emit({ type: "bot", botId });
+        return task;
+    }
     switchTask(botId, threadId) {
         const bot = this.bot(botId);
         const task = bot?.tasks?.find((t) => t.threadId === threadId);
@@ -1503,10 +1519,12 @@ export class Store {
         if (!bot.tasks.some((t) => t.threadId === threadId))
             return null;
         bot.tasks = bot.tasks.filter((t) => t.threadId !== threadId);
-        this.deleteThreadRecord(threadId);
-        if (bot.threadId === threadId) {
-            this.mirrorActiveTask(bot, bot.tasks[0]);
+        const visible = bot.tasks.find((task) => !task.routineRunId)
+            ?? this.createTask(botId, undefined, bot.threadId === threadId);
+        if (bot.threadId === threadId || this.taskByThread(botId, bot.threadId)?.routineRunId) {
+            this.mirrorActiveTask(bot, visible);
         }
+        this.deleteThreadRecord(threadId);
         bot.unread = bot.tasks.some((task) => task.unread);
         this.refreshBotActivity(bot);
         this.saveBots();

package/dist-server/server/system-prompt.js

@@ -36,6 +36,7 @@ export function computerPrompt(kind) {
 }
 export const COMPOSIO_PROMPT = " The user's connected apps (Gmail, Calendar, Slack, Notion, and the rest) are reachable through the composio tools — find the right one with COMPOSIO_SEARCH_TOOLS, read its arguments with COMPOSIO_GET_TOOL_SCHEMAS, then run it with COMPOSIO_MULTI_EXECUTE_TOOL. Reach for them before telling the user you have no access to a service.";
 export const CREDENTIAL_PROMPT = " If a supported API key is missing, use request_credential to create a secure credential request. A freshly QR-paired mobile app or the desktop app can show the secure entry card. Never claim it opened unless the request succeeded, and never ask the user to paste credentials into chat.";
+export const THREADS_PROMPT = " A thread is one conversation with its own history and its own run; a bot can have several running at once, and the person sees them as rows under that bot. Use start_thread to open one on yourself for separate work, or on a teammate to hand them a job that should run on its own. Use list_threads to see how the ones you opened are going. When you mention a thread to the person, write its title as #Title so it links. Do not use a ticket comment, a note, or a room post as a stand-in for a thread.";
 export const ROUTINE_PROMPT = " If the user explicitly asks to list or review, schedule, run, or change routines, use list_routines and propose_routine or propose_routine_action. A proposal is not applied until the user confirms its in-app card, so never claim the action completed before that confirmation.";
 export const ROUTINE_EXECUTION_PROMPT = " Execute this routine now: use available peer tools for required handoffs rather than merely announcing that you will wait; after an accepted delegation, end this turn for automatic resumption, and report a concrete blocker if no handoff is possible.";
 export const LEARN_PROMPT = " If the user sends /learn or asks you to save a reusable procedure from this work, use skills_list and skill_manage. Create new skills; update an existing learned skill only when the user explicitly asks to revise that exact name. Include source provenance and wait for the review card decision.";

package/dist-server/server/team-backup.js

@@ -29,6 +29,11 @@ export function createTeamBackup(store, routines, name) {
         const tasks = record.tasks?.length ? record.tasks : [{ threadId: record.threadId, title: "Conversation", createdAt: record.createdAt }];
         return tasks.map((task) => ({
             key: task.threadId, title: task.title, createdAt: task.createdAt,
+            // Who opened the thread travels; the handoff id does not — the
+            // delegation ledger is process-local and never part of a backup.
+            openedBy: "openedBy" in task && task.openedBy
+                ? { botId: task.openedBy.botId, name: task.openedBy.name, at: task.openedBy.at }
+                : undefined,
             activeLeafId: store.activeLeaf(task.threadId),
             messages: store.messagesFor(task.threadId).map((message) => ({
                 id: message.id, role: message.role, text: messageText(message), at: message.at,
@@ -131,10 +136,19 @@ export function importTeamBackup(store, routines, input, selection) {
         }
         for (const source of backup.bots) {
             const bot = store.bot(botIds.get(source.key));
-            const tasks = source.tasks.map((task, i) => ({
-                threadId: i === 0 ? bot.threadId : newId(), title: task.title, createdAt: task.createdAt, resumeCursors: {},
-                modelSelection: structuredClone(selection), activity: "idle", busy: false, unread: false,
-            }));
+            const tasks = source.tasks.map((task, i) => {
+                const record = {
+                    threadId: i === 0 ? bot.threadId : newId(), title: task.title, createdAt: task.createdAt, resumeCursors: {},
+                    modelSelection: structuredClone(selection), activity: "idle", busy: false, unread: false,
+                };
+                // Same rule as a message's `from`: the opener is remapped to its
+                // imported twin, and an opener outside this backup leaves no record
+                // rather than a bot id that resolves to a stranger.
+                const opener = task.openedBy && botIds.get(task.openedBy.botId);
+                if (task.openedBy && opener)
+                    record.openedBy = { botId: opener, name: task.openedBy.name, at: task.openedBy.at };
+                return record;
+            });
             // Own the task IDs before writing their transcripts, so rollback also
             // removes partially imported history if persistence fails midway.
             store.patchBot(bot.id, { tasks, threadId: tasks[source.tasks.findIndex((task) => task.key === source.activeTask)].threadId });

package/dist-server/shared/team-backup.js

@@ -20,6 +20,7 @@ const task = z.object({
     key,
     title: z.string().max(2_000),
     createdAt: timestamp,
+    openedBy: z.object({ botId: key, name, at: timestamp }).optional(),
     activeLeafId: key.nullable(),
     messages: z.array(message).max(100_000),
 });

package/dist-server/vps-container-mcp.js

@@ -141,9 +141,11 @@ function windowsKnownDirs() {
 var cached = null;
 var probed = false;
 var loginShellPath = null;
+var registeredDirs = [];
 function augmentedPath() {
   if (cached === null) {
     cached = mergePaths([
+      ...registeredDirs.filter((d) => existsSync(d)),
       ...process.env.OMB_EXTRA_PATH ? process.env.OMB_EXTRA_PATH.split(delimiter) : [],
       ...process.env.PATH ? process.env.PATH.split(delimiter) : [],
       // Keep the last successful login-shell result while a rescan starts a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmausbot",
-  "version": "0.1.69",
+  "version": "0.1.70",
   "description": "Run the OpenMausBot server anywhere and pair your devices to it",
   "license": "Apache-2.0",
   "type": "module",