symbio 0.3.0 → 0.5.0

package/dist/server/team.js

@@ -5,7 +5,7 @@ import { randomBytes } from "node:crypto";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { AssetRegister } from "./assets.js";
-import { AGENT_PERMISSIONS, wildcardMatch } from "./guard.js";
+import { AGENT_PERMISSIONS, imageReadRefusal, wildcardMatch } from "./guard.js";
 import { bus } from "./bus.js";
 import { privateDocsInstruction } from "./docs.js";
 import { parseModel } from "./opencode/client.js";
@@ -17,7 +17,7 @@ import { accountChildUsage, accountUsage, emptyUsage, sessionUsage } from "./cos
 import { AGENT_UPDATES, unseenUpdates, updatesNote } from "./updates.js";
 import { cleanBuildOutputs, dailyBackup, gb, helperFolders, lastBackup, unpushedWork } from "./housekeeping.js";
 import { coordinatorTools, workerTools } from "./tools.js";
-import { changedFiles, createWorkspace, mergeWorkspace, removeWorkspace, restoreWorkspace, syncWorkspace } from "./workspaces.js";
+import { changedFiles, createWorkspace, inProjectFolder, isGitRepo, leaveWorkspace, mergeWorkspace, reattachWorkspace, removeWorkspace, restoreWorkspace, syncWorkspace } from "./workspaces.js";
 const STUCK_AFTER_MS = Number(process.env.SYMBIO_STUCK_MINUTES ?? 10) * 60_000;
 const WATCHDOG_INTERVAL_MS = 30_000;
 // Loop guard: max conversational messages between the same pair in the window (per
