bazilion 0.20.0 → 0.21.0-beta.2

package/dist/daemon.js

@@ -135,12 +135,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve8, reject2) {
+        return new Promise(function(resolve9, reject2) {
           isexe(path, options || {}, function(er, is) {
             if (er) {
               reject2(er);
             } else {
-              resolve8(is);
+              resolve9(is);
             }
           });
         });
@@ -207,27 +207,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i) => new Promise((resolve8, reject2) => {
+      const step = (i) => new Promise((resolve9, reject2) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve8(found) : reject2(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve9(found) : reject2(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve8(subStep(p, i, 0));
+        resolve9(subStep(p, i, 0));
       });
-      const subStep = (p, i, ii) => new Promise((resolve8, reject2) => {
+      const subStep = (p, i, ii) => new Promise((resolve9, reject2) => {
         if (ii === pathExt.length)
-          return resolve8(step(i + 1));
+          return resolve9(step(i + 1));
         const ext = pathExt[ii];
         isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
           if (!er && is) {
             if (opt.all)
               found.push(p + ext);
             else
-              return resolve8(p + ext);
+              return resolve9(p + ext);
           }
-          return resolve8(subStep(p, i, ii + 1));
+          return resolve9(subStep(p, i, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -7796,7 +7796,7 @@ var init_stdio2 = __esm({
         if (this._process) {
           throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
         }
-        return new Promise((resolve8, reject2) => {
+        return new Promise((resolve9, reject2) => {
           this._process = (0, import_cross_spawn.default)(this._serverParams.command, this._serverParams.args ?? [], {
             // merge default env with server env because mcp server needs some env vars
             env: {
@@ -7813,7 +7813,7 @@ var init_stdio2 = __esm({
             this.onerror?.(error2);
           });
           this._process.on("spawn", () => {
-            resolve8();
+            resolve9();
           });
           this._process.on("close", (_code) => {
             this._process = void 0;
@@ -7872,22 +7872,22 @@ var init_stdio2 = __esm({
         if (this._process) {
           const processToClose = this._process;
           this._process = void 0;
-          const closePromise = new Promise((resolve8) => {
+          const closePromise = new Promise((resolve9) => {
             processToClose.once("close", () => {
-              resolve8();
+              resolve9();
             });
           });
           try {
             processToClose.stdin?.end();
           } catch {
           }
-          await Promise.race([closePromise, new Promise((resolve8) => setTimeout(resolve8, 2e3).unref())]);
+          await Promise.race([closePromise, new Promise((resolve9) => setTimeout(resolve9, 2e3).unref())]);
           if (processToClose.exitCode === null) {
             try {
               processToClose.kill("SIGTERM");
             } catch {
             }
-            await Promise.race([closePromise, new Promise((resolve8) => setTimeout(resolve8, 2e3).unref())]);
+            await Promise.race([closePromise, new Promise((resolve9) => setTimeout(resolve9, 2e3).unref())]);
           }
           if (processToClose.exitCode === null) {
             try {
@@ -7899,15 +7899,15 @@ var init_stdio2 = __esm({
         this._readBuffer.clear();
       }
       send(message) {
-        return new Promise((resolve8) => {
+        return new Promise((resolve9) => {
           if (!this._process?.stdin) {
             throw new Error("Not connected");
           }
           const json = serializeMessage(message);
           if (this._process.stdin.write(json)) {
-            resolve8();
+            resolve9();
           } else {
-            this._process.stdin.once("drain", resolve8);
+            this._process.stdin.once("drain", resolve9);
           }
         });
       }
@@ -7956,8 +7956,8 @@ async function random(size) {
   const evenDistCutoff = Math.pow(2, 8) - Math.pow(2, 8) % mask2.length;
   let result = "";
   while (result.length < size) {
-    const randomBytes6 = await getRandomValues(size - result.length);
-    for (const randomByte of randomBytes6) {
+    const randomBytes7 = await getRandomValues(size - result.length);
+    for (const randomByte of randomBytes7) {
       if (randomByte < evenDistCutoff) {
         result += mask2[randomByte % mask2.length];
       }
@@ -9803,7 +9803,7 @@ var init_sse = __esm({
       }
       _startOrAuth() {
         const fetchImpl = this?._eventSourceInit?.fetch ?? this._fetch ?? fetch;
-        return new Promise((resolve8, reject2) => {
+        return new Promise((resolve9, reject2) => {
           this._eventSource = new EventSource(this._url.href, {
             ...this._eventSourceInit,
             fetch: async (url2, init) => {
@@ -9824,7 +9824,7 @@ var init_sse = __esm({
           this._abortController = new AbortController();
           this._eventSource.onerror = (event2) => {
             if (event2.code === 401 && this._authProvider) {
-              this._authThenStart().then(resolve8, reject2);
+              this._authThenStart().then(resolve9, reject2);
               return;
             }
             const error2 = new SseError(event2.code, event2.message, event2);
@@ -9846,7 +9846,7 @@ var init_sse = __esm({
               void this.close();
               return;
             }
-            resolve8();
+            resolve9();
           });
           this._eventSource.onmessage = (event2) => {
             const messageEvent = event2;
@@ -11016,7 +11016,7 @@ var init_protocol = __esm({
               return;
             }
             const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-            await new Promise((resolve8) => setTimeout(resolve8, pollInterval));
+            await new Promise((resolve9) => setTimeout(resolve9, pollInterval));
             options?.signal?.throwIfAborted();
           }
         } catch (error2) {
@@ -11033,7 +11033,7 @@ var init_protocol = __esm({
        */
       request(request2, resultSchema, options) {
         const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-        return new Promise((resolve8, reject2) => {
+        return new Promise((resolve9, reject2) => {
           const earlyReject = (error2) => {
             reject2(error2);
           };
@@ -11111,7 +11111,7 @@ var init_protocol = __esm({
               if (!parseResult.success) {
                 reject2(parseResult.error);
               } else {
-                resolve8(parseResult.data);
+                resolve9(parseResult.data);
               }
             } catch (error2) {
               reject2(error2);
@@ -11372,12 +11372,12 @@ var init_protocol = __esm({
           }
         } catch {
         }
-        return new Promise((resolve8, reject2) => {
+        return new Promise((resolve9, reject2) => {
           if (signal.aborted) {
             reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
             return;
           }
-          const timeoutId = setTimeout(resolve8, interval);
+          const timeoutId = setTimeout(resolve9, interval);
           signal.addEventListener("abort", () => {
             clearTimeout(timeoutId);
             reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -14404,7 +14404,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve8.call(this, root, ref);
+      let _sch = resolve9.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -14431,7 +14431,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve8(root, ref) {
+    function resolve9(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -15062,7 +15062,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve8(baseURI, relativeURI, options) {
+    function resolve9(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -15320,7 +15320,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize: normalize4,
-      resolve: resolve8,
+      resolve: resolve9,
       resolveComponent,
       equal,
       serialize,
@@ -18283,8 +18283,8 @@ var require_dist = __commonJS({
         return ajv;
       }
       const [formats, exportName] = opts.mode === "fast" ? [formats_1.fastFormats, fastName] : [formats_1.fullFormats, fullName];
-      const list16 = opts.formats || formats_1.formatNames;
-      addFormats(ajv, list16, formats, exportName);
+      const list17 = opts.formats || formats_1.formatNames;
+      addFormats(ajv, list17, formats, exportName);
       if (opts.keywords)
         (0, limit_1.default)(ajv);
       return ajv;
@@ -18296,11 +18296,11 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list16, fs, exportName) {
+    function addFormats(ajv, list17, fs, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
-      for (const f of list16)
+      for (const f of list17)
         ajv.addFormat(f, fs[f]);
     }
     module.exports = exports = formatsPlugin;
@@ -20988,6 +20988,7 @@ function inTx(db, fn) {
 // ../daemon/src/core/db/migrate.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
 import { dirname, join as join8 } from "path";
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
 import { fileURLToPath } from "url";
 var migrationsDir = join8(dirname(fileURLToPath(import.meta.url)), "migrations");
 var schemaMigrationsSql = `
@@ -20996,23 +20997,28 @@ var schemaMigrationsSql = `
     applied_at INTEGER NOT NULL
   )
 `;
-var INCOMPATIBLE_DATABASE_MESSAGE = "Bazilion cannot start because this home uses an incompatible alpha database schema. Preserve the entire Bazilion home directory as a filesystem backup first, keeping bazilion.db and auth.json together. Then perform the reset with `bazilion uninstall --yes` (from the repository root of a source checkout: `pnpm tsx apps/cli/src/index.ts uninstall --yes`) and start Bazilion again. Use `--all` only if you also want to remove logs and installed skills.";
+var INCOMPATIBLE_DATABASE_MESSAGE = "Bazilion cannot start because this home uses an incompatible database schema. Preserve the entire Bazilion home directory as a filesystem backup first, keeping bazilion.db and auth.json together. Then perform the reset with `bazilion uninstall --yes` (from the repository root of a source checkout: `pnpm tsx apps/cli/src/index.ts uninstall --yes`) and start Bazilion again. Use `--all` only if you also want to remove logs and installed skills.";
 var IncompatibleDatabaseError = class extends Error {
   constructor() {
     super(INCOMPATIBLE_DATABASE_MESSAGE);
     this.name = "IncompatibleDatabaseError";
   }
 };
-var canonicalSchemaObjects = null;
-function migrationFiles() {
+var DatabaseNewerThanBinaryError = class extends Error {
+  constructor(dbVersion, supportedVersion) {
+    super(
+      `Bazilion cannot start because this home was written by a newer version: its database schema version (${dbVersion}) is newer than this binary supports (${supportedVersion}). Upgrade Bazilion to a release that supports this schema. Downgrades are unsupported; if you must run an older release, restore a pre-upgrade snapshot instead.`
+    );
+    this.name = "DatabaseNewerThanBinaryError";
+  }
+};
+function listMigrations() {
   return readdirSync2(migrationsDir).filter((file) => file.endsWith(".sql")).sort().map((file) => ({
     version: file.replace(/\.sql$/, ""),
     sql: readFileSync5(join8(migrationsDir, file), "utf8")
   }));
 }
-function normalizeSql(sql) {
-  return sql.replace(/\s+/g, " ").trim();
-}
+var canonicalSchemaObjectsByPrefix = /* @__PURE__ */ new Map();
 function schemaObjects(db) {
   return db.raw.query(
     `SELECT type, name, tbl_name, sql
@@ -21024,46 +21030,61 @@ function schemaObjects(db) {
 function schemaPayload(rows) {
   return rows.map((row2) => [row2.type, row2.name, row2.tbl_name, normalizeSql(row2.sql)].join("\0")).join("\n");
 }
-function expectedSchema(files) {
-  if (canonicalSchemaObjects !== null) return canonicalSchemaObjects;
+function normalizeSql(sql) {
+  return sql.replace(/\s+/g, " ").trim();
+}
+function expectedSchema(files, prefixLength) {
+  const cached2 = canonicalSchemaObjectsByPrefix.get(prefixLength);
+  if (cached2) return cached2;
   const canonical = openInMemoryDb();
   try {
     canonical.raw.exec(schemaMigrationsSql);
-    for (const file of files) canonical.raw.exec(file.sql);
-    canonicalSchemaObjects = schemaObjects(canonical);
-    return canonicalSchemaObjects;
+    for (const file of files.slice(0, prefixLength)) canonical.raw.exec(file.sql);
+    const objects = schemaObjects(canonical);
+    canonicalSchemaObjectsByPrefix.set(prefixLength, objects);
+    return objects;
   } finally {
     canonical.close();
   }
 }
 function assertMigrationCompatibility(db) {
-  const files = migrationFiles();
+  const files = listMigrations();
   const expectedVersions = files.map((file) => file.version);
+  const dbUserVersion = userVersion(db);
+  if (dbUserVersion > files.length) {
+    throw new DatabaseNewerThanBinaryError(dbUserVersion, files.length);
+  }
   let appliedVersions;
   try {
     appliedVersions = db.raw.query("SELECT version FROM schema_migrations ORDER BY version").all().map((row2) => row2.version);
   } catch {
     throw new IncompatibleDatabaseError();
   }
-  const actualObjects = schemaObjects(db);
-  const expectedObjects = expectedSchema(files);
   if (appliedVersions.length === 0) {
-    const migrationTable = actualObjects.filter(
+    const actualObjects2 = schemaObjects(db);
+    const migrationTable = actualObjects2.filter(
       (row2) => row2.type === "table" && row2.name === "schema_migrations"
     );
-    const expectedMigrationTable = expectedObjects.filter(
+    const expectedMigrationTable = expectedSchema(files, 0).filter(
       (row2) => row2.type === "table" && row2.name === "schema_migrations"
     );
-    if (actualObjects.length !== 1 || migrationTable.length !== 1 || schemaPayload(migrationTable) !== schemaPayload(expectedMigrationTable)) {
+    if (actualObjects2.length !== 1 || migrationTable.length !== 1 || schemaPayload(migrationTable) !== schemaPayload(expectedMigrationTable)) {
       throw new IncompatibleDatabaseError();
     }
     return;
   }
-  if (appliedVersions.length !== expectedVersions.length || appliedVersions.some((version2, index) => version2 !== expectedVersions[index]) || schemaPayload(actualObjects) !== schemaPayload(expectedObjects)) {
+  const expectedSet = new Set(expectedVersions);
+  const isPrefix = appliedVersions.every((version2) => expectedSet.has(version2)) && appliedVersions.length <= expectedVersions.length && appliedVersions.every((version2, index) => version2 === expectedVersions[index]);
+  if (!isPrefix) {
+    throw new IncompatibleDatabaseError();
+  }
+  const actualObjects = schemaObjects(db);
+  const expectedObjects = expectedSchema(files, appliedVersions.length);
+  if (schemaPayload(actualObjects) !== schemaPayload(expectedObjects)) {
     throw new IncompatibleDatabaseError();
   }
 }
-function runMigrations(db) {
+function runMigrations(db, options = {}) {
   const existingObjects = schemaObjects(db);
   if (existingObjects.length > 0 && !existingObjects.some((row2) => row2.type === "table" && row2.name === "schema_migrations")) {
     throw new IncompatibleDatabaseError();
@@ -21073,8 +21094,13 @@ function runMigrations(db) {
   const applied = new Set(
     db.raw.query("SELECT version FROM schema_migrations").all().map((r) => r.version)
   );
-  for (const file of migrationFiles()) {
-    if (applied.has(file.version)) continue;
+  const files = listMigrations();
+  const pending = files.filter((file) => !applied.has(file.version));
+  if (pending.length > 0 && applied.size > 0 && options.preMigrationSnapshotPath !== void 0) {
+    db.raw.exec(`VACUUM INTO '${options.preMigrationSnapshotPath.replaceAll("'", "''")}'`);
+    verifySnapshot(options.preMigrationSnapshotPath);
+  }
+  for (const file of pending) {
     const tx = db.raw.transaction(() => {
       db.raw.exec(file.sql);
       db.raw.run("INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)", [
@@ -21084,14 +21110,38 @@ function runMigrations(db) {
     });
     tx();
   }
+  if (userVersion(db) < files.length) {
+    db.raw.exec(`PRAGMA user_version = ${files.length}`);
+  }
   assertMigrationCompatibility(db);
 }
+function userVersion(db) {
+  const row2 = db.raw.query("PRAGMA user_version").all()[0];
+  const value = row2?.user_version;
+  return typeof value === "number" ? value : Number(value ?? 0);
+}
+function verifySnapshot(path) {
+  const snapshot = new DatabaseSync2(path);
+  try {
+    const row2 = snapshot.prepare("PRAGMA integrity_check").get();
+    if (row2.integrity_check !== "ok") {
+      throw new Error(
+        `Pre-migration snapshot failed integrity check: ${String(row2.integrity_check)}`
+      );
+    }
+  } finally {
+    snapshot.close();
+  }
+}
 
 // ../daemon/src/core/paths.ts
+import { realpathSync } from "fs";
 import { homedir } from "os";
-import { join as join9 } from "path";
+import { basename, dirname as dirname2, join as join9, resolve as resolve2 } from "path";
 function resolvePaths(home) {
-  const root = home ?? process.env.BAZILION_HOME ?? join9(homedir(), ".bazilion");
+  const root = canonicalHome(
+    resolve2(home ?? process.env.BAZILION_HOME ?? join9(homedir(), ".bazilion"))
+  );
   return {
     home: root,
     db: join9(root, "bazilion.db"),
@@ -21115,6 +21165,22 @@ function resolvePaths(home) {
     }
   };
 }
+function canonicalHome(root) {
+  let resolved = root;
+  const unresolvedTail = [];
+  while (true) {
+    try {
+      resolved = realpathSync(resolved);
+      break;
+    } catch {
+      const parent = dirname2(resolved);
+      if (parent === resolved) break;
+      unresolvedTail.unshift(basename(resolved));
+      resolved = parent;
+    }
+  }
+  return join9(resolved, ...unresolvedTail);
+}
 
 // ../daemon/src/core/profile/delete.ts
 import { existsSync as existsSync6, rmSync as rmSync4 } from "fs";
@@ -23606,60 +23672,197 @@ function remove8(db, id) {
   db.raw.run("DELETE FROM agent_triggers WHERE id = ?", [id]);
 }
 
+// ../daemon/src/core/repos/webPairingTokens.ts
+var webPairingTokens_exports = {};
+__export(webPairingTokens_exports, {
+  PAIRING_TOKEN_TTL_MS: () => PAIRING_TOKEN_TTL_MS,
+  completeExchange: () => completeExchange,
+  create: () => create2,
+  exchange: () => exchange,
+  list: () => list9
+});
+import { createHash as createHash3, randomBytes as randomBytes3, randomUUID as randomUUID11 } from "crypto";
+
+// ../../packages/api-types/src/entities.ts
+var REASONING_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh"
+];
+var DEVICE_TOKEN_SCOPES = ["read", "write", "approvals", "admin"];
+var ALL_DEVICE_TOKEN_SCOPES = DEVICE_TOKEN_SCOPES;
+
+// ../../packages/api-types/src/git-review.ts
+var REVIEW_LIMITS = {
+  files: 1e3,
+  fileBytes: 1024 * 1024,
+  totalBytes: 16 * 1024 * 1024,
+  patchBytes: 256 * 1024
+};
+
+// ../../packages/api-types/src/publication.ts
+var PUBLICATION_LIMITS = {
+  repository: 200,
+  branch: 200,
+  commitMessage: 2e3,
+  refusalDetail: 400,
+  error: 400,
+  /** Branches that are never published to, whatever the host says. */
+  protectedBranches: ["main", "master", "trunk", "develop", "release"]
+};
+
+// ../../packages/api-types/src/verification.ts
+var VERIFICATION_OUTCOME_LIMITS = [
+  "Facts above are executor-owned. A non-zero exit is a result about the commands that ran, never proof about later code, and this is not an approval to publish, merge or deploy.",
+  "Declared output paths are not enforced, so a change they do not cover appears above rather than being prevented."
+];
+
+// ../../packages/api-types/src/index.ts
+var PROFILE_FILES = [
+  "profile.json",
+  "SOUL.md",
+  "IDENTITY.md",
+  "BOOTSTRAP.md",
+  "AGENTS.md",
+  "TOOLS.md"
+];
+
+// ../daemon/src/core/repos/webPairingTokens.ts
+var PAIRING_TOKEN_TTL_MS = 10 * 6e4;
+function hashToken(token) {
+  return createHash3("sha256").update(token).digest("hex");
+}
+function create2(db, opts = {}) {
+  const id = randomUUID11();
+  const code = randomBytes3(24).toString("hex");
+  const now = Date.now();
+  const scopes = (opts.scopes ?? ALL_DEVICE_TOKEN_SCOPES).join(" ");
+  db.raw.run(
+    `INSERT INTO web_pairing_tokens (id, token_hash, scopes, created_at, expires_at)
+     VALUES (?, ?, ?, ?, ?)`,
+    [id, hashToken(code), scopes, now, now + PAIRING_TOKEN_TTL_MS]
+  );
+  return {
+    code,
+    meta: {
+      id,
+      scopes: scopes.split(" "),
+      createdAt: now,
+      expiresAt: now + PAIRING_TOKEN_TTL_MS,
+      usedAt: null,
+      usedByTokenId: null
+    }
+  };
+}
+function exchange(db, code, now = Date.now()) {
+  const tokenHash = hashToken(code);
+  const claimed = db.raw.run(
+    `UPDATE web_pairing_tokens
+       SET used_at = ?, used_by_token_id = 'pending'
+       WHERE token_hash = ? AND used_at IS NULL AND expires_at > ?`,
+    [now, tokenHash, now]
+  );
+  if (claimed.changes === 0) {
+    const row3 = db.raw.query(
+      "SELECT expires_at, used_at FROM web_pairing_tokens WHERE token_hash = ?"
+    ).get(tokenHash);
+    if (!row3) return { ok: false, reason: "invalid" };
+    if (row3.used_at !== null) return { ok: false, reason: "used" };
+    return { ok: false, reason: "expired" };
+  }
+  const row2 = db.raw.query(
+    "SELECT scopes, used_by_token_id FROM web_pairing_tokens WHERE token_hash = ?"
+  ).get(tokenHash);
+  if (!row2) return { ok: false, reason: "invalid" };
+  return { ok: true, scopes: row2.scopes.split(" ") };
+}
+function completeExchange(db, code, deviceTokenId) {
+  db.raw.run(
+    `UPDATE web_pairing_tokens SET used_by_token_id = ?
+     WHERE token_hash = ? AND used_by_token_id = 'pending'`,
+    [deviceTokenId, hashToken(code)]
+  );
+}
+function list9(db, opts) {
+  const sql = opts?.includeUsed ? "SELECT * FROM web_pairing_tokens ORDER BY created_at DESC" : "SELECT * FROM web_pairing_tokens WHERE used_at IS NULL AND expires_at > ? ORDER BY created_at DESC";
+  const rows = opts?.includeUsed ? db.raw.query(sql).all() : db.raw.query(sql).all(Date.now());
+  return rows.map((r) => ({
+    id: r.id,
+    scopes: r.scopes.split(" "),
+    createdAt: r.created_at,
+    expiresAt: r.expires_at,
+    usedAt: r.used_at,
+    usedByTokenId: r.used_by_token_id
+  }));
+}
+
 // ../daemon/src/core/repos/webSessions.ts
 var webSessions_exports = {};
 __export(webSessions_exports, {
   SESSION_ABSOLUTE_MS: () => SESSION_ABSOLUTE_MS,
   SESSION_IDLE_MS: () => SESSION_IDLE_MS,
   authenticate: () => authenticate,
-  create: () => create3,
+  create: () => create4,
   csrfMatches: () => csrfMatches,
-  list: () => list10,
+  list: () => list11,
   revoke: () => revoke3,
   revokeAll: () => revokeAll,
   revokeForDevice: () => revokeForDevice
 });
-import { createHash as createHash4, randomBytes as randomBytes4, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash5, randomBytes as randomBytes5, randomUUID as randomUUID13 } from "crypto";
 
 // ../daemon/src/core/repos/webTokens.ts
 var webTokens_exports = {};
 __export(webTokens_exports, {
-  create: () => create2,
+  create: () => create3,
   findActiveByToken: () => findActiveByToken,
   get: () => get16,
-  hashToken: () => hashToken,
-  list: () => list9,
+  hashToken: () => hashToken2,
+  list: () => list10,
   markUsed: () => markUsed,
+  parseScopes: () => parseScopes,
   rejectionReason: () => rejectionReason,
   revoke: () => revoke2
 });
-import { createHash as createHash3, randomBytes as randomBytes3, randomUUID as randomUUID11 } from "crypto";
+import { createHash as createHash4, randomBytes as randomBytes4, randomUUID as randomUUID12 } from "crypto";
+function parseScopes(raw2) {
+  if (!raw2) return [...ALL_DEVICE_TOKEN_SCOPES];
+  const parsed = raw2.split(/\s+/).filter(Boolean).filter(
+    (s) => ALL_DEVICE_TOKEN_SCOPES.includes(s)
+  );
+  return parsed.length > 0 ? parsed : [...ALL_DEVICE_TOKEN_SCOPES];
+}
 function toToken(r) {
   return {
     id: r.id,
     label: r.label,
     kind: r.kind,
+    scopes: parseScopes(r.scopes),
     createdAt: r.created_at,
     lastUsedAt: r.last_used_at,
     expiresAt: r.expires_at,
     revokedAt: r.revoked_at
   };
 }
-function hashToken(token) {
-  return createHash3("sha256").update(token).digest("hex");
+function hashToken2(token) {
+  return createHash4("sha256").update(token).digest("hex");
 }
-function create2(db, label, opts = {}) {
-  const id = randomUUID11();
-  const token = randomBytes3(24).toString("hex");
-  const tokenHash = hashToken(token);
+function create3(db, label, opts = {}) {
+  const id = randomUUID12();
+  const token = randomBytes4(24).toString("hex");
+  const tokenHash = hashToken2(token);
   const now = Date.now();
   const kind = opts.kind ?? "device";
   const expiresAt = kind === "bootstrap" ? null : opts.expiresAt ?? now + 90 * 864e5;
+  const scopes = (kind === "bootstrap" ? ALL_DEVICE_TOKEN_SCOPES : opts.scopes ?? ALL_DEVICE_TOKEN_SCOPES).join(" ");
   db.raw.run(
     `INSERT INTO web_tokens
-       (id, label, kind, token_hash, created_at, last_used_at, expires_at, revoked_at)
-     VALUES (?, ?, ?, ?, ?, NULL, ?, NULL)`,
-    [id, label, kind, tokenHash, now, expiresAt]
+       (id, label, kind, token_hash, scopes, created_at, last_used_at, expires_at, revoked_at)
+     VALUES (?, ?, ?, ?, ?, ?, NULL, ?, NULL)`,
+    [id, label, kind, tokenHash, scopes, now, expiresAt]
   );
   return {
     token,
@@ -23667,6 +23870,7 @@ function create2(db, label, opts = {}) {
       id,
       label,
       kind,
+      scopes: parseScopes(scopes),
       createdAt: now,
       lastUsedAt: null,
       expiresAt,
@@ -23674,7 +23878,7 @@ function create2(db, label, opts = {}) {
     }
   };
 }
-function list9(db, opts) {
+function list10(db, opts) {
   const sql = opts?.includeRevoked ? "SELECT * FROM web_tokens ORDER BY created_at ASC" : "SELECT * FROM web_tokens WHERE revoked_at IS NULL ORDER BY created_at ASC";
   return db.raw.query(sql).all().map(toToken);
 }
@@ -23683,7 +23887,7 @@ function get16(db, id) {
   return row2 ? toToken(row2) : null;
 }
 function findActiveByToken(db, token) {
-  const tokenHash = hashToken(token);
+  const tokenHash = hashToken2(token);
   const row2 = db.raw.query(
     `SELECT * FROM web_tokens
        WHERE token_hash = ? AND revoked_at IS NULL
@@ -23694,7 +23898,7 @@ function findActiveByToken(db, token) {
 function rejectionReason(db, token, now = Date.now()) {
   const row2 = db.raw.query(
     "SELECT expires_at, revoked_at FROM web_tokens WHERE token_hash = ?"
-  ).get(hashToken(token));
+  ).get(hashToken2(token));
   if (!row2) return "invalid";
   if (row2.revoked_at !== null) return "revoked";
   if (row2.expires_at !== null && row2.expires_at <= now) return "expired";
@@ -23715,7 +23919,7 @@ function revoke2(db, id, when = Date.now()) {
 var SESSION_IDLE_MS = 12 * 60 * 60 * 1e3;
 var SESSION_ABSOLUTE_MS = 7 * 24 * 60 * 60 * 1e3;
 function hash(value) {
-  return createHash4("sha256").update(value).digest("hex");
+  return createHash5("sha256").update(value).digest("hex");
 }
 function toSession(row2, currentId) {
   return {
@@ -23730,15 +23934,15 @@ function toSession(row2, currentId) {
     current: row2.id === currentId
   };
 }
-function create3(db, deviceTokenId, now = Date.now()) {
+function create4(db, deviceTokenId, now = Date.now()) {
   const token = db.raw.query(
     `SELECT id, label FROM web_tokens
        WHERE id = ? AND kind = 'device' AND revoked_at IS NULL AND expires_at > ?`
   ).get(deviceTokenId, now);
   if (!token) throw new Error("active device credential required");
-  const id = randomUUID12();
-  const secret = randomBytes4(32).toString("base64url");
-  const csrfToken = randomBytes4(32).toString("base64url");
+  const id = randomUUID13();
+  const secret = randomBytes5(32).toString("base64url");
+  const csrfToken = randomBytes5(32).toString("base64url");
   const idleExpiresAt = now + SESSION_IDLE_MS;
   const absoluteExpiresAt = now + SESSION_ABSOLUTE_MS;
   db.raw.run(
@@ -23771,7 +23975,7 @@ function authenticate(db, cookieValue, now = Date.now()) {
   const secret = cookieValue.slice(separator + 1);
   if (!secret) return null;
   const row2 = db.raw.query(
-    `SELECT s.*, t.label AS device_label
+    `SELECT s.*, t.label AS device_label, t.scopes AS device_scopes
        FROM web_sessions s JOIN web_tokens t ON t.id = s.device_token_id
        WHERE s.id = ? AND s.secret_hash = ? AND s.revoked_at IS NULL
          AND s.idle_expires_at > ? AND s.absolute_expires_at > ?
@@ -23788,13 +23992,14 @@ function authenticate(db, cookieValue, now = Date.now()) {
     id,
     deviceTokenId: row2.device_token_id,
     deviceLabel: row2.device_label,
+    deviceScopes: row2.device_scopes,
     csrfHash: row2.csrf_hash
   };
 }
 function csrfMatches(session, csrf) {
-  return hashToken(csrf) === session.csrfHash;
+  return hashToken2(csrf) === session.csrfHash;
 }
-function list10(db, opts = {}) {
+function list11(db, opts = {}) {
   const where = opts.includeRevoked ? "" : "WHERE s.revoked_at IS NULL";
   return db.raw.query(
     `SELECT s.*, t.label AS device_label FROM web_sessions s
@@ -23853,7 +24058,7 @@ function mergeSecretsIntoEnv(db, password, env = process.env) {
 // ../daemon/src/core/skills/import.ts
 import { cpSync, existsSync as existsSync8, mkdtempSync, readdirSync as readdirSync3, rmSync as rmSync5, statSync as statSync2 } from "fs";
 import { tmpdir } from "os";
-import { basename, join as join11, resolve as resolve2, sep } from "path";
+import { basename as basename2, join as join11, resolve as resolve3, sep } from "path";
 import AdmZip from "adm-zip";
 
 // ../daemon/src/core/skills/parse.ts
@@ -23967,7 +24172,7 @@ function extractZipSafely(zipPath) {
       if (rawName.startsWith("/") || rawName.startsWith("\\")) {
         throw new Error(`zip entry has absolute path: ${rawName}`);
       }
-      const resolved = resolve2(root, rawName);
+      const resolved = resolve3(root, rawName);
       if (resolved !== root && !resolved.startsWith(root + sep)) {
         throw new Error(`zip entry escapes extraction root: ${rawName}`);
       }
@@ -23985,7 +24190,7 @@ function extractZipSafely(zipPath) {
   return { root, effectiveSource };
 }
 function importSkills(paths2, input) {
-  const rawSource = resolve2(input.source);
+  const rawSource = resolve3(input.source);
   if (!existsSync8(rawSource)) {
     throw new Error(`source does not exist: ${rawSource}`);
   }
@@ -24011,7 +24216,7 @@ function importSkills(paths2, input) {
 function importSkillsFromDir(paths2, source, input) {
   const candidates = [];
   if (existsSync8(join11(source, "SKILL.md"))) {
-    candidates.push({ name: basename(source), dir: source });
+    candidates.push({ name: basename2(source), dir: source });
   } else {
     const entries = readdirSync3(source, { withFileTypes: true });
     for (const e of entries) {
@@ -24078,7 +24283,7 @@ function resolveAgentSkills(db, paths2, agentId) {
 }
 
 // ../daemon/src/core/team/delete.ts
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 import { existsSync as existsSync9, renameSync as renameSync2, rmSync as rmSync6 } from "fs";
 function deleteTeam(db, paths2, id, expectedTeamPolicyRevision) {
   const g2 = get3(db, id, paths2);
@@ -24097,7 +24302,7 @@ function deleteTeam(db, paths2, id, expectedTeamPolicyRevision) {
       `cannot delete team "${id}": ${members2.length} agent(s) still belong to it: ${names}. Move or delete them first.`
     );
   }
-  const stagedPath = `${g2.path}.deleting-${randomUUID13()}`;
+  const stagedPath = `${g2.path}.deleting-${randomUUID14()}`;
   const hadSlot = existsSync9(g2.path);
   if (hadSlot) renameSync2(g2.path, stagedPath);
   try {
@@ -24121,7 +24326,7 @@ function deleteTeam(db, paths2, id, expectedTeamPolicyRevision) {
 }
 
 // ../daemon/src/core/team-policy/adopt.ts
-import { randomUUID as randomUUID14 } from "crypto";
+import { randomUUID as randomUUID15 } from "crypto";
 function previewTeamPolicyAdoption(db, teamId, input) {
   return resolveAdoptionPlan(db, teamId, { ...input, previewEdges: [] }).resolved;
 }
@@ -24194,7 +24399,7 @@ function adoptTeamTemplate(db, teamId, input) {
     );
     db.raw.run("DELETE FROM template_instantiations WHERE team_id = ?", [teamId]);
     db.raw.run("DELETE FROM team_policy_edges WHERE team_id = ?", [teamId]);
-    const instantiationId = randomUUID14();
+    const instantiationId = randomUUID15();
     db.raw.run(
       `INSERT INTO template_instantiations
          (id, team_id, template_id, template_revision, created_at)
@@ -24292,7 +24497,7 @@ function edgeKey(edge) {
 }
 
 // ../daemon/src/core/team-policy/authorization.ts
-import { createHash as createHash5, randomUUID as randomUUID15 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID16 } from "crypto";
 function denied(channel, code, reason) {
   return {
     decision: "deny",
@@ -24442,7 +24647,7 @@ function authorizeInSnapshot(db, input) {
   };
 }
 function authorizationFingerprint(input, operation) {
-  return createHash5("sha256").update(JSON.stringify({ operation, source: input.source, target: input.target })).digest("hex");
+  return createHash6("sha256").update(JSON.stringify({ operation, source: input.source, target: input.target })).digest("hex");
 }
 function recordDenial(db, input, operation, result) {
   const fingerprint2 = authorizationFingerprint(input, operation);
@@ -24472,7 +24677,7 @@ function recordDenial(db, input, operation, result) {
   const sourceGroup = agentGroup(input.source) ?? agentGroup(input.target) ?? ("teamId" in input.source ? input.source.teamId : null);
   const targetGroup = agentGroup(input.target) ?? agentGroup(input.source) ?? ("teamId" in input.target ? input.target.teamId : null);
   const values = [
-    randomUUID15(),
+    randomUUID16(),
     input.attemptKind,
     input.attemptId,
     operation,
@@ -24522,7 +24727,7 @@ function recordDenial(db, input, operation, result) {
 }
 
 // ../daemon/src/core/team-policy/source.ts
-import { randomUUID as randomUUID16 } from "crypto";
+import { randomUUID as randomUUID17 } from "crypto";
 function diffTeamPolicy(db, teamId) {
   const detail3 = detail(db, teamId);
   if (!detail3) throw new Error(`team_policy_missing: ${teamId}`);
@@ -24590,7 +24795,7 @@ function saveTeamPolicyAsTemplate(db, paths2, teamId, input) {
     const team = get3(db, teamId, paths2);
     if (!team) throw new Error(`team not found: ${teamId}`);
     const members2 = list(db, { includeArchived: true }).filter((agent) => agent.teamId === teamId);
-    const slotByAgent = new Map(members2.map((agent) => [agent.id, randomUUID16()]));
+    const slotByAgent = new Map(members2.map((agent) => [agent.id, randomUUID17()]));
     const stateByAgent = new Map(
       agentState(db, teamId).map((state3) => [state3.agentId, state3])
     );
@@ -24666,7 +24871,7 @@ function updateTeamPolicySource(db, teamId, input) {
       baselineBindings.map((binding) => [binding.agentId, binding.sourceSlotId])
     );
     for (const id of selectedIds) {
-      if (!slotByAgent.has(id)) slotByAgent.set(id, randomUUID16());
+      if (!slotByAgent.has(id)) slotByAgent.set(id, randomUUID17());
     }
     const previousSlotById = new Map(previous.slots.map((slot) => [slot.slotId, slot]));
     const selectedMembers = [...selectedIds].map((id) => {
@@ -24734,7 +24939,7 @@ function pruneEmptyNonbaselineInstantiation(db, instantiationId, baselineId) {
 }
 
 // ../daemon/src/core/team-policy/spawn.ts
-import { randomUUID as randomUUID17 } from "crypto";
+import { randomUUID as randomUUID18 } from "crypto";
 import { readdirSync as readdirSync4, rmSync as rmSync8 } from "fs";
 
 // ../daemon/src/core/team-policy/rm-with-retry.ts
@@ -24901,7 +25106,7 @@ async function spawnTeamTemplate(db, paths2, input) {
           })
         );
       }
-      const instantiationId = randomUUID17();
+      const instantiationId = randomUUID18();
       db.raw.run(
         `INSERT INTO template_instantiations
            (id, team_id, template_id, template_revision, created_at)
@@ -24989,6 +25194,7 @@ function safeReaddir(path) {
 
 // ../daemon/src/lib/ctx.ts
 import { chmodSync, existsSync as existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync14 } from "fs";
+import { dirname as dirname7, join as join30 } from "path";
 
 // ../daemon/src/core/repos/coding-commands.ts
 var CODING_COMMAND_TTL_MS = 7 * 864e5;
@@ -25048,7 +25254,7 @@ function interruptCodingCommands(db, turnId) {
 }
 
 // ../daemon/src/core/repos/notifications.ts
-import { randomUUID as randomUUID18 } from "crypto";
+import { randomUUID as randomUUID19 } from "crypto";
 var NOTIFICATION_RECEIPT_LIMIT = 1e5;
 var settingsFields = `revision, enabled, restore_paused restorePaused, kinds_json kindsJson,
   timezone, quiet_json quietJson, destination_json destinationJson, eligible_after eligibleAfter,
@@ -25177,7 +25383,7 @@ function admit(db, item, binding, now = Date.now()) {
     if (existing) return decode(existing);
     const count3 = db.raw.query("SELECT COUNT(*) n FROM notification_receipts").get()?.n ?? 0;
     if (count3 >= NOTIFICATION_RECEIPT_LIMIT) throw new Error("notification_capacity_reached");
-    const id = randomUUID18();
+    const id = randomUUID19();
     db.raw.run(
       `INSERT INTO notification_receipts (id, source_kind, source_id, agent_id, team_id,
       destination_id, destination_json, state, created_at, updated_at)
@@ -25197,7 +25403,7 @@ function admit(db, item, binding, now = Date.now()) {
     return get17(db, id);
   })();
 }
-function list11(db, options = {}) {
+function list12(db, options = {}) {
   if (options.limit !== void 0 && !Number.isFinite(options.limit))
     throw new Error("notification_limit_invalid");
   const limit = Math.max(1, Math.min(100, Math.trunc(options.limit ?? 50)));
@@ -25271,7 +25477,7 @@ function recoverInterrupted(db, now = Date.now()) {
 }
 
 // ../daemon/src/core/repos/publications.ts
-import { randomUUID as randomUUID19 } from "crypto";
+import { randomUUID as randomUUID20 } from "crypto";
 var PUBLICATION_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var PublicationError = class extends Error {
   constructor(code, message) {
@@ -25312,7 +25518,7 @@ function toRecord(row2) {
 }
 function createPublication(db, input) {
   const now = input.now ?? Date.now();
-  const id = randomUUID19();
+  const id = randomUUID20();
   return inTx(db, () => {
     const published = db.raw.query(
       "SELECT id FROM publications WHERE packet_id = ? AND state = 'published'"
@@ -25465,7 +25671,7 @@ function notePublicationError(db, id, error2, now = Date.now()) {
 }
 
 // ../daemon/src/core/repos/questions.ts
-import { createHash as createHash6, randomUUID as randomUUID20 } from "crypto";
+import { createHash as createHash7, randomUUID as randomUUID21 } from "crypto";
 
 // ../daemon/src/lib/question-input.ts
 var QUESTION_LIMITS = Object.freeze({
@@ -25580,7 +25786,7 @@ function get18(db, agentId, id) {
   ).get(agentId, id);
   return row2 ? decode2(row2) : null;
 }
-function list12(db, agentId, limit = 20, conversationId) {
+function list13(db, agentId, limit = 20, conversationId) {
   if (!Number.isInteger(limit) || limit < 1 || limit > 100)
     throw new Error("Invalid question limit");
   return db.raw.query(
@@ -25592,7 +25798,7 @@ function required(db, agentId, id) {
   if (!item) throw new Error("Question unavailable");
   return item;
 }
-function create4(db, input, now = Date.now()) {
+function create5(db, input, now = Date.now()) {
   const question = parseQuestionInput(input.question);
   if (!input.turnId || !input.toolCallId || input.turnId.length > 256 || input.toolCallId.length > 256)
     throw new Error("Invalid question identity");
@@ -25611,7 +25817,7 @@ function create4(db, input, now = Date.now()) {
       COALESCE(SUM(status = 'pending'), 0) AS pending, COALESCE(SUM(turn_id = ?), 0) AS turn FROM agent_questions`).get(input.turnId);
     if (!count3 || count3.total >= QUESTION_LIMITS.recordsPerHome || count3.pending >= QUESTION_LIMITS.pendingPerHome || count3.turn >= QUESTION_LIMITS.perTurn)
       throw new Error("Question capacity reached");
-    const id = randomUUID20();
+    const id = randomUUID21();
     db.raw.run(
       `INSERT INTO agent_questions (id, agent_id, team_id, conversation_id, turn_id, tool_call_id,
       question_json, binding_json, status, created_at, expires_at, continuation) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?, ?, 'waiting')`,
@@ -25733,7 +25939,7 @@ function retireClosedApprovals(db, now) {
       now
     );
 }
-var digest2 = (value) => createHash6("sha256").update(JSON.stringify(value)).digest("hex");
+var digest2 = (value) => createHash7("sha256").update(JSON.stringify(value)).digest("hex");
 function approvalSnapshot(db, agentId, id) {
   const question = get18(db, agentId, id);
   if (!question) return null;
@@ -25812,9 +26018,9 @@ function ownsApproval(db, capturedId, providedId) {
 }
 
 // ../daemon/src/core/repos/review-packets.ts
-import { randomUUID as randomUUID21 } from "crypto";
+import { randomUUID as randomUUID22 } from "crypto";
 var REVIEW_PACKET_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
-var REVIEW_LIMITS = {
+var REVIEW_LIMITS2 = {
   summary: 2e3,
   note: 4e3,
   path: 1e3,
@@ -25842,8 +26048,8 @@ function assertLength(value, max, field) {
 }
 function createReviewPacket(db, input) {
   const now = input.now ?? Date.now();
-  const id = randomUUID21();
-  if (input.summary) assertLength(input.summary, REVIEW_LIMITS.summary, "summary");
+  const id = randomUUID22();
+  if (input.summary) assertLength(input.summary, REVIEW_LIMITS2.summary, "summary");
   db.raw.run(
     `INSERT INTO review_packets (
        id, team_id, requester_kind, requester_agent_id, reviewer_agent_id, snapshot_id,
@@ -25906,8 +26112,8 @@ function recordReviewExport(db, packetId, revision4, now = Date.now()) {
   return Number(result.changes) > 0;
 }
 function addReviewFinding(db, input) {
-  assertLength(input.path, REVIEW_LIMITS.path, "path");
-  assertLength(input.note, REVIEW_LIMITS.note, "note");
+  assertLength(input.path, REVIEW_LIMITS2.path, "path");
+  assertLength(input.note, REVIEW_LIMITS2.note, "note");
   if (input.note.trim() === "") {
     throw new ReviewPacketError("invalid_resolution", "a finding needs a note");
   }
@@ -25915,13 +26121,13 @@ function addReviewFinding(db, input) {
     const count3 = db.raw.query(
       "SELECT count(*) AS n FROM review_findings WHERE packet_id = ?"
     ).get(input.packetId)?.n;
-    if ((count3 ?? 0) >= REVIEW_LIMITS.findings) {
+    if ((count3 ?? 0) >= REVIEW_LIMITS2.findings) {
       throw new ReviewPacketError(
         "finding_limit",
-        `a packet holds at most ${REVIEW_LIMITS.findings} findings`
+        `a packet holds at most ${REVIEW_LIMITS2.findings} findings`
       );
     }
-    const id = randomUUID21();
+    const id = randomUUID22();
     db.raw.run(
       `INSERT INTO review_findings (
          id, packet_id, author_kind, author_agent_id, path, line_start, line_end, severity, note,
@@ -25968,7 +26174,7 @@ function resolveReviewFinding(db, input) {
   if (input.resolutionNote.trim() === "") {
     throw new ReviewPacketError("invalid_resolution", "resolving a finding needs a note saying how");
   }
-  assertLength(input.resolutionNote, REVIEW_LIMITS.summary, "resolution note");
+  assertLength(input.resolutionNote, REVIEW_LIMITS2.summary, "resolution note");
   const now = input.now ?? Date.now();
   db.raw.run(
     `UPDATE review_findings
@@ -25989,8 +26195,8 @@ function resolveReviewFinding(db, input) {
   return updated;
 }
 function recordReviewConclusion(db, input) {
-  if (input.note) assertLength(input.note, REVIEW_LIMITS.note, "conclusion note");
-  const id = randomUUID21();
+  if (input.note) assertLength(input.note, REVIEW_LIMITS2.note, "conclusion note");
+  const id = randomUUID22();
   db.raw.run(
     `INSERT INTO review_conclusions (
        id, packet_id, reviewer_kind, reviewer_agent_id, conclusion, note, snapshot_id, created_at
@@ -26033,7 +26239,7 @@ function claimReviewAttempt(db, input) {
     const next = (db.raw.query(
       "SELECT COALESCE(MAX(attempt_number), 0) AS n FROM review_attempts WHERE packet_id = ?"
     ).get(input.packetId)?.n ?? 0) + 1;
-    const id = randomUUID21();
+    const id = randomUUID22();
     db.raw.run(
       `INSERT INTO review_attempts (
          id, packet_id, attempt_number, supersedes_attempt_id, state, lease_owner, lease_expires_at, created_at
@@ -26065,7 +26271,7 @@ function listReviewAttempts(db, packetId) {
   ).all(packetId).map(toAttempt);
 }
 function finishReviewAttempt(db, input) {
-  if (input.error != null) assertLength(input.error, REVIEW_LIMITS.summary, "error");
+  if (input.error != null) assertLength(input.error, REVIEW_LIMITS2.summary, "error");
   const now = input.now ?? Date.now();
   return inTx(db, () => {
     const row2 = db.raw.query(
@@ -26156,7 +26362,7 @@ function recordReportedState(db, input) {
   if (!REVIEW_REPORTED_STATES.includes(input.state)) {
     throw new ReviewPacketError("invalid_resolution", `unknown reported state: ${input.state}`);
   }
-  if (input.reference && input.reference.length > REVIEW_LIMITS.path) {
+  if (input.reference && input.reference.length > REVIEW_LIMITS2.path) {
     throw new ReviewPacketError("invalid_resolution", "the reported reference is too long");
   }
   const next = { ...packet.reported, [input.state]: input.reference?.trim() || null };
@@ -26216,7 +26422,7 @@ function toAttempt(row2) {
 }
 
 // ../daemon/src/core/repos/user-queue.ts
-import { createHash as createHash7, randomUUID as randomUUID22 } from "crypto";
+import { createHash as createHash8, randomUUID as randomUUID23 } from "crypto";
 var QUEUE_LIMITS = Object.freeze({
   perAgent: 20,
   perHome: 100,
@@ -26233,7 +26439,7 @@ var fields2 = `id, agent_id AS agentId, team_id AS teamId, conversation_id AS co
  supersedes_id AS supersedesId, approval_id AS approvalId, diagnostic, created_at AS createdAt,
  updated_at AS updatedAt, started_at AS startedAt, finished_at AS finishedAt`;
 var uuid2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var hash2 = (value) => createHash7("sha256").update(value).digest("hex");
+var hash2 = (value) => createHash8("sha256").update(value).digest("hex");
 var QueueConflictError = class extends Error {
   code = "queue_conflict";
 };
@@ -26299,7 +26505,7 @@ function get19(db, agentId, id) {
   ).get(agentId, id);
   return row2 ? hydrate(db, row2) : null;
 }
-function list13(db, agentId, options = {}) {
+function list14(db, agentId, options = {}) {
   const { all = false, limit = 20, offset = 0 } = options;
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !Number.isSafeInteger(offset) || offset < 0)
     throw new Error("Invalid queue pagination");
@@ -26404,7 +26610,7 @@ function accept(db, input, replacement) {
       db.raw.run(
         `INSERT INTO user_queue_attachments (id,item_id,ordinal,name,mime_type,byte_length,sha256,bytes) VALUES (?,?,?,?,?,?,?,?)`,
         [
-          randomUUID22(),
+          randomUUID23(),
           input.id,
           ordinal,
           file.name,
@@ -26632,7 +26838,7 @@ function approvalReference(db, agentId, id) {
 }
 
 // ../daemon/src/core/repos/verification-requests.ts
-import { randomUUID as randomUUID23 } from "crypto";
+import { randomUUID as randomUUID24 } from "crypto";
 var VERIFICATION_REQUEST_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var VERIFICATION_MAX_CHECKS = 8;
 var VERIFICATION_LIMITS = {
@@ -26724,7 +26930,7 @@ var VerificationRequestError = class extends Error {
 };
 function createVerificationRequest(db, input) {
   const now = input.now ?? Date.now();
-  const id = input.id ?? randomUUID23();
+  const id = input.id ?? randomUUID24();
   if (input.checks.length < 1)
     throw new VerificationRequestError("a request needs at least one check");
   if (input.checks.length > VERIFICATION_MAX_CHECKS) {
@@ -26842,7 +27048,7 @@ function claimVerificationAttempt(db, input) {
       `SELECT id, attempt_number FROM verification_attempts WHERE request_id = ?
          ORDER BY attempt_number DESC LIMIT 1`
     ).get(input.requestId);
-    const attemptId = randomUUID23();
+    const attemptId = randomUUID24();
     db.raw.run(
       `INSERT INTO verification_attempts
         (id, request_id, attempt_number, supersedes_attempt_id, state, lease_owner,
@@ -27030,7 +27236,7 @@ function unregisterAgent(agentId) {
   if (!state3.active.delete(agentId)) return;
   const waiters = state3.idleWaiters.get(agentId);
   state3.idleWaiters.delete(agentId);
-  for (const resolve8 of waiters ?? []) resolve8();
+  for (const resolve9 of waiters ?? []) resolve9();
 }
 function cancelAgent(agentId) {
   const { active } = registry();
@@ -27048,9 +27254,9 @@ function ownsActiveAgent(agentId, controller) {
 function waitForAgentIdle(agentId) {
   const state3 = registry();
   if (!state3.active.has(agentId)) return Promise.resolve();
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const waiters = state3.idleWaiters.get(agentId) ?? /* @__PURE__ */ new Set();
-    waiters.add(resolve8);
+    waiters.add(resolve9);
     state3.idleWaiters.set(agentId, waiters);
   });
 }
@@ -27094,25 +27300,25 @@ function reconcilePrivateResults(db, options = {}) {
 }
 
 // ../daemon/src/lib/coding-environment/lifecycle.ts
-import { randomUUID as randomUUID27 } from "crypto";
+import { randomUUID as randomUUID28 } from "crypto";
 
 // ../daemon/src/lib/coding-environment/resources.ts
-import { randomUUID as randomUUID25 } from "crypto";
+import { randomUUID as randomUUID26 } from "crypto";
 
 // ../daemon/src/runtime/shell/docker.ts
 import { spawn } from "child_process";
-import { randomUUID as randomUUID24 } from "crypto";
+import { randomUUID as randomUUID25 } from "crypto";
 import { closeSync as closeSync2, constants as constants2, mkdtempSync as mkdtempSync2, openSync as openSync2, rmSync as rmSync9, writeFileSync as writeFileSync6 } from "fs";
 import { access, lstat, realpath, stat } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
 import { delimiter, isAbsolute as isAbsolute2, join as join14, relative, sep as sep2 } from "path";
 
 // ../daemon/src/runtime/coding-directory.ts
-import { realpathSync as realpathSync2 } from "fs";
+import { realpathSync as realpathSync3 } from "fs";
 import { join as join13 } from "path";
 
 // ../daemon/src/lib/repository-context/files.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import {
   closeSync,
   constants,
@@ -27121,10 +27327,10 @@ import {
   opendirSync,
   openSync,
   readSync,
-  realpathSync
+  realpathSync as realpathSync2
 } from "fs";
 import { isAbsolute, join as join12 } from "path";
-var hash3 = (value) => createHash8("sha256").update(value).digest("hex");
+var hash3 = (value) => createHash9("sha256").update(value).digest("hex");
 var ContextReadError = class extends Error {
   code;
   constructor(code) {
@@ -27162,7 +27368,7 @@ var ContextDirectory = class _ContextDirectory {
     this.label = label;
     this.parent = parent;
     if (process.platform !== "linux") throw new ContextReadError("safe_reads_unavailable");
-    const path = parent ? join12(parent.path, registeredPath) : realpathSync(registeredPath);
+    const path = parent ? join12(parent.path, registeredPath) : realpathSync2(registeredPath);
     this.fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
     const stat2 = fstatSync(this.fd);
     this.identity = hash3(identity(stat2));
@@ -27245,7 +27451,7 @@ var ContextDirectory = class _ContextDirectory {
     }
   }
   validate(skipGit = false, names) {
-    const currentPath = this.parent ? join12(this.parent.path, this.registeredPath) : realpathSync(this.registeredPath);
+    const currentPath = this.parent ? join12(this.parent.path, this.registeredPath) : realpathSync2(this.registeredPath);
     const stat2 = lstatSync(currentPath);
     if (!stat2.isDirectory() || identity(stat2) !== this.originalStamp)
       throw new ContextReadError("root_changed");
@@ -27274,7 +27480,7 @@ function resolveCodingDirectory(root, cwd) {
   try {
     let current = directory;
     for (const part of relativeParts(cwd)) current = current.directory(part);
-    const path = realpathSync2(join13(root, cwd));
+    const path = realpathSync3(join13(root, cwd));
     directory.validate();
     return { path, identity: current.identity };
   } finally {
@@ -27591,7 +27797,7 @@ function createPreparedDockerBashOperations(runtime, lifecycle) {
       }
       await assertDockerExecutableIdentity(runtime.dockerPath, runtime.executableIdentity);
       if (signal?.aborted) throw new Error("aborted");
-      const containerName = lifecycle?.name("bash") ?? `bazilion-bash-${process.pid}-${randomUUID24().replaceAll("-", "")}`;
+      const containerName = lifecycle?.name("bash") ?? `bazilion-bash-${process.pid}-${randomUUID25().replaceAll("-", "")}`;
       const spec = buildDockerRunSpec({
         image: runtime.image,
         resolvedImage: runtime.imageId,
@@ -27640,7 +27846,7 @@ async function preflightProtectedDockerEngine(input) {
 }
 async function proveProtectedContainerCreation(engine, workspace, readOnlyMounts, lifecycle, signal) {
   if (signal?.aborted) throw new Error("aborted");
-  const containerName = lifecycle?.name("preflight") ?? `bazilion-preflight-${process.pid}-${randomUUID24().replaceAll("-", "")}`;
+  const containerName = lifecycle?.name("preflight") ?? `bazilion-preflight-${process.pid}-${randomUUID25().replaceAll("-", "")}`;
   const dockerClientEnv = { DOCKER_HOST: engine.endpoint };
   const spec = buildDockerRunSpec({
     image: engine.image,
@@ -27701,7 +27907,7 @@ function runProtectedContainerCreate(spec, options) {
       )
     );
   }
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     let child;
     try {
       child = spawn(spec.executable, ["container", "create", ...spec.args.slice(1)], {
@@ -27727,7 +27933,7 @@ function runProtectedContainerCreate(spec, options) {
       if (killSettleHandle) clearTimeout(killSettleHandle);
       options?.signal?.removeEventListener("abort", onAbort);
       if (error2) reject2(error2);
-      else resolve8();
+      else resolve9();
     };
     const commandTimeout = options?.timeoutMs !== void 0 && options.timeoutMs <= DOCKER_CREATE_TIMEOUT_MS;
     const timeoutError = () => commandTimeout ? new Error(`timeout:${options?.timeout}`) : new Error(
@@ -27759,7 +27965,7 @@ function runProtectedContainerCreate(spec, options) {
 }
 function runProtectedContainerProbe(spec, signal) {
   if (signal?.aborted) return Promise.reject(new Error("aborted"));
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     let child;
     try {
       child = spawn(spec.executable, ["container", "start", "--attach", spec.containerName], {
@@ -27783,7 +27989,7 @@ function runProtectedContainerProbe(spec, signal) {
       if (killSettleHandle) clearTimeout(killSettleHandle);
       signal?.removeEventListener("abort", onAbort);
       if (error2) reject2(error2);
-      else resolve8();
+      else resolve9();
     };
     const timeoutError = () => new Error(
       `Docker sandbox could not start its protected preflight container within ${DOCKER_PROBE_START_TIMEOUT_MS}ms`
@@ -27816,7 +28022,7 @@ async function removePreflightContainer(dockerPath, containerName, processEnv, c
     last = await runCleanupCommand(dockerPath, args, processEnv);
     if (last.ok && !last.missing) return;
     if (attempt < CLEANUP_ATTEMPTS - 1) {
-      await new Promise((resolve8) => setTimeout(resolve8, CLEANUP_RETRY_DELAY_MS));
+      await new Promise((resolve9) => setTimeout(resolve9, CLEANUP_RETRY_DELAY_MS));
     }
   }
   if (last?.missing && creationAcknowledged) return;
@@ -27972,7 +28178,7 @@ function createDockerBashOperations(options) {
       const dockerClientEnv = await resolveLocalDockerClientEnv(dockerPath, hostEnv);
       const resolvedImage = await inspectSandboxImage(dockerPath, image, dockerClientEnv);
       if (signal?.aborted) throw new Error("aborted");
-      const containerName = options.lifecycle?.name("bash") ?? `bazilion-bash-${process.pid}-${randomUUID24().replaceAll("-", "")}`;
+      const containerName = options.lifecycle?.name("bash") ?? `bazilion-bash-${process.pid}-${randomUUID25().replaceAll("-", "")}`;
       const spec = buildDockerRunSpec({
         image,
         env,
@@ -28037,7 +28243,7 @@ function executeDockerRun(spec, options) {
       )
     );
   }
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     const child = spawn(spec.executable, spec.args, {
       stdio: ["ignore", "pipe", "pipe", envFileFd ?? "ignore"],
       windowsHide: true,
@@ -28080,7 +28286,7 @@ function executeDockerRun(spec, options) {
         reject2(new Error(`Docker sandbox CLI for container "${spec.containerName}" was killed`));
         return;
       }
-      resolve8({ exitCode });
+      resolve9({ exitCode });
     };
     child.stdout?.on("data", options.onData);
     child.stderr?.on("data", (data) => {
@@ -28249,7 +28455,7 @@ async function inspectSandboxImage(dockerPath, image, processEnv) {
   return id;
 }
 function runDockerInspection(dockerPath, args, processEnv, subject) {
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     const child = spawn(dockerPath, args, {
       stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
@@ -28266,7 +28472,7 @@ function runDockerInspection(dockerPath, args, processEnv, subject) {
         reject2(error2);
         return;
       }
-      resolve8(stdout.trim());
+      resolve9(stdout.trim());
     };
     const timeoutHandle = setTimeout(() => {
       child.kill("SIGKILL");
@@ -28405,7 +28611,7 @@ async function removeContainer(dockerPath, containerName, processEnv) {
     last = await runCleanupCommand(dockerPath, args, processEnv);
     if (last.ok) return;
     if (attempt < CLEANUP_ATTEMPTS - 1) {
-      await new Promise((resolve8) => setTimeout(resolve8, CLEANUP_RETRY_DELAY_MS));
+      await new Promise((resolve9) => setTimeout(resolve9, CLEANUP_RETRY_DELAY_MS));
     }
   }
   if (last && !last.missing) {
@@ -28415,7 +28621,7 @@ async function removeContainer(dockerPath, containerName, processEnv) {
   }
 }
 function runCleanupCommand(dockerPath, args, processEnv) {
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     let done = false;
     let stderr = "";
     const child = spawn(dockerPath, args, {
@@ -28428,7 +28634,7 @@ function runCleanupCommand(dockerPath, args, processEnv) {
       done = true;
       clearTimeout(timeoutHandle);
       const detail3 = error2 || stderr.trim();
-      resolve8({
+      resolve9({
         ok,
         missing: /no such container/i.test(detail3),
         error: detail3
@@ -28596,7 +28802,7 @@ async function terminateWorkerProcess(identity2, observedNormalExit = false) {
         }
         killed = true;
       }
-      await new Promise((resolve8) => setTimeout(resolve8, 25));
+      await new Promise((resolve9) => setTimeout(resolve9, 25));
     }
     return false;
   } catch {
@@ -28628,7 +28834,7 @@ var WorkspaceResources = class {
   }
   register(lease, resource) {
     return inTx(this.db, () => {
-      const id = randomUUID25();
+      const id = randomUUID26();
       lease.attach({ id, kind: resource.kind });
       this.db.raw.run(
         "INSERT INTO workspace_resources (id, writer_id, kind, identity_json) VALUES (?, ?, ?, ?)",
@@ -28666,8 +28872,8 @@ var WorkspaceResources = class {
 };
 
 // ../daemon/src/lib/coding-environment/workspace.ts
-import { randomUUID as randomUUID26 } from "crypto";
-import { realpathSync as realpathSync3 } from "fs";
+import { randomUUID as randomUUID27 } from "crypto";
+import { realpathSync as realpathSync4, statSync as statSync4 } from "fs";
 import { isAbsolute as isAbsolute3, relative as relative2 } from "path";
 var WorkspaceBusyError = class extends Error {
   constructor(recoveryRequired = false) {
@@ -28685,14 +28891,18 @@ function overlappingWorkspaceRoots(a, b2) {
   return contains(a, b2) || contains(b2, a);
 }
 function workspaceIdentity(registeredRoot) {
-  const directory = new ContextDirectory(registeredRoot);
-  try {
-    const root = realpathSync3(registeredRoot);
-    directory.validate();
-    return { root, rootIdentity: directory.identity };
-  } finally {
-    directory.close();
+  if (process.platform === "linux") {
+    const directory = new ContextDirectory(registeredRoot);
+    try {
+      const root2 = realpathSync4(registeredRoot);
+      directory.validate();
+      return { root: root2, rootIdentity: directory.identity };
+    } finally {
+      directory.close();
+    }
   }
+  const root = realpathSync4(registeredRoot);
+  return { root, rootIdentity: hash3(identity(statSync4(root))) };
 }
 function view(row2) {
   return {
@@ -28710,7 +28920,7 @@ var WorkspaceCoordinator = class {
     this.db = db;
   }
   db;
-  identity = randomUUID26();
+  identity = randomUUID27();
   leases = /* @__PURE__ */ new Set();
   issued = /* @__PURE__ */ new WeakSet();
   claim(teamId, registeredRoot, kind) {
@@ -28724,7 +28934,7 @@ var WorkspaceCoordinator = class {
         const recovery = row2.daemon_identity !== this.identity || row2.state === "recovery";
         if (recovery || exclusive || row2.exclusive === 1) throw new WorkspaceBusyError(recovery);
       }
-      const id = randomUUID26();
+      const id = randomUUID27();
       this.db.raw.run(
         `INSERT INTO workspace_writers
         (id, team_id, root_path, root_identity, daemon_identity, kind, exclusive, state, created_at)
@@ -28843,7 +29053,7 @@ var WorkspaceLifecycle = class {
     const prefix = `bazilion-${lease.writer.id}-`;
     const records2 = /* @__PURE__ */ new Map();
     return {
-      name: (kind) => `${prefix}${kind}-${randomUUID27()}`,
+      name: (kind) => `${prefix}${kind}-${randomUUID28()}`,
       beforeCreate: async (identity2) => {
         if (!identity2.containerName.startsWith(prefix) || !/^bazilion-[a-z0-9-]{1,160}$/.test(identity2.containerName) || records2.has(identity2.containerName))
           throw new Error("Invalid turn container identity");
@@ -28878,7 +29088,7 @@ var WorkspaceLifecycle = class {
 };
 
 // ../daemon/src/lib/conversation-target.ts
-import { randomUUID as randomUUID29 } from "crypto";
+import { randomUUID as randomUUID30 } from "crypto";
 
 // ../daemon/src/core/repos/conversations.ts
 var columns = "id, agent_id AS agentId, title, title_revision AS titleRevision, created_at AS createdAt, updated_at AS updatedAt";
@@ -28919,7 +29129,7 @@ function filename(db, agentId, id) {
   if (!row2) throw new Error("Conversation not found");
   return row2.filename;
 }
-function list14(db, agentId, limit = 20, offset = 0) {
+function list15(db, agentId, limit = 20, offset = 0) {
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || !Number.isSafeInteger(offset) || offset < 0)
     throw new Error("Invalid conversation pagination");
   const conversations = db.raw.query(
@@ -28935,7 +29145,7 @@ function title(value) {
     throw new Error("Conversation title must be 1\u2013200 characters without control characters");
   return value.trim();
 }
-function create5(db, agentId, input, persistFile) {
+function create6(db, agentId, input, persistFile) {
   if (!uuid3.test(input.requestId)) throw new Error("Conversation requestId must be a UUID");
   if (!input.expectedSelection || !Number.isSafeInteger(input.expectedSelection.revision) || input.expectedSelection.revision < 0 || input.expectedSelection.conversationId !== null && (typeof input.expectedSelection.conversationId !== "string" || !uuid3.test(input.expectedSelection.conversationId)))
     throw new Error("Invalid expected conversation selection");
@@ -28955,7 +29165,7 @@ function create5(db, agentId, input, persistFile) {
     if (!db.raw.query("SELECT id FROM agents WHERE id = ?").get(agentId))
       throw new Error("Agent not found");
     const now = Date.now();
-    const displayTitle = initialTitle ?? `Conversation ${list14(db, agentId, 1).total + 1}`;
+    const displayTitle = initialTitle ?? `Conversation ${list15(db, agentId, 1).total + 1}`;
     const file = persistFile(input.requestId);
     if (file !== `${input.requestId}.jsonl`)
       throw new Error("Invalid canonical conversation filename");
@@ -29000,14 +29210,14 @@ function rename(db, agentId, id, value, expectedRevision) {
 }
 
 // ../daemon/src/lib/conversation-file.ts
-import { randomUUID as randomUUID28 } from "crypto";
+import { randomUUID as randomUUID29 } from "crypto";
 import {
   closeSync as closeSync4,
   constants as constants4,
   fsyncSync,
   linkSync,
   openSync as openSync4,
-  realpathSync as realpathSync5,
+  realpathSync as realpathSync6,
   unlinkSync,
   writeFileSync as writeFileSync7
 } from "fs";
@@ -29015,18 +29225,21 @@ import { join as join16 } from "path";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 
 // ../daemon/src/lib/result-source.ts
-import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync2, openSync as openSync3, readSync as readSync2, realpathSync as realpathSync4 } from "fs";
-import { basename as basename2, join as join15 } from "path";
+import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync2, lstatSync as lstatSync2, openSync as openSync3, readSync as readSync2, realpathSync as realpathSync5 } from "fs";
+import { basename as basename3, join as join15 } from "path";
 function readResultSession(paths2, agentId, filename2, sessionId, minimumEntryOffset = 0) {
-  if (basename2(filename2) !== filename2) throw new Error("Invalid result session filename");
-  const directory = join15(realpathSync4(paths2.agentsDir), agentId, "sessions");
+  if (basename3(filename2) !== filename2) throw new Error("Invalid result session filename");
+  const directory = join15(realpathSync5(paths2.agentsDir), agentId, "sessions");
   return readCanonicalSessionFile(directory, filename2, sessionId, minimumEntryOffset);
 }
 function readCanonicalSessionFile(directory, filename2, sessionId, minimumEntryOffset = 0) {
-  if (basename2(filename2) !== filename2) throw new Error("Invalid session filename");
-  if (realpathSync4(directory) !== directory) throw new Error("Result session escaped its owner");
+  if (basename3(filename2) !== filename2) throw new Error("Invalid session filename");
+  if (realpathSync5(directory) !== directory) throw new Error("Result session escaped its owner");
+  const target = join15(directory, filename2);
+  if (lstatSync2(target).isSymbolicLink())
+    throw new Error("Result session file must not be a symlink");
   const fd = openSync3(
-    join15(directory, filename2),
+    target,
     constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK
   );
   try {
@@ -29061,11 +29274,11 @@ var uuid4 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function createConversationFile(paths2, agentId, conversationId, cwd) {
   if (!uuid4.test(agentId) || !uuid4.test(conversationId))
     throw new Error("Invalid conversation identity");
-  const directory = join16(realpathSync5(paths2.agentsDir), agentId, "sessions");
-  if (realpathSync5(directory) !== directory) throw new Error("Conversation escaped its Agent");
+  const directory = join16(realpathSync6(paths2.agentsDir), agentId, "sessions");
+  if (realpathSync6(directory) !== directory) throw new Error("Conversation escaped its Agent");
   const filename2 = `${conversationId}.jsonl`;
   const destination = join16(directory, filename2);
-  const staging = join16(directory, `.conversation-${randomUUID28()}.tmp`);
+  const staging = join16(directory, `.conversation-${randomUUID29()}.tmp`);
   const header = SessionManager.inMemory(cwd, { id: conversationId }).getHeader();
   const fd = openSync4(staging, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL, 384);
   try {
@@ -29085,6 +29298,8 @@ function createConversationFile(paths2, agentId, conversationId, cwd) {
     const directoryFd = openSync4(directory, constants4.O_RDONLY | constants4.O_DIRECTORY);
     try {
       fsyncSync(directoryFd);
+    } catch (error2) {
+      if (process.platform !== "win32") throw error2;
     } finally {
       closeSync4(directoryFd);
     }
@@ -29099,11 +29314,11 @@ function resolveConversationTarget(db, paths2, agentId, pinnedId) {
   let id = pinnedId ?? selection(db, agentId).conversationId;
   if (!id) {
     const agent = resolveAgent(db, paths2, agentId);
-    id = create5(
+    id = create6(
       db,
       agentId,
       {
-        requestId: randomUUID29(),
+        requestId: randomUUID30(),
         expectedSelection: { conversationId: null, revision: 0 }
       },
       (newId) => createConversationFile(paths2, agentId, newId, agent.team.path)
@@ -29135,9 +29350,9 @@ function acquireAgentLifecycleLease(agentId) {
     leases.held.add(agentId);
     return Promise.resolve(makeRelease(agentId));
   }
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     const queue = leases.waiters.get(agentId) ?? [];
-    queue.push({ resolve: resolve8 });
+    queue.push({ resolve: resolve9 });
     leases.waiters.set(agentId, queue);
   });
 }
@@ -29170,7 +29385,7 @@ async function runAgentLifecycleMutation(agentId, mutation) {
 }
 
 // ../daemon/src/lib/agent-loop-guard.ts
-import { randomUUID as randomUUID30 } from "crypto";
+import { randomUUID as randomUUID31 } from "crypto";
 var DEFAULT_MAX_HOPS = 8;
 function toEvent(row2) {
   return {
@@ -29222,8 +29437,8 @@ function enforceMessageCausality(db, input) {
   const target = agents_exports.get(db, input.to);
   if (!source || !target) return null;
   const event2 = {
-    id: randomUUID30(),
-    causalChainId: input.causality.causalChainId ?? input.causality.parentMessageId ?? randomUUID30(),
+    id: randomUUID31(),
+    causalChainId: input.causality.causalChainId ?? input.causality.parentMessageId ?? randomUUID31(),
     parentMessageId: input.causality.parentMessageId,
     fromAgentId: input.from,
     toAgentId: input.to,
@@ -29387,26 +29602,26 @@ import {
   readdirSync as readdirSync6,
   readFileSync as readFileSync9,
   rmSync as rmSync10,
-  statSync as statSync4,
+  statSync as statSync5,
   writeFileSync as writeFileSync8
 } from "fs";
-import { dirname as dirname2, join as join17 } from "path";
+import { dirname as dirname3, join as join17 } from "path";
 
 // ../daemon/src/runtime/memory/qmd.ts
 import {
   closeSync as closeSync5,
   constants as constants5,
   fstatSync as fstatSync3,
-  lstatSync as lstatSync2,
+  lstatSync as lstatSync3,
   mkdirSync as mkdirSync5,
   openSync as openSync5,
   readdirSync as readdirSync7,
   readFileSync as readFileSync10,
-  realpathSync as realpathSync6,
+  realpathSync as realpathSync7,
   rmSync as rmSync11,
   writeFileSync as writeFileSync9
 } from "fs";
-import { dirname as dirname3, isAbsolute as isAbsolute4, join as join18, relative as relative3, resolve as resolve3, sep as sep3 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute4, join as join18, relative as relative3, resolve as resolve4, sep as sep3 } from "path";
 import { createStore, extractSnippet } from "@tobilu/qmd";
 
 // ../daemon/src/lib/native-module-error.ts
@@ -29473,7 +29688,7 @@ function unsafeMemoryPath(path, reason) {
 }
 function lstatIfPresent(path) {
   try {
-    return lstatSync2(path);
+    return lstatSync3(path);
   } catch (error2) {
     if (error2.code === "ENOENT") return void 0;
     throw error2;
@@ -29490,14 +29705,14 @@ function assertContained(root, candidate) {
 }
 function initializeSafeRoot(root) {
   mkdirSync5(root, { recursive: true });
-  const info = lstatSync2(root);
+  const info = lstatSync3(root);
   if (info.isSymbolicLink()) {
     throw unsafeMemoryPath(root, "memory root must not be a symbolic link");
   }
   if (!info.isDirectory()) {
     throw unsafeMemoryPath(root, "memory root is not a directory");
   }
-  return realpathSync6(root);
+  return realpathSync7(root);
 }
 function assertRootUnchanged(root, canonicalRoot) {
   const info = lstatIfPresent(root);
@@ -29508,7 +29723,7 @@ function assertRootUnchanged(root, canonicalRoot) {
   if (!info.isDirectory()) {
     throw unsafeMemoryPath(root, "memory root is not a directory");
   }
-  const current = realpathSync6(root);
+  const current = realpathSync7(root);
   if (relative3(canonicalRoot, current) !== "" || relative3(current, canonicalRoot) !== "") {
     throw unsafeMemoryPath(root, "memory root changed after initialization");
   }
@@ -29518,7 +29733,7 @@ function safeKey(root, key3) {
   if (key3.length === 0 || key3.includes("\0") || isAbsolute4(key3) || /^[A-Za-z]:[\\/]/.test(key3) || key3.startsWith("\\\\") || segments.includes("..")) {
     throw new Error(`unsafe memory key: ${key3}`);
   }
-  const candidate = resolve3(root, key3);
+  const candidate = resolve4(root, key3);
   if (candidate === root) throw new Error(`unsafe memory key: ${key3}`);
   assertContained(root, candidate);
   return candidate;
@@ -29538,12 +29753,12 @@ function inspectSafePath(root, path) {
     if (index < components.length - 1 && !info.isDirectory()) {
       throw unsafeMemoryPath(current, "path ancestor is not a directory");
     }
-    assertContained(root, realpathSync6(current));
+    assertContained(root, realpathSync7(current));
   }
   return lstatIfPresent(path);
 }
 function ensureSafeParentDirectories(root, path) {
-  const parent = dirname3(path);
+  const parent = dirname4(path);
   assertContained(root, parent);
   const rel = relative3(root, parent);
   let current = root;
@@ -29552,7 +29767,7 @@ function ensureSafeParentDirectories(root, path) {
     let info = lstatIfPresent(current);
     if (!info) {
       mkdirSync5(current);
-      info = lstatSync2(current);
+      info = lstatSync3(current);
     }
     if (info.isSymbolicLink()) {
       throw unsafeMemoryPath(current, "symbolic-link ancestors are not allowed");
@@ -29560,7 +29775,7 @@ function ensureSafeParentDirectories(root, path) {
     if (!info.isDirectory()) {
       throw unsafeMemoryPath(current, "path ancestor is not a directory");
     }
-    assertContained(root, realpathSync6(current));
+    assertContained(root, realpathSync7(current));
   }
 }
 function readSafeFile(root, path) {
@@ -29612,10 +29827,10 @@ function writeSafeFile(root, path, content) {
   }
 }
 function assertSafeTree(root, dir = root) {
-  assertContained(root, realpathSync6(dir));
+  assertContained(root, realpathSync7(dir));
   for (const entry of readdirSync7(dir, { withFileTypes: true })) {
     const full = join18(dir, entry.name);
-    const info = lstatSync2(full);
+    const info = lstatSync3(full);
     if (info.isSymbolicLink()) {
       throw unsafeMemoryPath(full, "symbolic links are not allowed in memory storage");
     }
@@ -29629,7 +29844,7 @@ function assertSafeTree(root, dir = root) {
 function walkMd(root, dir, prefix, out) {
   for (const entry of readdirSync7(dir, { withFileTypes: true })) {
     const full = join18(dir, entry.name);
-    const info = lstatSync2(full);
+    const info = lstatSync3(full);
     if (info.isSymbolicLink()) {
       throw unsafeMemoryPath(full, "symbolic links are not allowed in memory storage");
     }
@@ -30599,7 +30814,7 @@ var keys = (value, required3, optional2 = []) => required3.every((key3) => Objec
 var string = (value, limit = 4096) => typeof value === "string" && value.length <= limit;
 var digest3 = (value) => typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
 var count2 = (value) => Number.isSafeInteger(value) && value >= 0;
-var list15 = (value, limit, check) => Array.isArray(value) && value.length <= limit && value.every(check);
+var list16 = (value, limit, check) => Array.isArray(value) && value.length <= limit && value.every(check);
 var issue = (value) => object2(value) && keys(value, ["code", "message"], ["path"]) && string(value.code, 100) && string(value.message, 1024) && (value.path === void 0 || string(value.path));
 function assertRepositoryContext(value, teamId) {
   if (!object2(value) || !keys(value, [
@@ -30628,15 +30843,15 @@ function assertRepositoryContext(value, teamId) {
     "untracked",
     "conflicted",
     "issues"
-  ]) || !["complete", "incomplete"].includes(String(instructions.state)) || !list15(instructions.issues, 128, issue) || !list15(
+  ]) || !["complete", "incomplete"].includes(String(instructions.state)) || !list16(instructions.issues, 128, issue) || !list16(
     instructions.files,
     17,
     (file) => object2(file) && keys(file, ["path", "scope", "precedence", "sha256", "content"]) && string(file.path) && string(file.scope) && count2(file.precedence) && digest3(file.sha256) && string(file.content, 64 * 1024) && Buffer.byteLength(file.content) <= 64 * 1024
-  ) || !["complete", "incomplete"].includes(String(commands.state)) || !list15(commands.issues, 128, issue) || !list15(
+  ) || !["complete", "incomplete"].includes(String(commands.state)) || !list16(commands.issues, 128, issue) || !list16(
     commands.sources,
     32,
     (source) => object2(source) && keys(source, ["path", "sha256"]) && string(source.path) && digest3(source.sha256)
-  ) || !list15(
+  ) || !list16(
     commands.candidates,
     32,
     (candidate) => object2(candidate) && keys(candidate, [
@@ -30648,7 +30863,7 @@ function assertRepositoryContext(value, teamId) {
       "kind",
       "packageManager"
     ]) && string(candidate.source) && digest3(candidate.sha256) && string(candidate.location) && string(candidate.cwd) && string(candidate.command) && ["script", "excerpt"].includes(String(candidate.kind)) && [null, "npm", "pnpm", "yarn"].includes(candidate.packageManager)
-  ) || !["available", "unavailable", "not_repository"].includes(String(git2.state)) || ![null, "branch", "detached", "unborn"].includes(git2.headState) || ![git2.root, git2.branch, git2.head].every((value2) => value2 === null || string(value2)) || ![git2.staged, git2.unstaged, git2.untracked, git2.conflicted].every(count2) || !list15(git2.issues, 128, issue))
+  ) || !["available", "unavailable", "not_repository"].includes(String(git2.state)) || ![null, "branch", "detached", "unborn"].includes(git2.headState) || ![git2.root, git2.branch, git2.head].every((value2) => value2 === null || string(value2)) || ![git2.staged, git2.unstaged, git2.untracked, git2.conflicted].every(count2) || !list16(git2.issues, 128, issue))
     throw new Error("Invalid repository context report");
   const report2 = value;
   if (report2.instructions.files.reduce((bytes, file) => bytes + Buffer.byteLength(file.content), 0) > 128 * 1024 || report2.instructions.state === "complete" && (report2.rootIdentity === null || report2.instructions.issues.length > 0))
@@ -30741,8 +30956,8 @@ ${JSON.stringify(current.commands)}`
 }
 
 // ../daemon/src/runtime/pi/session.ts
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, statSync as statSync7, writeFileSync as writeFileSync11 } from "fs";
-import { basename as basename4, join as join24 } from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, statSync as statSync8, writeFileSync as writeFileSync11 } from "fs";
+import { basename as basename5, join as join24 } from "path";
 import {
   createAssistantMessageEventStream
 } from "@earendil-works/pi-ai";
@@ -31260,14 +31475,14 @@ function isRetryableError(err) {
   return false;
 }
 function sleepWithAbort(ms, signal) {
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     if (signal?.aborted) {
       reject2(new Error("aborted"));
       return;
     }
     const t = setTimeout(() => {
       if (signal) signal.removeEventListener("abort", onAbort);
-      resolve8();
+      resolve9();
     }, ms);
     const onAbort = () => {
       clearTimeout(t);
@@ -31859,47 +32074,47 @@ import {
   closeSync as closeSync6,
   constants as constants6,
   fstatSync as fstatSync4,
-  lstatSync as lstatSync3,
+  lstatSync as lstatSync4,
   mkdirSync as mkdirSync6,
   openSync as openSync6,
   readFileSync as readFileSync11,
-  realpathSync as realpathSync7
+  realpathSync as realpathSync8
 } from "fs";
-import { dirname as dirname4, isAbsolute as isAbsolute5, relative as relative4, resolve as resolve4 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute5, relative as relative4, resolve as resolve5 } from "path";
 function resolveRealDirectory(path) {
-  const requested = resolve4(path);
-  const entry = lstatSync3(requested);
+  const requested = resolve5(path);
+  const entry = lstatSync4(requested);
   if (entry.isSymbolicLink() || !entry.isDirectory()) {
     throw new Error("expected a real directory");
   }
-  return realpathSync7(requested);
+  return realpathSync8(requested);
 }
 function ensureContainedRealDirectory(path, root, options = {}) {
-  const requestedRoot = resolve4(root);
-  const requested = resolve4(path);
+  const requestedRoot = resolve5(root);
+  const requested = resolve5(path);
   if (!isContained2(requestedRoot, requested)) throw new Error("directory escapes its root");
-  const canonicalRoot = realpathSync7(requestedRoot);
+  const canonicalRoot = realpathSync8(requestedRoot);
   try {
-    const entry = lstatSync3(requested);
+    const entry = lstatSync4(requested);
     if (entry.isSymbolicLink() || !entry.isDirectory()) {
       throw new Error("expected a real directory");
     }
   } catch (error2) {
     if (error2.code !== "ENOENT" || !options.create) throw error2;
-    const canonicalParent = realpathSync7(dirname4(requested));
+    const canonicalParent = realpathSync8(dirname5(requested));
     if (!isContained2(canonicalRoot, canonicalParent)) throw new Error("directory escapes its root");
     mkdirSync6(requested, { recursive: true, mode: 448 });
-    const entry = lstatSync3(requested);
+    const entry = lstatSync4(requested);
     if (entry.isSymbolicLink() || !entry.isDirectory()) {
       throw new Error("expected a real directory");
     }
   }
-  const canonical = realpathSync7(requested);
+  const canonical = realpathSync8(requested);
   if (!isContained2(canonicalRoot, canonical)) throw new Error("directory escapes its root");
   return canonical;
 }
 function readRegularFileNoFollow(path) {
-  const entry = lstatSync3(path);
+  const entry = lstatSync4(path);
   if (entry.isSymbolicLink()) throw new Error("symbolic links are not allowed");
   if (!entry.isFile()) throw new Error("target is not a regular file");
   let fd;
@@ -32090,8 +32305,8 @@ function boundReviewedLessons(lessons, maxCharacters = 8e3) {
 }
 
 // ../daemon/src/runtime/shell/tooling.ts
-import { existsSync as existsSync12, lstatSync as lstatSync4, realpathSync as realpathSync8 } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute6, join as join20, relative as relative5, sep as sep4 } from "path";
+import { existsSync as existsSync12, lstatSync as lstatSync5, realpathSync as realpathSync9 } from "fs";
+import { dirname as dirname6, isAbsolute as isAbsolute6, join as join20, relative as relative5, sep as sep4 } from "path";
 import {
   createBashToolDefinition,
   createLocalBashOperations as createLocalBashOperations2,
@@ -32149,9 +32364,9 @@ function createSessionShellTools(cwd, env, options = {}) {
     env: buildSandboxContainerEnv(env, config2.envAllowlist),
     readOnlyMounts: [
       ...existsSync12(join20(cwd, "memory")) ? [safeReadOnlyMount(join20(cwd, "memory"), SANDBOX_MEMORY_DIR, cwd)] : [],
-      ...options.inputsDir ? [safeReadOnlyMount(options.inputsDir, SANDBOX_INPUTS_DIR, dirname5(options.inputsDir))] : [],
+      ...options.inputsDir ? [safeReadOnlyMount(options.inputsDir, SANDBOX_INPUTS_DIR, dirname6(options.inputsDir))] : [],
       ...(options.skillMounts ?? []).map(
-        (mount) => safeReadOnlyMount(mount.source, mount.target, dirname5(mount.source))
+        (mount) => safeReadOnlyMount(mount.source, mount.target, dirname6(mount.source))
       )
     ]
   });
@@ -32165,12 +32380,12 @@ function createSessionShellTools(cwd, env, options = {}) {
   return { config: config2, hostToolNames: [], customBash };
 }
 function safeReadOnlyMount(source, target, expectedRoot) {
-  const info = lstatSync4(source);
+  const info = lstatSync5(source);
   if (info.isSymbolicLink() || !info.isDirectory()) {
     throw new Error(`Docker sandbox read-only mount must be a real directory: ${source}`);
   }
-  const sourceRoot = realpathSync8(expectedRoot);
-  const canonicalSource = realpathSync8(source);
+  const sourceRoot = realpathSync9(expectedRoot);
+  const canonicalSource = realpathSync9(source);
   const rel = relative5(sourceRoot, canonicalSource);
   const contained = rel === "" || rel !== ".." && !rel.startsWith(`..${sep4}`) && !isAbsolute6(rel);
   if (!contained) {
@@ -32183,18 +32398,18 @@ function safeReadOnlyMount(source, target, expectedRoot) {
 import {
   constants as constants7,
   existsSync as existsSync13,
-  lstatSync as lstatSync5,
+  lstatSync as lstatSync6,
   mkdirSync as mkdirSync7,
   mkdtempSync as mkdtempSync3,
-  realpathSync as realpathSync9,
+  realpathSync as realpathSync10,
   rmSync as rmSync12,
-  statSync as statSync5
+  statSync as statSync6
 } from "fs";
 import { access as access2 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { isAbsolute as isAbsolute7, join as join21, relative as relative6, sep as sep5 } from "path";
 var REDACTED_VALUE = "[REDACTED]";
-var REASONING_LEVELS = /* @__PURE__ */ new Set([
+var REASONING_LEVELS2 = /* @__PURE__ */ new Set([
   "off",
   "minimal",
   "low",
@@ -32507,7 +32722,7 @@ function assertProtectedProviderRuntime(value) {
   }
   if (!nonEmptyString(runtime.modelId))
     throw new Error("protected provider runtime requires a model id");
-  if (!REASONING_LEVELS.has(runtime.reasoningLevel)) {
+  if (!REASONING_LEVELS2.has(runtime.reasoningLevel)) {
     throw new Error("protected provider runtime requires a valid reasoning level");
   }
   if (runtime.apiKey !== void 0 && !nonEmptyString(runtime.apiKey)) {
@@ -32874,11 +33089,11 @@ function containsUnsafeDockerArgument(value) {
 function requireCanonicalRealDirectory(value, name) {
   if (typeof value !== "string") throw new Error(`worker: ${name} must be a path`);
   try {
-    const entry = lstatSync5(value);
+    const entry = lstatSync6(value);
     if (entry.isSymbolicLink() || !entry.isDirectory()) {
       throw new Error("unsafe entry");
     }
-    const canonical = realpathSync9(value);
+    const canonical = realpathSync10(value);
     if (canonical !== value) throw new Error("non-canonical entry");
     return canonical;
   } catch {
@@ -32887,9 +33102,9 @@ function requireCanonicalRealDirectory(value, name) {
 }
 function resolveCanonicalDirectory(value, name) {
   try {
-    const entry = statSync5(value);
+    const entry = statSync6(value);
     if (!entry.isDirectory()) throw new Error("not a directory");
-    return realpathSync9(value);
+    return realpathSync10(value);
   } catch {
     throw new Error(`worker: ${name} is unavailable or unsafe`);
   }
@@ -32922,16 +33137,16 @@ function assertMinimalWorkerScratch(value) {
   }
 }
 function requireCanonicalWindowsDirectory(value, name) {
-  if (!value || !isAbsolute7(value) || !existsSync13(value) || !statSync5(value).isDirectory()) {
+  if (!value || !isAbsolute7(value) || !existsSync13(value) || !statSync6(value).isDirectory()) {
     throw new Error(`minimal worker bootstrap requires a valid ${name} directory`);
   }
-  return realpathSync9(value);
+  return realpathSync10(value);
 }
 function requireCanonicalWindowsFile(value, name) {
-  if (!value || !isAbsolute7(value) || !existsSync13(value) || !statSync5(value).isFile()) {
+  if (!value || !isAbsolute7(value) || !existsSync13(value) || !statSync6(value).isFile()) {
     throw new Error(`minimal worker bootstrap requires a valid ${name} executable`);
   }
-  return realpathSync9(value);
+  return realpathSync10(value);
 }
 function objectRecord(value, label) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -33183,10 +33398,10 @@ import {
   fstatSync as fstatSync5,
   openSync as openSync7,
   readSync as readSync3,
-  realpathSync as realpathSync10,
-  statSync as statSync6
+  realpathSync as realpathSync11,
+  statSync as statSync7
 } from "fs";
-import { basename as basename3, extname, isAbsolute as isAbsolute8, relative as relative7, resolve as resolve5, sep as sep6 } from "path";
+import { basename as basename4, extname, isAbsolute as isAbsolute8, relative as relative7, resolve as resolve6, sep as sep6 } from "path";
 var MAX_DELIVER_BYTES = 25 * 1024 * 1024;
 var MIME = {
   ".pdf": "application/pdf",
@@ -33207,10 +33422,10 @@ function isWithin2(root, candidate) {
   return rel === "" || rel !== ".." && !rel.startsWith(`..${sep6}`) && !isAbsolute8(rel);
 }
 function deliverFileTool(cwd, sink, sessionId = "") {
-  const workspacePath = resolve5(cwd);
+  const workspacePath = resolve6(cwd);
   let workspaceRealPath = null;
   try {
-    workspaceRealPath = realpathSync10(workspacePath);
+    workspaceRealPath = realpathSync11(workspacePath);
   } catch {
   }
   return {
@@ -33235,7 +33450,7 @@ function deliverFileTool(cwd, sink, sessionId = "") {
       if (isAbsolute8(p)) {
         throw new Error(`deliver_file: path must stay within the workspace: ${p}`);
       }
-      const abs = resolve5(workspacePath, p);
+      const abs = resolve6(workspacePath, p);
       if (!isWithin2(workspacePath, abs)) {
         throw new Error(`deliver_file: path must stay within the workspace: ${p}`);
       }
@@ -33245,8 +33460,8 @@ function deliverFileTool(cwd, sink, sessionId = "") {
       let real;
       let expected;
       try {
-        real = realpathSync10(abs);
-        expected = statSync6(real);
+        real = realpathSync11(abs);
+        expected = statSync7(real);
       } catch {
         throw new Error(`deliver_file: no such file: ${p}`);
       }
@@ -33270,7 +33485,7 @@ function deliverFileTool(cwd, sink, sessionId = "") {
         }
         let confirmedReal;
         try {
-          confirmedReal = realpathSync10(abs);
+          confirmedReal = realpathSync11(abs);
         } catch {
           throw new Error(`deliver_file: path changed during validation: ${p}`);
         }
@@ -33279,7 +33494,7 @@ function deliverFileTool(cwd, sink, sessionId = "") {
         }
         if (stat2.size > MAX_DELIVER_BYTES) {
           throw new Error(
-            `deliver_file: "${basename3(abs)}" is too large (${(stat2.size / 1024 / 1024).toFixed(1)} MB > 25 MB)`
+            `deliver_file: "${basename4(abs)}" is too large (${(stat2.size / 1024 / 1024).toFixed(1)} MB > 25 MB)`
           );
         }
         const buffer = Buffer.alloc(MAX_DELIVER_BYTES + 1);
@@ -33294,7 +33509,7 @@ function deliverFileTool(cwd, sink, sessionId = "") {
       } finally {
         closeSync7(fd);
       }
-      const name = basename3(abs);
+      const name = basename4(abs);
       const mimeType = MIME[extname(abs).toLowerCase()] ?? "application/octet-stream";
       if (!context?.toolCallId || !sessionId)
         throw new Error("deliver_file: missing source operation");
@@ -33320,7 +33535,7 @@ import {
   closeSync as closeSync8,
   constants as constants9,
   fstatSync as fstatSync6,
-  lstatSync as lstatSync6,
+  lstatSync as lstatSync7,
   openSync as openSync8,
   readdirSync as readdirSync9,
   writeFileSync as writeFileSync10
@@ -33417,7 +33632,7 @@ function homeTools(agentDir) {
         for (const file of HOME_FILES_READABLE) {
           const path = privateHomeFile(homeRoot, file);
           try {
-            const s = lstatSync6(path);
+            const s = lstatSync7(path);
             if (s.isSymbolicLink() || !s.isFile()) continue;
             entries.push(`${file} (${s.size}b)`);
           } catch {
@@ -33449,7 +33664,7 @@ function privateHomeFile(homeRoot, file) {
   return join23(homeRoot, file);
 }
 function rejectSymlinkOrNonFile(path) {
-  const entry = lstatSync6(path);
+  const entry = lstatSync7(path);
   if (entry.isSymbolicLink()) throw new Error("symbolic links are not allowed");
   if (!entry.isFile()) throw new Error("target is not a regular file");
 }
@@ -34793,8 +35008,8 @@ function loadSessionHead(agent, paths2, target) {
   const recent = target ? explicitConversationFile(sessionDir, target) : null;
   if (!recent) return { file: null, size: 0 };
   try {
-    const s = statSync7(recent);
-    return { file: basename4(recent), size: s.size };
+    const s = statSync8(recent);
+    return { file: basename5(recent), size: s.size };
   } catch {
     return { file: null, size: 0 };
   }
@@ -34962,7 +35177,7 @@ function assertSelectedProvider(requested, expected) {
 }
 function waitForRefresh(pending, signal) {
   if (!signal) return pending;
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     let settled = false;
     const finish = (callback) => {
       if (settled) return;
@@ -34977,7 +35192,7 @@ function waitForRefresh(pending, signal) {
       return;
     }
     pending.then(
-      (value) => finish(() => resolve8(value)),
+      (value) => finish(() => resolve9(value)),
       (error2) => finish(() => reject2(error2))
     );
   });
@@ -35213,12 +35428,12 @@ async function* spawnWorker(spec, opts) {
   if (opts.signal?.aborted) onAbort();
   else opts.signal?.addEventListener("abort", onAbort);
   const waitForExit = new Promise(
-    (resolve8) => {
+    (resolve9) => {
       if (child.exitCode !== null || child.signalCode !== null) {
-        resolve8({ code: child.exitCode, signal: child.signalCode });
+        resolve9({ code: child.exitCode, signal: child.signalCode });
         return;
       }
-      child.once("close", (code, signal) => resolve8({ code, signal }));
+      child.once("close", (code, signal) => resolve9({ code, signal }));
     }
   );
   let emittedFatal = false;
@@ -35662,7 +35877,7 @@ var AsyncFrameQueue = class {
         const frame = this.#frames.shift();
         if (frame) return Promise.resolve({ done: false, value: frame });
         if (this.#ended) return Promise.resolve({ done: true, value: void 0 });
-        return new Promise((resolve8) => this.#waiters.push(resolve8));
+        return new Promise((resolve9) => this.#waiters.push(resolve9));
       }
     };
   }
@@ -35832,8 +36047,8 @@ var CommandApprovalRegistry = class {
       return { approval, decision: Promise.resolve(decision2) };
     }
     let resolveDecision;
-    const decision = new Promise((resolve8) => {
-      resolveDecision = resolve8;
+    const decision = new Promise((resolve9) => {
+      resolveDecision = resolve9;
     });
     const timer = setTimeout(() => {
       this.#settle(input.id, "deny", "timeout");
@@ -36047,11 +36262,11 @@ async function getSsrfProxy() {
   if (serverUrl) return serverUrl;
   const s = createServer(onRequest);
   s.on("connect", onConnect);
-  await new Promise((resolve8, reject2) => {
+  await new Promise((resolve9, reject2) => {
     s.once("error", reject2);
     s.listen(0, "127.0.0.1", () => {
       s.off("error", reject2);
-      resolve8();
+      resolve9();
     });
   });
   const addr = s.address();
@@ -36066,7 +36281,7 @@ async function closeSsrfProxy() {
   server = null;
   serverUrl = null;
   if (!s) return;
-  await new Promise((resolve8) => s.close(() => resolve8()));
+  await new Promise((resolve9) => s.close(() => resolve9()));
 }
 
 // ../daemon/src/lib/resources.ts
@@ -36446,7 +36661,7 @@ function createBrowserHost(config2) {
 }
 
 // ../daemon/src/lib/coding-environment/agent-host.ts
-import { createHash as createHash10, randomUUID as randomUUID33 } from "crypto";
+import { createHash as createHash11, randomUUID as randomUUID34 } from "crypto";
 
 // ../daemon/src/core/repos/coding-command-logs.ts
 var CODING_LOG_BYTES = 2 * 1024 * 1024;
@@ -36666,7 +36881,7 @@ function pruneCodingCommandLogs(db, now = Date.now(), budgetBytes = CODING_LOG_H
 }
 
 // ../daemon/src/lib/communication.ts
-import { randomUUID as randomUUID32 } from "crypto";
+import { randomUUID as randomUUID33 } from "crypto";
 
 // ../daemon/src/lib/question-approval.ts
 function questionApprovalReference(snapshot, kind) {
@@ -36761,7 +36976,7 @@ function questionVisible(db, item) {
 }
 
 // ../daemon/src/core/repos/results.ts
-import { createHash as createHash9, randomUUID as randomUUID31 } from "crypto";
+import { createHash as createHash10, randomUUID as randomUUID32 } from "crypto";
 var MAX_RESULT_BYTES = 25 * 1024 * 1024;
 var MAX_RETAINED_RESULT_BYTES = 1024 * 1024 * 1024;
 var columns2 = `id, team_id AS teamId, agent_id AS agentId, source_kind AS sourceKind,
@@ -36796,7 +37011,7 @@ function publish(db, input) {
     throw new Error("Result exceeds the 25 MiB per-file limit");
   }
   const bytes = Buffer.from(input.bytes);
-  const sha256 = createHash9("sha256").update(bytes).digest("hex");
+  const sha256 = createHash10("sha256").update(bytes).digest("hex");
   return db.raw.transaction(() => {
     const existing = source === "session_tool" ? db.raw.query(
       `SELECT ${columns2} FROM agent_results
@@ -36824,7 +37039,7 @@ function publish(db, input) {
         "Result storage is full (1 GiB). Delete saved results before delivering more files."
       );
     }
-    const id = randomUUID31();
+    const id = randomUUID32();
     db.raw.run(
       `INSERT INTO agent_results
       (id, team_id, agent_id, source_kind, session_id, tool_call_id, review_packet_id, review_revision,
@@ -36897,7 +37112,7 @@ function readCaptured(db, id) {
   ).get(id);
   if (!row2) throw new Error("Captured result is unavailable");
   const bytes = Buffer.from(row2.bytes);
-  if (bytes.byteLength !== row2.byte_length || createHash9("sha256").update(bytes).digest("hex") !== row2.sha256) {
+  if (bytes.byteLength !== row2.byte_length || createHash10("sha256").update(bytes).digest("hex") !== row2.sha256) {
     throw new Error("Captured result failed integrity verification");
   }
   return bytes;
@@ -37144,7 +37359,7 @@ function isUserFacingFrame(frame) {
 }
 function sendAgentMessage(db, input) {
   const attemptKind = input.attemptKind ?? "agent_tool";
-  const attemptId = input.attemptId ?? randomUUID32();
+  const attemptId = input.attemptId ?? randomUUID33();
   const outcome = db.raw.transaction(
     () => {
       const causality = resolveMessageCausality(db, input);
@@ -37576,7 +37791,7 @@ async function captureRepositoryGit(root, budgetMs = INSPECTION_BUDGET_MS) {
     rmSync14(scratch, { recursive: true, force: true });
   };
   try {
-    const rawGit = (args) => new Promise((resolve8, reject2) => {
+    const rawGit = (args) => new Promise((resolve9, reject2) => {
       execFile(
         "git",
         args,
@@ -37597,7 +37812,7 @@ async function captureRepositoryGit(root, budgetMs = INSPECTION_BUDGET_MS) {
           maxBuffer: RUN_MAX_BUFFER,
           encoding: "utf8"
         },
-        (error2, stdout) => error2 ? reject2(error2) : resolve8(stdout)
+        (error2, stdout) => error2 ? reject2(error2) : resolve9(stdout)
       );
     });
     const inspectionArgs = (args) => [
@@ -37726,51 +37941,6 @@ objectformat = ${value}`
   }
 }
 
-// ../../packages/api-types/src/entities.ts
-var REASONING_LEVELS2 = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh"
-];
-
-// ../../packages/api-types/src/git-review.ts
-var REVIEW_LIMITS2 = {
-  files: 1e3,
-  fileBytes: 1024 * 1024,
-  totalBytes: 16 * 1024 * 1024,
-  patchBytes: 256 * 1024
-};
-
-// ../../packages/api-types/src/publication.ts
-var PUBLICATION_LIMITS = {
-  repository: 200,
-  branch: 200,
-  commitMessage: 2e3,
-  refusalDetail: 400,
-  error: 400,
-  /** Branches that are never published to, whatever the host says. */
-  protectedBranches: ["main", "master", "trunk", "develop", "release"]
-};
-
-// ../../packages/api-types/src/verification.ts
-var VERIFICATION_OUTCOME_LIMITS = [
-  "Facts above are executor-owned. A non-zero exit is a result about the commands that ran, never proof about later code, and this is not an approval to publish, merge or deploy.",
-  "Declared output paths are not enforced, so a change they do not cover appears above rather than being prevented."
-];
-
-// ../../packages/api-types/src/index.ts
-var PROFILE_FILES = [
-  "profile.json",
-  "SOUL.md",
-  "IDENTITY.md",
-  "BOOTSTRAP.md",
-  "AGENTS.md",
-  "TOOLS.md"
-];
-
 // ../daemon/src/lib/git-review/refs.ts
 var REF_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]{0,254}$/;
 function isCommitOid(value) {
@@ -37888,7 +38058,7 @@ var CREDENTIAL_EXTENSIONS = [
 ];
 function reviewScope(path) {
   const segments = path.split("/");
-  const basename6 = segments[segments.length - 1] ?? "";
+  const basename7 = segments[segments.length - 1] ?? "";
   for (const prefix of BAZILION_STATE_PREFIXES) {
     if (path === prefix.slice(0, -1) || path.startsWith(prefix)) {
       return { included: false, reason: "bazilion_state" };
@@ -37897,7 +38067,7 @@ function reviewScope(path) {
   if (segments.some((segment) => CREDENTIAL_SEGMENTS.has(segment.toLowerCase()))) {
     return { included: false, reason: "credential_shaped" };
   }
-  const lower = basename6.toLowerCase();
+  const lower = basename7.toLowerCase();
   if (CREDENTIAL_BASENAME_PATTERNS.some((pattern) => pattern.test(lower))) {
     return { included: false, reason: "credential_shaped" };
   }
@@ -37908,7 +38078,7 @@ function reviewScope(path) {
 }
 
 // ../daemon/src/lib/git-review/changes.ts
-async function listChanges(captured, base, identity2, limits = REVIEW_LIMITS2) {
+async function listChanges(captured, base, identity2, limits = REVIEW_LIMITS) {
   const issues = [];
   const raw2 = await readDiff(captured, base, [
     "--raw",
@@ -37997,7 +38167,7 @@ async function listChanges(captured, base, identity2, limits = REVIEW_LIMITS2) {
     issues
   };
 }
-async function readChangePatch(captured, base, change, patchBytes = REVIEW_LIMITS2.patchBytes) {
+async function readChangePatch(captured, base, change, patchBytes = REVIEW_LIMITS.patchBytes) {
   if (change.excludedReason) return { patch: null, truncated: false, omitted: "excluded" };
   if (change.binary) return { patch: null, truncated: false, omitted: "binary" };
   if (change.status === "untracked") {
@@ -38029,7 +38199,7 @@ async function readChangePatch(captured, base, change, patchBytes = REVIEW_LIMIT
     omitted: null
   };
 }
-async function attachPatches(captured, report2, limits = REVIEW_LIMITS2, onlyPath) {
+async function attachPatches(captured, report2, limits = REVIEW_LIMITS, onlyPath) {
   let total = 0;
   let tooLarge = 0;
   const changes = [];
@@ -38162,7 +38332,7 @@ function compareSnapshots(before, after) {
   return before.id === after.id ? "identical" : "changed";
 }
 async function captureSourceSnapshot(captured, base, identity2, input = {}) {
-  const limits = input.limits ?? REVIEW_LIMITS2;
+  const limits = input.limits ?? REVIEW_LIMITS;
   const issues = [];
   const withheld = { excluded: 0, tooLarge: 0, notRegular: 0, unstable: 0 };
   let incomplete = false;
@@ -38825,10 +38995,18 @@ async function resolveRepositoryContext(input) {
   report2.fingerprint = hash3(JSON.stringify({ ...report2, capturedAt: 0, fingerprint: "" }));
   return report2;
 }
+var RepositoryContextIncompleteError = class extends Error {
+  codes;
+  constructor(codes) {
+    super(`Repository instructions incomplete (${codes.join(", ")}). Inspect Team repository context before coding.`);
+    this.name = "RepositoryContextIncompleteError";
+    this.codes = codes;
+  }
+};
 function requireCompleteRepositoryContext(report2) {
   if (report2.instructions.state !== "complete") {
-    throw new Error(
-      `Repository instructions incomplete (${report2.instructions.issues.map((i) => i.code).join(", ")}). Inspect Team repository context before coding.`
+    throw new RepositoryContextIncompleteError(
+      report2.instructions.issues.map((i) => i.code)
     );
   }
 }
@@ -38875,12 +39053,12 @@ function createCodingHost(input) {
           sources2.push([
             current.label,
             name,
-            value ? createHash10("sha256").update(value).digest("hex") : null
+            value ? createHash11("sha256").update(value).digest("hex") : null
           ]);
         }
       }
       dir.validate();
-      fingerprint2 = createHash10("sha256").update(JSON.stringify(sources2)).digest("hex");
+      fingerprint2 = createHash11("sha256").update(JSON.stringify(sources2)).digest("hex");
     } catch {
     } finally {
       dir.close();
@@ -38947,7 +39125,7 @@ function createCodingHost(input) {
         try {
           const environment2 = await snapshot(command.cwd);
           const receipt = {
-            id: randomUUID33(),
+            id: randomUUID34(),
             agentId: input.agentId,
             teamId: input.teamId,
             turnId: input.turnId,
@@ -39282,7 +39460,7 @@ function createDbMessagingHost(db, opts = {}) {
 }
 
 // ../daemon/src/lib/question-service.ts
-import { randomUUID as randomUUID35 } from "crypto";
+import { randomUUID as randomUUID36 } from "crypto";
 
 // ../daemon/src/lib/question-consumption.ts
 import { isDeepStrictEqual } from "util";
@@ -39330,13 +39508,13 @@ function verifyQuestionConsumption(paths2, question, target, turnStartEntry = 1)
 }
 
 // ../daemon/src/lib/question-receipt.ts
-import { createHash as createHash11, createHmac, randomBytes as randomBytes5, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { createHash as createHash12, createHmac, randomBytes as randomBytes6, timingSafeEqual as timingSafeEqual2 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
-var hash4 = (text3) => createHash11("sha256").update(text3).digest("hex");
-function key(db, create7) {
-  if (create7)
+var hash4 = (text3) => createHash12("sha256").update(text3).digest("hex");
+function key(db, create8) {
+  if (create8)
     db.raw.run("INSERT OR IGNORE INTO question_receipt_key (singleton, key) VALUES (1, ?)", [
-      randomBytes5(32)
+      randomBytes6(32)
     ]);
   const row2 = db.raw.query("SELECT key FROM question_receipt_key WHERE singleton = 1").get();
   return row2 ? Buffer.from(row2.key) : null;
@@ -39412,7 +39590,7 @@ var QuestionWaiters = class {
     if ([...this.#waiting.values()].some((entry) => entry.question.turnId === current.turnId)) {
       throw new Error("This turn already has a waiting question");
     }
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const abort = () => this.closeTurn(current.turnId, "cancelled");
       const timer = setTimeout(
         () => {
@@ -39422,7 +39600,7 @@ var QuestionWaiters = class {
         Math.max(0, current.expiresAt - this.now())
       );
       timer.unref();
-      this.#waiting.set(current.id, { question: current, resolve: resolve8, signal, abort, timer });
+      this.#waiting.set(current.id, { question: current, resolve: resolve9, signal, abort, timer });
       signal.addEventListener("abort", abort, { once: true });
       if (signal.aborted) abort();
     });
@@ -39455,7 +39633,7 @@ var QuestionWaiters = class {
 };
 
 // ../daemon/src/lib/telegram/question-transport.ts
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 
 // ../daemon/src/lib/telegram/outbound-queue.ts
 var DEFAULT_MIN_INTERVAL_MS = Number(process.env.BAZILION_TELEGRAM_SEND_INTERVAL_MS ?? 200);
@@ -39512,7 +39690,7 @@ function sleep(ms) {
 }
 
 // ../daemon/src/lib/telegram/queue-binding.ts
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 
 // ../daemon/src/lib/telegram/ingress-attempt.ts
 function isTelegramIngressPayload(value) {
@@ -39598,7 +39776,7 @@ function captureTelegramQueueBinding(db, authToken, authorization, transportBotT
     teamId: agent.team_id,
     ownerGrantId: owner.grant_id,
     topicBindingId: agent.telegram_binding_id,
-    botDigest: createHash12("sha256").update(JSON.stringify([botToken, credential?.envelope ?? null])).digest("hex")
+    botDigest: createHash13("sha256").update(JSON.stringify([botToken, credential?.envelope ?? null])).digest("hex")
   };
 }
 function requireTelegramQueueBinding(db, authToken, value) {
@@ -39762,7 +39940,7 @@ Reply to THIS message with Other text, or /answer ${question.id} your answer. Cl
   };
 }
 function requestId(identity2) {
-  const hex = createHash13("sha256").update(identity2).digest("hex");
+  const hex = createHash14("sha256").update(identity2).digest("hex");
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-4${hex.slice(13, 16)}-8${hex.slice(17, 20)}-${hex.slice(20, 32)}`;
 }
 function parseTelegramQuestionReply(db, authToken, update3) {
@@ -39810,7 +39988,7 @@ function parseTelegramQuestionReply(db, authToken, update3) {
 }
 
 // ../daemon/src/lib/attachments.ts
-import { randomUUID as randomUUID34 } from "crypto";
+import { randomUUID as randomUUID35 } from "crypto";
 import { closeSync as closeSync9, constants as constants10, fstatSync as fstatSync7, openSync as openSync9, writeFileSync as writeFileSync13 } from "fs";
 import { join as join26, posix } from "path";
 var MAX_FILE_BYTES = 25 * 1024 * 1024;
@@ -39837,7 +40015,7 @@ function saveInputFiles(agentDir, files, options = {}) {
       lines.push(`[attachment "${label}" skipped: too large (${fmtBytes(buf.byteLength)} > 25 MB)]`);
       continue;
     }
-    const filename2 = `${randomUUID34().slice(0, 8)}-${safeName(label)}`;
+    const filename2 = `${randomUUID35().slice(0, 8)}-${safeName(label)}`;
     const path = join26(dir, filename2);
     let fd;
     try {
@@ -40710,7 +40888,7 @@ var QuestionService = class {
       turn.conversation.id
     ).length;
     this.#attached.add(turn);
-    const turnId = randomUUID35();
+    const turnId = randomUUID36();
     const listeners = /* @__PURE__ */ new Set();
     if (onQuestion) listeners.add(onQuestion);
     this.#turns.set(turnId, {
@@ -40755,7 +40933,7 @@ var QuestionService = class {
       ask: async (toolCallId, input) => {
         if (closed) throw new Error("Question turn is closed");
         this.#validateTurn(turn);
-        const item = create4(this.db, {
+        const item = create5(this.db, {
           agentId: turn.agent.agent.id,
           teamId: turn.agent.team.id,
           conversationId: turn.conversation.id,
@@ -42881,18 +43059,18 @@ var _pendingByAgent = /* @__PURE__ */ new Map();
 function reactSeen(agentId, chatId2, messageId) {
   const deps = _liveDepsResolver?.();
   if (!deps) return;
-  const list16 = _pendingByAgent.get(agentId) ?? [];
-  list16.push({ chatId: chatId2, messageId });
-  _pendingByAgent.set(agentId, list16);
+  const list17 = _pendingByAgent.get(agentId) ?? [];
+  list17.push({ chatId: chatId2, messageId });
+  _pendingByAgent.set(agentId, list17);
   void deps.api.setMessageReaction(chatId2, messageId, [{ type: "emoji", emoji: SEEN_EMOJI }]).catch(() => void 0);
 }
 function clearReactionsFor(agentId) {
-  const list16 = _pendingByAgent.get(agentId);
-  if (!list16 || list16.length === 0) return;
+  const list17 = _pendingByAgent.get(agentId);
+  if (!list17 || list17.length === 0) return;
   _pendingByAgent.delete(agentId);
   const deps = _liveDepsResolver?.();
   if (!deps) return;
-  for (const { chatId: chatId2, messageId } of list16) {
+  for (const { chatId: chatId2, messageId } of list17) {
     void deps.api.setMessageReaction(chatId2, messageId, []).catch(() => void 0);
   }
 }
@@ -43209,10 +43387,10 @@ function mirrorTypingStop(agentId) {
 }
 
 // ../daemon/src/lib/user-md-host.ts
-import { createHash as createHash14 } from "crypto";
+import { createHash as createHash15 } from "crypto";
 var USER_MD_MAX_BYTES = 12e3;
 function computeEtag(content) {
-  return createHash14("sha256").update(content, "utf8").digest("hex").slice(0, 16);
+  return createHash15("sha256").update(content, "utf8").digest("hex").slice(0, 16);
 }
 function createDbUserMdHost(db, paths2) {
   return {
@@ -43825,7 +44003,7 @@ function bound(value) {
 }
 
 // ../daemon/src/lib/review/dispatch.ts
-import { randomUUID as randomUUID36 } from "crypto";
+import { randomUUID as randomUUID37 } from "crypto";
 
 // ../daemon/src/lib/review/preparation.ts
 async function prepareChangeReviewTurn(input) {
@@ -44188,7 +44366,7 @@ function refused(message) {
 }
 
 // ../daemon/src/lib/review/dispatch.ts
-var REVIEW_DISPATCH_OWNER = randomUUID36();
+var REVIEW_DISPATCH_OWNER = randomUUID37();
 var REVIEW_LEASE_MS = 10 * 60 * 1e3;
 var dispatchRegistry = () => {
   const global2 = globalThis;
@@ -44629,9 +44807,9 @@ async function dispatchClaimableReviews(now = Date.now()) {
 }
 
 // ../daemon/src/lib/verification/admission.ts
-import { randomUUID as randomUUID37 } from "crypto";
+import { randomUUID as randomUUID38 } from "crypto";
 var VERIFICATION_LEASE_MS = 10 * 60 * 1e3;
-var VERIFICATION_DISPATCH_OWNER = randomUUID37();
+var VERIFICATION_DISPATCH_OWNER = randomUUID38();
 async function admitVerificationRequest(db, paths2, requestId2, now = Date.now()) {
   const request2 = getVerificationRequestById(db, requestId2, now);
   if (!request2) return { kind: "deferred", requestId: requestId2, reason: "unknown_or_expired" };
@@ -44769,7 +44947,7 @@ function safeTeam3(db, paths2, teamId) {
 }
 
 // ../daemon/src/lib/verification/executor.ts
-import { randomUUID as randomUUID38 } from "crypto";
+import { randomUUID as randomUUID39 } from "crypto";
 import { existsSync as existsSync17 } from "fs";
 import { join as join28, posix as posix2, relative as relative8, sep as sep7 } from "path";
 import { createLocalBashOperations as createLocalBashOperations3 } from "@earendil-works/pi-coding-agent";
@@ -44800,14 +44978,14 @@ function createProtectedCheckExecutor(input) {
       }
       const container = buildContainerOperations(input, env, config2.envAllowlist, absoluteCwd);
       if ("blocked" in container) return blocked3("environment_unavailable", container.blocked);
-      const commandId = randomUUID38();
+      const commandId = randomUUID39();
       const startedAt = Date.now();
       const receipt = {
         id: commandId,
         agentId: input.request.recipientAgentId,
         teamId: input.request.teamId,
         turnId: input.attemptId,
-        toolCallId: `verification:${input.attemptId}:${randomUUID38()}`,
+        toolCallId: `verification:${input.attemptId}:${randomUUID39()}`,
         input: {
           command,
           cwd: relative9,
@@ -45269,7 +45447,7 @@ function abandonVerificationAttempt(db, input) {
 }
 
 // ../daemon/src/lib/verification/writes.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { lstat as lstat2, readdir, readFile, readlink } from "fs/promises";
 import { join as join29 } from "path";
 var FINGERPRINT_LIMITS = {
@@ -45284,10 +45462,11 @@ var FINGERPRINT_LIMITS = {
 async function fingerprintPath(root, path, digest4) {
   const absolute = join29(root, path);
   const info = await lstat2(absolute);
-  if (info.isSymbolicLink()) return `link:${await readlink(absolute)}`;
+  if (info.isSymbolicLink())
+    return `link:${(await readlink(absolute)).replaceAll("\\", "/")}`;
   if (!info.isFile()) return `other:${info.mode}`;
   if (!digest4 || info.size > FINGERPRINT_LIMITS.fileBytes) return `size:${info.size}`;
-  return `sha256:${createHash15("sha256").update(await readFile(absolute)).digest("hex")}`;
+  return `sha256:${createHash16("sha256").update(await readFile(absolute)).digest("hex")}`;
 }
 async function fingerprintWorkspace(root) {
   const entries = /* @__PURE__ */ new Map();
@@ -45996,7 +46175,15 @@ function bootstrap(paths2) {
   }
   const db = openDb(paths2.db);
   try {
-    runMigrations(db);
+    runMigrations(db, {
+      // Before the first forward migration of an existing home, preserve the
+      // pre-upgrade state beside the database. A failed migration then leaves
+      // a restorable copy instead of a half-migrated home.
+      preMigrationSnapshotPath: join30(
+        dirname7(paths2.db),
+        `bazilion.pre-migration-${(/* @__PURE__ */ new Date()).toISOString().replace(/[-:T]/g, "").replace(/\..*/, "")}.db`
+      )
+    });
     let existingAuthToken = null;
     if (authFileExists) {
       try {
@@ -46078,6 +46265,7 @@ function authenticateToken(token) {
         kind: match.kind,
         tokenId: match.id,
         label: match.label,
+        scopes: match.scopes,
         sessionId: null
       };
     }
@@ -46122,8 +46310,49 @@ function isLoopbackHost(hostname2) {
   return hostname2 === "127.0.0.1" || hostname2 === "localhost" || hostname2 === "[::1]" || hostname2 === "::1";
 }
 
+// ../daemon/src/lib/scopes.ts
+var ADMIN_PREFIXES = [
+  "/api/config",
+  "/api/mcp-servers",
+  "/api/backup",
+  "/api/tokens",
+  "/api/pair/codes",
+  "/api/auth/openai",
+  "/api/providers/test",
+  "/api/communication"
+];
+var APPROVALS_MUTATION_PREFIXES = ["/api/approvals", "/api/shell-approvals", "/api/notifications"];
+var APPROVALS_MUTATION_PATTERNS = [
+  /\/queue(\/|$)/,
+  // follow-up queue resolve/control/stop/reconcile
+  /\/questions\/[^/]+\/answer$/,
+  // structured question answers (BAZ-037)
+  /\/acknowledge/
+  // attention acknowledge / acknowledge-all (BAZ-026)
+];
+var READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "OPTIONS"]);
+function requiredScope(method, path) {
+  const isRead = READ_METHODS.has(method.toUpperCase());
+  if (ADMIN_PREFIXES.some((p) => path === p || path.startsWith(`${p}/`))) {
+    return "admin";
+  }
+  if (!isRead) {
+    if (APPROVALS_MUTATION_PREFIXES.some((p) => path === p || path.startsWith(`${p}/`))) {
+      return "approvals";
+    }
+    if (path.startsWith("/api/agents") || path.startsWith("/api/attention")) {
+      if (APPROVALS_MUTATION_PATTERNS.some((re) => re.test(path))) return "approvals";
+    }
+  }
+  return isRead ? "read" : "write";
+}
+function scopeAllows(scopes, method, path) {
+  const required3 = requiredScope(method, path);
+  return { allowed: scopes.includes(required3), required: required3 };
+}
+
 // ../daemon/src/lib/middleware-auth.ts
-var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/api/login", "/api/health"]);
+var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/api/login", "/api/health", "/api/pair/exchange"]);
 var SETUP_OPEN_PREFIXES = [
   "/api/config",
   "/api/auth",
@@ -46158,6 +46387,7 @@ async function authMiddleware(c, next) {
     kind: "session",
     tokenId: session.deviceTokenId,
     label: session.deviceLabel,
+    scopes: parseScopes(session.deviceScopes),
     sessionId: session.id
   } : null);
   if (!principal) {
@@ -46176,6 +46406,19 @@ async function authMiddleware(c, next) {
   }
   c.set("authPrincipal", principal);
   if (session) c.set("authSession", session);
+  if (principal.kind !== "bootstrap") {
+    const check = scopeAllows(principal.scopes, c.req.method, path);
+    if (!check.allowed) {
+      return c.json(
+        {
+          error: `credential is missing the '${check.required}' scope`,
+          code: "insufficient_scope",
+          requiredScope: check.required
+        },
+        403
+      );
+    }
+  }
   if (!isSetupOpen(path) && !isSetupComplete(getCtx().db)) {
     return c.json({ error: "setup incomplete" }, 409);
   }
@@ -46183,9 +46426,9 @@ async function authMiddleware(c, next) {
 }
 
 // ../daemon/src/routes/agents.ts
-import { randomUUID as randomUUID40 } from "crypto";
+import { randomUUID as randomUUID41 } from "crypto";
 import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 import { Hono } from "hono";
 
 // ../daemon/src/lib/agent-id.ts
@@ -46513,7 +46756,7 @@ var handle5 = async (ctx) => {
   try {
     reconcileApprovalHolds(ctx.db);
     if (command === "list" || command === "history") {
-      const state3 = list13(ctx.db, agent.id, {
+      const state3 = list14(ctx.db, agent.id, {
         all: command === "history",
         offset: command === "history" && arg ? revision2(arg) : 0
       });
@@ -47411,7 +47654,7 @@ function errMsg(e) {
 }
 
 // ../daemon/src/lib/telegram/notification-transport.ts
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 var resolver = null;
 function notificationDestinationAllowed(chat, owner, bot) {
   return chat.type === "supergroup" && chat.is_forum === true && !chat.username && !chat.active_usernames?.length && owner.status !== "left" && owner.status !== "kicked" && (owner.status !== "restricted" || owner.is_member === true) && (bot.status === "creator" || bot.status === "administrator" && bot.can_manage_topics === true);
@@ -47434,8 +47677,8 @@ function capture(db, authToken) {
   const topicId = Number(topic?.value);
   if (!owner || !Number.isSafeInteger(chatId2) || chatId2 >= 0 || !Number.isSafeInteger(topicId) || topicId <= 0 || !env.TELEGRAM_BOT_TOKEN || env.TELEGRAM_BOT_TOKEN !== live2.botToken)
     return null;
-  const botDigest = createHash16("sha256").update(JSON.stringify([live2.botToken, envelope])).digest("hex");
-  const id = createHash16("sha256").update(JSON.stringify([chatId2, topicId, owner.grant_id, botDigest])).digest("hex");
+  const botDigest = createHash17("sha256").update(JSON.stringify([live2.botToken, envelope])).digest("hex");
+  const id = createHash17("sha256").update(JSON.stringify([chatId2, topicId, owner.grant_id, botDigest])).digest("hex");
   return {
     binding: { id, chatId: chatId2, topicId, ownerGrantId: owner.grant_id, botDigest },
     ownerId: owner.user_id,
@@ -47508,7 +47751,7 @@ async function notifyTelegramQueueStatus(db, agentId, itemId) {
 }
 
 // ../daemon/src/lib/user-queue-admission.ts
-import { randomUUID as randomUUID39 } from "crypto";
+import { randomUUID as randomUUID40 } from "crypto";
 async function enqueueTelegramInput(binding, message, attachments2, context = getCtx()) {
   validateInput(message, attachments2);
   const { db, paths: paths2, authToken } = context;
@@ -47527,7 +47770,7 @@ async function enqueueTelegramInput(binding, message, attachments2, context = ge
     const existing = findAttempt(db, "telegram", binding.authorization.attemptId);
     return db.raw.transaction(() => {
       const item = accept(db, {
-        id: existing?.id ?? randomUUID39(),
+        id: existing?.id ?? randomUUID40(),
         agentId,
         teamId: existing?.teamId ?? agent.team.id,
         conversationId,
@@ -48589,7 +48832,7 @@ agentsRouter.get("/", (c) => {
   const { db, paths: paths2, authToken } = getCtx();
   const agents = agents_exports.list(db, { includeArchived }).map((agent) => ({
     ...agent,
-    identity: loadIdentityFromFile(join30(agent.dir, "IDENTITY.md"))
+    identity: loadIdentityFromFile(join31(agent.dir, "IDENTITY.md"))
   }));
   return c.json(agents);
 });
@@ -48611,7 +48854,7 @@ agentsRouter.post("/", async (c) => {
   }
   let reasoningLevel;
   if (typeof raw2.reasoningLevel === "string") {
-    if (!REASONING_LEVELS2.includes(raw2.reasoningLevel)) {
+    if (!REASONING_LEVELS.includes(raw2.reasoningLevel)) {
       return c.json({ error: `invalid reasoningLevel: ${raw2.reasoningLevel}` }, 400);
     }
     reasoningLevel = raw2.reasoningLevel;
@@ -48683,7 +48926,7 @@ agentsRouter.patch("/:id", async (c) => {
     void syncAgentTopicIcon(db, resolvedId).catch(() => void 0);
   }
   if (body.reasoningLevel !== void 0) {
-    if (typeof body.reasoningLevel !== "string" || !REASONING_LEVELS2.includes(body.reasoningLevel)) {
+    if (typeof body.reasoningLevel !== "string" || !REASONING_LEVELS.includes(body.reasoningLevel)) {
       return c.json({ error: `invalid reasoningLevel: ${body.reasoningLevel}` }, 400);
     }
     agents_exports.setReasoningLevel(db, resolvedId, body.reasoningLevel);
@@ -49014,7 +49257,7 @@ agentsRouter.patch("/:id/review-config", async (c) => {
   if (!Number.isInteger(everyNTurns) || everyNTurns < 1 || everyNTurns > 100) {
     return c.json({ error: "everyNTurns must be an integer from 1 to 100" }, 400);
   }
-  if (!REASONING_LEVELS2.includes(reasoningLevel)) {
+  if (!REASONING_LEVELS.includes(reasoningLevel)) {
     return c.json({ error: `invalid reasoningLevel: ${reasoningLevel}` }, 400);
   }
   if (body.model !== void 0 && body.model !== null && !body.model.includes(":")) {
@@ -49121,7 +49364,7 @@ for (const decision of ["approve", "reject", "revoke"]) {
     if (!team) return c.json({ error: `team not found: ${agent.teamId}` }, 404);
     try {
       const proposal = await runAgentLifecycleMutation(agent.id, async () => {
-        const memory = qmdBackend(join30(team.path, "memory"));
+        const memory = qmdBackend(join31(team.path, "memory"));
         if (decision === "approve")
           return approveLessonProposal(db, memory, current.id, body.version);
         if (decision === "reject") return rejectLessonProposal(db, current.id, body.version);
@@ -49347,7 +49590,7 @@ agentsRouter.post("/:id/chat", async (c) => {
   if (!message && attachments2.length === 0) {
     return c.json({ error: "message or an attachment is required" }, 400);
   }
-  const requestAttemptId = c.req.header("x-request-id") ?? randomUUID40();
+  const requestAttemptId = c.req.header("x-request-id") ?? randomUUID41();
   let preparedTurn;
   try {
     preparedTurn = await prepareAgentTurn({
@@ -49369,6 +49612,14 @@ agentsRouter.post("/:id/chat", async (c) => {
   } catch (error2) {
     if (error2 instanceof WorkspaceBusyError)
       return c.json({ error: error2.message, code: error2.message }, 409);
+    if (error2 instanceof ContextReadError || error2 instanceof RepositoryContextIncompleteError)
+      return c.json(
+        {
+          error: `this turn needs repository context, which this platform cannot prepare (${error2 instanceof RepositoryContextIncompleteError ? error2.codes.join(", ") : error2.code}); agent turns currently require Linux`,
+          code: error2 instanceof RepositoryContextIncompleteError ? error2.codes[0] : error2.code
+        },
+        422
+      );
     if (error2 instanceof ConversationConflictError)
       return c.json({ error: error2.message, code: error2.code, selection: error2.selection }, 409);
     if (error2 instanceof CommunicationPendingError) {
@@ -49477,7 +49728,7 @@ agentsRouter.post("/:id/chat/compact", async (c) => {
         );
       const resolved = resolveAgent(db, paths2, id);
       const env = mergeSecretsIntoEnv(db, authToken);
-      const memory = qmdBackend(join30(resolved.team.path, "memory"));
+      const memory = qmdBackend(join31(resolved.team.path, "memory"));
       await memory.init();
       const apiKeyResolution = await resolveAgentApiKey(db, authToken, resolved, {
         withRefresher: true
@@ -49552,7 +49803,7 @@ agentsRouter.get("/:id/chat/context", async (c) => {
       const promptSkills = loadPromptSkills(paths2.skillsDir, resolved.skills);
       const files = [];
       for (const file of CONTEXT_FILE_ORDER2) {
-        const path = join30(resolved.agent.dir, file);
+        const path = join31(resolved.agent.dir, file);
         if (!existsSync19(path)) continue;
         const content = readFileSync12(path, "utf8").trimEnd();
         if (!content) continue;
@@ -49582,7 +49833,7 @@ Read-only context about the human you're working with in this team. You cannot e
 
 ${resolved.team.userMd.trim()}`.length : 0;
       const memoryHintChars = "# Memory\n\nYou have a persistent memory backend. Use `memory_write` to remember things across sessions, and `memory_search` / `memory_read` / `memory_list` to recall them. Always check memory at the start of a session if the user might have told you something important before.".length;
-      const memory = qmdBackend(join30(resolved.team.path, "memory"));
+      const memory = qmdBackend(join31(resolved.team.path, "memory"));
       await memory.init();
       const apiKeyResolution = await resolveAgentApiKey(db, authToken, resolved, {
         withRefresher: true
@@ -49724,7 +49975,7 @@ agentsRouter.post("/:id/chat/truncate", async (c) => {
           409
         );
       const resolved = resolveAgent(db, paths2, id);
-      const memory = qmdBackend(join30(resolved.team.path, "memory"));
+      const memory = qmdBackend(join31(resolved.team.path, "memory"));
       await memory.init();
       const env = mergeSecretsIntoEnv(db, authToken);
       const apiKeyResolution = await resolveAgentApiKey(db, authToken, resolved, {
@@ -50167,7 +50418,7 @@ function queuedApprovalInput(agentId, itemId) {
 function assertQueuedApprovalReady(approval) {
   const { db } = getCtx();
   const ref = validateQueuedUserApproval(approval, queuedApprovalInput);
-  const head = list13(db, ref.agentId, { limit: 1 }).items[0];
+  const head = list14(db, ref.agentId, { limit: 1 }).items[0];
   if (control(db, ref.agentId).paused || head?.id !== ref.itemId || head.status !== "held")
     throw new QueueConflictError("Queued approval is paused or waiting for earlier input");
 }
@@ -50228,7 +50479,7 @@ async function deliverQueuedApproval(approval) {
         });
       } catch (error2) {
         if (error2 instanceof WorkspaceBusyError && !error2.recoveryRequired) {
-          await new Promise((resolve8) => setTimeout(resolve8, 1e3));
+          await new Promise((resolve9) => setTimeout(resolve9, 1e3));
           continue;
         }
         if (isAgentTurnActiveError(error2, ref.agentId)) continue;
@@ -50880,14 +51131,14 @@ function callbackUnavailable(error2, host2, port2) {
 }
 function closeServer(server3) {
   if (!server3.listening) return Promise.resolve();
-  return new Promise((resolve8) => server3.close(() => resolve8()));
+  return new Promise((resolve9) => server3.close(() => resolve9()));
 }
 async function preflightOpenAICodexCallback(options) {
   const host2 = options?.host ?? openAICodexCallbackHost();
   const port2 = options?.port ?? OPENAI_CODEX_CALLBACK_PORT;
   const server3 = createServer2();
   try {
-    await new Promise((resolve8, reject2) => {
+    await new Promise((resolve9, reject2) => {
       const cleanup = () => {
         server3.removeListener("error", onError);
         server3.removeListener("listening", onListening);
@@ -50898,7 +51149,7 @@ async function preflightOpenAICodexCallback(options) {
       };
       const onListening = () => {
         cleanup();
-        resolve8();
+        resolve9();
       };
       server3.once("error", onError);
       server3.once("listening", onListening);
@@ -50984,7 +51235,7 @@ var webOpenAILoginTail = Promise.resolve();
 function waitForLoginTurn(turn, signal) {
   if (!signal) return turn;
   if (signal.aborted) return Promise.reject(abortReason(signal));
-  return new Promise((resolve8, reject2) => {
+  return new Promise((resolve9, reject2) => {
     const onAbort = () => {
       signal.removeEventListener("abort", onAbort);
       reject2(abortReason(signal));
@@ -50992,7 +51243,7 @@ function waitForLoginTurn(turn, signal) {
     signal.addEventListener("abort", onAbort, { once: true });
     void turn.then(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve8();
+      resolve9();
     });
   });
 }
@@ -51000,8 +51251,8 @@ async function acquireWebOpenAILogin(signal) {
   const previous = webOpenAILoginTail;
   let releaseGate = () => {
   };
-  const gate = new Promise((resolve8) => {
-    releaseGate = resolve8;
+  const gate = new Promise((resolve9) => {
+    releaseGate = resolve9;
   });
   webOpenAILoginTail = previous.then(() => gate);
   try {
@@ -51229,6 +51480,47 @@ authRouter.delete("/sessions/:id", (c) => {
   }
   return c.body(null, 204);
 });
+authRouter.post("/pair/codes", async (c) => {
+  const body = await c.req.json().catch(() => null);
+  let scopes = [...ALL_DEVICE_TOKEN_SCOPES];
+  if (body?.scopes !== void 0) {
+    if (!Array.isArray(body.scopes) || body.scopes.length === 0 || body.scopes.some((s) => !DEVICE_TOKEN_SCOPES.includes(s))) {
+      return c.json(
+        { error: `scopes must be a non-empty subset of: ${DEVICE_TOKEN_SCOPES.join(", ")}` },
+        400
+      );
+    }
+    scopes = [...new Set(body.scopes)];
+  }
+  const created = webPairingTokens_exports.create(getCtx().db, { scopes });
+  const serverOrigin = process.env.BAZILION_PUBLIC_ORIGIN?.replace(/\/$/, "");
+  const setupUrl = `bazilion-pair://pair?server=${encodeURIComponent(serverOrigin ?? new URL(c.req.url).origin)}&code=${encodeURIComponent(created.code)}`;
+  return c.json(
+    { code: created.code, meta: created.meta, setupUrl },
+    201
+  );
+});
+authRouter.post("/pair/exchange", async (c) => {
+  const body = await c.req.json().catch(() => null);
+  if (!body || typeof body.code !== "string" || !body.code.trim()) {
+    return c.json({ error: "code is required" }, 400);
+  }
+  const { db } = getCtx();
+  const outcome = db.raw.transaction(() => {
+    const result = webPairingTokens_exports.exchange(db, body.code.trim());
+    if (!result.ok) return result;
+    const minted = webTokens_exports.create(db, "paired device", { scopes: result.scopes });
+    webPairingTokens_exports.completeExchange(db, body.code.trim(), minted.meta.id);
+    return { ok: true, minted };
+  })();
+  if (!outcome.ok) {
+    return c.json({ error: `pairing code ${outcome.reason}` }, 400);
+  }
+  return c.json(
+    { token: outcome.minted.token, meta: outcome.minted.meta },
+    201
+  );
+});
 
 // ../daemon/src/routes/communication.ts
 import { Hono as Hono5 } from "hono";
@@ -51446,7 +51738,7 @@ conversationsRouter.onError((error2, c) => {
 });
 conversationsRouter.get("/:agentId/conversations", (c) => {
   return c.json(
-    list14(
+    list15(
       getCtx().db,
       c.req.param("agentId"),
       Number(c.req.query("limit") ?? 20),
@@ -51462,7 +51754,7 @@ conversationsRouter.post("/:agentId/conversations", async (c) => {
     return c.json({ error: "Invalid conversation request" }, 400);
   if (get20(db, agentId, input.requestId)) {
     return c.json(
-      create5(db, agentId, input, () => {
+      create6(db, agentId, input, () => {
         throw new Error("Existing conversation disappeared");
       })
     );
@@ -51472,7 +51764,7 @@ conversationsRouter.post("/:agentId/conversations", async (c) => {
       if (pendingCount(db, agentId) > 0)
         throw new Error("Pending follow-ups must be resolved first");
       const agent = resolveAgent(db, paths2, agentId);
-      return create5(
+      return create6(
         db,
         agentId,
         input,
@@ -51675,23 +51967,23 @@ messagesRouter.patch("/:id", async (c) => {
 // ../daemon/src/routes/misc.ts
 import { existsSync as existsSync20 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 import { Hono as Hono10 } from "hono";
 
 // ../daemon/src/lib/backup.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import { mkdtempSync as mkdtempSync5, rmSync as rmSync15 } from "fs";
 import { tmpdir as tmpdir5 } from "os";
-import { join as join31, resolve as resolve6 } from "path";
-import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
-import { create as create6 } from "tar";
+import { join as join32, resolve as resolve7 } from "path";
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+import { create as create7 } from "tar";
 var snapshotTail = Promise.resolve();
 async function serializeSnapshot(work) {
   let release2 = () => {
   };
   const previous = snapshotTail;
-  snapshotTail = new Promise((resolve8) => {
-    release2 = resolve8;
+  snapshotTail = new Promise((resolve9) => {
+    release2 = resolve9;
   });
   await previous;
   try {
@@ -51701,7 +51993,7 @@ async function serializeSnapshot(work) {
   }
 }
 function assertSnapshotIntegrity(path) {
-  const snapshot = new DatabaseSync2(path, { readOnly: true });
+  const snapshot = new DatabaseSync3(path, { readOnly: true });
   try {
     const rows = snapshot.prepare("PRAGMA integrity_check").all();
     if (rows.length !== 1 || rows[0]?.integrity_check !== "ok") {
@@ -51710,7 +52002,7 @@ function assertSnapshotIntegrity(path) {
     }
     for (const row2 of snapshot.prepare("SELECT id, bytes, byte_length, sha256 FROM agent_results WHERE deleted_at IS NULL").iterate()) {
       const bytes = row2.bytes;
-      if (!(bytes instanceof Uint8Array) || bytes.byteLength !== row2.byte_length || createHash17("sha256").update(bytes).digest("hex") !== row2.sha256) {
+      if (!(bytes instanceof Uint8Array) || bytes.byteLength !== row2.byte_length || createHash18("sha256").update(bytes).digest("hex") !== row2.sha256) {
         throw new Error(`Result snapshot integrity verification failed: ${row2.id}`);
       }
     }
@@ -51726,8 +52018,8 @@ function assertSnapshotIntegrity(path) {
 }
 async function createBackupSnapshot(db) {
   return serializeSnapshot(async () => {
-    const directory = mkdtempSync5(join31(tmpdir5(), "bazilion-backup-"));
-    const database = join31(directory, "bazilion.snapshot");
+    const directory = mkdtempSync5(join32(tmpdir5(), "bazilion-backup-"));
+    const database = join32(directory, "bazilion.snapshot");
     let cleaned = false;
     const cleanup = () => {
       if (cleaned) return;
@@ -51748,8 +52040,8 @@ async function createBackupSnapshot(db) {
   });
 }
 function createBackupArchive(paths2, snapshot) {
-  const snapshotPath = resolve6(snapshot.database);
-  return create6(
+  const snapshotPath = resolve7(snapshot.database);
+  return create7(
     {
       cwd: paths2.home,
       gzip: true,
@@ -51760,7 +52052,7 @@ function createBackupArchive(paths2, snapshot) {
       preservePaths: true,
       strict: true,
       filter(path) {
-        if (resolve6(path) === snapshotPath) return true;
+        if (resolve7(path) === snapshotPath) return true;
         const normalized = path.replaceAll("\\", "/").replace(/^\.\//, "");
         if (normalized === "bazilion.db" || normalized.startsWith("bazilion.db-")) return false;
         if (normalized === "daemon-runtime.json" || normalized.startsWith("daemon-runtime.json.reclaim-")) {
@@ -51770,7 +52062,7 @@ function createBackupArchive(paths2, snapshot) {
         return true;
       },
       onWriteEntry(entry) {
-        if (resolve6(entry.absolute) === snapshotPath) entry.path = "./bazilion.db";
+        if (resolve7(entry.absolute) === snapshotPath) entry.path = "./bazilion.db";
       }
     },
     [".", snapshotPath]
@@ -51778,7 +52070,7 @@ function createBackupArchive(paths2, snapshot) {
 }
 
 // ../daemon/src/lib/daemon-liveness.ts
-import { createHash as createHash18, randomUUID as randomUUID41 } from "crypto";
+import { createHash as createHash19, randomUUID as randomUUID42 } from "crypto";
 import {
   chmodSync as chmodSync2,
   closeSync as closeSync10,
@@ -51786,32 +52078,32 @@ import {
   fsyncSync as fsyncSync2,
   ftruncateSync,
   futimesSync,
-  lstatSync as lstatSync7,
+  lstatSync as lstatSync8,
   mkdirSync as mkdirSync11,
   openSync as openSync10,
   readFileSync as readFileSync13,
-  realpathSync as realpathSync11,
+  realpathSync as realpathSync12,
   renameSync as renameSync3,
   rmSync as rmSync16,
   writeSync
 } from "fs";
-import { basename as basename5, dirname as dirname6, join as join32, resolve as resolve7 } from "path";
+import { basename as basename6, dirname as dirname8, join as join33, resolve as resolve8 } from "path";
 var HEARTBEAT_MS = 2e3;
 function canonicalHomeIdentity(home) {
-  const absolute = resolve7(home);
+  const absolute = resolve8(home);
   try {
-    return realpathSync11.native(absolute);
+    return realpathSync12.native(absolute);
   } catch (error2) {
     if (errorCode(error2) !== "ENOENT") throw error2;
-    const parent = dirname6(absolute);
+    const parent = dirname8(absolute);
     if (parent === absolute) throw error2;
-    return join32(canonicalHomeIdentity(parent), basename5(absolute));
+    return join33(canonicalHomeIdentity(parent), basename6(absolute));
   }
 }
 function daemonLivenessPath(home) {
-  const canonicalHome = canonicalHomeIdentity(home);
-  const identity2 = createHash18("sha256").update(canonicalHome).digest("hex").slice(0, 24);
-  return join32(dirname6(canonicalHome), `.bazilion-runtime-${identity2}.json`);
+  const canonicalHome2 = canonicalHomeIdentity(home);
+  const identity2 = createHash19("sha256").update(canonicalHome2).digest("hex").slice(0, 24);
+  return join33(dirname8(canonicalHome2), `.bazilion-runtime-${identity2}.json`);
 }
 var activeInstanceId = null;
 function getDaemonInstanceId() {
@@ -51825,7 +52117,7 @@ function errorCode(error2) {
 }
 function readExisting(path) {
   try {
-    const stat2 = lstatSync7(path);
+    const stat2 = lstatSync8(path);
     const raw2 = stat2.isFile() ? readFileSync13(path, "utf8") : "";
     let instanceId;
     let version2;
@@ -51906,7 +52198,7 @@ function pidIsAlive(pid) {
   }
 }
 function reclaimStaleRecord(path, existing) {
-  const identity2 = createHash18("sha256").update(existing.instanceId ?? existing.raw).update(`\0${existing.stat.dev}\0${existing.stat.ino}`).digest("hex").slice(0, 24);
+  const identity2 = createHash19("sha256").update(existing.instanceId ?? existing.raw).update(`\0${existing.stat.dev}\0${existing.stat.ino}`).digest("hex").slice(0, 24);
   const claim5 = `${path}.reclaim-${identity2}`;
   try {
     mkdirSync11(claim5, { mode: 448 });
@@ -51919,7 +52211,7 @@ function reclaimStaleRecord(path, existing) {
     if (!current || !sameFile(current.stat, existing.stat) || current.raw !== existing.raw) {
       return null;
     }
-    renameSync3(path, join32(claim5, "stale-record.json"));
+    renameSync3(path, join33(claim5, "stale-record.json"));
     return claim5;
   } catch (error2) {
     if (!["ENOENT", "EEXIST"].includes(errorCode(error2) ?? "")) throw error2;
@@ -51936,7 +52228,7 @@ function writeRecord(fd, record3) {
 function fsyncParentDirectory(path) {
   let directoryFd = null;
   try {
-    directoryFd = openSync10(dirname6(path), "r");
+    directoryFd = openSync10(dirname8(path), "r");
     fsyncSync2(directoryFd);
   } catch (error2) {
     if (process.platform !== "win32") throw error2;
@@ -51945,10 +52237,10 @@ function fsyncParentDirectory(path) {
   }
 }
 function acquireDaemonLiveness(paths2) {
-  mkdirSync11(dirname6(resolve7(paths2.home)), { recursive: true });
+  mkdirSync11(dirname8(resolve8(paths2.home)), { recursive: true });
   const path = daemonLivenessPath(paths2.home);
-  mkdirSync11(dirname6(path), { recursive: true });
-  const instanceId = randomUUID41();
+  mkdirSync11(dirname8(path), { recursive: true });
+  const instanceId = randomUUID42();
   const startedAt = Date.now();
   let fd = null;
   let reclaimClaim = null;
@@ -52020,7 +52312,7 @@ function acquireDaemonLiveness(paths2) {
     closeSync10(fd);
     fd = null;
     try {
-      if (sameFile(lstatSync7(path), ownedStat)) rmSync16(path, { force: true });
+      if (sameFile(lstatSync8(path), ownedStat)) rmSync16(path, { force: true });
     } catch {
     }
     throw error2;
@@ -52029,7 +52321,7 @@ function acquireDaemonLiveness(paths2) {
   let stopped = false;
   const stillOwnsPath = () => {
     try {
-      return sameFile(lstatSync7(path), ownedStat);
+      return sameFile(lstatSync8(path), ownedStat);
     } catch {
       return false;
     }
@@ -52072,7 +52364,18 @@ function acquireDaemonLiveness(paths2) {
       const ownsPath = stillOwnsPath();
       closeSync10(fd);
       fd = null;
-      if (ownsPath) rmSync16(path, { force: true });
+      if (!ownsPath) return;
+      for (let attempt = 1; attempt <= 8; attempt++) {
+        try {
+          rmSync16(path, { force: true });
+          return;
+        } catch (error2) {
+          const code = error2.code;
+          if (attempt === 8 || !["EPERM", "EBUSY", "ENOTEMPTY"].includes(code ?? "")) throw error2;
+          const wait = attempt * 250;
+          Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, wait);
+        }
+      }
     }
   };
 }
@@ -52173,7 +52476,14 @@ var protectedDockerReadiness = createProtectedDockerReadinessCache();
 miscRouter.get("/health", (c) => {
   const instanceId = getDaemonInstanceId();
   if (instanceId) c.header("x-bazilion-daemon-instance", instanceId);
-  return c.json({ ok: true });
+  return c.json({
+    ok: true,
+    auth: {
+      required: true,
+      credentialKinds: ["bootstrap", "device", "pairing-code"],
+      setupComplete: isSetupComplete(getCtx().db)
+    }
+  });
 });
 miscRouter.get("/health/details", async (c) => {
   const paths2 = resolvePaths();
@@ -52239,7 +52549,7 @@ miscRouter.get("/health/details", async (c) => {
     }
   }
   const providerConfig = loadProviderConfigFromEnv(effectiveEnv, oauth);
-  const openclawSkillsDir = join33(homedir2(), ".openclaw", "skills");
+  const openclawSkillsDir = join34(homedir2(), ".openclaw", "skills");
   const CLOUD_KEYS = [
     ["anthropic", "anthropic"],
     ["openai", "openai"],
@@ -52431,10 +52741,23 @@ miscRouter.post("/tokens", async (c) => {
   if (!Number.isInteger(expiresInDays) || expiresInDays < 1 || expiresInDays > 365) {
     return c.json({ error: "expiresInDays must be an integer from 1 to 365" }, 400);
   }
+  let scopes = [...ALL_DEVICE_TOKEN_SCOPES];
+  if (body.scopes !== void 0) {
+    if (!Array.isArray(body.scopes) || body.scopes.length === 0 || body.scopes.some((s) => !DEVICE_TOKEN_SCOPES.includes(s))) {
+      return c.json(
+        {
+          error: `scopes must be a non-empty subset of: ${DEVICE_TOKEN_SCOPES.join(", ")}`
+        },
+        400
+      );
+    }
+    scopes = [...new Set(body.scopes)];
+  }
   const { db } = getCtx();
   const created = webTokens_exports.create(db, body.label.trim(), {
     kind: "device",
-    expiresAt: Date.now() + expiresInDays * 864e5
+    expiresAt: Date.now() + expiresInDays * 864e5,
+    scopes
   });
   return c.json({ token: created.token, meta: created.meta }, 201);
 });
@@ -52463,7 +52786,7 @@ import { bodyLimit } from "hono/body-limit";
 import { HTTPException } from "hono/http-exception";
 
 // ../daemon/src/lib/notification-control.ts
-import { randomUUID as randomUUID42 } from "crypto";
+import { randomUUID as randomUUID43 } from "crypto";
 
 // ../daemon/src/lib/notification-authorization.ts
 function authorizeAttentionNotification(db, item, captured) {
@@ -52628,7 +52951,7 @@ var NotificationControl = class {
     );
     for (const item of items) byKind[item.kind]++;
     const value = {
-      id: randomUUID42(),
+      id: randomUUID43(),
       settingsRevision: revision4,
       destinationId: binding.id,
       kinds,
@@ -52838,7 +53161,7 @@ var NotificationDispatcher = class {
       if (!settings2.enabled || settings2.restorePaused) return;
       const binding = destinationBinding(this.db);
       if (!binding || this.transport.capture()?.id !== binding.id) {
-        for (const item of list11(this.db, { deferredOnly: true, limit: 100 }).receipts)
+        for (const item of list12(this.db, { deferredOnly: true, limit: 100 }).receipts)
           suppress(this.db, item.id, "destination_changed", this.now());
         this.diagnostic = "notification_destination_unavailable";
         return;
@@ -52868,7 +53191,7 @@ var NotificationDispatcher = class {
           suppress(this.db, receipt.id, authorization.reason, this.now());
         if (++admitted >= 100) break;
       }
-      for (const receipt of list11(this.db, { deferredOnly: true, limit: 10 }).receipts) {
+      for (const receipt of list12(this.db, { deferredOnly: true, limit: 10 }).receipts) {
         if (!this.#current(receipt.id)) continue;
         let claimed = null;
         const owner = { attempt: null };
@@ -53027,7 +53350,7 @@ notificationsRouter.get("/receipts", (c) => {
   const cursor = c.req.query("cursor");
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100 || cursor && !/^[a-f0-9-]{36}$/.test(cursor))
     return c.json({ error: "Invalid notification receipt page" }, 400);
-  return c.json(list11(getCtx().db, { limit, cursor }));
+  return c.json(list12(getCtx().db, { limit, cursor }));
 });
 notificationsRouter.get("/receipts/:id", (c) => {
   const receipt = get17(getCtx().db, c.req.param("id"));
@@ -53053,7 +53376,7 @@ notificationsRouter.post("/receipts/:id/retry", async (c) => {
 
 // ../daemon/src/routes/profiles.ts
 import { existsSync as existsSync21, readFileSync as readFileSync14, writeFileSync as writeFileSync15 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 import { Hono as Hono12 } from "hono";
 var profilesRouter = new Hono12();
 profilesRouter.get("/", (c) => {
@@ -53205,7 +53528,7 @@ profilesRouter.put("/:id/files/:file", async (c) => {
 });
 function resolveFilePath(profilesDir, id, file) {
   if (!PROFILE_FILES.includes(file)) return null;
-  return join34(profilesDir, id, file);
+  return join35(profilesDir, id, file);
 }
 function csvToArray(v2) {
   if (Array.isArray(v2)) return v2.filter((s) => typeof s === "string");
@@ -53257,7 +53580,7 @@ questionsRouter.get("/:agentId/questions", (c) => {
   const { db } = getCtx();
   const conversationId = c.req.query("conversationId");
   return c.json({
-    questions: list12(db, c.req.param("agentId"), 100, conversationId).filter((item) => questionVisible(db, item))
+    questions: list13(db, c.req.param("agentId"), 100, conversationId).filter((item) => questionVisible(db, item))
   });
 });
 questionsRouter.get("/:agentId/questions/:id", (c) => {
@@ -53418,7 +53741,7 @@ shellApprovalsRouter.post("/:id", async (c) => {
 // ../daemon/src/routes/skills.ts
 import { existsSync as existsSync22, mkdtempSync as mkdtempSync6, rmSync as rmSync17, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir3, tmpdir as tmpdir6 } from "os";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { Hono as Hono16 } from "hono";
 var MAX_ZIP_BYTES = 50 * 1024 * 1024;
 var skillsRouter = new Hono16();
@@ -53512,8 +53835,8 @@ async function parseImportInput(request2) {
     if (!filename2.toLowerCase().endsWith(".zip")) {
       throw new Error("uploaded file must be a .zip archive");
     }
-    const tmpDir = mkdtempSync6(join35(tmpdir6(), "bazilion-skill-upload-"));
-    const zipPath = join35(tmpDir, filename2.replace(/[^\w.-]+/g, "_"));
+    const tmpDir = mkdtempSync6(join36(tmpdir6(), "bazilion-skill-upload-"));
+    const zipPath = join36(tmpDir, filename2.replace(/[^\w.-]+/g, "_"));
     const buf = Buffer.from(await file.arrayBuffer());
     writeFileSync16(zipPath, buf);
     const forceField = form.get("force");
@@ -53528,7 +53851,7 @@ async function parseImportInput(request2) {
   if (!body) throw new Error("invalid JSON body");
   const from = body.source ?? body.from;
   if (typeof from !== "string" || !from) throw new Error("source is required");
-  const source = from === "openclaw" ? join35(homedir3(), ".openclaw", "skills") : from;
+  const source = from === "openclaw" ? join36(homedir3(), ".openclaw", "skills") : from;
   return {
     source,
     force: Boolean(body.force),
@@ -53538,7 +53861,7 @@ async function parseImportInput(request2) {
 }
 
 // ../daemon/src/routes/team-templates.ts
-import { randomUUID as randomUUID43 } from "crypto";
+import { randomUUID as randomUUID44 } from "crypto";
 import { Hono as Hono17 } from "hono";
 var teamTemplatesRouter = new Hono17();
 teamTemplatesRouter.get("/", (c) => {
@@ -53578,7 +53901,7 @@ teamTemplatesRouter.post("/import", async (c) => {
       if (!profiles_exports.get(db, parsed.profileId)) {
         throw new Error(`profile not found: ${parsed.profileId}`);
       }
-      const slotId = randomUUID43();
+      const slotId = randomUUID44();
       keyToSlot.set(clientKey, slotId);
       return { ...parsed, slotId };
     });
@@ -53799,7 +54122,7 @@ function parseSlot(value, index) {
     throw new Error(`invalid_template_definition: slot ${index} requires profileId and agentName`);
   }
   const reasoning = slot.reasoningLevel;
-  if (reasoning !== void 0 && reasoning !== null && (typeof reasoning !== "string" || !REASONING_LEVELS2.includes(reasoning))) {
+  if (reasoning !== void 0 && reasoning !== null && (typeof reasoning !== "string" || !REASONING_LEVELS.includes(reasoning))) {
     throw new Error(`invalid_template_definition: slot ${index} reasoningLevel is invalid`);
   }
   const result = {
@@ -53870,7 +54193,7 @@ function canonicalError(c, error2) {
 }
 
 // ../daemon/src/routes/teams.ts
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 import { Hono as Hono18 } from "hono";
 
 // ../daemon/src/lib/coding-environment/management.ts
@@ -54075,9 +54398,9 @@ function resolvePublicationTarget(db, authToken) {
 }
 
 // ../daemon/src/lib/publication/revision-content.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import { readFileSync as readFileSync15 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 function readReviewedRevisionFiles(db, paths2, packet) {
   const record3 = getSourceSnapshot(db, packet.teamId, packet.snapshotId);
   if (!record3) {
@@ -54127,7 +54450,7 @@ function readReviewedRevisionFiles(db, paths2, packet) {
     }
     let content;
     try {
-      content = readFileSync15(join36(paths2.teamDir(packet.teamId), entry.path));
+      content = readFileSync15(join37(paths2.teamDir(packet.teamId), entry.path));
     } catch {
       return {
         ok: false,
@@ -54135,7 +54458,7 @@ function readReviewedRevisionFiles(db, paths2, packet) {
         detail: `the reviewed content for ${entry.path} can no longer be read`
       };
     }
-    const digest4 = createHash19("sha256").update(content).digest("hex");
+    const digest4 = createHash20("sha256").update(content).digest("hex");
     if (digest4 !== entry.digest) {
       return {
         ok: false,
@@ -54251,7 +54574,7 @@ function refused2(reason, detail3) {
 // ../daemon/src/lib/publication/git-publish.ts
 import { execFile as execFile2 } from "child_process";
 import { mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync7, rmSync as rmSync18, writeFileSync as writeFileSync17 } from "fs";
-import { dirname as dirname7, join as join37 } from "path";
+import { dirname as dirname9, join as join38 } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile2);
 var COMMAND_BUDGET_MS = 6e4;
@@ -54259,8 +54582,8 @@ var MAX_OUTPUT = 64 * 1024;
 var AUTHOR_NAME = "Bazilion";
 var AUTHOR_EMAIL = "bazilion@localhost";
 async function publishRevisionCommit(input) {
-  const scratch = mkdtempSync7(join37(input.scratchParentDir ?? "/tmp", "bazilion-publish-"));
-  const gitDir = join37(scratch, "repo");
+  const scratch = mkdtempSync7(join38(input.scratchParentDir ?? "/tmp", "bazilion-publish-"));
+  const gitDir = join38(scratch, "repo");
   const gitEnv = environment(scratch, input.remoteUrl, input.credential);
   const run = (args, cwd = scratch) => git(["-C", gitDir, ...args], cwd, gitEnv);
   try {
@@ -54297,8 +54620,8 @@ async function publishRevisionCommit(input) {
     }
     await run(["checkout", "--quiet", "--detach", input.baseOid]);
     for (const file of input.files) {
-      const target = join37(gitDir, file.path);
-      mkdirSync12(dirname7(target), { recursive: true });
+      const target = join38(gitDir, file.path);
+      mkdirSync12(dirname9(target), { recursive: true });
       writeFileSync17(target, file.content);
     }
     for (const path of input.removed) {
@@ -54883,7 +55206,7 @@ function renderExportDocument(exported) {
 // ../daemon/src/lib/review/file-link.ts
 import { execFile as execFile3 } from "child_process";
 import { hostname } from "os";
-import { isAbsolute as isAbsolute10, join as join38 } from "path";
+import { isAbsolute as isAbsolute10, join as join39 } from "path";
 import { promisify as promisify2 } from "util";
 var execFileAsync2 = promisify2(execFile3);
 var EDITOR_TEMPLATE_ENV = "BAZILION_REVIEW_EDITOR";
@@ -54896,7 +55219,7 @@ function buildFileLink(input) {
   const known = revision4.ok && revision4.changes.some((change) => change.path === input.path);
   const line = input.line !== null && input.line >= 1 ? input.line : null;
   const copyTarget = line === null ? input.path : `${input.path}:${line}`;
-  const hostPath = known ? join38(team.path, input.path) : null;
+  const hostPath = known ? join39(team.path, input.path) : null;
   const template = env[EDITOR_TEMPLATE_ENV]?.trim();
   const mapped = hostPath ? mapHostPath(hostPath, env[EDITOR_MAP_ENV]) : null;
   if (!known) {
@@ -55445,7 +55768,7 @@ teamsRouter.post("/:id/review/snapshots", async (c) => {
   }
   let includeUntracked;
   if (input.includeUntracked !== void 0) {
-    if (!Array.isArray(input.includeUntracked) || input.includeUntracked.length > REVIEW_LIMITS2.files) {
+    if (!Array.isArray(input.includeUntracked) || input.includeUntracked.length > REVIEW_LIMITS.files) {
       return c.json({ error: "Invalid untracked selection" }, 400);
     }
     includeUntracked = [];
@@ -55779,7 +56102,7 @@ async function openMemory(rawId) {
   const { db, paths: paths2 } = getCtx();
   const team = teams_exports.get(db, rawId, paths2);
   if (!team) throw new TeamMemoryNotFoundError(`team not found: ${rawId}`);
-  const mem = qmdBackend(join39(team.path, "memory"));
+  const mem = qmdBackend(join40(team.path, "memory"));
   await mem.init();
   return { mem, team };
 }
@@ -56392,7 +56715,7 @@ userQueueRouter.onError((error2, c) => {
 userQueueRouter.get(
   "/:agentId/queue",
   (c) => c.json(
-    list13(getCtx().db, c.req.param("agentId"), {
+    list14(getCtx().db, c.req.param("agentId"), {
       all: c.req.query("all") === "1",
       limit: Number(c.req.query("limit") ?? 20),
       offset: Number(c.req.query("offset") ?? 0)
@@ -56633,7 +56956,7 @@ function startUserQueuePump() {
       stopping = true;
       clearInterval(timer);
       for (const agentId of active.keys()) {
-        const head = list13(db, agentId, { limit: 1 }).items[0];
+        const head = list14(db, agentId, { limit: 1 }).items[0];
         if (head?.status === "running") cancelAgent(agentId);
       }
       await Promise.allSettled(active.values());
@@ -56662,7 +56985,7 @@ try {
 try {
   getCtx();
 } catch (error2) {
-  const detail3 = error2 instanceof IncompatibleDatabaseError || error2 instanceof IncompatibleBootstrapIdentityError ? error2.message : error2 instanceof Error ? error2.stack ?? error2.message : String(error2);
+  const detail3 = error2 instanceof IncompatibleDatabaseError || error2 instanceof DatabaseNewerThanBinaryError || error2 instanceof IncompatibleBootstrapIdentityError ? error2.message : error2 instanceof Error ? error2.stack ?? error2.message : String(error2);
   writeSync2(process.stderr.fd, `bazilion daemon failed to start: ${detail3}
 `);
   try {