symbio 0.7.1 → 0.8.0

package/CHANGELOG.md

@@ -5,6 +5,28 @@ versions follow [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.8.0]
+
+- Fixed: a multiple-choice question from an agent disappeared from its chat when another
+  agent's message arrived while it waited (only *Needs you* remained), and ten minutes later the
+  watchdog interrupted it as if it were hung. The agent now stays *waiting* until you answer, and
+  the messages wait their turn.
+- Attach files to a message: the paperclip, drag and drop onto the chat, or paste a screenshot.
+  Agents get each file's path with how to open it; the sent message shows the files. Each project
+  has a **Files** tab with everything sent (preview, open, download, resend to an agent, delete).
+- `read_document`: agents read PDFs (by pages), Word, Excel, PowerPoint and OpenDocument text a part
+  at a time. Reading PDFs with the read tool is refused like images, since it put the whole file in
+  the conversation.
+- Folders of several git repositories (e.g. `client/` and `server/` with their own remotes): the
+  New project dialog shows them and no longer offers to create a repository on top, which hid
+  their files from helpers. Each helper works in a copy of one of them (`repo` on `spawn_agent`),
+  merges go back to that repository, `git_push` / `git_pull` take `repo`, and the daily check looks
+  for unpushed work in each.
+- Projects added with an earlier version over a folder of repositories (Symbio created one on top
+  of them): after the update, core checks the project and switches it to the inner repositories on
+  its own when the outer one is Symbio's and has no remote, or asks you otherwise. Nothing on disk
+  changes, and Settings → Team switches back.
+
 ## [0.7.1]
 
 - On a Node.js older than 22, `sym` says what to install instead of Symbio crashing at start

package/README.md

@@ -27,7 +27,9 @@ Budget*, run on free models: the conversations, plan and messages were produced
 mocked.
 
 **1. Start from a folder.** Pick an empty folder for something new, or an existing one for core to
-study first. Symbio can set up version history so helpers can work side by side.
+study first. Symbio can set up version history so helpers can work side by side; a folder that
+holds several git repositories (say `client/` and `server/`) is kept as it is, and helpers work
+inside each one.
 
 ![New project dialog](docs/images/new-project.png)
 
@@ -64,6 +66,10 @@ place. Here Symbio was restarted mid-task, and it told the helper to pick up whe
   database, a spreadsheet) can be declared a *shared asset*. Agents request it from core, wait for
   the grant and release it when done. Changes to an asset an agent wasn't granted are flagged at
   merge.
+- **Attach files to a message.** Upload, drag in or paste images and documents into the chat, as in
+  other AI chats. Agents get them as files they can open (images as scaled-down copies, PDF, Word,
+  Excel and PowerPoint as text), and each project's **Files** tab keeps everything sent, to open,
+  resend or delete.
 - **Documentation you can find your way in.** core keeps the project's docs up to date, and the
   Docs tab shows them as a folder tree with search across every doc, links between docs that open
   in place, an outline of long docs, and plain-text sources (e-mails, transcripts) with line
