symbio 0.5.0 → 0.7.0

package/CHANGELOG.md

@@ -5,6 +5,29 @@ versions follow [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+## [0.7.0]
+
+- Updates: `sym update` installs the latest version and restarts Symbio once the team is idle
+  (`--now` doesn't wait). Symbio also checks for new versions and, by default, updates itself while
+  no agent is working and remote access is off: it backs up first, keeps (or restores) the old
+  version if the install fails and doesn't retry it for a day, and tells you in Messages. Settings →
+  Updates: automatic, tell me, or off, and what's new; a badge in the top bar when a version is
+  available.
+- Docs brought up to date; the roadmap is now a priority list with collected ideas; `sym doctor`
+  prints Symbio's version.
+
+## [0.6.0]
+
+- Azure DevOps connections: add an organization with a personal access token in Settings; agents
+  push and pull through it (HTTPS remotes of that organization) and call its REST API with the new
+  `azure_devops_api` tool, e.g. to open pull requests. The token never reaches the agent and only
+  goes to the connection's own organization.
+- Credentials rule clarified: Symbio's own secrets stay off-limits to agents, but a project's own
+  credentials (connection strings, `.env`…) and ones the human gives may be used for the task;
+  agents must not copy them into anything committed or shared, and only read from systems the
+  human calls read-only or production. Agents had refused legitimate work (querying a database
+  with the app's connection string) under the old blanket rule.
+
 ## [0.5.0]
 
 - Docs tab: a folder tree instead of a flat list; search across all docs (any case or accent) that

package/README.md

@@ -77,11 +77,16 @@ place. Here Symbio was restarted mid-task, and it told the helper to pick up whe
 - **You stay in control.** Questions, plan approvals, permission requests (like installing
   software) and deploy approvals collect in a **Needs you** inbox. Pause one team or everything at
   once.
-- **Connections without exposing secrets.** Give agents a GitHub account or an SSH server. They
-  ask Symbio to push, call the API or deploy, and Symbio does it with credentials the agents never
+- **Connections without exposing secrets.** Give agents a GitHub account, an Azure DevOps
+  organization or an SSH server. They ask Symbio to push, open pull requests, call the API or deploy, and Symbio does it with credentials the agents never
   see. Each connection can require your approval for every action.
 - **Resilient.** A supervisor restarts OpenCode if it crashes, a watchdog unsticks hung agents, and
   when a model fails (quota, outage) the agent switches to the next allowed model and carries on.
+- **Long-running teams stay healthy.** Agents can continue in a fresh session with a handoff note
+  (when you ask, after each finished task, or automatically when a conversation grows too large to
+  send). A daily check backs up Symbio's state and tells you and core about work that exists only
+  on this machine and build outputs filling the disk.
+- **Costs in view.** Tokens and estimated cost per agent and model, with prices you can set.
 - **Safety rails.** Agents can't kill processes by name (which would take down your terminals and
   editors), can't read your SSH keys or Symbio's secret store, and must ask before installing
   software. They look at images through scaled-down copies, so a few large pictures can't make a
@@ -123,6 +128,12 @@ on your computer, including the agents, from using Symbio's API behind your back
 | `sym doctor` | Check Node.js, git, OpenCode, the port and model providers. |
 | `sym run` | Run in the foreground, with the log in the terminal. |
 | `sym remote` | Open a temporary link and access code to use Symbio from another device (see below). `sym remote off` closes it. |
+| `sym update` | Install the latest version and restart Symbio, once no agent is working (`--now` doesn't wait). |
+
+**Updates.** Symbio checks for new versions and, by default, installs them by itself while the team
+is idle: never while an agent is working or waiting for you, or while remote access is on. It backs
+up first, restarts in a minute or two, and tells you in Messages. In Settings → Updates you can
+choose to be only told instead, or turn checking off, and see what's new.
 
 **From another device.** `sym remote` opens a temporary Cloudflare link to your Symbio and prints it
 with an access code. Open the link anywhere (phone, another computer), enter the code, and you're
@@ -142,7 +153,7 @@ itself. Whoever gets in controls your agents, so keep the link and code to yours
    - **Folder:** browse for or paste a folder. An empty folder starts a new project; an existing
      one is studied first. Symbio offers to set up git if the folder doesn't have it.
    - **Setup:** choose where the project documentation goes (in the project, or private), and which
-     connections (GitHub, servers) the agents may use.
+     connections (GitHub, Azure DevOps, servers) the agents may use.
    - **Models:** pick the models agents may use, and the one core runs on (the crown).
 3. **Talk to core.** Describe what you want. core asks questions, proposes a plan, and waits for
    your approval in the **Plan** tab (it shows a *Review* badge).
@@ -159,7 +170,7 @@ itself. Whoever gets in controls your agents, so keep the link and code to yours
 | **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>`) 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. |
+| **Connection** | A GitHub account, Azure DevOps organization 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. |
 
 ## Where your data lives
@@ -171,8 +182,13 @@ itself. Whoever gets in controls your agents, so keep the link and code to yours
 | `~/.symbio/secrets.enc` | Connection secrets, encrypted with a key kept in your OS credential store |
 | `~/.symbio/worktrees/` | Helpers' working copies |
 | `~/.symbio/backups/` | Daily backups of Symbio's state (the last 7 days) |
+| `~/.symbio/approvals/` | Remote actions waiting for (or decided by) your approval |
+| `~/.symbio/prices.json` | Model prices used for cost estimates |
+| `~/.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>/AGENTS.md`, `<project>/docs/` | Project documentation for agents (unless you chose *private*) |
+| `<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>`. |
 
 Symbio never deletes your project files. Removing a project from Symbio only forgets it, and can
@@ -193,13 +209,17 @@ All optional, set as environment variables:
 | `SYMBIO_STUCK_MINUTES` | `10` | Silence before the watchdog interrupts a working agent |
 | `SYMBIO_RECYCLE_MB` | `1500` | Restart OpenCode above this memory use once every agent is idle |
 | `SYMBIO_RECYCLE_HARD_MB` | `3000` | Restart OpenCode above this memory use regardless (agents resume) |
+| `SYMBIO_MEMORY_CHECK_SECONDS` | `60` | How often OpenCode's memory use is checked |
+| `SYMBIO_BACKUP_DAYS` | `7` | How many daily backups of Symbio's state to keep |
+| `SYMBIO_BUILD_ALERT_GB` | `2` | Build outputs in a helper's folder above this size are reported by the daily check |
 
 ## Status
 
-Symbio is young (version 0.1) and changing quickly. The core workflow works end to end: projects,
-core and helpers, messaging, plan and kanban, shared assets, connections, providers, and recovery.
-Planned next: npm packaging with first-run checks, an agent graph, and screenshots for agents so
-they can see what they build. See [docs/roadmap.md](docs/roadmap.md).
+Symbio is young and changing quickly, shaped by people using it for real work. The core workflow
+works end to end: projects, core and helpers, messaging, plan and kanban, shared assets, docs and
+the rules register, connections (GitHub, Azure DevOps, servers), providers, costs and recovery.
+What's planned and what's open for help is in [docs/roadmap.md](docs/roadmap.md); what changed in
+each version is in [CHANGELOG.md](CHANGELOG.md).
 
 ## Documentation
 

package/bin/symbio.js

@@ -9,9 +9,10 @@
 //   sym doctor     check that everything Symbio needs is in place
 //   sym run        run in the foreground (for debugging)
 //   sym remote     open a temporary link to use Symbio from another device (sym remote off to close it)
+//   sym update     install the latest version (waits for an idle team; --now doesn't)
 
-import { execFileSync, exec, spawn } from "node:child_process";
-import { existsSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { execFileSync, exec, spawn, spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, openSync, readFileSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
@@ -33,8 +34,13 @@ const token = () => {
 };
 const link = () => `${BASE}/?token=${token()}`;
 
-async function api(method, p) {
-  const res = await fetch(BASE + p, { method, headers: { "x-symbio-token": token() }, signal: AbortSignal.timeout(3000) });
+async function api(method, p, body) {
+  const res = await fetch(BASE + p, {
+    method,
+    headers: { "x-symbio-token": token(), ...(body === undefined ? {} : { "content-type": "application/json" }) },
+    body: body === undefined ? undefined : JSON.stringify(body),
+    signal: AbortSignal.timeout(body === undefined ? 3000 : 30_000),
+  });
   return { status: res.status, body: await res.json().catch(() => null) };
 }
 
@@ -164,6 +170,7 @@ async function doctor() {
     console.log(`${pass ? "✔" : "✘"} ${label}${!pass && fix ? `\n    → ${fix}` : ""}`);
     if (!pass) ok = false;
   };
+  console.log(`Symbio ${pkg.version}`);
   const [major] = process.versions.node.split(".").map(Number);
   check(major >= 22, `Node.js ${process.versions.node}`, "Symbio needs Node.js 22 or newer: https://nodejs.org");
   let gitVersion = "";
@@ -189,6 +196,82 @@ async function doctor() {
   if (!ok) process.exitCode = 1;
 }
 
+/**
+ * Installs the latest version. Running: Symbio hands over to its updater and restarts (waiting
+ * for an idle team unless --now). Stopped: the updater runs here, and Symbio stays stopped.
+ */
+async function update() {
+  const now = process.argv.includes("--now");
+  const self = await import(pathToFileURL(path.join(root, "dist", "server", "self-update.js")).href);
+  const install = self.installInfo(root);
+  if (install.kind === "dev") {
+    console.log(`This Symbio runs from a development folder (${install.root}). Update it there: git pull, npm install, npm run build.`);
+    return;
+  }
+  let latest;
+  try {
+    latest = await self.latestVersion();
+  } catch (err) {
+    console.error(`Couldn't check for updates: ${err.message}`);
+    process.exit(1);
+  }
+  if (self.compareVersions(latest, pkg.version) <= 0) return console.log(`Symbio ${pkg.version} is up to date.`);
+  console.log(`Symbio ${latest} is available (you have ${pkg.version}).`);
+  const resultFile = path.join(HOME, "update-result.json");
+  const before = existsSync(resultFile) ? readFileSync(resultFile, "utf8") : "";
+
+  if ((await state()) === "running") {
+    const st = (await api("GET", "/api/update")).body;
+    if (st?.busy && !now) {
+      console.log(`Not now: ${st.busy}.\nRun "sym update" again when the team is idle, or "sym update --now" (agents that are working are interrupted and continue after the restart).`);
+      process.exitCode = 1;
+      return;
+    }
+    const res = await api("POST", "/api/update/apply", { force: true });
+    if (res.status !== 200) {
+      console.error(res.body?.error ?? `Symbio answered ${res.status}`);
+      process.exit(1);
+    }
+    process.stdout.write("Updating: Symbio stops, installs the new version and starts again");
+    for (let i = 0; i < 300; i++) {
+      await sleep(1000);
+      const after = existsSync(resultFile) ? readFileSync(resultFile, "utf8") : "";
+      if (after && after !== before && (await state()) === "running") break;
+      if (i % 3 === 0) process.stdout.write(".");
+    }
+    console.log("");
+  } else {
+    // Not running: install right here, from a copy of the updater (npm replaces this folder).
+    const dir = mkdtempSync(path.join(os.tmpdir(), "symbio-update-"));
+    const runner = path.join(dir, "update-runner.mjs");
+    copyFileSync(path.join(root, "bin", "update-runner.mjs"), runner);
+    const job = path.join(dir, "job.json");
+    writeFileSync(
+      job,
+      JSON.stringify({
+        prefix: install.prefix,
+        spec: process.env.SYMBIO_UPDATE_SPEC ?? `symbio@${latest}`,
+        from: pkg.version,
+        to: latest,
+        root: install.root,
+        home: HOME,
+        port: PORT,
+        start: false,
+        resultFile,
+        logFile: path.join(HOME, "logs", "update.log"),
+      }),
+    );
+    console.log("Installing…");
+    spawnSync(process.execPath, [runner, job], { stdio: "inherit", windowsHide: true });
+  }
+  const result = existsSync(resultFile) ? JSON.parse(readFileSync(resultFile, "utf8")) : null;
+  if (result?.ok && result.to === latest) console.log(`Updated to ${latest}.${(await state()) === "running" ? ` Symbio is running: ${link()}` : ' Start it with "sym".'}`);
+  else {
+    console.error(`The update didn't complete${result?.error ? `: ${result.error}` : "."} Details: ${path.join(HOME, "logs", "update.log")}`);
+    process.exitCode = 1;
+  }
+}
+
 function help() {
   console.log(`Symbio ${pkg.version} — run a team of AI agents on your project, from your browser.
 
@@ -203,6 +286,7 @@ Usage: sym [command]
   run             run in the foreground (logs in this terminal)
   remote          open a temporary link + access code to use Symbio from another device
   remote off      close that link
+  update          install the latest version (when the team is idle; --now to not wait)
   --version       print the version
 
 Environment: SYMBIO_PORT (default 4310), SYMBIO_HOME (default ~/.symbio), SYMBIO_NO_OPEN=1.`);
@@ -230,6 +314,9 @@ switch (cmd) {
     if (process.argv[3] === "off") await remoteOff();
     else await remoteOn();
     break;
+  case "update":
+    await update();
+    break;
   case "logs":
     logs();
     break;

package/bin/update-runner.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+// Installs a Symbio update while Symbio is stopped, then starts it again. Runs as its own process,
+// from a copy outside the package folder (which npm replaces): Symbio hands over and exits, or
+// `sym update` runs it when Symbio isn't running. It can't install in place: on Windows, OpenCode
+// and the native modules keep their files locked while they run.
+//
+// Usage: node update-runner.mjs <job.json>
+//   job: { waitPid?, prefix, spec, from, to, root, home, port, start, resultFile, logFile }
+
+import { spawn, spawnSync } from "node:child_process";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const job = JSON.parse(readFileSync(process.argv[2], "utf8"));
+mkdirSync(path.dirname(job.logFile), { recursive: true });
+const log = (line) => appendFileSync(job.logFile, `${new Date().toISOString()} ${line}\n`);
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const alive = (pid) => {
+  try {
+    process.kill(pid, 0); // signal 0: only checks the process exists
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/** npm install -g <spec> into the prefix Symbio was installed in. */
+function install(spec) {
+  log(`npm install -g ${spec} (prefix ${job.prefix})`);
+  const res = spawnSync(process.platform === "win32" ? "npm.cmd" : "npm", ["install", "-g", spec, "--no-fund", "--no-audit"], {
+    encoding: "utf8",
+    shell: process.platform === "win32",
+    windowsHide: true,
+    timeout: 10 * 60_000,
+    env: { ...process.env, npm_config_prefix: job.prefix },
+  });
+  const output = `${res.stdout ?? ""}${res.stderr ?? ""}`.trim();
+  if (output) log(output.split("\n").slice(-30).join("\n"));
+  return { ok: res.status === 0, output: res.error ? res.error.message : output };
+}
+
+/** The installed package is the old version and can start. */
+function intact() {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(job.root, "package.json"), "utf8"));
+    return pkg.version === job.from && existsSync(path.join(job.root, "bin", "symbio.js")) && existsSync(path.join(job.root, "dist", "server", "index.js"));
+  } catch {
+    return false;
+  }
+}
+
+const result = { from: job.from, to: job.to, ok: false, error: null, finishedAt: 0, seen: false };
+try {
+  log(`Updating Symbio ${job.from} → ${job.to}`);
+  if (job.waitPid) {
+    for (let i = 0; i < 180 && alive(job.waitPid); i++) await sleep(500);
+    if (alive(job.waitPid)) throw new Error("Symbio didn't stop within 90 seconds; nothing was changed.");
+  }
+  const done = install(job.spec);
+  if (done.ok) {
+    result.ok = true;
+    log("Installed.");
+  } else {
+    result.error = `npm couldn't install ${job.to}: ${done.output.split("\n").slice(-6).join(" ").slice(0, 600)}`;
+    log(result.error);
+    // npm often fails before touching anything (no network, a lock); only if the old version
+    // was damaged, put it back so Symbio still starts.
+    if (intact()) log(`${job.from} is still in place.`);
+    else {
+      const back = install(`symbio@${job.from}`);
+      log(back.ok ? `Reinstalled ${job.from}.` : `Couldn't reinstall ${job.from} either; run: npm install -g symbio`);
+      if (!back.ok) result.error += ` Reinstalling ${job.from} failed too; run "npm install -g symbio".`;
+    }
+  }
+} catch (err) {
+  result.error = err.message;
+  log(`Failed: ${err.message}`);
+}
+result.finishedAt = Date.now();
+writeFileSync(job.resultFile, JSON.stringify(result, null, 2));
+
+if (job.start) {
+  log("Starting Symbio.");
+  // `sym start` from the (possibly new) package, in the background like a normal start.
+  const child = spawn(process.execPath, [path.join(job.root, "bin", "symbio.js"), "start"], {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    env: { ...process.env, SYMBIO_NO_OPEN: "1", SYMBIO_HOME: job.home, SYMBIO_PORT: String(job.port) },
+  });
+  child.unref();
+}

package/dist/server/connections.js

@@ -1,14 +1,22 @@
-// Global connections (set once in Settings, used by any project): GitHub accounts
-// and servers reachable over SSH. Public details live in ~/.symbio/connections.json;
-// secrets live in the encrypted vault and are never returned by the API.
+// Global connections (set once in Settings, used by any project): GitHub accounts,
+// Azure DevOps organizations and servers reachable over SSH. Public details live in
+// ~/.symbio/connections.json; secrets live in the encrypted vault and are never
+// returned by the API.
 import { promises as fs, readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { SecretVault } from "./secrets.js";
 import { sshExec } from "./ssh.js";
 import { globalDir, newId } from "./store.js";
+/** Organization from what people paste: "org", https://dev.azure.com/org/…, https://org.visualstudio.com/…. */
+export function azureOrganization(value) {
+    const v = value.trim();
+    const m = /^https?:\/\/(?:[^@/]+@)?dev\.azure\.com\/([^/?#]+)/i.exec(v) ?? /^https?:\/\/(?:[^@/]+@)?([^./]+)\.visualstudio\.com/i.exec(v);
+    return decodeURIComponent(m ? m[1] : v.replace(/\/+$/, ""));
+}
 const SECRET_FIELDS = {
     github: ["token"],
+    azure: ["token"],
     server: ["privateKey", "passphrase", "password"],
 };
 export class Connections {
@@ -37,13 +45,15 @@ export class Connections {
         return { ...c, secrets };
     }
     async create(input) {
-        if (input.type !== "github" && input.type !== "server")
-            throw new Error("type must be github or server");
+        if (input.type !== "github" && input.type !== "azure" && input.type !== "server")
+            throw new Error("type must be github, azure or server");
         const now = Date.now();
         const base = { id: newId("con"), name: "", createdAt: now, updatedAt: now, lastTest: null };
         const conn = input.type === "github"
             ? { ...base, type: "github", account: null }
-            : { ...base, type: "server", host: "", port: 22, username: "", auth: "key", keyPath: null };
+            : input.type === "azure"
+                ? { ...base, type: "azure", organization: "", account: null }
+                : { ...base, type: "server", host: "", port: 22, username: "", auth: "key", keyPath: null };
         this.apply(conn, input);
         if (!conn.name)
             throw new Error("Give the connection a name.");
@@ -91,6 +101,14 @@ export class Connections {
                 conn.account = user.login;
                 result = { ok: true, message: `Signed in as ${user.login}${user.name ? ` (${user.name})` : ""}`, time: Date.now() };
             }
+            else if (conn.type === "azure") {
+                const data = await this.azureRequest(conn, "GET", "_apis/connectionData", undefined, "7.1-preview");
+                const user = data?.authenticatedUser;
+                conn.account = user?.providerDisplayName ?? user?.customDisplayName ?? null;
+                const projects = await this.azureRequest(conn, "GET", "_apis/projects").catch(() => null);
+                const count = Array.isArray(projects?.value) ? ` — ${projects.value.length} project(s) visible` : "";
+                result = { ok: true, message: `Signed in to ${conn.organization}${conn.account ? ` as ${conn.account}` : ""}${count}`, time: Date.now() };
+            }
             else {
                 const res = await sshExec(await this.sshTarget(conn), "uname -srm 2>/dev/null || ver", 30_000);
                 const out = (res.stdout || res.stderr).trim().split("\n")[0];
@@ -129,6 +147,40 @@ export class Connections {
         }
         return target;
     }
+    /** Calls the Azure DevOps REST API of the connection's organization with its token. */
+    async azureRequest(conn, method, apiPath, body, apiVersion = "7.1") {
+        const rel = apiPath.trim().replace(/^\/+/, "");
+        if (/^[a-z]+:/i.test(rel))
+            throw new Error("Give a path inside the organization (e.g. MyProject/_apis/git/repositories), not a full URL.");
+        const url = new URL(`https://dev.azure.com/${encodeURIComponent(conn.organization)}/${rel}`);
+        if (!url.searchParams.has("api-version"))
+            url.searchParams.set("api-version", apiVersion);
+        const token = await this.githubToken(conn);
+        const res = await fetch(url, {
+            method,
+            redirect: "manual", // a sign-in redirect means the token was refused
+            headers: {
+                authorization: `Basic ${Buffer.from(`:${token}`).toString("base64")}`,
+                accept: "application/json",
+                "user-agent": "symbio",
+                ...(body === undefined ? {} : { "content-type": "application/json" }),
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await res.text();
+        // A rejected token gets a sign-in page (203 or a redirect) rather than a 401.
+        const html = /^\s*</.test(text) || (res.headers.get("content-type") ?? "").includes("text/html");
+        if (res.status === 401 || res.status === 203 || (res.status >= 300 && res.status < 400) || (html && res.ok)) {
+            throw new Error(`Azure DevOps rejected the token for "${conn.organization}" (expired, revoked, or without access to this organization?)`);
+        }
+        const data = text ? safeJson(text) : null;
+        if (!res.ok) {
+            const msg = data?.message ?? res.statusText;
+            throw new Error(`Azure DevOps ${res.status}: ${msg}`);
+        }
+        return data;
+    }
+    /** The stored token of a GitHub or Azure DevOps connection. */
     async githubToken(conn) {
         const token = await this.vault.get(`${conn.id}:token`);
         if (!token)
@@ -159,6 +211,8 @@ export class Connections {
     apply(conn, input) {
         if (input.name !== undefined)
             conn.name = input.name.trim();
+        if (conn.type === "azure" && input.organization !== undefined)
+            conn.organization = azureOrganization(input.organization);
         if (conn.type === "server") {
             if (input.host !== undefined)
                 conn.host = input.host.trim();
@@ -173,6 +227,9 @@ export class Connections {
         }
     }
     validate(conn) {
+        if (conn.type === "azure" && !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/.test(conn.organization)) {
+            throw new Error("Give the organization, e.g. \"contoso\" or https://dev.azure.com/contoso.");
+        }
         if (conn.type === "server") {
             if (!conn.host)
                 throw new Error("Host is required.");
@@ -189,7 +246,7 @@ export class Connections {
             if (typeof value === "string" && value.trim())
                 await this.vault.set(`${conn.id}:${field}`, value.trim());
         }
-        if (conn.type === "github" && !(await this.vault.has(`${conn.id}:token`)))
+        if ((conn.type === "github" || conn.type === "azure") && !(await this.vault.has(`${conn.id}:token`)))
             throw new Error("The token is required.");
         if (conn.type === "server") {
             if (conn.auth === "password" && !(await this.vault.has(`${conn.id}:password`)))

package/dist/server/housekeeping.js

@@ -14,10 +14,18 @@ export const backupsDir = () => path.join(globalDir, "backups");
  * Returns the folder, or null when today's backup already exists.
  */
 export async function dailyBackup(projects, now = new Date()) {
-    const day = now.toISOString().slice(0, 10);
-    const dest = path.join(backupsDir(), day);
+    const dest = path.join(backupsDir(), now.toISOString().slice(0, 10));
     if (existsSync(dest))
         return null;
+    return writeBackup(projects, dest);
+}
+/** A backup on demand, e.g. right before an update ("2026-11-06-before-0.7.0"); pruned like the daily ones. */
+export async function labeledBackup(projects, label, now = new Date()) {
+    const dest = path.join(backupsDir(), `${now.toISOString().slice(0, 10)}-${label.replace(/[^\w.-]+/g, "-")}`);
+    await fs.rm(dest, { recursive: true, force: true });
+    return writeBackup(projects, dest);
+}
+async function writeBackup(projects, dest) {
     const tmp = `${dest}.partial`;
     await fs.rm(tmp, { recursive: true, force: true });
     for (const p of projects) {
@@ -32,9 +40,10 @@ export async function dailyBackup(projects, now = new Date()) {
     }
     await fs.mkdir(tmp, { recursive: true });
     await fs.rename(tmp, dest);
-    // Keep the newest days only.
-    const days = (await fs.readdir(backupsDir())).filter((d) => /^\d{4}-\d{2}-\d{2}$/.test(d)).sort();
-    for (const old of days.slice(0, Math.max(0, days.length - BACKUP_KEEP))) {
+    // Keep the last BACKUP_KEEP days that have backups (daily and labeled alike).
+    const entries = (await fs.readdir(backupsDir())).filter((d) => /^\d{4}-\d{2}-\d{2}(-[\w.-]+)?$/.test(d));
+    const keepDays = [...new Set(entries.map((d) => d.slice(0, 10)))].sort().slice(-BACKUP_KEEP);
+    for (const old of entries.filter((d) => !keepDays.includes(d.slice(0, 10)))) {
         await fs.rm(path.join(backupsDir(), old), { recursive: true, force: true }).catch(() => { });
     }
     return dest;

package/dist/server/index.js

@@ -1,6 +1,6 @@
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
-import { promises as fs, existsSync } from "node:fs";
+import { promises as fs, existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { exec } from "node:child_process";
@@ -16,6 +16,8 @@ import { OpencodeRuntime } from "./opencode/runtime.js";
 import { Store, globalDir } from "./store.js";
 import { Team } from "./team.js";
 import { removeOrphanWorkspaces } from "./workspaces.js";
+import { packageRoot, QUIET_MS, SelfUpdate } from "./self-update.js";
+import { labeledBackup } from "./housekeeping.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));
@@ -72,6 +74,23 @@ async function main() {
     team.markInterrupted("Symbio was stopped and has been restarted");
     const uiToken = loadUiToken(globalDir);
     const remote = new RemoteAccess(path.join(globalDir, "bin"));
+    // Updates: checked now and then; applied when allowed and the team is idle (see self-update.ts).
+    const version = JSON.parse(readFileSync(path.join(packageRoot, "package.json"), "utf8")).version;
+    const updates = new SelfUpdate({
+        version,
+        home: globalDir,
+        port: PORT,
+        busy: () => team.busyReason(QUIET_MS),
+        remoteActive: () => remote.active,
+        backup: async () => {
+            await labeledBackup(store.list(), `before-${updates.state().latest ?? "update"}`);
+        },
+        announce: (text) => team.announce(text),
+        shutdown: async () => {
+            await shutdown?.();
+        },
+    });
+    await updates.load();
     remote.onChange = () => bus.publish({ type: "remote.updated" });
     const remoteRequests = new WeakSet(); // requests that came through the tunnel
     const app = new Hono();
@@ -123,6 +142,25 @@ async function main() {
         setTimeout(() => void shutdown?.(), 200);
         return c.json({ ok: true });
     });
+    // Updates: state and settings for the UI; applying stops Symbio (never through remote access).
+    app.get("/api/update", (c) => c.json(updates.state()));
+    app.post("/api/update/check", async (c) => c.json(await updates.check()));
+    app.put("/api/update/settings", async (c) => {
+        const { mode } = await c.req.json();
+        if (mode !== "auto" && mode !== "notify" && mode !== "off")
+            return c.json({ error: "mode must be auto, notify or off" }, 400);
+        await updates.setMode(mode);
+        return c.json(updates.state());
+    });
+    app.post("/api/update/apply", async (c) => {
+        const { force } = await c.req.json().catch(() => ({ force: false }));
+        try {
+            return c.json({ message: await updates.apply(force !== false) });
+        }
+        catch (err) {
+            return c.json({ error: err.message }, 400);
+        }
+    });
     // Remote access: status for everyone (the code only locally), start locally, stop from anywhere.
     app.get("/api/remote", (c) => c.json(remote.status(!remoteRequests.has(c.req.raw))));
     app.post("/api/remote/start", async (c) => {
@@ -164,10 +202,12 @@ async function main() {
         .then(() => console.log(`OpenCode ${runtime.version} ready`))
         .catch((err) => console.error("OpenCode failed to start:", err.message));
     team.startWatchdog();
+    updates.start();
     shutdown = async () => {
         remote.stop("Symbio stopped");
         team.shuttingDown = true;
         team.stopWatchdog();
+        updates.stop();
         await runtime.stop();
         process.exit(0);
     };

package/dist/server/prompts.js

@@ -337,15 +337,33 @@ export function kickoffMessage(project) {
         : "Symbio: the project was just created on a folder that already has content (see the folder summary in your instructions). Greet the human briefly, mention in one or two sentences what you can see at a glance, and offer to study the folder before planning.";
 }
 function connectionsSection(connections) {
-    return `## Connections (GitHub, servers)
+    return `## Connections (GitHub, Azure DevOps, servers)
 
 ${connections || "None."}
 
-Use connections only through Symbio's tools: \`list_connections\`, \`git_push\`,
-\`git_pull\`, \`github_api\` (GitHub) and \`remote_exec\`, \`remote_upload\` (servers).
-Symbio performs the action with the stored credentials — you never see them.
-Never ask for credentials, never write secrets into files or commands, and never
-look for them on this machine. Remote commands must be non-interactive. Always
-give a clear \`reason\`: when a connection needs approval, the human decides based
-on it, and the result arrives later as a message.`;
+Use connections only through Symbio's tools: \`list_connections\`; \`git_push\`,
+\`git_pull\` (GitHub or Azure DevOps); \`github_api\` (GitHub); \`azure_devops_api\`
+(Azure DevOps: pull requests, repositories, branches); \`remote_exec\`,
+\`remote_upload\` (servers). Symbio performs the action with the stored
+credentials — you never see them. To open a pull request: push the branch with
+\`git_push\`, then create it with \`github_api\` or \`azure_devops_api\`.
+Remote commands must be non-interactive. Always give a clear \`reason\`: when a
+connection needs approval, the human decides based on it, and the result
+arrives later as a message.
+
+## Credentials
+
+- **Symbio's secrets are off-limits:** its vault and connections, SSH keys, its
+  UI key. Use connections only through the tools above; never try to read them.
+- **The project's own credentials** (in its config files: connection strings,
+  \`.env\`, \`Web.config\`, \`appsettings.json\`…) and **credentials the human gives
+  you** may be used for the task, e.g. connecting to a database the work needs.
+  A developer on this project would use them too; don't refuse a task over that.
+- **Don't spread them:** never put a credential into anything that is committed
+  or shared — new files in the project, docs, the rules register, the plan,
+  messages to other agents — and don't print it in your answers. Prefer
+  commands that read it from the config file over pasting it into a command line.
+- **Respect the environment:** if the human says a system is a read-only mirror
+  or production, only read from it; changing production needs the human's
+  explicit OK.`;
 }

package/dist/server/remote-access.js

@@ -37,7 +37,7 @@ export function isTunnelRequest(headers, tunnelHost) {
 }
 // Never through the tunnel: the agents' tools, debugging, shutting Symbio down, starting a
 // tunnel, and the native folder dialog (it would open on this computer's screen).
-const NEVER_REMOTE = [/^\/mcp(\/|$)/, /^\/api\/debug(\/|$)/, /^\/api\/shutdown$/, /^\/api\/remote\/start$/, /^\/api\/pick-folder$/];
+const NEVER_REMOTE = [/^\/mcp(\/|$)/, /^\/api\/debug(\/|$)/, /^\/api\/shutdown$/, /^\/api\/remote\/start$/, /^\/api\/pick-folder$/, /^\/api\/update\/apply$/];
 /** What to do with a request that came through the tunnel. */
 export function remoteDecision(req) {
     if (!req.active)