openmausbot 0.1.89 → 0.1.91

package/dist-server/server/routes/bot-memory.js

@@ -0,0 +1,215 @@
+// The bot-memory family, extracted from server/index.ts's inline routes
+// into the route table (server/routes/README.md). The table runs after the
+// auth gate; scope rules stay keyed by path in server/request-auth.ts.
+//
+// The files already belong to the person (plain markdown in the bot's
+// workspace). server/memory-store.ts decides which paths can be reached
+// and refuses a save whose expectedHash no longer matches the file;
+// server/memory-journal.ts records every change made here so it can be
+// read back and reverted. Reads never create the workspace — a bot that
+// has not run yet simply has nothing to show. Admin scope by default
+// (request-auth.ts), like the bot profile routes.
+import { z } from "zod";
+import { json } from "../harness/http.js";
+import { MEMORY_INDEX, MemoryStoreError, memoryCapacity, memoryOverview, openMemoryLocation, readMemoryDoc, } from "../memory-store.js";
+import { flushMemoryJournal, journalMemoryDelete, journalMemoryWrite, readMemoryJournal, revertMemoryChange, } from "../memory-journal.js";
+import { isMemoryTopicName, readMemoryTopic } from "../workspace.js";
+import { upkeepEnabled } from "../memory-upkeep.js";
+import { listLearnedFacts, removeLearned } from "../profile-learned.js";
+import { PASS } from "./table.js";
+export function createBotMemoryRoutes(deps) {
+    /** A store refusal is a client error with a status of its own (400 path,
+     * 409 conflict, 413 too large); a 409 also carries what is on disk now so
+     * the editor can show the bot's version instead of guessing. Anything else
+     * is a real failure and goes to the handler's catch-all. */
+    function replyMemoryError(res, error) {
+        if (!(error instanceof MemoryStoreError))
+            throw error;
+        if (error.code === "conflict") {
+            return json(res, error.status, { error: error.message, code: error.code, currentHash: error.currentHash, current: error.current });
+        }
+        return json(res, error.status, { error: error.message, code: error.code });
+    }
+    /** The journal row as the panel shows it: the full prior text stays on
+     * the server (a revert needs it there, the list does not), and the thread
+     * id becomes the chat title people recognise. */
+    function journalEntryForClient(botId, entry) {
+        const { before: _before, ...visible } = entry;
+        const threadTitle = entry.threadId ? deps.taskByThread(botId, entry.threadId)?.title : undefined;
+        return threadTitle ? { ...visible, threadTitle } : visible;
+    }
+    return async ({ req, res, url, path, method, auth, json, readBody }) => {
+        /** scratch for route matches, shared by every `path.match` below */
+        let m = null;
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory$/);
+        if (m && method === "GET") {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            try {
+                const overview = memoryOverview(m[1]);
+                // `text` and `truncated` ride along one release for clients of the
+                // old whole-file shape; the panel reads the file through /memory/file
+                return json(res, 200, { ...overview, text: readMemoryDoc(m[1], MEMORY_INDEX).text, truncated: overview.index.truncated });
+            }
+            catch (error) {
+                return replyMemoryError(res, error);
+            }
+        }
+        if (m && method === "PUT") {
+            // The pre-panel whole-file write, kept one release: no hash check, so
+            // it can still overwrite a note the bot just wrote — journaled as the
+            // person's so at least the journal can undo it.
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            const parsed = z.object({ text: z.string() }).safeParse(await readBody(req));
+            if (!parsed.success)
+                return json(res, 400, { error: "text must be a string" });
+            try {
+                const { doc } = journalMemoryWrite(m[1], MEMORY_INDEX, parsed.data.text, { actor: "person", via: "api" });
+                return json(res, 200, { ok: true, hash: doc.hash, truncated: memoryCapacity(doc.text).truncated });
+            }
+            catch (error) {
+                // the old route answered 400 for an oversized body; keep that for
+                // its callers while the new route says 413
+                if (error instanceof MemoryStoreError && error.code === "too-large")
+                    return json(res, 400, { error: error.message });
+                return replyMemoryError(res, error);
+            }
+        }
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/file$/);
+        if (m && method === "GET") {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            try {
+                return json(res, 200, readMemoryDoc(m[1], url.searchParams.get("path") ?? MEMORY_INDEX));
+            }
+            catch (error) {
+                return replyMemoryError(res, error);
+            }
+        }
+        if (m && method === "PUT") {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            const parsed = z
+                .object({ path: z.string().default(MEMORY_INDEX), text: z.string(), expectedHash: z.string().optional() })
+                .safeParse(await readBody(req));
+            if (!parsed.success)
+                return json(res, 400, { error: "text must be a string; path and expectedHash are optional strings" });
+            try {
+                const { doc, entry } = journalMemoryWrite(m[1], parsed.data.path, parsed.data.text, {
+                    actor: "person",
+                    via: "ui",
+                    expectedHash: parsed.data.expectedHash,
+                });
+                return json(res, 200, { ok: true, ...doc, entry: entry ? journalEntryForClient(m[1], entry) : null, overview: memoryOverview(m[1]) });
+            }
+            catch (error) {
+                return replyMemoryError(res, error);
+            }
+        }
+        if (m && method === "DELETE") {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            const file = url.searchParams.get("path") ?? "";
+            try {
+                const entry = journalMemoryDelete(m[1], file, { actor: "person", via: "ui" });
+                return json(res, 200, { ok: true, path: file, entry: entry ? journalEntryForClient(m[1], entry) : null, overview: memoryOverview(m[1]) });
+            }
+            catch (error) {
+                return replyMemoryError(res, error);
+            }
+        }
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/journal$/);
+        if (m && method === "GET") {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            // the row a save queued a moment ago may not have reached disk yet
+            await flushMemoryJournal(m[1]);
+            const limit = Math.min(200, Math.max(1, Number(url.searchParams.get("limit") ?? 50) || 50));
+            const botId = m[1];
+            return json(res, 200, { entries: readMemoryJournal(botId, limit).map((entry) => journalEntryForClient(botId, entry)) });
+        }
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/journal\/([\w-]+)\/revert$/);
+        if (m && method === "POST") {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            await flushMemoryJournal(m[1]);
+            const result = revertMemoryChange(m[1], m[2]);
+            if (!result.ok)
+                return json(res, result.status, { error: result.error });
+            return json(res, 200, { ok: true, ...result.doc, entry: result.entry ? journalEntryForClient(m[1], result.entry) : null, overview: memoryOverview(m[1]) });
+        }
+        // What upkeep learned about the person is shared through About me.
+        if (method === "GET" && path === "/api/profile/learned") {
+            return json(res, 200, { learned: listLearnedFacts() });
+        }
+        m = path.match(/^\/api\/profile\/learned\/([\w-]+)\/remove$/);
+        if (m && method === "POST") {
+            const removed = removeLearned(m[1], deps.aboutMe(), deps.saveAboutMe);
+            if (!removed)
+                return json(res, 404, { error: "That fact was already removed." });
+            return json(res, 200, { ok: true, aboutMe: deps.aboutMe(), learned: listLearnedFacts() });
+        }
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/upkeep$/);
+        if (m && method === "GET") {
+            const bot = deps.bot(m[1]);
+            if (!bot)
+                return json(res, 404, { error: "no such bot" });
+            return json(res, 200, { enabled: upkeepEnabled(bot), ...deps.upkeep.status(bot.id) });
+        }
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/tidy$/);
+        if (m && method === "POST") {
+            const bot = deps.bot(m[1]);
+            if (!bot)
+                return json(res, 404, { error: "no such bot" });
+            if (!upkeepEnabled(bot))
+                return json(res, 409, { error: "Switch on Memory upkeep for this bot first." });
+            const report = await deps.upkeep.tidy(bot.id);
+            await flushMemoryJournal(bot.id);
+            return json(res, 200, { report, overview: memoryOverview(bot.id) });
+        }
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/open$/);
+        if (m && method === "POST") {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            const parsed = z.object({ target: z.enum(["obsidian", "folder"]) }).safeParse(await readBody(req));
+            if (!parsed.success)
+                return json(res, 400, { error: "target must be obsidian or folder" });
+            // The folder is on this machine's disk; opening it only makes sense
+            // from this machine. A paired phone or a remote browser gets the path
+            // to open by hand instead.
+            const workspacePath = memoryOverview(m[1]).workspacePath;
+            if (auth.kind !== "loopback") {
+                return json(res, 403, { error: `This only works on the computer running OpenMausBot. The memory folder there is ${workspacePath}`, workspacePath });
+            }
+            const opened = await openMemoryLocation(m[1], parsed.data.target);
+            if (!opened.ok)
+                return json(res, 500, { error: opened.error, workspacePath: opened.workspacePath });
+            return json(res, 200, opened);
+        }
+        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/topics\/([^/]+)$/);
+        if (m && method === "GET") {
+            if (!deps.bot(m[1]))
+                return json(res, 404, { error: "no such bot" });
+            // Decode before validating: a UI-sent name arrives percent-encoded
+            // ("my notes.md" → "my%20notes.md"), and an encoded traversal
+            // ("..%2F..") must be judged by what it decodes TO, not slip through
+            // as an opaque token. The name gate then rejects anything that is not
+            // a single plain-markdown path segment.
+            let name;
+            try {
+                name = decodeURIComponent(m[2]);
+            }
+            catch {
+                return json(res, 400, { error: "invalid topic name" });
+            }
+            if (!isMemoryTopicName(name))
+                return json(res, 400, { error: "invalid topic name" });
+            const text = readMemoryTopic(m[1], name);
+            if (text === null)
+                return json(res, 404, { error: "no such topic file" });
+            return json(res, 200, { name, text });
+        }
+        return PASS;
+    };
+}

