symbio 0.3.0-beta.2 → 0.4.0

package/CHANGELOG.md

@@ -5,6 +5,21 @@ versions follow [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.4.0]
+
+- Helpers can work in the project folder itself instead of their own copy on a branch: what one
+  writes, the next sees at once, with nothing to merge (for pipelines and step-by-step work).
+  Settings → Team sets the default for new helpers; core can choose per helper; existing helpers
+  can be moved into the project folder from their chat (or by core) once their work is merged.
+- Background processes belong to the agent that started them: in a shared folder, agents only
+  see and stop their own, and stopping a helper stops only its processes.
+- Agents are told that OpenCode's "tool catalog changed" notices don't list Symbio's tools, so they
+  keep using them instead of reporting them missing.
+- update_task accepts summary as well as note, so review notes aren't lost.
+- Symbio no longer crashes when OpenCode is restarted (to free memory) while it was reading usage;
+  errors in background work are logged instead of stopping the app.
+- Long chats: asking for a 200-message page no longer fails.
+
 ## [0.3.0]
 
 - Remote access: `sym remote` (or Settings → Remote access) opens a temporary Cloudflare link with an

package/README.md

@@ -55,7 +55,8 @@ place. Here Symbio was restarted mid-task, and it told the helper to pick up whe
 - **One conversation, a whole team.** You chat with core. It asks what you want, studies an
   existing folder before touching it, and proposes a plan of tasks for you to approve.
 - **Helpers that work in parallel without collisions.** Each helper gets its own git worktree and
-  branch. core reviews and merges their work. Helpers are only created when work can really run in
+  branch, and core reviews and merges their work. For step-by-step work (each step using the
+  previous one's files), helpers can share the project folder instead, with nothing to merge. Helpers are only created when work can really run in
   parallel; one helper is the default.
 - **Agents talk to each other.** Messages go straight from agent to agent through Symbio, and
   delivering a message wakes the recipient. No copy-pasting between terminals.
@@ -147,7 +148,7 @@ itself. Whoever gets in controls your agents, so keep the link and code to yours
 | Term | Meaning |
 |---|---|
 | **core** | The project's lead agent. It plans, delegates, reviews and merges; it coordinates rather than doing the work itself. |
-| **Helper** | An agent core creates for a piece of work. It works in its own git worktree (branch `symbio/<name>`). |
+| **Helper** | An agent core creates for a piece of work. It works in its own git worktree (branch `symbio/<name>`) or, if the project is set to, in the project folder itself. |
 | **Shared asset** | Something more than one agent could change. Access goes through core: request, grant, release. |
 | **Connection** | A GitHub account or SSH server agents can use through Symbio, without ever seeing its credentials. |
 | **Allowed models** | The models a project's agents may run on. If one fails, agents fall back to the next. |

package/dist/server/api.js

@@ -291,6 +291,8 @@ 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 (body.helperWorkspace === "own" || body.helperWorkspace === "shared")
+            await team.setHelperWorkspace(project, body.helperWorkspace);
         if (body.name?.trim())
             project.name = body.name.trim();
         if (body.renewSessions === "manual" || body.renewSessions === "after-task")
@@ -501,6 +503,18 @@ export function createApi(store, runtime, team, connections) {
             return c.json({ error: err.message }, 400);
         }
     });