@@ -187,7 +193,7 @@ itself. Whoever gets in controls your agents, so keep the link and code to yours
 | `~/.symbio/ui-token` | The key that unlocks the UI (it's in the link Symbio opens) |
 | `~/.symbio/logs/symbio.log` | Symbio's log when started in the background (`sym logs`); `update.log` next to it for updates |
 | `~/.symbio/updates.json` | Your update setting (automatic, tell me, off) |
-| `<project>/.symbio/` | Project state: agents, plan, message log, shared assets (git-ignored automatically) |
+| `<project>/.symbio/` | Project state: agents, plan, message log, shared assets, and the files attached in chats (`attachments/`) — git-ignored automatically |
 | `<project>/AGENTS.md`, `<project>/docs/` | Project documentation for agents (unless you chose *private*), and `docs/rules.json` if the rules register is on |
 | OpenCode's database | The conversations themselves. Every agent is an OpenCode session, so you can also open one with `opencode -s <session-id>`. |
 

package/dist/server/api.js

@@ -11,6 +11,7 @@ import { pickFolder } from "./folder-picker.js";
 import { beginOauth, cancelOauth, completeOauth, connectWithKey, listProviders, oauthStatus, removeLogin } from "./providers.js";
 import { docsRoot, listDocs, rawDoc, readDoc, searchDocs, writeDoc } from "./docs.js";
 import { readRegister } from "./rules.js";
+import { addAttachment, attachmentNote, getAttachments, listAttachments, markSent, removeAttachment } from "./attachments.js";
 import { PriceBook, projectUsage, resolvePrices } from "./costs.js";
 import { globalDir } from "./store.js";
 // Debug routes pass OpenCode responses through, which can contain provider keys.
@@ -260,7 +261,8 @@ export function createApi(store, runtime, team, connections) {
         const directory = body.directory.trim();
         await fs.mkdir(directory, { recursive: true });
         let inspection = await inspectFolder(directory);
-        if (body.initGit && !inspection.isGit) {
+        // A folder of repositories keeps them as they are: one on top would swallow them.
+        if (body.initGit && !inspection.isGit && !inspection.repos.length) {
             await initRepository(directory);
             inspection = { ...inspection, isGit: true };
         }
@@ -293,6 +295,14 @@ export function createApi(store, runtime, team, connections) {
     api.patch("/projects/:id", async (c) => {
         const project = withProject(c.req.param("id"));
         const body = await c.req.json();
+        if (typeof body.subRepositories === "boolean") {
+            try {
+                await team.useSubRepositories(project, body.subRepositories, "the human");
+            }
+            catch (err) {
+                return c.json({ error: err.message }, 400);
+            }
+        }
         if (typeof body.rulesRegister === "boolean")
             await team.setRulesRegister(project, body.rulesRegister);
         if (body.helperWorkspace === "own" || body.helperWorkspace === "shared")
@@ -624,11 +634,75 @@ export function createApi(store, runtime, team, connections) {
         const project = withProject(c.req.param("id"));
         const agent = withAgent(project, c.req.param("agentId"));
         const body = await c.req.json();
-        if (!body.text?.trim())
+        const ids = Array.isArray(body.attachments) ? body.attachments.map(String) : [];
+        if (!body.text?.trim() && !ids.length)
             return c.json({ error: "text is required" }, 400);
-        await team.sendFromHuman(project, agent, body.text.trim(), !!body.urgent);
+        let files;
+        try {
+            files = await getAttachments(project, ids);
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+        const text = (body.text?.trim() || (files.length === 1 ? "Here's a file." : "Here are some files.")) + attachmentNote(files);
+        await team.sendFromHuman(project, agent, text, !!body.urgent);
+        if (ids.length) {
+            await markSent(project, ids, agent.id);
+            bus.publish({ type: "attachments.updated", projectId: project.id });
+        }
         return c.json({ ok: true });
     });
+    // ---- attachments: files the human sends in the chat, and the project's gallery of them
+    api.get("/projects/:id/attachments", async (c) => {
+        const project = withProject(c.req.param("id"));
+        // Paths stay on the server: the browser gets names, sizes and who received each file.
+        const list = await listAttachments(project);
+        return c.json(list.map(({ file: _file, ...rest }) => rest).reverse());
+    });
+    api.post("/projects/:id/attachments", async (c) => {
+        const project = withProject(c.req.param("id"));
+        const form = await c.req.parseBody({ all: true }).catch(() => null);
+        const files = [].concat(form?.files ?? form?.file ?? []).filter((f) => f instanceof File);
+        if (!files.length)
+            return c.json({ error: "Send the files as multipart form data (field \"files\")." }, 400);
+        try {
+            const added = [];
+            for (const f of files)
+                added.push(await addAttachment(project, f.name || "pasted", new Uint8Array(await f.arrayBuffer()), f.type));
+            bus.publish({ type: "attachments.updated", projectId: project.id });
+            return c.json(added.map(({ file: _file, ...rest }) => rest));
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
+    api.get("/projects/:id/attachments/:aid/file", async (c) => {
+        const project = withProject(c.req.param("id"));
+        const [a] = await getAttachments(project, [c.req.param("aid")]).catch(() => [null]);
+        if (!a)
+            throw new HttpError(404, "attachment not found");
+        // Shown inline only for types a browser displays safely; anything else downloads.
+        const inline = /^(image\/(png|jpe?g|gif|webp|bmp)|application\/pdf|text\/plain)$/.test(a.mime);
+        return new Response(new Uint8Array(await fs.readFile(a.file)), {
+            headers: {
+                "content-type": inline ? a.mime : "application/octet-stream",
+                "content-disposition": `${inline ? "inline" : "attachment"}; filename*=UTF-8''${encodeURIComponent(a.name)}`,
+                "x-content-type-options": "nosniff",
+                "content-security-policy": "default-src 'none'; img-src 'self' blob: data:; style-src 'unsafe-inline'",
+            },
+        });
+    });
+    api.delete("/projects/:id/attachments/:aid", async (c) => {
+        const project = withProject(c.req.param("id"));
+        try {
+            await removeAttachment(project, c.req.param("aid"));
+            bus.publish({ type: "attachments.updated", projectId: project.id });
+            return c.json({ ok: true });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 404);
+        }
+    });
     api.post("/projects/:id/agents/:agentId/interrupt", async (c) => {
         const project = withProject(c.req.param("id"));
         const agent = withAgent(project, c.req.param("agentId"));

package/dist/server/attachments.js

@@ -0,0 +1,104 @@
+// Files the human attaches to messages (uploaded, dropped or pasted in the chat), kept per project
+// in .symbio/attachments (git-ignored with the rest of .symbio) with an index: the project's
+// gallery. Agents get the files' full paths in the message, so helpers in their own copies can
+// open them too; images through view_image, documents through read_document.
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+import { IMAGE_EXTENSIONS } from "./guard.js";
+import { DOCUMENT_EXTENSIONS } from "./documents.js";
+import { newId } from "./store.js";
+export const MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024;
+const dir = (project) => path.join(project.directory, ".symbio", "attachments");
+const indexFile = (project) => path.join(project.directory, ".symbio", "attachments.json");
+// One write at a time per project (several files are often dropped at once).
+const queues = new Map();
+function serial(project, fn) {
+    const run = (queues.get(project.id) ?? Promise.resolve()).then(fn);
+    queues.set(project.id, run.catch(() => { }));
+    return run;
+}
+export async function listAttachments(project) {
+    const raw = await fs.readFile(indexFile(project), "utf8").catch(() => "[]");
+    const all = JSON.parse(raw);
+    return all.filter((a) => existsSync(a.file));
+}
+async function save(project, list) {
+    await fs.mkdir(path.dirname(indexFile(project)), { recursive: true });
+    const tmp = `${indexFile(project)}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(list, null, 2));
+    await fs.rename(tmp, indexFile(project));
+}
+/** A file name safe on every OS, keeping the extension. */
+export function safeName(name) {
+    const base = path.basename(name.replace(/\\/g, "/")).normalize("NFC");
+    const cleaned = base
+        .replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_")
+        .replace(/^\.+/, "")
+        .trim()
+        .slice(-120);
+    return cleaned || "file";
+}
+export async function addAttachment(project, name, data, mime) {
+    if (data.byteLength > MAX_ATTACHMENT_BYTES)
+        throw new Error(`${name} is larger than ${MAX_ATTACHMENT_BYTES / 1024 / 1024} MB.`);
+    return serial(project, async () => {
+        const id = newId("att");
+        const clean = safeName(name);
+        // The id keeps names unique; the readable name stays visible to agents and in file managers.
+        const file = path.join(dir(project), `${id.slice(4, 12)}-${clean}`);
+        await fs.mkdir(dir(project), { recursive: true });
+        await fs.writeFile(file, data);
+        const record = { id, name: clean, mime: mime || "application/octet-stream", size: data.byteLength, file, addedAt: Date.now(), sentTo: [] };
+        const list = await listAttachments(project);
+        list.push(record);
+        await save(project, list);
+        return record;
+    });
+}
+export async function getAttachments(project, ids) {
+    const all = await listAttachments(project);
+    const found = ids.map((id) => all.find((a) => a.id === id));
+    const missing = ids.filter((_, i) => !found[i]);
+    if (missing.length)
+        throw new Error(`Attachment not found: ${missing.join(", ")}`);
+    return found;
+}
+export async function markSent(project, ids, agentId) {
+    await serial(project, async () => {
+        const list = await listAttachments(project);
+        for (const a of list)
+            if (ids.includes(a.id))
+                a.sentTo.push({ agentId, at: Date.now() });
+        await save(project, list);
+    });
+}
+export async function removeAttachment(project, id) {
+    await serial(project, async () => {
+        const list = await listAttachments(project);
+        const target = list.find((a) => a.id === id);
+        if (!target)
+            throw new Error("Attachment not found");
+        await fs.rm(target.file, { force: true });
+        await save(project, list.filter((a) => a.id !== id));
+    });
+}
+const kb = (n) => (n >= 1024 * 1024 ? `${(n / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round(n / 1024))} KB`);
+/** What the agent reads below the human's message: each file's full path and how to open it. */
+export function attachmentNote(files) {
+    if (!files.length)
+        return "";
+    const how = (a) => {
+        const ext = path.extname(a.name).slice(1).toLowerCase();
+        if (IMAGE_EXTENSIONS.includes(ext))
+            return "image: look at it with view_image";
+        if (ext === "pdf" || ["docx", "xlsx", "pptx", "odt"].includes(ext))
+            return "document: read it with read_document";
+        if (DOCUMENT_EXTENSIONS.includes(ext))
+            return "text: read it with read (or read_document for long ones)";
+        return "open it with the tools that fit its type";
+    };
+    // Seen live: without naming the tools' home, a model first tried webfetch and the read tool.
+    return (`\n\n[Attached by the human — ${files.length === 1 ? "a file" : `${files.length} files`}, saved in the project:]\n` +
+        files.map((a) => `- ${a.file} (${a.name}, ${kb(a.size)}; ${how(a)})`).join("\n") +
+        "\n(view_image and read_document are Symbio's tools: tools.symbio.view_image / tools.symbio.read_document, with the path above.)");
+}

package/dist/server/documents.js

@@ -0,0 +1,166 @@
+// read_document: the text of documents agents can't (or shouldn't) open with the read tool.
+// OpenCode's read tool puts a whole PDF into the conversation as data (sent again every turn, like
+// images) and refuses Office files as binary. This returns their text, a part at a time.
+import { existsSync, promises as fs } from "node:fs";
+import path from "node:path";
+import { strFromU8, unzipSync } from "fflate";
+import { isSecretPath } from "./guard.js";
+export const DOCUMENT_EXTENSIONS = ["pdf", "docx", "xlsx", "pptx", "odt", "txt", "md", "csv", "tsv", "json", "xml", "html", "htm"];
+const MAX_CHARS = 40_000; // per call; agents ask for the next part
+const MAX_BYTES = 100 * 1024 * 1024;
+export async function readDocument(folder, input) {
+    const given = String(input.path ?? "").trim();
+    if (!given)
+        throw new Error("Give the document's path.");
+    const file = path.resolve(folder, given);
+    const ext = path.extname(file).slice(1).toLowerCase();
+    if (!DOCUMENT_EXTENSIONS.includes(ext))
+        throw new Error(`Not a document read_document understands (${DOCUMENT_EXTENSIONS.join(", ")}): ${given}`);
+    if (isSecretPath(file))
+        throw new Error(`Not allowed: ${given}`);
+    if (!existsSync(file))
+        throw new Error(`No such file: ${file}`);
+    const stat = await fs.stat(file);
+    if (stat.size > MAX_BYTES)
+        throw new Error(`${given} is ${Math.round(stat.size / 1024 / 1024)} MB; documents up to ${MAX_BYTES / 1024 / 1024} MB can be read.`);
+    const data = await fs.readFile(file);
+    if (ext === "pdf")
+        return readPdf(given, data, String(input.pages ?? ""));
+    const from = Math.max(0, Math.floor(Number(input.from) || 0));
+    let text;
+    let unit = "";
+    if (ext === "docx")
+        text = docxText(data);
+    else if (ext === "odt")
+        text = odtText(data);
+    else if (ext === "xlsx") {
+        text = xlsxText(data);
+        unit = " (sheets as tab-separated rows)";
+    }
+    else if (ext === "pptx")
+        text = pptxText(data);
+    else
+        text = data.toString("utf8");
+    return page(given, text, from, unit);
+}
+/** A slice of a long text, with how to get the next one. */
+function page(name, text, from, unit = "") {
+    const total = text.length;
+    if (!total)
+        return `${name}: no text found${unit}.`;
+    const slice = text.slice(from, from + MAX_CHARS);
+    const end = from + slice.length;
+    const more = end < total ? `\n\n[… characters ${from + 1}–${end} of ${total}; for the next part call read_document with from=${end}]` : "";
+    return `${name}${unit}${from || more ? `, characters ${from + 1}–${end} of ${total}` : ""}:\n\n${slice}${more}`;
+}
+async function readPdf(name, data, pages) {
+    const { extractText, getDocumentProxy } = await import("unpdf");
+    const pdf = await getDocumentProxy(new Uint8Array(data));
+    const { totalPages, text } = await extractText(pdf, { mergePages: false });
+    const all = text;
+    let [first, last] = [1, totalPages];
+    const m = /^\s*(\d+)\s*(?:-\s*(\d+))?\s*$/.exec(pages);
+    if (m) {
+        first = Math.min(Math.max(1, Number(m[1])), totalPages);
+        last = Math.min(Math.max(first, Number(m[2] ?? m[1])), totalPages);
+    }
+    const out = [];
+    let used = 0;
+    let p = first;
+    for (; p <= last; p++) {
+        const t = `--- page ${p} ---\n${(all[p - 1] ?? "").trim()}`;
+        if (used + t.length > MAX_CHARS && out.length)
+            break;
+        out.push(t);
+        used += t.length;
+    }
+    const shown = p - 1;
+    const noText = all.every((t) => !t.trim());
+    const head = `${name}: ${totalPages} page${totalPages === 1 ? "" : "s"}, showing ${first}–${shown}.`;
+    if (noText)
+        return `${head} It has no text layer (probably scanned images): ask the human for a text version, or for the pages as images to look at with view_image.`;
+    const more = shown < totalPages ? `\n\n[… for more, call read_document with pages="${shown + 1}-${Math.min(totalPages, shown + 20)}"]` : "";
+    return `${head}\n\n${out.join("\n\n")}${more}`;
+}
+const unzip = (data) => unzipSync(new Uint8Array(data));
+const decode = (s) => s
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)))
+    .replace(/&amp;/g, "&");
+/** Word: paragraphs (w:p) of w:t runs; tabs and breaks kept; table cells separated by tabs. */
+function docxText(data) {
+    const files = unzip(data);
+    const xml = files["word/document.xml"] ? strFromU8(files["word/document.xml"]) : "";
+    if (!xml)
+        throw new Error("This doesn't look like a Word document (no word/document.xml).");
+    return xml
+        .replace(/<w:tab\/>/g, "\t")
+        .replace(/<w:br[^>]*\/>/g, "\n")
+        .replace(/<\/w:tc>/g, "\t")
+        .replace(/<\/w:p>/g, "\n")
+        .replace(/<[^>]+>/g, "")
+        .split("\n")
+        .map((l) => decode(l).trimEnd())
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+/** OpenDocument text: paragraphs and headings of content.xml. */
+function odtText(data) {
+    const files = unzip(data);
+    const xml = files["content.xml"] ? strFromU8(files["content.xml"]) : "";
+    if (!xml)
+        throw new Error("This doesn't look like an OpenDocument text (no content.xml).");
+    return decode(xml.replace(/<text:tab\/>/g, "\t").replace(/<\/text:(p|h)>/g, "\n").replace(/<[^>]+>/g, "")).replace(/\n{3,}/g, "\n\n").trim();
+}
+/** Excel: every sheet, by name, as tab-separated rows (shared strings, inline strings, numbers). */
+function xlsxText(data) {
+    const files = unzip(data);
+    const read = (p) => (files[p] ? strFromU8(files[p]) : "");
+    const shared = [...read("xl/sharedStrings.xml").matchAll(/<si>([\s\S]*?)<\/si>/g)].map((m) => decode(m[1].replace(/<[^>]+>/g, "")));
+    const workbook = read("xl/workbook.xml");
+    const rels = read("xl/_rels/workbook.xml.rels");
+    const target = (rid) => /Target="([^"]+)"/.exec(new RegExp(`<Relationship[^>]*Id="${rid}"[^>]*>`).exec(rels)?.[0] ?? "")?.[1];
+    const sheets = [...workbook.matchAll(/<sheet [^>]*name="([^"]*)"[^>]*r:id="([^"]+)"/g)].map((m) => ({ name: decode(m[1]), file: target(m[2]) }));
+    if (!sheets.length)
+        throw new Error("This doesn't look like an Excel workbook (no sheets found).");
+    const col = (ref) => [...(/^[A-Z]+/.exec(ref)?.[0] ?? "A")].reduce((n, c) => n * 26 + c.charCodeAt(0) - 64, 0) - 1;
+    return sheets
+        .map(({ name, file }) => {
+        const xml = file ? read(`xl/${file.replace(/^\/?xl\//, "")}`) : "";
+        const rows = [...xml.matchAll(/<row[^>]*>([\s\S]*?)<\/row>/g)].map((r) => {
+            const cells = [];
+            for (const c of r[1].matchAll(/<c ([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g)) {
+                const attrs = c[1];
+                const body = c[2] ?? "";
+                const ref = /r="([A-Z]+)\d+"/.exec(attrs)?.[1] ?? "";
+                const type = /t="([^"]+)"/.exec(attrs)?.[1];
+                const v = /<v>([\s\S]*?)<\/v>/.exec(body)?.[1];
+                const value = type === "s" ? shared[Number(v)] ?? "" : type === "inlineStr" ? decode(body.replace(/<[^>]+>/g, "")) : decode(v ?? "");
+                cells[ref ? col(ref) : cells.length] = value.replace(/\s*\n\s*/g, " ");
+            }
+            return Array.from(cells, (x) => x ?? "").join("\t").trimEnd();
+        });
+        return `## ${name}\n${rows.filter((r) => r).join("\n")}`;
+    })
+        .join("\n\n");
+}
+/** PowerPoint: the text of each slide, in order. */
+function pptxText(data) {
+    const files = unzip(data);
+    const slides = Object.keys(files)
+        .filter((f) => /^ppt\/slides\/slide\d+\.xml$/.test(f))
+        .sort((a, b) => Number(/(\d+)\.xml$/.exec(a)[1]) - Number(/(\d+)\.xml$/.exec(b)[1]));
+    if (!slides.length)
+        throw new Error("This doesn't look like a PowerPoint presentation (no slides found).");
+    return slides
+        .map((f, i) => {
+        const xml = strFromU8(files[f]);
+        const text = decode(xml.replace(/<\/a:p>/g, "\n").replace(/<[^>]+>/g, "")).replace(/\n{2,}/g, "\n").trim();
+        return `--- slide ${i + 1} ---\n${text}`;
+    })
+        .join("\n\n");
+}

package/dist/server/guard.js

@@ -107,20 +107,33 @@ const SECRET_SHELL = [
 // Patterns are case-sensitive, hence both spellings.
 export const IMAGE_EXTENSIONS = ["png", "jpg", "jpeg", "gif", "webp", "bmp"];
 const IMAGE_PATHS = IMAGE_EXTENSIONS.flatMap((ext) => [`*.${ext}`, `*.${ext.toUpperCase()}`]);
-/** A read Symbio refuses on the agent's behalf (an image file), with what to do instead. */
-export function imageReadRefusal(action, resources) {
-    if (action !== "read" || !resources.length || !resources.every((r) => IMAGE_PATHS.some((p) => wildcardMatch(p, r))))
+// PDFs the same way (the read tool attaches the whole file as data; verified with OpenCode 2.1.4):
+// agents read their text with read_document, a part at a time.
+const PDF_PATHS = ["*.pdf", "*.PDF"];
+/** A read Symbio refuses on the agent's behalf (an image or a PDF), with what to do instead. */
+export function readRefusal(action, resources) {
+    if (action !== "read" || !resources.length)
         return null;
-    return ("Symbio blocks reading image files directly: a full-size image stays in your conversation and is sent again on every " +
-        `turn. Use Symbio's view_image tool instead (in code mode: tools.symbio.view_image({ path: ${JSON.stringify(resources[0])} })); ` +
-        "it returns a scaled-down copy, and a crop shows details at full resolution.");
+    const all = (patterns) => resources.every((r) => patterns.some((p) => wildcardMatch(p, r)));
+    const file = JSON.stringify(resources[0]);
+    if (all(IMAGE_PATHS)) {
+        return ("Symbio blocks reading image files directly: a full-size image stays in your conversation and is sent again on every " +
+            `turn. Use Symbio's view_image tool instead (in code mode: tools.symbio.view_image({ path: ${file} })); ` +
+            "it returns a scaled-down copy, and a crop shows details at full resolution.");
+    }
+    if (all(PDF_PATHS)) {
+        return ("Symbio blocks reading PDFs directly: the whole file would stay in your conversation and be sent again on every turn. " +
+            `Use Symbio's read_document tool instead (in code mode: tools.symbio.read_document({ path: ${file} })); ` +
+            'it returns the text, a few pages at a time (pages: "3-8").');
+    }
+    return null;
 }
 const rules = (action, effect, patterns) => patterns.map((resource) => ({ action, resource, effect }));
 // Any matching deny blocks a call; otherwise any ask prompts. Deny rules come last
 // so they also win under "last match wins".
 export const AGENT_PERMISSIONS = [
     ...rules("shell", "ask", INSTALL_PATTERNS),
-    ...rules("read", "ask", IMAGE_PATHS), // refused by Symbio with a message (imageReadRefusal)
+    ...rules("read", "ask", [...IMAGE_PATHS, ...PDF_PATHS]), // refused by Symbio with a message (readRefusal)
     ...rules("shell", "deny", KILL_PATTERNS),
     ...rules("shell", "deny", SECRET_SHELL),
     ...rules("read", "deny", SECRET_PATHS),

package/dist/server/housekeeping.js

@@ -4,6 +4,7 @@
 import { existsSync, promises as fs } from "node:fs";
 import path from "node:path";
 import { git } from "./git.js";
+import { projectRepositoriesSync } from "./repos.js";
 import { globalDir } from "./store.js";
 // ---------------------------------------------------------------- backups
 const BACKUP_KEEP = Number(process.env.SYMBIO_BACKUP_DAYS ?? 7);
@@ -54,21 +55,38 @@ export async function lastBackup() {
 }
 /** The project's current branch and the helpers' branches, with commits that exist only here. */
 export async function unpushedWork(project) {
-    if (!existsSync(path.join(project.directory, ".git")))
+    // Several repositories: each one against its own remote, branches named "repo: branch".
+    const repos = projectRepositoriesSync(project);
+    if (!repos.length) {
+        if (existsSync(path.join(project.directory, ".git")))
+            return unpushedIn(project.directory, "");
         return { remote: null, branches: [] };
-    const remote = (await git(project.directory, "remote").catch(() => "")).split("\n")[0]?.trim() || null;
+    }
+    const remotes = new Set();
+    const branches = [];
+    for (const repo of repos) {
+        const found = await unpushedIn(path.join(project.directory, ...repo.split("/")), `${repo}: `);
+        if (!found.remote)
+            continue;
+        remotes.add(found.remote);
+        branches.push(...found.branches);
+    }
+    return { remote: remotes.size === 0 ? null : remotes.size === 1 ? [...remotes][0] : "each repository's remote", branches };
+}
+async function unpushedIn(dir, label) {
+    const remote = (await git(dir, "remote").catch(() => "")).split("\n")[0]?.trim() || null;
     if (!remote)
         return { remote: null, branches: [] };
-    const current = await git(project.directory, "rev-parse", "--abbrev-ref", "HEAD").catch(() => "");
-    const helpers = (await git(project.directory, "branch", "--list", "symbio/*", "--format=%(refname:short)").catch(() => ""))
+    const current = await git(dir, "rev-parse", "--abbrev-ref", "HEAD").catch(() => "");
+    const helpers = (await git(dir, "branch", "--list", "symbio/*", "--format=%(refname:short)").catch(() => ""))
         .split("\n")
         .map((b) => b.trim())
         .filter(Boolean);
     const branches = [];
     for (const branch of [...new Set([current, ...helpers].filter((b) => b && b !== "HEAD"))]) {
-        const commits = Number(await git(project.directory, "rev-list", "--count", branch, "--not", "--remotes").catch(() => "0")) || 0;
+        const commits = Number(await git(dir, "rev-list", "--count", branch, "--not", "--remotes").catch(() => "0")) || 0;
         if (commits > 0)
-            branches.push({ branch, commits, latest: await git(project.directory, "log", "-1", "--format=%s", branch).catch(() => "") });
+            branches.push({ branch: label + branch, commits, latest: await git(dir, "log", "-1", "--format=%s", branch).catch(() => "") });
     }
     return { remote, branches };
 }

package/dist/server/inspect.js

@@ -2,6 +2,7 @@
 // content does it hold, and does it already have guidance for agents/humans.
 import { promises as fs, existsSync } from "node:fs";
 import path from "node:path";
+import { findRepositories, swallowedRepositories } from "./repos.js";
 const KIND_BY_EXT = {};
 const add = (kind, exts) => exts.split(" ").forEach((e) => (KIND_BY_EXT[e] = kind));
 add("documents", ".md .markdown .txt .doc .docx .odt .rtf .pdf .tex .rst .adoc .epub .pages");
@@ -41,6 +42,7 @@ export async function inspectFolder(input) {
         exists: false,
         empty: true,
         isGit: false,
+        repos: [],
         fileCount: 0,
         totalBytes: 0,
         truncated: false,
@@ -54,6 +56,13 @@ export async function inspectFolder(input) {
         return result;
     result.exists = true;
     result.isGit = existsSync(path.join(directory, ".git"));
+    if (!result.isGit)
+        result.repos = await findRepositories(directory);
+    else {
+        const swallowed = await swallowedRepositories(directory);
+        if (swallowed.inner.length)
+            result.swallowed = swallowed;
+    }
     const top = await fs.readdir(directory, { withFileTypes: true }).catch(() => []);
     const visibleTop = top.filter((e) => e.name !== ".symbio");
     result.empty = visibleTop.length === 0;
@@ -121,7 +130,11 @@ export function describeInspection(i) {
         `Most common extensions: ${i.topExtensions.map((e) => `${e.ext} (${e.count})`).join(", ") || "none"}.`,
         `Top level: ${i.topLevel.join(", ")}.`,
         i.guidance.length ? `Existing guidance: ${i.guidance.join(", ")}.` : "No README, AGENTS.md or docs folder.",
-        i.isGit ? "It is a git repository." : "It is not a git repository.",
+        i.isGit
+            ? "It is a git repository."
+            : i.repos.length
+                ? `It is not a git repository itself; it holds ${i.repos.length} git repositories: ${i.repos.join(", ")}.`
+                : "It is not a git repository.",
     ];
     return lines.join("\n");
 }