package/dist-server/server/routes/decider.js

@@ -0,0 +1,19 @@
+import { PASS } from "./table.js";
+const MAX_KEY_LENGTH = 512;
+export function createDeciderRoutes(deps) {
+    return async ({ req, res, path, method, json, readBody }) => {
+        if (path !== "/api/decider/test" || method !== "POST")
+            return PASS;
+        const body = await readBody(req, 8192);
+        if (body?.key !== undefined && typeof body.key !== "string")
+            return json(res, 400, { error: "key must be a string" });
+        const draft = typeof body?.key === "string" ? body.key.trim() : "";
+        if (draft.length > MAX_KEY_LENGTH)
+            return json(res, 400, { error: "That does not look like an API key." });
+        res.setHeader("cache-control", "no-store");
+        const result = await deps.decider.testKey(draft ? { key: draft } : {});
+        if (result.ok)
+            return json(res, 200, { ok: true, latencyMs: result.latencyMs });
+        return json(res, 200, { ok: false, reason: result.reason, ...(result.status ? { status: result.status } : {}) });
+    };
+}

package/dist-server/server/routine-requests.js

@@ -76,11 +76,11 @@ const targetBotSchema = z.object({
 }).strict();
 const routineProposalSchema = z.discriminatedUnion("action", [
     z.object({ action: z.literal("create"), routine: routineToolDefinitionSchema, forBot: targetBotSchema.optional() }).strict(),
-    z.object({ action: z.literal("update"), routineId: z.string().max(128), changes: routineToolChangesSchema }).strict(),
-    z.object({ action: z.literal("pause"), routineId: z.string().max(128) }).strict(),
-    z.object({ action: z.literal("resume"), routineId: z.string().max(128) }).strict(),
-    z.object({ action: z.literal("run_now"), routineId: z.string().max(128) }).strict(),
-    z.object({ action: z.literal("delete"), routineId: z.string().max(128) }).strict(),
+    z.object({ action: z.literal("update"), routineId: z.string().max(128), changes: routineToolChangesSchema, forBot: targetBotSchema.optional() }).strict(),
+    z.object({ action: z.literal("pause"), routineId: z.string().max(128), forBot: targetBotSchema.optional() }).strict(),
+    z.object({ action: z.literal("resume"), routineId: z.string().max(128), forBot: targetBotSchema.optional() }).strict(),
+    z.object({ action: z.literal("run_now"), routineId: z.string().max(128), forBot: targetBotSchema.optional() }).strict(),
+    z.object({ action: z.literal("delete"), routineId: z.string().max(128), forBot: targetBotSchema.optional() }).strict(),
 ]);
 const storedWeekdaysSchema = z.array(z.number().int().min(0).max(6)).min(1).max(7).refine((weekdays) => new Set(weekdays).size === weekdays.length, "Stored routine weekdays must be unique");
 const storedIntervalWindowSchema = z.object({
@@ -190,6 +190,7 @@ const storedChangesSchema = storedDefinitionSchema
 const storedManageBase = {
     routineId: z.string().regex(ROUTINE_ID),
     expectedUpdatedAt: z.number().int().nonnegative(),
+    forBot: targetBotSchema.optional(),
 };
 const storedOperationSchema = z.discriminatedUnion("action", [
     z.object({ action: z.literal("create"), routine: storedDefinitionSchema, forBot: targetBotSchema.optional() }).strict(),
@@ -441,7 +442,11 @@ function normalizedOperation(manager, botId, validated, now) {
         return operation;
     }
     const id = routineId(validated.routineId);
-    const current = ownedRoutine(manager, id, botId);
+    // A targeted action manages the named bot's routine: ownership and every
+    // run's permissions stay with that bot, exactly as a routine created
+    // through the for_bot_id path keeps them.
+    const ownerBotId = validated.forBot?.botId ?? botId;
+    const current = ownedRoutine(manager, id, ownerBotId);
     if (!current)
         throw new RoutineRequestError("That routine does not exist", 404);
     if (validated.action === "update") {
@@ -450,12 +455,18 @@ function normalizedOperation(manager, botId, validated, now) {
             routineId: id,
             expectedUpdatedAt: current.updatedAt,
             changes: normalizeChanges(validated.changes, now),
+            ...(validated.forBot ? { forBot: validated.forBot } : {}),
         };
     }
     if (validated.action === "resume" && nextOccurrence(current.schedule, now) === null) {
         throw new RoutineRequestError(noFutureResumeMessage(current.schedule), 409);
     }
-    return { action: validated.action, routineId: id, expectedUpdatedAt: current.updatedAt };
+    return {
+        action: validated.action,
+        routineId: id,
+        expectedUpdatedAt: current.updatedAt,
+        ...(validated.forBot ? { forBot: validated.forBot } : {}),
+    };
 }
 function asSchedule(schedule, now) {
     if (schedule.type === "cron")
@@ -651,7 +662,7 @@ function cardCopy(operation, manager, timeZone, now) {
     const actionCopy = ACTION_COPY[operation.action];
     const actionLabel = actionCopy.title;
     const name = redactSecretsInText(definition?.name ?? "routine");
-    const forBot = operation.action === "create" ? operation.forBot : undefined;
+    const forBot = operation.forBot;
     const forSuffix = forBot ? ` for @${redactSecretsInText(forBot.name)}` : "";
     const title = `${actionLabel} “${name}”${forSuffix}?`;
     if (!definition) {
@@ -666,7 +677,7 @@ function cardCopy(operation, manager, timeZone, now) {
     const nextRunAt = nextForOperation(operation, manager, now);
     const scheduleTimeZone = definition.schedule.type === "cron" ? definition.schedule.timeZone : timeZone;
     const when = operation.action === "run_now" ? "Now" : scheduleText(definition.schedule, timeZone);
-    const destination = definition.runOn === "cloud" ? "Box-hosted agent" : "Bot’s current model and configured computer";
+    const destination = definition.runOn === "cloud" ? "Boat-hosted agent" : "Bot’s current model and configured computer";
     const current = operation.action === "create"
         ? null
         : manager.listRoutines().find((routine) => routine.id === operation.routineId) ?? null;
@@ -838,7 +849,7 @@ function revalidateOperation(operation, manager, botId, now) {
     }
     const current = operation.action === "create"
         ? null
-        : verifyManageSnapshot(operation, manager, botId);
+        : verifyManageSnapshot(operation, manager, operation.forBot?.botId ?? botId);
     const schedule = operation.action === "create"
         ? operation.routine.schedule
         : operation.action === "update"
@@ -923,7 +934,7 @@ export class RoutineRequestService {
             throw new RoutineRequestError(schemaIssue(parsedProposal.error, "Invalid routine proposal"));
         }
         const operation = normalizedOperation(this.routines, botId, parsedProposal.data, at);
-        if (operation.action === "create" && operation.forBot && this.validateTarget) {
+        if (operation.forBot && this.validateTarget) {
             const refusal = this.validateTarget(botId, operation.forBot);
             if (refusal)
                 throw new RoutineRequestError(refusal, 403);
@@ -1130,7 +1141,7 @@ export class RoutineRequestService {
                 return { claimed: true, state: "denied" };
             }
             revalidateOperation(payload.operation, this.routines, payload.botId, this.now());
-            if (payload.operation.action === "create" && payload.operation.forBot && this.validateTarget) {
+            if (payload.operation.forBot && this.validateTarget) {
                 const refusal = this.validateTarget(payload.botId, payload.operation.forBot);
                 if (refusal)
                     throw new RoutineRequestError(refusal, 404, { terminal: true });
@@ -1229,7 +1240,7 @@ export class RoutineRequestService {
                     fingerprint,
                 }).id;
             case "update": {
-                const current = verifyManageSnapshot(operation, this.routines, payload.botId);
+                const current = verifyManageSnapshot(operation, this.routines, operation.forBot?.botId ?? payload.botId);
                 const updated = this.routines.update(operation.routineId, updateFromChanges(operation.changes, confirmationAt, current.schedule), {
                     requestId: payload.requestId,
                     messageId,
@@ -1245,7 +1256,7 @@ export class RoutineRequestService {
             }
             case "pause":
             case "resume": {
-                verifyManageSnapshot(operation, this.routines, payload.botId);
+                verifyManageSnapshot(operation, this.routines, operation.forBot?.botId ?? payload.botId);
                 const updated = this.routines.update(operation.routineId, { enabled: operation.action === "resume" }, {
                     requestId: payload.requestId,
                     messageId,
@@ -1260,7 +1271,7 @@ export class RoutineRequestService {
                 return updated.id;
             }
             case "run_now": {
-                verifyManageSnapshot(operation, this.routines, payload.botId);
+                verifyManageSnapshot(operation, this.routines, operation.forBot?.botId ?? payload.botId);
                 const run = this.routines.runNow(operation.routineId, {
                     requestId: payload.requestId,
                     messageId,
@@ -1275,7 +1286,7 @@ export class RoutineRequestService {
                 return run.id;
             }
             case "delete":
-                verifyManageSnapshot(operation, this.routines, payload.botId);
+                verifyManageSnapshot(operation, this.routines, operation.forBot?.botId ?? payload.botId);
                 if (!this.routines.remove(operation.routineId, {
                     requestId: payload.requestId,
                     messageId,

package/dist-server/server/routines.js

@@ -1284,12 +1284,16 @@ export class RoutineManager {
                     continue;
                 }
                 // A webhook is an incoming message, so make its task the bot's live
-                // chat immediately. Scheduled work remains detached and unobtrusive.
-                const task = run.target === "room-goal"
-                    ? run.groupId
-                        ? this.options.createGoalTask?.(run.groupId, run.routineName) ?? null
-                        : null
-                    : this.options.createTask(run.botId, run.routineName, run.triggerSource === "webhook");
+                // chat immediately. Scheduled work stays in its own task unless the
+                // workspace has asked for runs to join the conversation they report to.
+                const joined = run.target === "room-goal" ? null : this.options.joinConversation?.(run) || null;
+                const task = joined
+                    ? { threadId: joined }
+                    : run.target === "room-goal"
+                        ? run.groupId
+                            ? this.options.createGoalTask?.(run.groupId, run.routineName) ?? null
+                            : null
+                        : this.options.createTask(run.botId, run.routineName, run.triggerSource === "webhook");
                 if (!task) {
                     this.failRun(run, run.target === "room-goal"
                         ? "Could not create a room task for this goal"

package/dist-server/server/shared-computers.js

@@ -15,41 +15,120 @@ export const sharedComputerOperation = z.object({
     arguments: z.record(z.string(), z.unknown()).optional(),
 }).strict();
 const failure = (message, status = 409) => Object.assign(new Error(message), { status });
+/** Bounds memory, not anyone's share: a desktop session holds one entry. */
+const TOTAL = 100;
+/** How long a lent computer that stopped polling (asleep, app closed) stays
+ * known, so a status reader can tell "lent but offline" from "not lent". */
+const RETAIN_MS = 14 * 24 * 60 * 60_000;
+const OFFLINE = "This shared computer is offline. Keep its desktop app open; do not substitute files on the server.";
+/** The scopes the desktop registered, checked by the server as well. The
+ * desktop's own grant is the authority and checks every operation again;
+ * this only means the server never even queues work outside what the desktop
+ * said it lends. */
+export function sharedComputerScopeRefusal(registration, operation) {
+    switch (operation.action) {
+        case "run_command":
+            return registration.terminal ? null : "Terminal access is not lent to this server.";
+        case "computer_tools":
+        case "computer_call":
+            return registration.computer ? null : "Apps and screen are not lent to this server.";
+        case "list_files":
+        case "read_file":
+        case "write_file": {
+            const lent = registration.folders.find(entry => entry.id === operation.folder_id);
+            if (!lent)
+                return "This folder has not been shared with this server.";
+            return operation.action === "write_file" && !lent.write ? "This folder is read-only." : null;
+        }
+    }
+}
+/** The person a bot turn acts for, from the harness's own record of which
+ * message started it: that request must name this exact turn generation (a
+ * continuation of the same request adds its generation), must not have been
+ * stopped, and its message must come from a person. Anything else is nobody. */
+export function provenRequestPerson(request, generation, personOf) {
+    if (!request?.messageId || request.stopped || !request.generations.has(generation))
+        return null;
+    return personOf(request.messageId) ?? null;
+}
 /** In-memory rendezvous only. Authority over local resources stays on the
- * desktop. Restart/disconnect NEVER replays an operation with an unknown outcome. */
+ * desktop. Restart/disconnect NEVER replays an operation with an unknown outcome.
+ *
+ * Partitioned by owner: an entry is keyed by the registering session and the
+ * desktop's id, so another session can never take over an id, and a bot turn
+ * sees only the computers of the person it acts for. A turn that acts for
+ * nobody provable (principal null) sees none. */
 export class SharedComputers {
     computers = new Map();
     sessionLive;
     constructor(sessionLive) { this.sessionLive = sessionLive; }
+    static key(session, id) { return `${session}\n${id}`; }
     register(registration, owner, secret) {
         if (!/^[a-f0-9]{64}$/.test(secret))
             throw failure("Invalid computer credential", 400);
-        const old = this.computers.get(registration.id);
+        const key = SharedComputers.key(owner.session, registration.id);
+        const old = this.computers.get(key);
         if (old) {
-            this.authorize(registration.id, owner, secret);
+            this.authorize(registration.id, owner.session, secret);
             old.registration = registration;
             old.seen = Date.now();
+            return;
+        }
+        this.reap();
+        // A paired desktop runs one grant per server, so a new id from the same
+        // session is a new save: its earlier entry is stale and goes. No other
+        // session can reach, replace or squat this key.
+        for (const [stale, entry] of this.computers) {
+            if (entry.owner.session !== owner.session)
+                continue;
+            this.computers.delete(stale);
+            entry.wake?.();
+            for (const job of entry.jobs.values())
+                this.finish(entry, job, failure("This computer's access changed. An in-flight action may have completed; inspect before retrying."));
         }
-        else {
-            // Reap dead devices before applying the bounded registration limit.
-            for (const [id, entry] of this.computers)
-                if (!this.online(entry) && entry.jobs.size === 0)
-                    this.computers.delete(id);
-            if (this.computers.size >= 20)
-                throw failure("Too many shared computers");
-            this.computers.set(registration.id, { registration, owner, secret, seen: Date.now(), jobs: new Map() });
+        if (this.computers.size >= TOTAL)
+            throw failure("Too many shared computers");
+        this.computers.set(key, { registration, owner: { ...owner }, secret, seen: Date.now(), jobs: new Map() });
+    }
+    /** Forget entries whose session ended or that have been silent too long. */
+    reap() {
+        for (const [key, entry] of this.computers) {
+            if (entry.jobs.size === 0 && (!this.sessionLive(entry.owner.session) || Date.now() - entry.seen > RETAIN_MS))
+                this.computers.delete(key);
         }
     }
-    online(entry) { return this.sessionLive(entry.owner) && Date.now() - entry.seen < 40_000; }
-    authorize(id, owner, secret) {
-        const entry = this.computers.get(id);
-        if (!entry || entry.owner !== owner || !this.sessionLive(owner) || !/^[a-f0-9]{64}$/.test(secret) || !timingSafeEqual(Buffer.from(secret), Buffer.from(entry.secret)))
+    online(entry) { return this.sessionLive(entry.owner.session) && Date.now() - entry.seen < 40_000; }
+    authorize(id, session, secret) {
+        const entry = this.computers.get(SharedComputers.key(session, id));
+        if (!entry || !this.sessionLive(session) || !/^[a-f0-9]{64}$/.test(secret) || !timingSafeEqual(Buffer.from(secret), Buffer.from(entry.secret)))
             throw failure("Shared computer is disconnected or not authorized", 403);
         return entry;
     }
-    list() { return [...this.computers.values()].filter(entry => this.online(entry)).map(entry => entry.registration); }
-    async poll(id, owner, secret) {
-        const entry = this.authorize(id, owner, secret);
+    /** The online computers one person lent. */
+    list(principal) {
+        if (!principal)
+            return [];
+        return [...this.computers.values()].filter(entry => entry.owner.person === principal && this.online(entry)).map(entry => entry.registration);
+    }
+    /** What one person has lent, online or not: the documented status a
+     * reader (the Cloud UI, the next step's placement) uses to tell "your Mac
+     * is lent and awake" from "lent but asleep" and "not lent". No secret, no
+     * session. Resets when this server restarts; a lending desktop registers
+     * again within seconds of being online. */
+    status(principal) {
+        if (!principal)
+            return [];
+        this.reap();
+        return [...this.computers.values()].filter(entry => entry.owner.person === principal).map(entry => ({
+            id: entry.registration.id, name: entry.registration.name, online: this.online(entry), busy: entry.jobs.size > 0, lastSeenAt: entry.seen,
+            scopes: {
+                folders: entry.registration.folders.map(({ id, name, write }) => ({ id, name, write })),
+                terminal: entry.registration.terminal, screen: entry.registration.computer,
+            },
+        }));
+    }
+    async poll(id, session, secret) {
+        const entry = this.authorize(id, session, secret);
         if (entry.wake)
             throw failure("A computer poll is already running");
         entry.seen = Date.now();
@@ -73,34 +152,41 @@ export class SharedComputers {
             const timer = setTimeout(() => { entry.wake = undefined; resolve(); }, 20_000);
             entry.wake = () => { clearTimeout(timer); entry.wake = undefined; resolve(); };
         });
-        this.authorize(id, owner, secret);
+        this.authorize(id, session, secret);
         entry.seen = Date.now();
         return next();
     }
-    liveJob(id, owner, secret, jobId) {
-        const entry = this.authorize(id, owner, secret);
+    liveJob(id, session, secret, jobId) {
+        const entry = this.authorize(id, session, secret);
         entry.seen = Date.now();
         const job = entry.jobs.get(jobId);
         return job?.sent === true && job.active();
     }
-    complete(id, owner, secret, jobId, result) {
-        const entry = this.authorize(id, owner, secret);
+    complete(id, session, secret, jobId, result) {
+        const entry = this.authorize(id, session, secret);
         const job = entry.jobs.get(jobId);
         if (!job || !job.sent)
             throw failure("This computer operation expired; it will not be replayed");
         this.finish(entry, job, job.active() ? null : failure("The requesting turn ended"), result);
     }
-    disconnect(id, owner, secret) {
-        const entry = this.authorize(id, owner, secret);
-        this.computers.delete(id);
+    disconnect(id, session, secret) {
+        const entry = this.authorize(id, session, secret);
+        this.computers.delete(SharedComputers.key(session, id));
         entry.wake?.();
         for (const job of entry.jobs.values())
             this.finish(entry, job, failure("Computer disconnected. An in-flight action may have completed; inspect before retrying."));
     }
-    request(operation, active) {
-        const entry = this.computers.get(operation.computer_id);
-        if (!entry || !this.online(entry))
-            return Promise.reject(failure("This shared computer is offline. Keep its desktop app open; do not substitute files on the server."));
+    /** One bot operation for the person the turn acts for. Another person's
+     * computer answers exactly like one that does not exist. */
+    request(operation, principal, active) {
+        if (!principal)
+            return Promise.reject(failure("This conversation cannot use a shared computer: only a conversation started by the person who shared it can.", 403));
+        const entry = [...this.computers.values()].find(candidate => candidate.registration.id === operation.computer_id && candidate.owner.person === principal && this.online(candidate));
+        if (!entry)
+            return Promise.reject(failure(OFFLINE));
+        const refusal = sharedComputerScopeRefusal(entry.registration, operation);
+        if (refusal)
+            return Promise.reject(failure(refusal, 403));
         if (entry.jobs.size >= 1)
             return Promise.reject(failure("This shared computer is busy. Wait for its current action to finish."));
         if (!active())