symbio 0.4.0 → 0.6.0

package/dist/server/remote.js

@@ -1,7 +1,7 @@
 // Actions agents take through connections (SSH commands and uploads, git push/pull,
-// GitHub API). Symbio runs them itself with credentials from the vault — agents
-// only see results. Connections set to "ask" queue an approval for the human; the
-// result is delivered to the agent as a message once approved.
+// GitHub and Azure DevOps APIs). Symbio runs them itself with credentials from the
+// vault — agents only see results. Connections set to "ask" queue an approval for
+// the human; the result is delivered to the agent as a message once approved.
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { promises as fs, existsSync, realpathSync } from "node:fs";
@@ -28,13 +28,16 @@ export class RemoteOps {
     }
     describeFor(project) {
         const list = this.enabled(project);
-        if (list.length === 0)
-            return "This project has no connections. If the work needs GitHub or a server, tell the human to add one in the project's sidebar (Connections).";
+        if (list.length === 0) {
+            return "This project has no connections. If the work needs GitHub, Azure DevOps or a server, tell the human to add one in the project's Settings (Connections).";
+        }
         return list
             .map(({ conn, link }) => {
             const what = conn.type === "github"
                 ? `GitHub${conn.account ? ` account ${conn.account}` : ""} — git_push, git_pull, github_api`
-                : `server ${conn.username}@${conn.host} — remote_exec, remote_upload`;
+                : conn.type === "azure"
+                    ? `Azure DevOps organization ${conn.organization}${conn.account ? ` (as ${conn.account})` : ""} — git_push, git_pull, azure_devops_api`
+                    : `server ${conn.username}@${conn.host} — remote_exec, remote_upload`;
             return `- "${conn.name}": ${what} (${link.policy === "ask" ? "each action needs the human's approval" : "allowed without approval"})`;
         })
             .join("\n");
@@ -43,7 +46,7 @@ export class RemoteOps {
     async request(project, agent, action, reason) {
         const { conn, link } = this.resolve(project, action.connectionId, action.kind);
         const summary = this.summarize(conn, action, agent);
-        const readOnly = action.kind === "github_api" && action.method.toUpperCase() === "GET";
+        const readOnly = (action.kind === "github_api" || action.kind === "azure_devops_api") && action.method.toUpperCase() === "GET";
         if (link.policy === "allow" || readOnly) {
             return this.execute(project, agent, conn, action, summary, reason);
         }
@@ -106,9 +109,17 @@ export class RemoteOps {
             const names = this.enabled(project).map(({ conn }) => conn.name).join(", ") || "none";
             throw new Error(`No connection "${connectionRef}" in this project. Available: ${names}.`);
         }
-        const needs = kind.startsWith("remote_") ? "server" : "github";
-        if (found.conn.type !== needs)
-            throw new Error(`"${found.conn.name}" is a ${found.conn.type} connection; ${kind} needs a ${needs} connection.`);
+        const needs = kind.startsWith("remote_")
+            ? ["server"]
+            : kind === "github_api"
+                ? ["github"]
+                : kind === "azure_devops_api"
+                    ? ["azure"]
+                    : ["github", "azure"]; // git_push / git_pull
+        if (!needs.includes(found.conn.type)) {
+            const label = (t) => (t === "azure" ? "Azure DevOps" : t === "github" ? "GitHub" : "server");
+            throw new Error(`"${found.conn.name}" is a ${label(found.conn.type)} connection; ${kind} needs a ${needs.map(label).join(" or ")} connection.`);
+        }
         return found;
     }
     summarize(conn, a, agent) {
@@ -123,6 +134,8 @@ export class RemoteOps {
                 return `git pull ${a.remote ?? "origin"} ${a.branch ?? "(current branch)"} into ${agent.name}'s workspace using ${conn.name}`;
             case "github_api":
                 return `GitHub API ${a.method.toUpperCase()} ${a.path} using ${conn.name}`;
+            case "azure_devops_api":
+                return `Azure DevOps API ${a.method.toUpperCase()} ${a.path} using ${conn.name}`;
         }
     }
     async execute(project, agent, conn, a, summary, reason) {
@@ -163,12 +176,11 @@ export class RemoteOps {
             }
             case "git_push":
             case "git_pull": {
-                const token = await this.connections.githubToken(conn);
+                const gitConn = conn;
+                const token = await this.connections.githubToken(gitConn);
                 const remote = a.remote ?? "origin";
                 const url = remote.startsWith("https://") ? remote : await gitOut(agent.directory, ["remote", "get-url", remote]);
-                if (!/^https:\/\/github\.com\//i.test(url)) {
-                    throw new Error(`The remote must be a GitHub HTTPS URL (got ${url || "nothing"}). Add one with: git remote add origin https://github.com/<owner>/<repo>.git`);
-                }
+                const auth = gitAuth(gitConn, url, token);
                 const branch = a.branch ?? (await gitOut(agent.directory, ["rev-parse", "--abbrev-ref", "HEAD"]));
                 // The agent controls this repository, so its config and hooks are untrusted: a hook
                 // would see the token, a proxy or URL rewrite would send it elsewhere.
@@ -177,7 +189,7 @@ export class RemoteOps {
                 const safe = ["-c", `core.hooksPath=${noHooks}`, "-c", "http.proxy=", "-c", "http.sslVerify=true", "-c", "credential.helper="];
                 // The token goes in an HTTP header via environment-only git config: never in
                 // the command line, the repo config or the agent's view.
-                const header = `Authorization: Basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}`;
+                const { headerKey, header } = auth;
                 const git = (args, withToken) => run("git", [...safe, ...args], {
                     cwd: agent.directory,
                     windowsHide: true,
@@ -185,9 +197,7 @@ export class RemoteOps {
                     env: {
                         ...process.env,
                         GIT_TERMINAL_PROMPT: "0",
-                        ...(withToken
-                            ? { GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: "http.https://github.com/.extraheader", GIT_CONFIG_VALUE_0: header }
-                            : {}),
+                        ...(withToken ? { GIT_CONFIG_COUNT: "1", GIT_CONFIG_KEY_0: headerKey, GIT_CONFIG_VALUE_0: header } : {}),
                     },
                 }).catch((err) => {
                     throw new Error(scrub(String(err.stderr || err.message), token));
@@ -201,8 +211,11 @@ export class RemoteOps {
                 const merged = await git(["merge", "--no-edit", "FETCH_HEAD"], false);
                 return scrub(`${fetched.stdout}${fetched.stderr}${merged.stdout}${merged.stderr}`.trim() || "done", token);
             }
-            case "github_api": {
-                const data = await this.connections.githubRequest(conn, a.method.toUpperCase(), a.path, a.body);
+            case "github_api":
+            case "azure_devops_api": {
+                const data = a.kind === "github_api"
+                    ? await this.connections.githubRequest(conn, a.method.toUpperCase(), a.path, a.body)
+                    : await this.connections.azureRequest(conn, a.method.toUpperCase(), a.path, a.body);
                 const text = JSON.stringify(data, null, 2) ?? "(no content)";
                 return text.length > 20_000 ? `${text.slice(0, 20_000)}\n… (truncated)` : text;
             }
@@ -258,7 +271,7 @@ export async function refuseRiskyGitConfig(dir) {
         .filter(([scope, key]) => (scope === "local" || scope === "worktree") && key && RISKY_GIT_CONFIG.some((re) => re.test(key.toLowerCase())))
         .map(([, key]) => key);
     if (risky.length) {
-        throw new Error(`Refusing to use GitHub credentials: this repository's git config sets ${risky.join(", ")}, which could redirect or capture them. Remove ${risky.length > 1 ? "these settings" : "it"} (git config --unset <name>) and try again.`);
+        throw new Error(`Refusing to use the connection's credentials: this repository's git config sets ${risky.join(", ")}, which could redirect or capture them. Remove ${risky.length > 1 ? "these settings" : "it"} (git config --unset <name>) and try again.`);
     }
 }
 async function gitOut(cwd, args) {
@@ -266,6 +279,35 @@ async function gitOut(cwd, args) {
     return stdout.trim();
 }
 function scrub(text, secret) {
-    const b64 = Buffer.from(`x-access-token:${secret}`).toString("base64");
-    return text.split(secret).join("***").split(b64).join("***");
+    let out = text.split(secret).join("***");
+    for (const user of ["x-access-token:", ":"])
+        out = out.split(Buffer.from(`${user}${secret}`).toString("base64")).join("***");
+    return out;
+}
+/**
+ * How to send a connection's token to a git remote, after checking the remote belongs to it:
+ * a GitHub HTTPS URL for GitHub; for Azure DevOps, a dev.azure.com (or older visualstudio.com)
+ * URL of the connection's own organization, so its token never goes to someone else's.
+ */
+export function gitAuth(conn, url, token) {
+    if (conn.type === "github") {
+        if (!/^https:\/\/github\.com\//i.test(url)) {
+            throw new Error(`The remote must be a GitHub HTTPS URL (got ${url || "nothing"}). Add one with: git remote add origin https://github.com/<owner>/<repo>.git`);
+        }
+        return { headerKey: "http.https://github.com/.extraheader", header: `Authorization: Basic ${Buffer.from(`x-access-token:${token}`).toString("base64")}` };
+    }
+    const devAzure = /^https:\/\/(?:[^@/]+@)?dev\.azure\.com\/([^/]+)\//i.exec(url);
+    const legacy = /^https:\/\/(?:[^@/]+@)?([^./]+)\.visualstudio\.com\//i.exec(url);
+    if (!devAzure && !legacy) {
+        throw new Error(`The remote must be an Azure DevOps HTTPS URL (got ${url || "nothing"}). ` +
+            (/^git@|^ssh:/i.test(url)
+                ? "It's an SSH remote; switch it to HTTPS: git remote set-url origin https://dev.azure.com/<organization>/<project>/_git/<repository>"
+                : "Add one with: git remote add origin https://dev.azure.com/<organization>/<project>/_git/<repository>"));
+    }
+    const org = decodeURIComponent((devAzure ?? legacy)[1]);
+    if (org.toLowerCase() !== conn.organization.toLowerCase()) {
+        throw new Error(`This remote belongs to the Azure DevOps organization "${org}", but "${conn.name}" is for "${conn.organization}". Use a connection for "${org}".`);
+    }
+    const host = devAzure ? "https://dev.azure.com/" : `https://${legacy[1]}.visualstudio.com/`;
+    return { headerKey: `http.${host}.extraheader`, header: `Authorization: Basic ${Buffer.from(`:${token}`).toString("base64")}` };
 }

package/dist/server/rules.js

@@ -0,0 +1,191 @@
+// Rules register: the project's rules, each with where it came from and how it's met. Kept as
+// JSON next to the project docs so the Docs tab can show it as a filterable index. Agents change
+// it only through Symbio's tools (validated, stable ids), never by editing the file.
+//
+// Domain-neutral on purpose: a "rule" is anything the project must respect (a requirement, a
+// decision, a style rule, a constraint), whatever the project is about.
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+import { docsRoot } from "./docs.js";
+export const CONFIRMATIONS = ["found", "checked-by-agent", "checked-by-human", "contested"];
+export const STATUSES = ["done", "partial", "missing", "not-applicable"];
+const empty = () => ({ areas: [], sources: [], authorities: [], rules: [] });
+export function registerPath(project) {
+    return path.join(docsRoot(project), project.docsLocation === "private" ? "rules.json" : path.join("docs", "rules.json"));
+}
+export async function readRegister(project) {
+    const file = registerPath(project);
+    if (!existsSync(file))
+        return empty();
+    const data = JSON.parse(await fs.readFile(file, "utf8"));
+    return { areas: data.areas ?? [], sources: data.sources ?? [], authorities: data.authorities ?? [], rules: data.rules ?? [] };
+}
+// Several agents may write at once: one write at a time per file.
+const queues = new Map();
+async function change(project, fn) {
+    const file = registerPath(project);
+    const run = (queues.get(file) ?? Promise.resolve()).then(async () => {
+        const reg = await readRegister(project);
+        const result = fn(reg);
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        const tmp = `${file}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(reg, null, 2) + "\n");
+        await fs.rename(tmp, file);
+        return result;
+    });
+    queues.set(file, run.catch(() => { }));
+    return run;
+}
+const CODE = /^[A-Za-z0-9][A-Za-z0-9_.]{0,15}$/;
+function code(value, what) {
+    const s = String(value ?? "").trim();
+    if (!CODE.test(s))
+        throw new Error(`${what} must be a short code (letters, digits, dots; up to 16), e.g. "AP" or "MA".`);
+    return s;
+}
+const text = (value) => (value === undefined || value === null ? undefined : String(value).trim() || undefined);
+export async function saveArea(project, input) {
+    const id = code(input.id, "The area id").toUpperCase();
+    const name = text(input.name);
+    if (!name)
+        throw new Error("Give the area a name.");
+    const stages = Array.isArray(input.stages)
+        ? input.stages.map((s, i) => {
+            const stageName = text(s?.name ?? s);
+            if (!stageName)
+                throw new Error(`Stage ${i + 1} needs a name.`);
+            return { id: text(s?.id) ?? String.fromCharCode(65 + i), name: stageName };
+        })
+        : undefined;
+    return change(project, (reg) => {
+        if (reg.sources.some((s) => s.id === id))
+            throw new Error(`"${id}" is already a source code; an area prefix must differ from every source code.`);
+        const existing = reg.areas.find((a) => a.id === id);
+        const area = { id, name, group: text(input.group), description: text(input.description), stages: stages ?? existing?.stages ?? [] };
+        if (existing)
+            Object.assign(existing, area);
+        else
+            reg.areas.push(area);
+        return `${existing ? "Updated" : "Added"} area ${id} "${name}"${area.stages.length ? ` with stages ${area.stages.map((s) => `${s.id}. ${s.name}`).join("; ")}` : ""}.`;
+    });
+}
+export async function saveSource(project, input) {
+    const id = code(input.id, "The source id");
+    const name = text(input.name);
+    if (!name)
+        throw new Error("Give the source a name.");
+    const authority = input.authority === undefined || input.authority === "" ? undefined : code(input.authority, "The authority");
+    return change(project, (reg) => {
+        if (reg.areas.some((a) => a.id === id))
+            throw new Error(`"${id}" is already an area prefix; a source code must differ from every area prefix.`);
+        const source = { id, name, file: text(input.file)?.replace(/\\/g, "/"), authority };
+        const existing = reg.sources.find((s) => s.id === id);
+        if (existing)
+            Object.assign(existing, source);
+        else
+            reg.sources.push(source);
+        const authorityName = text(input.authority_name);
+        if (authority && authorityName) {
+            const known = reg.authorities.find((a) => a.id === authority);
+            if (known)
+                known.name = authorityName;
+            else
+                reg.authorities.push({ id: authority, name: authorityName });
+        }
+        return `${existing ? "Updated" : "Added"} source ${id} "${name}".`;
+    });
+}
+/** Creates a rule (id assigned in its area) or updates one; only the given fields change. */
+export async function saveRule(project, input, by) {
+    return change(project, (reg) => {
+        const id = text(input.id)?.toUpperCase();
+        const existing = id ? reg.rules.find((r) => r.id === id) : undefined;
+        if (id && !existing)
+            throw new Error(`No rule ${id}. Leave id out to add a new rule (Symbio assigns the next id in its area).`);
+        const areaId = text(input.area)?.toUpperCase() ?? existing?.area;
+        const area = reg.areas.find((a) => a.id === areaId);
+        if (!area) {
+            throw new Error(areaId
+                ? `No area ${areaId}. Define it first with save_rule_area.${reg.areas.length ? ` Areas: ${reg.areas.map((a) => a.id).join(", ")}.` : ""}`
+                : "Say which area the rule belongs to (area).");
+        }
+        const stage = input.stage === undefined ? existing?.stage : text(input.stage);
+        if (stage && !area.stages.some((s) => s.id === stage)) {
+            throw new Error(`Area ${area.id} has no stage "${stage}". Stages: ${area.stages.map((s) => s.id).join(", ") || "none (define them with save_rule_area)"}.`);
+        }
+        const ruleText = input.text === undefined ? existing?.text : text(input.text);
+        if (!ruleText)
+            throw new Error("Say what the rule is (text).");
+        const confirmation = (input.confirmation ?? existing?.confirmation ?? "found");
+        if (!CONFIRMATIONS.includes(confirmation))
+            throw new Error(`confirmation must be one of: ${CONFIRMATIONS.join(", ")}.`);
+        const status = (input.status ?? existing?.status ?? "missing");
+        if (!STATUSES.includes(status))
+            throw new Error(`status must be one of: ${STATUSES.join(", ")}.`);
+        let citations = existing?.citations ?? [];
+        if (input.citations !== undefined) {
+            if (!Array.isArray(input.citations))
+                throw new Error("citations must be a list of {source, location, excerpt}.");
+            citations = input.citations.map((c) => {
+                const source = code(c?.source, "A citation's source");
+                if (!reg.sources.some((s) => s.id === source))
+                    throw new Error(`Unknown source "${source}". Define it first with save_rule_source.`);
+                return { source, location: text(c?.location), excerpt: text(c?.excerpt) };
+            });
+        }
+        const imposedBy = input.imposed_by === undefined ? existing?.imposedBy : text(input.imposed_by);
+        const supersededBy = input.superseded_by === undefined ? existing?.supersededBy : text(input.superseded_by)?.toUpperCase();
+        if (supersededBy && !reg.rules.some((r) => r.id === supersededBy))
+            throw new Error(`No rule ${supersededBy} to supersede this one.`);
+        const rule = {
+            id: existing?.id ?? nextId(reg, area.id),
+            area: area.id,
+            stage,
+            text: ruleText,
+            action: input.action === undefined ? existing?.action : text(input.action),
+            citations,
+            imposedBy,
+            confirmation,
+            status,
+            current: input.current === undefined ? existing?.current : text(input.current),
+            check: input.check === undefined ? existing?.check : text(input.check),
+            supersededBy,
+            updatedAt: Date.now(),
+            updatedBy: by,
+        };
+        if (existing)
+            Object.assign(existing, rule);
+        else
+            reg.rules.push(rule);
+        const unsourced = rule.citations.length === 0 ? " It has no source yet: add one when you find it." : "";
+        return `${existing ? "Updated" : "Added"} ${rule.id}.${unsourced}`;
+    });
+}
+/** Numbers are never reused: the next one is above every number the area ever had. */
+function nextId(reg, area) {
+    const used = reg.rules.filter((r) => r.id.startsWith(`${area}-`)).map((r) => Number(r.id.slice(area.length + 1)) || 0);
+    return `${area}-${String(Math.max(0, ...used) + 1).padStart(3, "0")}`;
+}
+/** A compact listing for agents. */
+export async function listRules(project, filter) {
+    const reg = await readRegister(project);
+    const q = text(filter.query)?.toLowerCase();
+    const area = text(filter.area)?.toUpperCase();
+    const status = text(filter.status);
+    const rules = reg.rules.filter((r) => (!area || r.area === area) &&
+        (!status || r.status === status) &&
+        (!q || [r.id, r.text, r.current, r.action, ...r.citations.map((c) => `${c.source} ${c.location ?? ""} ${c.excerpt ?? ""}`)].some((s) => s?.toLowerCase().includes(q))));
+    const head = [
+        `Areas: ${reg.areas.map((a) => `${a.id} (${a.name}${a.stages.length ? `; stages ${a.stages.map((s) => `${s.id}. ${s.name}`).join(", ")}` : ""})`).join(" · ") || "none yet"}`,
+        `Sources: ${reg.sources.map((s) => `${s.id} = ${s.name}${s.file ? ` [${s.file}]` : ""}`).join(" · ") || "none yet"}`,
+    ];
+    if (!rules.length)
+        return [...head, reg.rules.length ? "No rules match." : "No rules yet."].join("\n");
+    const shown = rules.slice(0, 200);
+    return [
+        ...head,
+        `${rules.length} rule(s)${rules.length > shown.length ? ` (first ${shown.length}; narrow the filter for the rest)` : ""}:`,
+        ...shown.map((r) => `- ${r.id}${r.stage ? ` [${r.stage}]` : ""} ${r.status}/${r.confirmation}${r.supersededBy ? ` superseded by ${r.supersededBy}` : ""}: ${r.text.replace(/\s+/g, " ").slice(0, 220)}` +
+            (r.citations.length ? ` — ${r.citations.map((c) => `${c.source}${c.location ? ` ${c.location}` : ""}`).join(", ")}` : " — no source")),
+    ].join("\n");
+}

package/dist/server/store.js

@@ -84,6 +84,7 @@ export class Store {
                 allowedModels: input.allowedModels,
                 coordinatorModel: input.coordinatorModel,
                 docsLocation: input.docsLocation,
+                rulesRegister: input.rulesRegister,
                 origin: input.origin,
                 inspectionSummary: input.inspectionSummary,
                 kickedOff: false,
@@ -93,6 +94,10 @@ export class Store {
                 createdAt: Date.now(),
             };
         project.directory = directory;
+        // A reopened project keeps its history and team, but takes the options just chosen in the
+        // dialog that have no history behind them.
+        if (onDisk && input.rulesRegister !== undefined)
+            project.rulesRegister = input.rulesRegister;
         this.projects.set(project.id, project);
         await this.saveProject(project);
         await this.saveGlobal();

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, inProjectFolder, isGitRepo, leaveWorkspace, 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. */
@@ -268,6 +270,24 @@ export class Team {
             : "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")
@@ -954,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) {
@@ -1236,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));
@@ -1374,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.
@@ -1386,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 ||