@chibitek/chibi 0.1.154 → 0.1.157

package/dist-server/server/incidents.js

@@ -78,6 +78,8 @@ function whatHappened(incident) {
             return `${incident.bot.name}'s run ${where} continued on another model because its engine refused the one it was set to${detail}`;
         case "engine-fallback":
             return `${incident.bot.name}'s run ${where} continued on another engine after its selected engine failed${detail}`;
+        case "mcp-unavailable":
+            return `${incident.bot.name}'s run ${where} continued without one of its tool servers${detail}`;
         default:
             return `${incident.bot.name}'s run ${where} failed${detail}`;
     }
@@ -99,13 +101,15 @@ export function incidentText(incident, count) {
         lines.push(`${incident.bot.name} last said: "${fold(incident.lastReply, 300)}"`);
     if (count.count > 1)
         lines.push(`This is the ${ordinal(count.count)} incident on that thread within the hour.`);
-    if (incident.kind === "model-fallback" || incident.kind === "engine-fallback") {
-        // Nothing broke: the turn ran. The failed selection or engine still
-        // needs attention, but the completed work must never be retried.
+    if (incident.kind === "model-fallback" || incident.kind === "engine-fallback" || incident.kind === "mcp-unavailable") {
+        // Nothing broke: the turn ran. The failed selection, engine or tool
+        // server still needs attention, but the completed work must never be retried.
         lines.push("The run was not interrupted and needs no retry; do not call retry_thread.");
         lines.push(incident.kind === "model-fallback"
             ? "Tell the person in one or two plain sentences that this engine no longer offers that model and that the bot's or the conversation's model setting should be changed, then stop."
-            : "Use the incident detail to correct the failed engine if action is needed, then report what happened in one or two plain sentences and stop.");
+            : incident.kind === "mcp-unavailable"
+                ? "Tell the person in one or two plain sentences which tool server is not working, that bots carry on without it until it answers again, and that its command and settings in Settings may need a look, then stop."
+                : "Use the incident detail to correct the failed engine if action is needed, then report what happened in one or two plain sentences and stop.");
         return lines.join("\n");
     }
     lines.push(count.mayRetry

package/dist-server/server/index.js

@@ -1,3 +1,7 @@
+import { hasUnboundGoalGuard, goalGuardForEvent, addGoalGuard, removeGoalGuard, runPersonalGoalTurn, updatePersonalGoalReceipt } from "./personal-goal-turn.js";
+import { PersonalGoalRuntime, receiveGoalCommand } from "./personal-goal-runtime.js";
+import { personalGoalInstructions } from "./personal-goals.js";
+import { parseGoalCommand } from "../shared/personal-goal.js";
 // OpenMausBot server — the harness host. Clients hold no transports
 // (upstream rule): the React app dispatches typed commands over HTTP and
 // folds one SSE event stream; every provider process runs here.
@@ -92,7 +96,7 @@ import { probeMcpServer } from "./mcp-probe.js";
 import { McpToolHintStore, readOnlyToolAllowed } from "./mcp-tool-hints.js";
 import { McpAuthStateStore } from "./mcp-auth-state.js";
 import { McpHealthStore } from "./mcp-health.js";
-import { drainMcpAuthSignals } from "./mcp-auth-signal.js";
+import { mcpTurnPolicy } from "./mcp-turn.js";
 import { mcpAuthSignalDir } from "./mcp-gate-config.js";
 import { bridgeMcpRemote } from "./mcp-remote-bridge.js";
 import { mcpToolRefFromLabel } from "../shared/mcp-tool-ref.js";
@@ -143,7 +147,7 @@ import { MEMORY_INDEX, MemoryStoreError, memoryCapacity, memoryOverview, openFol
 import { beginMemoryTurn, endMemoryTurn, flushAllMemoryJournals, flushMemoryJournal, journalMemoryDelete, journalMemoryWrite, readMemoryJournal, revertMemoryChange, } from "./memory-journal.js";
 import { readSectionContext, readSections, sectionContextKey, sectionContextLabel, sectionContextSystemPrompt, writeSectionContext, SECTION_CONTEXT_MAX_BYTES, } from "./section-context.js";
 import { applyStagedSkillWrite, applySkillWriteWithReceipt, getStagedSkillWrite, installSkill, parseSkillMd, scanSkillText, listSkills, listStagedSkillWrites, isSkillName, readSkillFile, rejectStagedSkillWrite, removeSkill, setSkillEnabled, skillsSystemPrompt, stageSkillWrite, } from "./skills.js";
-import { fetchSkillFromSource } from "./skill-fetch.js";
+import { resolveSkillImport, skillImportSchema } from "./skill-fetch.js";
 import { pickBotName } from "./names.js";
 import { botSkillTemplateSchema, newBotDefaultsSchema, resolveBotCreationDefaults } from "./new-bot-defaults.js";
 import { expandLearnTurnText, learnSource } from "./skill-learn.js";
@@ -235,6 +239,7 @@ import { activityCsv, activityEntries, appendAdminAction, botAuditSnapshot, botC
 import { frameForMember, memberBody, memberBot, noteSeen, notFoundFor, audienceEquals, memberGroup, narrowestAudience, parseVisibility, pathSubject, roomFeeds, routineVisible, sameAudience, SEES_EVERYTHING, SEES_ALL_BUT_PRIVATE, VisibleSet, } from "./bot-visibility.js";
 import { describeBrand, loadBrand } from "./brand.js";
 import { deliverSseFrame } from "./sse-fanout.js";
+import { DeviceRouteRegistry, removeStream } from "./device-routing.js";
 import { PHONE_SECRET_PROTOCOL_VERSION, PhoneSecretBridge, PhoneSecretError, PhoneSecretSubmissionRegistry, assertPhoneSecretRequestMatches, phoneSecretOperationId, } from "./phone-secret.js";
 // Keep these two last: a route module may import any server module, and
 // loading the table after everything above leaves module start-up order as is.
@@ -248,7 +253,7 @@ import { createModelLevelsRoutes } from "./routes/model-levels.js";
 import { createMcpMarketplaceRoutes } from "./routes/mcp-marketplace.js";
 import { createLocalModelRoutes, OLLAMA_LOCAL_URL, ollamaInstalledHere } from "./routes/local-models.js";
 import { createSetupRoutes } from "./routes/setup.js";
-import { installOllamaApp, openPodmanInstaller, runTool, startPodmanMachine } from "./app-installers.js";
+import { installOllamaApp, openPodmanInstaller, startOllamaApp, runTool, startPodmanMachine } from "./app-installers.js";
 import { CliLoginRunner } from "./cli-login.js";
 import { JobFailure, SetupJobs } from "./setup-jobs.js";
 import { localHost, probeLocalInjects } from "./drivers/local-inject.js";
@@ -1820,6 +1825,7 @@ function requestedTaskBot(botId, rawThreadId) {
     return task;
 }
 async function interruptDirectThread(botId, threadId) {
+    personalGoals.steer(threadId);
     const requestOwner = directRequestOwners.get(threadId);
     if (requestOwner) {
         requestOwner.stopped = true;
@@ -3350,7 +3356,7 @@ function localModeTurn(resolution, turn) {
     return { ...resolution, local: true, choice: { ...choice, selection: placement.selection, candidate: placement.candidate } };
 }
 const payPerUsePausedLine = (until) => `Pay-per-use is paused until ${restTime(until)}, when a subscription is back, so this turn stopped.`;
-/** A model this machine serves: never a stand-in for Engineering and above. */
+/** A model this machine serves: a rung when a ladder names it, else local rules only. */
 const isLocalModel = (candidate, model) => localModel(candidate, model) || modelLevels.classOf(candidate.driverKind, model)?.local === true;
 // ── silent automatic failover (docs/chibitek/engine-tiers.md, step 2) ────
 // Resting engines are shared by every bot and survive a restart.
@@ -3589,10 +3595,7 @@ const eventBase = (event) => ({
     ...(event.providerInstanceId ? { providerInstanceId: event.providerInstanceId } : {}), ...(event.turnId ? { turnId: event.turnId } : {}),
 });
 const restTime = (at) => new Date(at).toLocaleTimeString("en-GB", { hour: "2-digit", minute: "2-digit" });
-/** A watched turn ended failed because its engine ran out or was signed
- * out. Rest the engine, then run the same turn on the next engine at the
- * same level, silently; or, when nothing is left, stop it with one line
- * naming the resting engines. Returns what subscribers see. */
+/** Rest a refused engine and continue on an eligible engine, or show an actionable line. */
 function engineFailover(turn, completion) {
     const failure = turn.failure;
     const record = failoverTurns.get(turn.threadId);
@@ -3615,17 +3618,14 @@ function engineFailover(turn, completion) {
     const restFailed = () => engineRests.rest(turn.instanceId, failedCandidate ? engineAccount(failedCandidate) : undefined, failure.kind, { resetAt: failure.resetAt, resetText: failure.resetText, windowMs: failure.windowMs, message: redactSecretsInText(failure.message),
         ...(failure.permanent ? { permanent: true } : {}), ...(scope ? { scope } : {}), ...(ran?.model ? { model: ran.model } : {}),
         ...(failure.kind === "auth_failed" && failedCandidate ? { reportedSignedIn: failedCandidate.snapshot.state === "available" && failedCandidate.snapshot.authenticated === true } : {}) });
-    // An unrecognised failure (provider_error) is only a reason to try the
-    // next engine: the engine rests (the circuit breaker) only once the turn
-    // really moves, and with nowhere to go the turn ends with the engine's own
-    // report, exactly as before, rather than a "resting" line about it.
+    // Unknown failures rest only when the turn moves; otherwise preserve their report.
     const rest = failure.kind === "provider_error" ? undefined : restFailed();
     const label = (instanceId) => candidates.find((candidate) => candidate.instanceId === instanceId)?.displayName ?? instanceId;
     // The one plain line, never the provider's own words: which account needs
     // the person and where to fix it, or that every engine is resting.
     const stop = (line, category = "failover_exhausted") => [
         { ...eventBase(completion), type: "runtime.error", message: line, terminal: true, category, ...(failure.setup ? { setup: true } : {}) },
-        completion,
+        failure.kind === "auth_failed" ? { ...completion, stopReason: "auth_required" } : completion,
     ];
     const restingNamed = (instanceIds) => [...new Set(instanceIds)].flatMap((instanceId) => {
         const candidate = candidates.find((entry) => entry.instanceId === instanceId);
@@ -3648,13 +3648,11 @@ function engineFailover(turn, completion) {
         return stop(pick.line, pick.category);
     const { choice } = pick;
     const tried = new Set(record.tried);
-    // Move the turn. The attempt that failed is retired quietly afterwards: no
-    // chip, no notification, no incident, and nothing settled that the same
-    // turn still owns.
+    // Retire the failed attempt without settling the request that the next engine owns.
     const moved = ran ?? record.selection;
     const failedOwner = turnResourceOwners.get(turn.threadId);
     const tokens = completion.usage ?? turnUsage.get(turn.threadId);
-    const partialText = turn.partial.trim();
+    const partialText = groupGoalCoordinatorTurns.get(turn.threadId)?.size ? parseGroupGoalDecision(turn.partial).visibleText : turn.partial.trim();
     const requestOwner = directRequestOwners.get(turn.threadId);
     if (partialText) {
         // The answer it was in the middle of stays: the person saw it stream.
@@ -3666,6 +3664,12 @@ function engineFailover(turn, completion) {
     const tools = earlier.filter((message) => message.kind === "activity" && message.tool?.name).map((message) => message.tool.name);
     const note = continuationNote(said.map((message) => message.text ?? ""), tools);
     const attempt = record.attempt + 1;
+    for (const guard of groupGoalCoordinatorTurns.get(turn.threadId) ?? []) {
+        if (!guard.discard && (guard.turnId === completion.turnId || guard.turnId === turn.turnId)) {
+            guard.turnId = undefined;
+            guard.assistantItems = [];
+        }
+    }
     const rerun = startTurn(turn.botId, note ? `${record.text}\n\n${note}` : record.text, {
         ...record.opts,
         threadId: turn.threadId,
@@ -3703,6 +3707,11 @@ function engineFailover(turn, completion) {
         });
     }
     retireFailedAttempt(turn.botId, turn.threadId, turn.generation, failedOwner, completion);
+    if (failure.kind === "auth_failed")
+        reportIncident({
+            kind: "engine-fallback", bot: profile, threadId: turn.threadId, notifyChief: true,
+            detail: `${engineLabel(candidates, moved)} needs signing in again in Settings > Engines; the turn continued on ${engineLabel(candidates, choice.selection)}`,
+        });
     console.error(`[omb-failover] thread=${turn.threadId} ${failure.kind}: ${moved.instanceId} -> ${choice.selection.instanceId} (attempt ${attempt})`);
     // No turnId: the failed provider turn is retired, and its id would hide
     // this record from every window.
@@ -5013,67 +5022,21 @@ const publicBotQueuedMessages = () => queuedSteerSnapshot((botId, threadId) => B
 const groupTurnOperations = new Map();
 const groupGoalCoordinatorTurns = new Map();
 const GROUP_GOAL_COORDINATOR_GUARD_MS = 5 * 60_000;
-function addGroupGoalCoordinatorTurn(threadId, turn) {
-    const turns = groupGoalCoordinatorTurns.get(threadId) ?? new Set();
-    turns.add(turn);
-    groupGoalCoordinatorTurns.set(threadId, turns);
-}
-function removeGroupGoalCoordinatorTurn(threadId, turn) {
-    if (turn.cleanupTimer)
-        clearTimeout(turn.cleanupTimer);
-    const turns = groupGoalCoordinatorTurns.get(threadId);
-    turns?.delete(turn);
-    if (turns?.size === 0)
-        groupGoalCoordinatorTurns.delete(threadId);
-}
-function hasUnboundDiscardedGroupGoalTurn(threadId) {
-    return [...(groupGoalCoordinatorTurns.get(threadId) ?? [])]
-        .some((turn) => turn.discard && !turn.turnId);
-}
-/** Match private coordinator output to one provider turn, never merely to a
- * reusable room thread. Most adapters emit turn.started before sendTurn
- * resolves, so the first stable event may bind an otherwise pending guard. */
-function groupGoalCoordinatorTurnForEvent(event) {
-    const turns = groupGoalCoordinatorTurns.get(event.threadId);
-    if (!turns?.size)
-        return undefined;
-    const candidates = [...turns];
-    if (event.turnId) {
-        const exact = candidates.find((turn) => turn.turnId === event.turnId);
-        if (exact)
-            return exact;
-        // Until an interrupted handshake returns its own id, no new id can be
-        // attributed safely. The stall fallback keeps this thread unavailable in
-        // that narrow window; private text is suppressed below until sendTurn's
-        // result binds the old guard or its bounded expiry releases ownership.
-        const unboundDiscarded = candidates.filter((turn) => turn.discard && !turn.turnId);
-        if (unboundDiscarded.length > 0) {
-            // The ownership fallback below keeps a lone abandoned handshake's
-            // thread closed, so its first eventual id can safely bind here. More
-            // than one unbound candidate is genuinely ambiguous and stays gated.
-            if (candidates.length === 1) {
-                unboundDiscarded[0].turnId = event.turnId;
-                // This event is the first stable identity for an already-abandoned
-                // provider turn. Tombstone it immediately so this event and every
-                // later completion/request cannot settle a replacement on the same
-                // room thread.
-                retireProviderTurn(event.turnId);
-                return unboundDiscarded[0];
-            }
-            return undefined;
-        }
-        const pending = candidates.findLast((turn) => !turn.turnId && !turn.discard);
-        if (pending && !pending.turnId) {
-            pending.turnId = event.turnId;
-            return pending;
-        }
-        return undefined;
-    }
-    // Turn-scoped events normally carry an id. If an adapter omits it, fail
-    // closed for private text; with multiple overlapping guards there is no
-    // safe way to attribute a completion, so leave cleanup to the bounded timer.
-    return candidates.length === 1 ? candidates[0] : undefined;
-}
+const personalGoals = new PersonalGoalRuntime(join(DATA_DIR, "personal-goals.json"), {
+    busy: (botId, threadId) => threadBusy(botId, threadId) || Boolean(activeGroupTurnForBot(botId)),
+    interrupt: async (botId, threadId, goalId) => {
+        const owns = [...(groupGoalCoordinatorTurns.get(threadId) ?? [])].some(guard => guard.personalGoalId === goalId && !guard.discard && (!guard.turnId || guard.turnId === liveTurnByThread.get(threadId)));
+        if (owns)
+            await interruptDirectThread(botId, threadId);
+    },
+    changed: (goal) => updatePersonalGoalReceipt(goal, store),
+    run: (goal) => runPersonalGoalTurn(goal, { store, addGuard: addGroupGoalCoordinatorTurn, removeGuard: removeGroupGoalCoordinatorTurn,
+        subscribe: (listener) => bus.subscribe(listener), ignore: shouldIgnoreProviderEvent, busy: threadBusy, start: startTurn }),
+});
+const addGroupGoalCoordinatorTurn = (threadId, turn) => addGoalGuard(groupGoalCoordinatorTurns, threadId, turn);
+const removeGroupGoalCoordinatorTurn = (threadId, turn) => removeGoalGuard(groupGoalCoordinatorTurns, threadId, turn);
+const hasUnboundDiscardedGroupGoalTurn = (threadId) => hasUnboundGoalGuard(groupGoalCoordinatorTurns, threadId);
+const groupGoalCoordinatorTurnForEvent = (event) => goalGuardForEvent(groupGoalCoordinatorTurns, retireProviderTurn, event);
 function groupIsWorking(group) {
     return Boolean(group.busyBotId) || Boolean(groupTurnOperations.get(group.id)?.size);
 }
@@ -6024,6 +5987,9 @@ function messageWindow(threadId, messageId, limit) {
     return { messages: all.slice(start, stop).map(slimMessage), hasMore: start > 0 };
 }
 const sseClients = new Set();
+// Approval device routing: docs/specs/remote-approval/spec.md.
+const deviceRoutes = new DeviceRouteRegistry();
+const removeSseClient = (client) => removeStream(sseClients, deviceRoutes, client);
 /** The frame at which a bot's audience last changed (see the SSE route). */
 let audienceChangedAt = 0;
 /** A bot's audience changed: end every member stream. Each reconnects at
@@ -6035,27 +6001,15 @@ function audienceChanged() {
     for (const client of sseClients) {
         if (client.viewer.kind !== "member")
             continue;
-        sseClients.delete(client);
-        try {
-            client.res.end();
-        }
-        catch {
-            /* already gone */
-        }
+        removeSseClient(client);
     }
 }
 function closeSessionStreams(sessionId) {
     browserLive.closeForOwner(sessionId);
-    for (const client of sseClients) {
+    for (const client of Array.from(sseClients)) {
         if (client.sessionId !== sessionId)
             continue;
-        sseClients.delete(client);
-        try {
-            client.res.end();
-        }
-        catch {
-            /* already gone */
-        }
+        removeSseClient(client);
     }
 }
 sessions.onSessionRevoked((sessionId) => {
@@ -6253,7 +6207,7 @@ function broadcast(payload, options = {}) {
         // Screen frames are replaceable and durable events are not: see
         // ./sse-fanout.ts for the backpressure/bound decision this makes.
         if (deliverSseFrame(client, kind, out) === "disconnected") {
-            sseClients.delete(client);
+            removeSseClient(client);
         }
     }
 }
@@ -8258,6 +8212,8 @@ bus.subscribe((event) => {
             lastReply.delete(event.threadId);
             const turnError = lastTurnError.get(event.threadId);
             lastTurnError.delete(event.threadId);
+            // A tool server that broke under this turn is reported with the turn (mcp-turn.ts), not at whatever turn next starts.
+            syncMcpAuthState();
             // A run that broke — not one the person stopped, and not a routine's,
             // which reports through its own failure path — is the Chief's to see.
             // A lazy computer-claim rejection already reported its failure and
@@ -8269,7 +8225,7 @@ bus.subscribe((event) => {
             if (!event.ok && event.stopReason !== "interrupted" && !lazyClaimAlreadyReported && !routines?.runForThread(event.threadId)) {
                 const broken = bot ?? (speaker ? store.bot(speaker.botId) : undefined);
                 if (broken)
-                    reportIncident({ kind: "failed", bot: broken, threadId: event.threadId, detail: failedRunDetail(event.stopReason, turnError) });
+                    reportIncident({ kind: "failed", bot: broken, threadId: event.threadId, detail: failedRunDetail(event.stopReason, turnError), notifyChief: event.stopReason === "auth_required" });
             }
             const lastReported = turnUsage.get(event.threadId);
             turnUsage.delete(event.threadId);
@@ -8625,17 +8581,17 @@ function incidentContext(threadId) {
 }
 function reportIncident(input) {
     const { bot, threadId } = input;
-    // A fallback is a run that went on, not a broken one.
-    const quiet = input.kind === "model-fallback" || input.kind === "engine-fallback";
+    // A fallback, or a turn that ran on without a broken tool server, is a run that went on, not a broken one.
+    const quiet = input.kind === "model-fallback" || input.kind === "engine-fallback" || input.kind === "mcp-unavailable";
     // The Primary Bot's pre-check reads broken runs from here (a failed
     // routine has its own run record, so it is not noted twice).
-    if (input.kind !== "routine-failed" && input.kind !== "model-fallback" && input.kind !== "engine-fallback") {
+    if (input.kind !== "routine-failed" && input.kind !== "model-fallback" && input.kind !== "engine-fallback" && input.kind !== "mcp-unavailable") {
         primaryBotStore.noteFailure({ botId: bot.id, threadId, kind: input.kind, detail: redactSecretsInText(input.detail).slice(0, 300), at: Date.now() });
     }
     const task = store.taskByThread(bot.id, threadId);
     // A thread another bot opened and is watching is that bot's to handle:
     // the delegator is woken with the failure already (wakeDelegationSource).
-    if (task?.openedBy?.delegationId || delegationWatch.has(threadId) || roomHandoffs.activeDirect(threadId))
+    if (!input.notifyChief && (task?.openedBy?.delegationId || delegationWatch.has(threadId) || roomHandoffs.activeDirect(threadId)))
         return;
     const group = store.groupByThread(threadId);
     const incident = {
@@ -10758,6 +10714,7 @@ async function startTurn(botId, text, opts) {
                 ? await nexusMemory.readBack({ bot: liveBot ?? bot, threadId, query: providerText })
                 : "";
             const prompt = buildSystemPrompt(persona, liveBot?.soul ?? bot.soul ?? "", roomPromptSections(roomTurn, [
+                { id: "personal-goal", label: "Active goal", text: personalGoals.goals.get(threadId)?.status === "working" ? personalGoalInstructions(personalGoals.goals.get(threadId)) : "" },
                 { id: "user-profile", label: "About the user", text: userProfileSystemPrompt(cfg.profile) },
                 // the ICM folder is on this machine; a cloud run cannot reach it
                 // first after the soul: the block names agent tools, so it only goes
@@ -10775,7 +10732,7 @@ async function startTurn(botId, text, opts) {
                 { id: "team-computer", label: "Team computer", text: teamComputerPrompt(teamComputer) },
                 { id: "plan", label: "Surface", text: surfacePrompt({ computer: mountedComputer, browser: Boolean(integrations.browser) }, { pinned: plan.pinned, note: plan.note, canSelect: computerSelectionTurns.has(threadId) }) },
                 { id: "accounts", label: "Google and Microsoft accounts", text: integrations.accounts ? accountsPrompt(botAccountEmails(bot)) : "" },
-                { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {})) },
+                { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {}), instance.adapter.capabilities.customMcp === true ? mcpTurn.unavailable(engineMcpServers(bot)) : []) },
                 { id: "browser", label: "Browser", text: integrations.browser ? BUILT_IN_BROWSER_SYSTEM_PROMPT : "" },
                 { id: "coordination", label: "Team", text: coordinationPrompt ? ` ${coordinationPrompt}` : "" },
                 { id: "assignment", label: "Teammate task", text: coordinationNode ? `\n${coordinationSystemInstructions()}` : "" },
@@ -12623,7 +12580,7 @@ failover) {
             { id: "private-bot", label: "Private Bot", text: isPersonalBot(bot) ? privateBotPrompt(false) : "" },
             { id: "files", label: "File locations", text: workspace ? workspaceLocationsPrompt(bot.id, cwd, readyBot.cwd) : "" },
             { id: "repos", label: "Linked repos", text: repoPlan ? repoPromptSection(repoPlan, repoPlace(undefined, roomTeamComputer || roomComputerKind === "box" ? "box" : roomVmMounted ? "vm" : roomComputerKind), cwd) : "" },
-            { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {})) },
+            { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {}), instance.adapter.capabilities.customMcp === true ? mcpTurn.unavailable(engineMcpServers(bot)) : []) },
             { id: "computer", label: "Computer", text: computerPrompt(roomTeamComputer || roomComputerKind === "box" ? instance.driverKind === "boxAgent" ? "box-agent" : instance.adapter.capabilities.cloudComputerMcp ? "box-chat" : "box" : roomVmMounted ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared" : roomComputerKind) },
             { id: "team-computer", label: "Team computer", text: teamComputerPrompt(roomTeamComputer) },
             { id: "plan", label: "Surface", text: surfacePrompt({ computer: roomTeamComputer ? "cloud" : roomVmMounted ? "vm" : surfaceOfComputerKind(roomComputerKind), browser: Boolean(integrations.browser) }, { note: roomPlan.note }) },
@@ -14781,23 +14738,19 @@ function warmMcpToolHints(custom) {
 /** Each configured server's sign-in state, and whether it is otherwise broken. */
 const mcpAuthState = new McpAuthStateStore(join(DATA_DIR, "mcp-auth-state.json"));
 const mcpHealth = new McpHealthStore();
-/** Fold in what gates and the chat runtime reported since the last look. */
-function syncMcpAuthState() {
-    const signals = drainMcpAuthSignals(mcpAuthSignalDir());
-    if (signals.length)
-        for (const state of [mcpAuthState, mcpHealth])
-            state.ingest(signals, customMcpServers(cfg));
-}
+const mcpTurn = mcpTurnPolicy({ auth: mcpAuthState, health: mcpHealth, signalDir: mcpAuthSignalDir, specs: () => customMcpServers(cfg),
+    reportUnavailable: (threadId, detail) => { const bot = store.botByThread(threadId); if (bot)
+        reportIncident({ kind: "mcp-unavailable", bot, threadId, detail }); } });
+function syncMcpAuthState() { mcpTurn.sync(); }
 /** How a start runs an mcp-remote bridge: background starts never open a
  * browser; only a person's click in Settings may (server/mcp-remote-bridge.ts). */
 function bridgedMcpServer(spec, allowBrowser) {
     return bridgeMcpRemote(spec, { bridge: resolveMcpRemoteBridge(), execPath: process.execPath, allowBrowser });
 }
-/** The servers one turn starts: the bot's servers, minus any whose sign-in
- * is backing off or stopped, or that lately would not start or crashed. */
+/** The servers one turn starts (mcp-turn.ts), after folding in what the gates reported. */
 function turnMcpServers(bot) {
     syncMcpAuthState();
-    return Object.fromEntries(Object.entries(engineMcpServers(bot)).filter(([name, spec]) => mcpAuthState.mountable(name, spec) && mcpHealth.mountable(name, spec)));
+    return mcpTurn.mountable(engineMcpServers(bot));
 }
 function engineMcpServers(bot) {
     // Rule 4 (server/personal-bot.ts): a bot with no list of its own gets every
@@ -16131,7 +16084,7 @@ ROUTES.push(createSetupRoutes({
         }
     },
     startOllama: async (context) => {
-        await runTool("/usr/bin/open", ["-a", "Ollama"]);
+        startOllamaApp();
         for (let attempt = 0; attempt < 30 && !context.signal.aborted; attempt++) {
             if ((await setupOllamaState()) === "running")
                 return;
@@ -19064,6 +19017,7 @@ const handleRequest = async (req, res) => {
                 admin: auth.scopes.includes("admin"),
                 screens: url.searchParams.get("screens") !== "off",
                 backpressured: false,
+                authKind: auth.kind,
                 viewer,
                 // What this person's hydration (GET /api/bots, narrowed the same way) showed them.
                 seen: viewer.kind === "all" && viewer.privateOwner ? { bots: new Set(), groups: new Set() } : {
@@ -19107,6 +19061,7 @@ const handleRequest = async (req, res) => {
                 // A client that offered no cursor gets false too, which is exactly
                 // what a cold start should do.
                 resumed,
+                approvalTarget: deviceRoutes.route(),
             })}\n\n`);
             if (resumed) {
                 for (const buffered of replayBuffer) {
@@ -19122,6 +19077,7 @@ const handleRequest = async (req, res) => {
                 }
             }
             sseClients.add(client);
+            deviceRoutes.streamOpened(client.authKind);
             // Keep this long-lived response out of socket idle-timeout handling
             // without weakening timeouts for every other API request.
             req.socket.setTimeout(0);
@@ -19141,7 +19097,7 @@ const handleRequest = async (req, res) => {
             }, SSE_HEARTBEAT_MS);
             req.on("close", () => {
                 clearInterval(keepalive);
-                sseClients.delete(client);
+                removeSseClient(client);
             });
             return;
         }
@@ -20586,11 +20542,11 @@ const handleRequest = async (req, res) => {
             });
         }
         if (method === "POST" && path === "/api/bot-defaults/skills/preview") {
-            const checked = z.object({ source: z.string().min(1).max(2000) }).strict().safeParse(await readBody(req));
+            // Drafts accept the same uploaded bytes as existing bots, without installing them.
+            const checked = skillImportSchema.safeParse(await readBody(req));
             if (!checked.success)
                 return json(res, 400, { error: checked.error.message });
-            const input = checked.data;
-            const fetched = await fetchSkillFromSource(input.source);
+            const fetched = await resolveSkillImport(checked.data);
             if ("error" in fetched)
                 return json(res, 422, { error: fetched.error });
             const skills = [];
@@ -21703,10 +21659,10 @@ const handleRequest = async (req, res) => {
         if (m && method === "POST") {
             if (!store.bot(m[1]))
                 return json(res, 404, { error: "no such bot" });
-            const parsed = z.object({ source: z.string().min(1).max(2000) }).safeParse(await readBody(req));
+            const parsed = skillImportSchema.safeParse(await readBody(req));
             if (!parsed.success)
-                return json(res, 400, { error: "source must be a GitHub URL or owner/repo" });
-            const fetched = await fetchSkillFromSource(parsed.data.source);
+                return json(res, 400, { error: "Choose a Markdown skill file or enter a GitHub source (maximum 256 KiB per file)." });
+            const fetched = await resolveSkillImport(parsed.data);
             if ("error" in fetched)
                 return json(res, 422, { error: fetched.error });
             const results = fetched.skills.map((skill) => installSkill(m[1], skill.source, skill.files));
@@ -22235,10 +22191,20 @@ const handleRequest = async (req, res) => {
                 userAgent: typeof req.headers["user-agent"] === "string" ? req.headers["user-agent"] : undefined,
                 relayed: Boolean(onBehalfOf),
             }));
+            let goalCommand;
+            try {
+                goalCommand = parseGoalCommand(text);
+            }
+            catch (error) {
+                return json(res, 400, { error: error instanceof Error ? error.message : "Invalid goal command" });
+            }
+            if (guarded && goalCommand)
+                return json(res, 400, { error: "Goal commands require the conversation command interface." });
             // The send is acknowledged before the turn starts, so a workspace at its
             // spend limit is refused here, where the person can see it.
             try {
-                assertWithinBudget(cfg, DATA_DIR);
+                if (!goalCommand || goalCommand.action === "start" || goalCommand.action === "resume")
+                    assertWithinBudget(cfg, DATA_DIR);
             }
             catch (error) {
                 return json(res, 409, { error: error instanceof Error ? error.message : String(error), code: "spend_cap" });
@@ -22307,6 +22273,12 @@ const handleRequest = async (req, res) => {
                     const message = await startTurn(bot.id, text, { threadId, replyTo, sendId, sender: messageSender(auth), trigger });
                     return { ok: true, threadId, message };
                 }
+                if (goalCommand) {
+                    if (auth.kind === "assistant")
+                        throw Object.assign(new Error("Only the person controls goals."), { status: 403 });
+                    return receiveGoalCommand(personalGoals, store, bot.id, threadId, goalCommand, text, sendId, messageSender(auth), trigger);
+                }
+                personalGoals.steer(threadId);
                 // Claude can accept the message inside its live turn. If the write
                 // loses a race with turn settlement, or the engine cannot steer, the
                 // existing server-side queue records it atomically for the next turn.
@@ -23735,6 +23707,8 @@ const handleRequest = async (req, res) => {
         if (method === "GET" && authStatus) {
             res.setHeader("cache-control", "no-store");
             const state = await providerAuthSessions.status(authStatus[1], auth.kind === "session" ? auth.session.id : "loopback", url.searchParams.get("flowId") ?? "");
+            if (state.phase === "succeeded")
+                engineRests.clear(authStatus[1], "signed-in");
             return json(res, 200, { auth: state });
         }
         const instanceAction = /^\/api\/instances\/([\w.-]+)\/(refresh-models|install|auth\/start|auth\/complete|auth\/cancel|auth\/sign-out)$/.exec(path);
@@ -23776,6 +23750,8 @@ const handleRequest = async (req, res) => {
                         providerAuthSessions.revokeOwner(owner);
                         return json(res, 401, { error: "Your session ended. Start a new sign-in." });
                     }
+                    if (started.phase === "succeeded")
+                        engineRests.clear(instanceId, "signed-in");
                     return json(res, 200, { auth: started });
                 }
                 if (action === "auth/sign-out") {
@@ -23793,6 +23769,8 @@ const handleRequest = async (req, res) => {
                     if (!flowId || !callbackUrl)
                         return json(res, 400, { error: "flowId and a code or callbackUrl are required" });
                     await providerAuthSessions.complete(instanceId, owner, flowId, callbackUrl);
+                    engineRests.clear(instanceId, "signed-in");
+                    await describeEngines();
                     return json(res, 200, { ok: true });
                 }
                 const body = await readBody(req, 4096);

package/dist-server/server/mcp-auth-signal.js

@@ -45,7 +45,8 @@ export function drainMcpAuthSignals(dir) {
             const parsed = JSON.parse(readFileSync(file, "utf8"));
             if (typeof parsed.name === "string" && MCP_SIGNAL_KINDS.includes(parsed.kind)
                 && typeof parsed.at === "number" && Number.isFinite(parsed.at)) {
-                signals.push({ name: parsed.name, kind: parsed.kind, at: parsed.at });
+                signals.push({ name: parsed.name, kind: parsed.kind, at: parsed.at,
+                    ...(typeof parsed.threadId === "string" && parsed.threadId ? { threadId: parsed.threadId } : {}) });
             }
         }
         catch {

package/dist-server/server/mcp-gate-config.js

@@ -57,6 +57,7 @@ export function gateServer(input) {
             OMB_GATE_SPILL_DIR: spillDir(input.threadId),
             OMB_GATE_BUDGET: String(budget),
             OMB_GATE_AUTH_DIR: mcpAuthSignalDir(),
+            OMB_GATE_THREAD: input.threadId,
         },
     };
 }

package/dist-server/server/mcp-gate.js

@@ -40,9 +40,12 @@ const SPILL_MAX_AGE_MS = 24 * 60 * 60_000;
 const SPILL_HINT = process.env.OMB_GATE_SPILL_HINT === "1";
 /** The gate's own settings never reach the upstream server's environment. */
 const GATE_ENV_KEYS = ["OMB_GATE_NAME", "OMB_GATE_SPILL_DIR", "OMB_GATE_BUDGET", "OMB_GATE_UPSTREAM", "OMB_GATE_SPILL_HINT", "OMB_GATE_AUTH_DIR",
-    "OMB_GATE_START_TIMEOUT_MS"];
+    "OMB_GATE_START_TIMEOUT_MS", "OMB_GATE_THREAD"];
 /** Where this gate reports whether its server's sign-in worked. */
 const AUTH_DIR = process.env.OMB_GATE_AUTH_DIR || "";
+/** The turn this gate serves, so a failure can be reported for its bot. */
+const THREAD = process.env.OMB_GATE_THREAD || "";
+const signalHarness = (kind) => writeMcpAuthSignal(AUTH_DIR, { name: NAME, kind, at: Date.now(), ...(THREAD ? { threadId: THREAD } : {}) });
 function fail(message) {
     process.stderr.write(`mcp-gate(${NAME}): ${message}\n`);
     process.exit(1);
@@ -196,7 +199,7 @@ function goDown(reason, why, signal = true) {
         clearTimeout(startTimer);
     process.stderr.write(`mcp-gate(${NAME}): ${why}; answering as an empty server so the turn carries on without it\n`);
     if (signal)
-        writeMcpAuthSignal(AUTH_DIR, { name: NAME, kind: reason, at: Date.now() });
+        signalHarness(reason);
     for (const message of inFlight.values())
         answer(strandedResponse(NAME, message));
     inFlight.clear();
@@ -290,7 +293,7 @@ createInterface({ input: child.stdout }).on("line", (line) => {
         reportedOk = true;
         if (startTimer)
             clearTimeout(startTimer);
-        writeMcpAuthSignal(AUTH_DIR, { name: NAME, kind: "ok", at: Date.now() });
+        signalHarness("ok");
     }
     const tool = id === undefined ? undefined : pending.get(id);
     if (id !== undefined)
@@ -317,7 +320,7 @@ child.on("exit", (code, signal) => {
         return;
     if (!reportedOk && exitMeansSignInRequired(code, stderrTail)) {
         process.stderr.write(`mcp-gate(${NAME}): sign-in required; not opening a browser from a background start\n`);
-        writeMcpAuthSignal(AUTH_DIR, { name: NAME, kind: "sign-in-required", at: Date.now() });
+        signalHarness("sign-in-required");
         if (!clientGone)
             return goDown("start-failed", "needs a sign-in", false);
     }

package/dist-server/server/mcp-health.js

@@ -29,12 +29,13 @@ export class McpHealthStore {
     noteFailed(name, spec, kind, at = this.now()) {
         const entry = this.entry(name, spec);
         if (entry && at < entry.retryAt)
-            return;
+            return false;
         const failures = (entry?.failures ?? 0) + 1;
         const wait = MCP_FAILURE_BACKOFF_MS[Math.min(failures, MCP_FAILURE_BACKOFF_MS.length) - 1];
         const retryAt = at + wait;
         this.servers.set(name, { fingerprint: mcpServerFingerprint(spec), kind, failures, lastFailureAt: at, retryAt });
         this.log(`[mcp] "${name}" ${kind === "crashed" ? "stopped during a turn" : "would not start"}; turns run without it until ${formatTime(retryAt)}`);
+        return true;
     }
     /** The server answered: whatever was wrong is over. An answer from a start
      * that began before a later failure does not clear that failure. */
@@ -54,17 +55,26 @@ export class McpHealthStore {
         const when = this.now() >= entry.retryAt ? "Atomic tries it again on the next turn." : `Atomic tries it again at ${formatTime(entry.retryAt)}.`;
         return `This server ${what}, so bots are working without it for now. ${when} Check its command and settings if this keeps happening.`;
     }
+    /** Why a server is left out of turns right now, or undefined when it mounts. */
+    unavailableKind(name, spec) {
+        const entry = this.entry(name, spec);
+        return entry && this.now() < entry.retryAt ? entry.kind : undefined;
+    }
     /** Apply what gates and the chat runtime reported, in order. `specs` are
-     * the servers as configured now; a signal for a removed server is dropped. */
+     * the servers as configured now; a signal for a removed server is dropped.
+     * Returns the signals that recorded a new failure (a repeat inside the
+     * backoff window is not one), so the harness can raise one incident each. */
     ingest(signals, specs) {
+        const fresh = [];
         for (const signal of signals) {
             const spec = specs[signal.name];
             if (!spec)
                 continue;
             if (signal.kind === "ok")
                 this.noteOk(signal.name, signal.at);
-            else if (signal.kind === "start-failed" || signal.kind === "crashed")
-                this.noteFailed(signal.name, spec, signal.kind, signal.at);
+            else if ((signal.kind === "start-failed" || signal.kind === "crashed") && this.noteFailed(signal.name, spec, signal.kind, signal.at))
+                fresh.push(signal);
         }
+        return fresh;
     }
 }