@@ -85,6 +85,8 @@ export class Team {
     limitNoticed = new Map(); // pair → when the human was last told
     failedModels = new Map(); // agentId → model → failedAt
     fallbackBusy = new Set();
+    /** When each agent last got a fresh session because its conversation was too large to send. */
+    oversizedAt = new Map();
     /** agentId → tool call id of an open interactive question. */
     pendingQuestion = new Map();
     /** Connection actions (SSH, git, GitHub API) and their approvals. Set at startup. */
@@ -251,6 +253,41 @@ export class Team {
             return true;
         return project.agents.some((a) => a !== except && (a.name === name || a.aliases?.includes(name)));
     }
+    /** The human chose where new helpers work; core's brief describes it, so it's told too. */
+    async setHelperWorkspace(project, mode) {
+        if ((project.helperWorkspace ?? "own") === mode)
+            return;
+        project.helperWorkspace = mode;
+        await this.store.update(project);
+        const coordinator = this.coordinator(project);
+        if (!coordinator || coordinator.status === "stopped")
+            return;
+        await this.refreshInstructions(project, coordinator).catch(() => { });
+        await this.system(project, coordinator, mode === "shared"
+            ? "Symbio: the human set this project's helpers to work in the project folder itself. New helpers work there by default " +
+                "(what they write is there at once; nothing to merge). Helpers that already have their own copy keep it: when one is idle " +
+                "and its work merged, move it with move_to_project_folder if it should share the folder too."
+            : "Symbio: the human set this project's helpers to work in their own copy (own branch) by default. Helpers already in the " +
+                "project folder stay there.", false);
+    }
+    /** The human turned the rules register on or off; every brief mentions it, and core is told. */
+    async setRulesRegister(project, on) {
+        if (!!project.rulesRegister === on)
+            return;
+        project.rulesRegister = on;
+        await this.store.update(project);
+        bus.publish({ type: "project.updated", projectId: project.id });
+        for (const agent of project.agents.filter(active))
+            await this.refreshInstructions(project, agent).catch(() => { });
+        const coordinator = this.coordinator(project);
+        if (!coordinator || coordinator.status === "stopped")
+            return;
+        await this.system(project, coordinator, on
+            ? "Symbio: the human turned on the rules register for this project. Your instructions now explain it (save_rule, list_rules…). " +
+                "Record rules as they come up in the work; if the project already has rules written down somewhere, offer the human to " +
+                "bring them into the register as a planned task."
+            : "Symbio: the human turned off the rules register for this project. Stop recording rules; what's recorded stays in the file.", false);
+    }
     /** Renames a helper. Its branch and folder keep their names; the old name keeps working. */
     async renameAgent(project, agent, newName) {
         if (agent.role === "coordinator")
@@ -356,7 +393,7 @@ export class Team {
         this.planChanged(project);
         const assets = task.assets.length ? `\nShared assets involved: ${task.assets.join(", ")} — request them before changing them.` : "";
         await this.deliver(project, coordinator, helper, "request", `Task ${task.id}: ${task.title}\n\n${task.description}${assets}${extra ? `\n\n${extra}` : ""}\n\n` +
-            `When it's done, commit your work and call update_task("${task.id}", "review", <summary>) — that is your report. ` +
+            `When it's done, ${helper.branch ? "commit your work and " : ""}call update_task("${task.id}", "review", <summary>) — that is your report. ` +
             `If you get stuck, update_task("${task.id}", "blocked", <why>).`, { protocol: true });
         return `Assigned ${task.id} to ${helper.name}.`;
     }
@@ -372,9 +409,19 @@ export class Team {
         const coordinator = this.coordinator(project);
         if (coordinator && agent.role !== "coordinator" && (status === "review" || status === "blocked")) {
             await this.deliver(project, agent, coordinator, status === "review" ? "task-review" : "task-blocked", `${task.id} "${task.title}" → ${status}${note ? `: ${note}` : ""}` +
-                (status === "review" && agent.branch ? `\nMerge with merge_work("${agent.name}") when it looks right.` : ""));
+                (status === "review"
+                    ? agent.branch
+                        ? `\nMerge with merge_work("${agent.name}") when it looks right.`
+                        : `\nIts work is already in the project folder; check it there, then mark the task done (update_task) or send it back.`
+                    : ""));
             return `${task.id} is now ${status}. The coordinator has been notified — no separate report needed.`;
         }
+        // Helpers without a branch have nothing to merge: the coordinator marking their task done
+        // is the moment a fresh session fits (what merging is for the others).
+        const helper = task.assignee ? project.agents.find((a) => a.id === task.assignee) : undefined;
+        if (agent.role === "coordinator" && status === "done" && helper && !helper.branch && helper.role !== "coordinator") {
+            await this.renewAfterTask(project, helper, "its task was done");
+        }
         return `${task.id} is now ${task.status}.`;
     }
     /** Resolves MCP callers: the token says which folder, the session says which agent. */
@@ -460,7 +507,7 @@ export class Team {
         if (!project.allowedModels.includes(model)) {
             throw new Error(`Model "${model}" is not allowed for this project. Allowed: ${project.allowedModels.join(", ")}`);
         }
-        const workspace = await createWorkspace(project, name);
+        const workspace = await createWorkspace(project, name, opts.workspace ?? project.helperWorkspace ?? "own");
         const client = this.client();
         await this.registerTools(project, workspace.directory);
         const session = await client.createSession({
@@ -494,7 +541,10 @@ export class Team {
             await this.deliver(project, coordinator, agent, "request", opts.task, { protocol: true });
         const where = workspace.branch
             ? `It works in its own copy of the project on branch ${workspace.branch} (${workspace.directory}); merge its work with merge_work.`
-            : "It works directly in the project folder (no git), so rely on shared-asset grants to avoid conflicts.";
+            : (await isGitRepo(project.directory))
+                ? "It works in the project folder itself, alongside you: what it writes is there at once, and there is nothing to merge. " +
+                    "Shared-asset grants keep it from colliding with others; it doesn't commit unless you ask."
+                : "It works directly in the project folder (no git), so rely on shared-asset grants to avoid conflicts.";
         return [`Created ${name} on ${model} and sent it the task. ${where}`, workspace.warning].filter(Boolean).join("\n");
     }
     async stopAgent(project, agent, reason) {
@@ -505,8 +555,7 @@ export class Team {
         await reg.forget(agent.id);
         this.assetsChanged(project);
         // Helpers have their own folder; the project root is shared, so leave its processes alone.
-        if (agent.directory !== project.directory)
-            await this.stopAllProcesses(agent);
+        await this.stopAllProcesses(project, agent);
         const { committed, uncommitted } = await changedFiles(agent);
         const unmerged = committed.length > 0 || uncommitted.length > 0;
         if (!unmerged)
@@ -565,7 +614,7 @@ export class Team {
      * lossy (compactions), and they inflate OpenCode's memory. The new session starts from
      * a handoff note built from what Symbio knows; the old one stays readable.
      */
-    async renewSession(project, agent, reason) {
+    async renewSession(project, agent, reason, opts = {}) {
         if (agent.status === "busy" || agent.status === "waiting" || agent.status === "stuck") {
             throw new Error(`${agent.name} is working; renew its session when it's idle.`);
         }
@@ -575,7 +624,7 @@ export class Team {
         const oldSession = agent.sessionId;
         // Count everything the old session used before leaving it.
         await this.refreshUsage(project, agent).catch(() => { });
-        const handoff = await this.handoffNote(project, agent, oldSession);
+        const handoff = await this.handoffNote(project, agent, oldSession, opts.moved);
         await this.registerTools(project, agent.directory);
         const session = await client.createSession({
             title: `${project.name} · ${agent.name}`,
@@ -603,8 +652,54 @@ export class Team {
         });
         bus.publish({ type: "project.updated", projectId: project.id });
     }
+    /**
+     * Moves a helper from its own worktree into the project folder (for pipeline-style work
+     * where each step reads the previous step's files). OpenCode ties a session to its folder,
+     * so the helper continues in a fresh session there, with the usual handoff note.
+     */
+    async moveToProjectFolder(project, agent, reason) {
+        if (agent.role === "coordinator")
+            throw new Error("core already works in the project folder.");
+        if (inProjectFolder(project, agent))
+            return `${agent.name} already works in the project folder.`;
+        if (agent.status === "stopped")
+            throw new Error(`${agent.name} is stopped; restart it first.`);
+        if (agent.status === "busy" || agent.status === "waiting" || agent.status === "stuck") {
+            throw new Error(`${agent.name} is working; move it when it's idle.`);
+        }
+        // Its processes run in the folder about to go away (and would keep files open on Windows).
+        await this.stopAllProcesses(project, agent);
+        await leaveWorkspace(project, agent);
+        const branch = agent.branch;
+        agent.directory = project.directory;
+        agent.branch = null;
+        agent.base = null;
+        agent.workSince = Date.now();
+        await this.store.update(project);
+        try {
+            await this.renewSession(project, agent, reason, { moved: true });
+        }
+        catch (err) {
+            agent.status = "error";
+            agent.problem = `It moved to the project folder but its new session couldn't start (${err.message}). Give it a fresh session to retry.`;
+            await this.store.update(project);
+            bus.publish({ type: "project.updated", projectId: project.id });
+            throw new Error(agent.problem);
+        }
+        await this.log(project, {
+            from: "symbio",
+            to: "human",
+            kind: "system",
+            text: `${agent.name} now works in the project folder (${reason}); its own copy${branch ? ` on ${branch}` : ""} was removed.`,
+        });
+        const coordinator = this.coordinator(project);
+        if (coordinator && reason !== "moved by the coordinator") {
+            await this.system(project, coordinator, `Symbio: the human moved ${agent.name} into the project folder. It now works on the project's files directly: nothing of its to merge from now on.`, false);
+        }
+        return `${agent.name} now works in the project folder, in a fresh session with a handoff note. Its own copy was removed.`;
+    }
     /** What an agent needs to carry on in a fresh session, from Symbio's own records. */
-    async handoffNote(project, agent, oldSession) {
+    async handoffNote(project, agent, oldSession, moved = false) {
         const plan = (await this.plan(project)).plan;
         const reg = await this.assets(project);
         const mine = plan.tasks.filter((t) => t.assignee === agent.id);
@@ -624,14 +719,21 @@ export class Team {
         const cut = (s, n) => (s.length > n ? `${s.slice(0, n)}…` : s);
         const parts = [
             `# Handoff: you are continuing as ${agent.name} in a fresh session`,
-            `Your previous session had grown long, so Symbio started a new one. Nothing about your role changed. ` +
+            (moved
+                ? `You now work in the project folder itself instead of your own copy, so Symbio started a new session there. ` +
+                    `Nothing else about your role changed. `
+                : `Your previous session had grown long, so Symbio started a new one. Nothing about your role changed. `) +
                 `This note is what carries over; the project's docs (AGENTS.md, docs/) hold the durable knowledge, ` +
-                `and your committed work is in your folder.`,
+                `and your work is in your folder.`,
             agent.purpose ? `**Your purpose:** ${agent.purpose}` : "",
             agent.role === "coordinator"
                 ? `**Plan:** ${plan.status}${plan.goal ? ` — ${plan.goal}` : ""}\n${plan.tasks.map((t) => `- ${t.id} [${t.status}] ${t.title}${t.assignee ? ` (${nameOf(t.assignee)})` : ""}`).join("\n")}`
                 : "",
-            agent.role !== "coordinator" && agent.branch ? `**Your folder:** ${agent.directory} (branch ${agent.branch}).` : "",
+            agent.role === "coordinator"
+                ? ""
+                : agent.branch
+                    ? `**Your folder:** ${agent.directory} (branch ${agent.branch}).`
+                    : `**Your folder:** ${agent.directory} (the project folder, shared with the team).`,
             open.length ? `**Your open tasks:**\n${open.map((t) => `- ${t.id} [${t.status}] ${t.title}\n  ${cut(t.description, 600)}`).join("\n")}` : "**Open tasks:** none right now; wait for the next one.",
             done.length ? `**Recently finished:**\n${done.map((t) => `- ${t.id} ${t.title}${lastNote(t) ? ` — ${cut(lastNote(t), 300)}` : ""}`).join("\n")}` : "",
             held.length ? `**Shared assets you hold:** ${held.join(", ")} (release them when done).` : "",
@@ -640,6 +742,17 @@ export class Team {
         ];
         return parts.filter(Boolean).join("\n\n");
     }
+    /** With "after-task" renewal, a helper with no other task under way gets a fresh session. */
+    async renewAfterTask(project, agent, reason) {
+        const plan = await this.plan(project);
+        const renew = project.renewSessions === "after-task" &&
+            agent.status === "idle" &&
+            !plan.plan.tasks.some((t) => t.assignee === agent.id && t.status !== "done" && t.status !== "todo");
+        if (!renew)
+            return false;
+        await this.renewSession(project, agent, reason).catch((err) => console.error(`[renew] ${agent.name}:`, err.message));
+        return true;
+    }
     async mergeWork(project, agent, force) {
         const { committed, uncommitted } = await changedFiles(agent);
         const reg = await this.assets(project);
@@ -663,14 +776,7 @@ export class Team {
         }
         if (completed.length)
             this.planChanged(project);
-        const renew = completed.length > 0 &&
-            project.renewSessions === "after-task" &&
-            agent.status === "idle" &&
-            !plan.plan.tasks.some((t) => t.assignee === agent.id && t.status !== "done" && t.status !== "todo");
-        if (renew) {
-            await this.renewSession(project, agent, "its task was merged").catch((err) => console.error(`[renew] ${agent.name}:`, err.message));
-        }
-        else {
+        if (!(completed.length > 0 && (await this.renewAfterTask(project, agent, "its task was merged")))) {
             await this.system(project, agent, "Symbio: your committed work was merged into the project, and your workspace now includes the latest project state.", false);
         }
         return (`${result.summary}\n${result.files.map((f) => `- ${f}`).join("\n")}` +
@@ -839,8 +945,7 @@ export class Team {
         for (const agent of project.agents) {
             if (client) {
                 await client.interrupt(agent.sessionId).catch(() => { });
-                if (agent.directory !== project.directory)
-                    await this.stopAllProcesses(agent).catch(() => { });
+                await this.stopAllProcesses(project, agent).catch(() => { });
             }
             if (agent.branch)
                 await removeWorkspace(project, agent).catch(() => { });
@@ -869,6 +974,14 @@ export class Team {
     async onPermissionAsked(project, agent, req) {
         const action = String(req.action ?? "");
         const resources = Array.isArray(req.resources) ? req.resources.map(String) : [];
+        // Image files: refused at once, with what to use instead (never a question for the human).
+        const refusal = imageReadRefusal(action, resources);
+        if (refusal) {
+            await this.client()
+                .request("POST", `/api/session/${agent.sessionId}/permission/${req.id}/reply`, { decision: "reject", message: refusal })
+                .catch(() => { });
+            return;
+        }
         // Already answered "always" for this kind of request in this project?
         const allowed = resources.length > 0 && resources.every((r) => project.allowedPatterns.some((a) => a.action === action && wildcardMatch(a.pattern, r)));
         if (allowed) {
@@ -1024,37 +1137,53 @@ export class Team {
             return;
         this.usageTimers.set(agent.id, setTimeout(() => {
             this.usageTimers.delete(agent.id);
-            void this.refreshUsage(project, agent);
+            // OpenCode may be restarting; the next burst of usage events reads the totals again.
+            this.refreshUsage(project, agent).catch(() => { });
         }, 3000));
     }
     // ---------------------------------------------------------------- processes
-    /** Background shells running in the agent's working folder. */
-    async listProcesses(agent) {
-        const shells = (await this.client().shells(agent.directory)).filter((s) => s.status === "running");
+    /**
+     * The agent's running background shells. An agent alone in its folder owns everything
+     * there; in the project folder (shared by the coordinator and shared helpers) a shell
+     * belongs to the session that started it, which OpenCode records in its metadata.
+     */
+    async ownShells(project, agent) {
+        const running = (await this.client().shells(agent.directory)).filter((s) => s.status === "running");
+        if (!inProjectFolder(project, agent))
+            return running;
+        const sessionsOf = (a) => [a.sessionId, ...(a.previousSessions ?? []).map((p) => p.sessionId), ...Object.keys(a.childSessions ?? {})];
+        const mine = new Set(sessionsOf(agent));
+        const others = new Set(project.agents.filter((a) => a.id !== agent.id).flatMap(sessionsOf));
+        return running.filter((s) => {
+            const owner = s.metadata?.sessionID;
+            if (owner)
+                return mine.has(owner) || (agent.role === "coordinator" && !others.has(owner));
+            // No owner recorded (started outside an agent session): the coordinator manages it.
+            return agent.role === "coordinator";
+        });
+    }
+    /** Background shells the agent started that are still running. */
+    async listProcesses(project, agent) {
+        const shells = await this.ownShells(project, agent);
         if (shells.length === 0)
             return "You have no background processes running.";
         return shells
             .map((s) => `- ${s.id}: ${s.command} (pid ${s.pid ?? "?"}, started ${new Date(s.time.started).toLocaleTimeString()})`)
             .join("\n");
     }
-    /** Stops one background shell — only ones started in the agent's own working folder. */
-    async stopProcess(agent, shellId) {
-        const shells = await this.client().shells(agent.directory);
-        const shell = shells.find((s) => s.id === shellId.trim());
+    /** Stops one background shell — only one the agent itself started. */
+    async stopProcess(project, agent, shellId) {
+        const shell = (await this.ownShells(project, agent)).find((s) => s.id === shellId.trim());
         if (!shell) {
-            throw new Error(`No background process "${shellId}" in your folder. Use list_processes to see yours.`);
+            throw new Error(`No running background process "${shellId}" of yours. Use list_processes to see yours.`);
         }
-        if (shell.status !== "running")
-            return `${shell.id} already ${shell.status}.`;
         await this.client().stopShell(agent.directory, shell.id);
         return `Stopped ${shell.id} (${shell.command}).`;
     }
     /** Stops every background shell an agent left running (used when the agent is stopped). */
-    async stopAllProcesses(agent) {
-        const shells = await this.client()
-            .shells(agent.directory)
-            .catch(() => []);
-        for (const s of shells.filter((s) => s.status === "running")) {
+    async stopAllProcesses(project, agent) {
+        const shells = await this.ownShells(project, agent).catch(() => []);
+        for (const s of shells) {
             await this.client()
                 .stopShell(agent.directory, s.id)
                 .catch(() => { });
@@ -1135,11 +1264,29 @@ export class Team {
     }
     /** Before starting an agent's turn: make sure its tools and private docs are in place. */
     async prepare(project, agent) {
+        await this.reattach(project, agent);
         await this.ensureTools(project, agent.directory);
         await this.syncPrivateDocs(project, agent);
     }
+    /** A helper whose folder disappeared gets it back from its branch (see reattachWorkspace). */
+    async reattach(project, agent) {
+        if (agent.status === "stopped")
+            return;
+        const recreated = await reattachWorkspace(project, agent).catch((err) => {
+            console.error(`[team] could not recreate ${agent.name}'s folder:`, err.message);
+            return false;
+        });
+        if (!recreated)
+            return;
+        const text = `${agent.name}'s folder (${agent.directory}) had disappeared; Symbio recreated it from its branch ${agent.branch}. ` +
+            "Everything it committed is there; changes it hadn't committed were in the folder and are gone.";
+        await this.log(project, { from: "symbio", to: "human", kind: "system", text });
+        await this.system(project, agent, `Symbio: ${text.replace(`${agent.name}'s folder`, "Your folder")} Check your state before continuing.`, false);
+    }
     async refreshAll() {
         for (const project of this.store.list()) {
+            for (const agent of project.agents.filter(active))
+                await this.reattach(project, agent);
             const dirs = new Set(project.agents.filter(active).map((a) => a.directory));
             for (const dir of dirs) {
                 await this.registerTools(project, dir).catch((err) => console.error(`[team] could not register tools for ${project.name} (${dir}):`, err.message));
@@ -1273,6 +1420,47 @@ export class Team {
             bus.publish({ type: "agent.stream", projectId: project.id, agentId: agent.id, event: { type: e.type, data: e.data } });
         }
     }
+    /**
+     * An agent whose conversation got too large to send continues in a fresh session (with the
+     * usual handoff note) and is told why. Once per 15 minutes: if the fresh one fails the same
+     * way, the human is told instead of looping.
+     */
+    async renewOversized(project, agent, message) {
+        const last = this.oversizedAt.get(agent.id) ?? 0;
+        if (Date.now() - last < 15 * 60_000) {
+            if (agent.problem)
+                return;
+            agent.problem = `Its conversation is too large to send, even after a fresh session (${message}).`;
+            this.setStatus(project, agent, "error");
+            await this.store.update(project);
+            bus.publish({ type: "project.updated", projectId: project.id });
+            await this.log(project, { from: "symbio", to: "human", kind: "alert", text: `${agent.name} can't continue: ${agent.problem}` });
+            return;
+        }
+        this.oversizedAt.set(agent.id, Date.now());
+        this.fallbackBusy.add(agent.id);
+        try {
+            agent.problem = null;
+            if (agent.status !== "idle")
+                this.setStatus(project, agent, "idle");
+            await this.renewSession(project, agent, "its conversation had grown too large to send");
+            await this.system(project, agent, "Symbio: your previous conversation had grown too large to send to the model (the provider said: " +
+                `"${message}"), so you continue in this fresh session; the handoff note above has what carries over. ` +
+                "Usually it's images read in full: each one stays in the conversation and is sent again every turn. " +
+                "To look at an image, read a small copy (scaled down to about 1000 px wide) or have a helper review it. " +
+                "Continue where you left off.");
+        }
+        catch (err) {
+            agent.problem = `Its conversation is too large to send (${message}), and a fresh session couldn't start: ${err.message}. Use New session in its chat.`;
+            this.setStatus(project, agent, "error");
+            await this.store.update(project);
+            bus.publish({ type: "project.updated", projectId: project.id });
+            await this.log(project, { from: "symbio", to: "human", kind: "alert", text: `${agent.name} can't continue: ${agent.problem}` });
+        }
+        finally {
+            this.fallbackBusy.delete(agent.id);
+        }
+    }
     /**
      * When an agent's model fails for provider reasons (quota, outage, timeouts),
      * switch it to the next allowed model and tell it to continue.
@@ -1285,6 +1473,15 @@ export class Team {
         const status = Number(error?.status ?? 0);
         if (/interrupt|abort|cancel/i.test(`${type} ${message}`))
             return; // our own interrupts
+        // The conversation itself is too big to send (seen with Copilot: "Timed out reading request
+        // body", after an agent read several large images). Another model won't help; a fresh session will.
+        if (status === 413 || /request body|request size|payload too large|request too large|request entity too large/i.test(message)) {
+            // Still retrying the same oversized request: stop it before moving on.
+            if (interruptFirst)
+                await this.client().interrupt(agent.sessionId).catch(() => { });
+            await this.renewOversized(project, agent, message);
+            return;
+        }
         const providerProblem = type.startsWith("provider") ||
             [401, 402, 403, 404, 408, 429].includes(status) ||
             status >= 500 ||
@@ -1301,7 +1498,8 @@ export class Team {
             if (!next) {
                 if (agent.problem)
                     return; // already reported
-                agent.problem = `Every allowed model failed recently. Last error (${agent.model}): ${message}`;
+                const problem = `Every allowed model failed recently. Last error (${agent.model}): ${message}`;
+                agent.problem = problem;
                 this.setStatus(project, agent, "error");
                 await this.store.update(project);
                 bus.publish({ type: "project.updated", projectId: project.id });
@@ -1309,7 +1507,7 @@ export class Team {
                     from: "symbio",
                     to: "human",
                     kind: "alert",
-                    text: `${agent.name} can't continue: ${agent.problem}\n\nAdd another model to the project (Models in the sidebar) — stuck agents resume automatically — or use “Retry now” once the quota resets.`,
+                    text: `${agent.name} can't continue: ${problem}\n\nAdd another model to the project (Models in the sidebar) — stuck agents resume automatically — or use “Retry now” once the quota resets.`,
                 });
                 return;
             }