+    // Moves a helper from its own copy (branch) into the project folder.
+    api.post("/projects/:id/agents/:agentId/move-to-project-folder", async (c) => {
+        const project = withProject(c.req.param("id"));
+        const agent = withAgent(project, c.req.param("agentId"));
+        try {
+            await team.moveToProjectFolder(project, agent, "moved by the human");
+            return c.json(project);
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
     // A fresh session for a long-running agent (keeps its identity; the old session stays readable).
     api.post("/projects/:id/agents/:agentId/renew", async (c) => {
         const project = withProject(c.req.param("id"));

package/dist/server/index.js

@@ -16,6 +16,9 @@ import { OpencodeRuntime } from "./opencode/runtime.js";
 import { Store, globalDir } from "./store.js";
 import { Team } from "./team.js";
 import { removeOrphanWorkspaces } from "./workspaces.js";
+// Background work (timers, event handlers) must never take the whole app down: an error there
+// (e.g. OpenCode restarting mid-call) is logged and the next tick tries again.
+process.on("unhandledRejection", (err) => console.error("[unhandled]", err instanceof Error ? err.stack ?? err.message : err));
 const PORT = Number(process.env.SYMBIO_PORT ?? 4310);
 const here = path.dirname(fileURLToPath(import.meta.url));
 // dist/server/index.js → dist/web ; src/server/index.ts → dist/web (after a build)

package/dist/server/opencode/client.js

@@ -101,6 +101,7 @@ export class OpencodeClient {
      * "older than id" (verified against 2.1.4, see docs/opencode-api.md).
      */
     async messagePage(sessionId, limit, before) {
+        limit = Math.min(limit, 199); // OpenCode refuses more than 200, and we ask for one extra
         const params = new URLSearchParams({ limit: String(limit + 1) }); // one extra tells whether more exist
         if (before)
             params.set("cursor", Buffer.from(JSON.stringify({ id: before, order: "desc", direction: "next" })).toString("base64url"));

package/dist/server/prompts.js

@@ -1,7 +1,18 @@
 // Briefings injected into agent sessions as instruction entries.
 // Keep these domain-neutral: projects can be software, writing, research, design, anything.
+import { existsSync } from "node:fs";
+import path from "node:path";
 import { docsPaths } from "./docs.js";
 import { PROCESS_RULES } from "./guard.js";
+// OpenCode's code mode posts "tool catalog changed" notices that list only its own tools and
+// say the catalog is complete; Symbio's tools still work (seen live: a coordinator kept using
+// them after such a notice, another gave up without trying).
+const FINDING_TOOLS = `These tools come from the "symbio" tool server. In OpenCode's code mode you call
+them inside \`execute\` as \`tools.symbio.<name>(…)\`, and \`search({ namespace: "symbio" })\`
+finds them. OpenCode's tool catalog notices may list only its own tools, even
+when they say the catalog is complete: Symbio's tools are still there. Never
+conclude they are gone without calling one; if a call really fails, tell the
+human what the error said.`;
 export function coordinatorBrief(project, connections = "") {
     return `# You are "core", the coordinator of a Symbio project
 
@@ -71,17 +82,20 @@ ${docsSection(project)}
   marks its tasks in review as done.
 - \`spawn_agent\` — create a helper agent with a name, a purpose, its first task
   (\`task_id\` from the plan, or a description) and optionally a model. ${project.allowedModels.length > 1 ? "Pick cheaper models for simpler work. " : ""}Allowed models: ${project.allowedModels.join(", ")}.
-  In a git project each helper works in its own isolated copy (its own branch);
-  it only sees **committed** files, so commit before spawning if it needs recent
-  changes.
+${helperFolders(project)}
 - \`send_message\` — message an agent. Delivering a message wakes the recipient.
 - \`list_team\` — who exists, what they do, whether they are working.
-- \`merge_work\` — bring a helper's committed work into the project. Merges are
-  checked against shared-asset grants; ungranted changes are reported to you.
+- \`merge_work\` — bring a helper's committed work into the project (helpers with
+  their own copy). Merges are checked against shared-asset grants; ungranted
+  changes are reported to you.
+- \`move_to_project_folder\` — move an idle helper from its own copy into the
+  project folder (after its work is merged); it continues in a fresh session.
 - \`stop_agent\` — stop a helper when its area of the project is finished for good.
 - \`declare_asset\`, \`grant_asset\`, \`deny_asset\`, \`list_assets\` — the shared-asset register.
 - \`ask_human\` — reach the human when you are not in a direct conversation.
 
+${FINDING_TOOLS}
+
 Team members are created with \`spawn_agent\` only. OpenCode's built-in subagent
 tool is fine for quick, read-only lookups, but never use it to do project work:
 Symbio can't see, coordinate or merge what built-in subagents do.
@@ -121,6 +135,22 @@ ${connectionsSection(connections)}
 ${PROCESS_RULES}
 `;
 }
+/** Where helpers work, for the coordinator's tool list. */
+function helperFolders(project) {
+    if (!existsSync(path.join(project.directory, ".git"))) {
+        return "  Helpers work directly in the project folder, alongside you.";
+    }
+    const def = project.helperWorkspace === "shared" ? "shared" : "own";
+    return `  Where a helper works (\`workspace\`; this project's default is **${def}**, set by
+  the human):
+  - **own**: its own isolated copy on its own branch. It only sees **committed**
+    files (commit before spawning if it needs recent changes), and its work
+    reaches the project when you merge it. For parallel work on the same files.
+  - **shared**: the project folder itself. What it writes is there at once for
+    you and the next helper; nothing to merge, and it doesn't commit. For steps
+    that produce or check files others use next (pipelines, reviews of outputs).
+    Helpers in the project folder claim the files they write as shared assets.`;
+}
 function onboarding(project) {
     if (project.origin === "new") {
         return `## Starting point
@@ -194,7 +224,11 @@ assets. Your tasks come from the coordinator.
         ? `You work in your own isolated copy of the project, on branch \`${agent.branch}\`.
   Commit your work there with clear messages; never merge or push — the
   coordinator merges your work into the project.`
-        : "You work directly in the shared project folder, alongside other agents."}
+        : `You work directly in the project folder, alongside the coordinator and other
+  agents: what you write is there for them at once, and theirs for you. Before
+  writing files others may also write, claim them as a shared asset (below).
+  Don't commit, merge or push unless the coordinator asks; don't touch files or
+  processes that aren't yours.`}
 - When you finish a task, or are blocked, report it once: with \`update_task\`
   for plan tasks (see below), otherwise with \`send_message\` to the coordinator
   (what you did, where, anything they should know). Then end your turn; new
@@ -219,7 +253,9 @@ If you are unsure whether something is shared, ask the coordinator.
 \`send_message\`, \`ask_human\`, \`list_team\`, \`list_assets\`, \`request_asset\`,
 \`release_asset\`, \`check_messages\`, \`list_tasks\`, \`update_task\`.
 
-Tasks from the plan arrive as "Task T3: …". When you finish one, commit and call
+${FINDING_TOOLS}
+
+Tasks from the plan arrive as "Task T3: …". When you finish one, ${isolated ? "commit and " : ""}call
 \`update_task("T3", "review", <summary of what you did>)\` — that **is** your
 report to the coordinator; don't also send a message. If you are stuck, use
 \`update_task("T3", "blocked", <why>)\`.

package/dist/server/team.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, 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
@@ -251,6 +251,23 @@ 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);
+    }
     /** 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 +373,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 +389,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 +487,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 +521,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 +535,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 +594,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 +604,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 +632,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 +699,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 +722,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 +756,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 +925,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(() => { });
@@ -1024,37 +1109,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(() => { });
@@ -1301,7 +1402,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 +1411,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;
             }

package/dist/server/tools.js

@@ -90,16 +90,20 @@ const releaseAsset = {
 // ---- coordinator-only ----
 const spawnAgent = {
     name: "spawn_agent",
-    description: "Create a helper agent. It gets its own isolated workspace in git projects. Give it a short name, its purpose, and its first task.",
+    description: "Create a helper agent. Give it a short name, its purpose, and its first task. In a git project it works either in its own copy " +
+        "on its own branch (\"own\": parallel edits, merged with merge_work) or in the project folder itself (\"shared\": its files are " +
+        "there at once for the next step, nothing to merge). Without workspace, the project's setting applies.",
     inputSchema: obj({
         name: str("Short unique name, e.g. 'researcher' or 'chapter-writer'"),
         purpose: str("What this agent is responsible for"),
         task_id: str("The plan task to start with (e.g. 'T2'). Preferred when there is a plan."),
         task: str("Its first task as text (when there is no plan task), or extra instructions for task_id"),
         model: str("Optional provider/model from the allowed list; defaults to your own model"),
+        workspace: { type: "string", enum: ["own", "shared"], description: "Where it works (git projects); defaults to the project's setting" },
     }, ["name", "purpose"]),
     async run(args, { team, project, agent }) {
         return team.spawnWorker(project, agent, {
+            workspace: args.workspace === "own" || args.workspace === "shared" ? args.workspace : undefined,
             name: String(args.name),
             purpose: String(args.purpose),
             task: args.task ? String(args.task) : undefined,
@@ -176,9 +180,12 @@ const updateTask = {
         task_id: str("Task id, e.g. T3"),
         status: { type: "string", enum: [...TASK_STATUSES] },
         note: str("What happened: progress, blocker, or a summary of the finished work"),
+        summary: str("Same as note (either name works)"),
     }, ["task_id"]),
-    async run({ task_id, status, note }, { team, project, agent }) {
-        return team.updateTask(project, agent, String(task_id), status, note ? String(note) : undefined);
+    async run({ task_id, status, note, summary }, { team, project, agent }) {
+        // Agents often call it "summary"; dropping it silently lost their review notes.
+        const text = note ?? summary;
+        return team.updateTask(project, agent, String(task_id), status, text ? String(text) : undefined);
     },
 };
 const stopAgent = {
@@ -192,6 +199,18 @@ const stopAgent = {
         return team.stopAgent(project, target, reason ? String(reason) : "work finished");
     },
 };
+const moveToProjectFolder = {
+    name: "move_to_project_folder",
+    description: "Move an idle helper from its own copy (branch) into the project folder, so it works on the project's files directly. " +
+        "It continues in a fresh session with a handoff note. Refused while its own copy has work that isn't merged yet.",
+    inputSchema: obj({ agent: str("Helper name") }, ["agent"]),
+    async run({ agent: name }, { team, project }) {
+        const target = team.findAgent(project, name);
+        if (!target || target.role === "coordinator")
+            throw new Error(`No helper agent named "${name}".`);
+        return team.moveToProjectFolder(project, target, "moved by the coordinator");
+    },
+};
 const cleanBuildOutputs = {
     name: "clean_build_outputs",
     description: "Free disk space in an idle helper's folder by deleting its build outputs (git-ignored folders such as bin, obj, node_modules). " +
@@ -270,14 +289,14 @@ const listProcesses = {
     name: "list_processes",
     description: "List the background processes (servers, watchers) you started that are still running, with their ids.",
     inputSchema: obj({}),
-    run: (_args, { team, agent }) => team.listProcesses(agent),
+    run: (_args, { team, project, agent }) => team.listProcesses(project, agent),
 };
 const stopProcess = {
     name: "stop_process",
     description: "Stop a background process you started (by its shell id, e.g. sh_…, shown when you started it or by list_processes). " +
         "This is the only way to stop processes — killing by name or PID is blocked.",
     inputSchema: obj({ shell_id: str("The background shell id, e.g. sh_179a…") }, ["shell_id"]),
-    run: ({ shell_id }, { team, agent }) => team.stopProcess(agent, String(shell_id)),
+    run: ({ shell_id }, { team, project, agent }) => team.stopProcess(project, agent, String(shell_id)),
 };
 // ---- connections (GitHub, servers): Symbio acts with the stored credentials
 const reasonField = str("Why — the human sees this when approving");
@@ -365,6 +384,7 @@ const COORDINATOR_ONLY = [
     stopAgent,
     mergeWork,
     cleanBuildOutputs,
+    moveToProjectFolder,
     declareAsset,
     grantAsset,
     denyAsset,

package/dist/server/updates.js

@@ -40,6 +40,24 @@ export const AGENT_UPDATES = [
             "free disk space in idle helpers' folders with the new clean_build_outputs tool (it only deletes git-ignored build folders " +
             "like bin, obj and node_modules; work is never touched). Symbio also backs up its own state every day.",
     },
+    {
+        id: "2026-10-30-shared-folder",
+        text: "Where helpers work: in a git project a helper can now work in the project folder itself instead of its own copy on its own " +
+            "branch. spawn_agent has a workspace option: \"own\" (as before: parallel work, merged with merge_work) or \"shared\" (the " +
+            "project folder: what it writes is there at once for you and the next helper; nothing to merge, and it doesn't commit). " +
+            "Use shared for step-by-step work where each step uses the previous one's files. Without the option, the project's setting " +
+            "applies (the human sets it in Settings; it stays \"own\" unless they change it). A shared helper's finished task arrives for " +
+            "review as usual; check its files in the project folder and mark the task done. move_to_project_folder moves an idle helper " +
+            "whose work is merged into the project folder (it continues in a fresh session). Background processes now belong to the agent " +
+            "that started them: list_processes and stop_process only show and stop your own, even in a shared folder.",
+    },
+    {
+        id: "2026-11-03-tool-catalog",
+        text: "Finding Symbio's tools: OpenCode sometimes posts a \"tool catalog has changed\" notice that lists only its own tools and says " +
+            "the catalog is complete. Symbio's tools are still there: call them inside execute as tools.symbio.<name>(…), or find them " +
+            "with search({ namespace: \"symbio\" }). Never conclude they're gone without calling one; if a call really fails, tell the " +
+            "human what the error said.",
+    },
 ];
 /** Entries a project hasn't been told about yet. */
 export function unseenUpdates(seen) {