@agentdocumentformat/cli 0.7.6 → 0.7.7

package/dist/chunks/{daemon-ZT5J445W.mjs → daemon-CHZHTLGR.mjs}

@@ -18,8 +18,9 @@ import {
   checkFetchTarget,
   contextCategories,
   contextTotal,
-  resolveCompactThreshold
-} from "./chunk-2WSQ7V6K.mjs";
+  resolveCompactThreshold,
+  resolveLoopThreshold
+} from "./chunk-4N4ASPH6.mjs";
 import {
   startCallbackServer
 } from "./chunk-2NAP2ZF7.mjs";
@@ -434,8 +435,8 @@ var require_types = __commonJS({
       TokenType2[TokenType2.IS_POSTFIX = IS_POSTFIX] = "IS_POSTFIX";
       let IS_EXPRESSION_START = 512;
       TokenType2[TokenType2.IS_EXPRESSION_START = IS_EXPRESSION_START] = "IS_EXPRESSION_START";
-      let num = 512;
-      TokenType2[TokenType2.num = num] = "num";
+      let num2 = 512;
+      TokenType2[TokenType2.num = num2] = "num";
       let bigint = 1536;
       TokenType2[TokenType2.bigint = bigint] = "bigint";
       let decimal = 2560;
@@ -12388,14 +12389,14 @@ var require_sourcemap_codec_umd = __commonJS({
         let shouldNegate = value & 1;
         return value >>>= 1, shouldNegate && (value = -2147483648 | -value), relative4 + value;
       }
-      function encodeInteger(builder, num, relative4) {
-        let delta = num - relative4;
+      function encodeInteger(builder, num2, relative4) {
+        let delta = num2 - relative4;
         delta = delta < 0 ? -delta << 1 | 1 : delta << 1;
         do {
           let clamped = delta & 31;
           delta >>>= 5, delta > 0 && (clamped |= 32), builder.write(intToChar[clamped]);
         } while (delta > 0);
-        return num;
+        return num2;
       }
       function hasMoreVlq(reader, max) {
         return reader.pos >= max ? !1 : reader.peek() !== comma;
@@ -23557,10 +23558,10 @@ var require_serializer = __commonJS({
         return "" + integer;
       }
       asNumber(i) {
-        let num = Number(i);
-        if (num !== num)
+        let num2 = Number(i);
+        if (num2 !== num2)
           throw new Error(`The value "${i}" cannot be converted to a number.`);
-        return num === 1 / 0 || num === -1 / 0 ? "null" : "" + num;
+        return num2 === 1 / 0 || num2 === -1 / 0 ? "null" : "" + num2;
       }
       asBoolean(bool) {
         return bool && "true" || "false";
@@ -25317,21 +25318,21 @@ var require_secure_json_parse = __commonJS({
         return obj;
       return filter2(obj, { protoAction, constructorAction, safe: options && options.safe });
     }
-    function filter2(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
+    function filter2(obj, { protoAction = "error", constructorAction = "error", safe: safe2 } = {}) {
       let next = [obj];
       for (; next.length; ) {
         let nodes = next;
         next = [];
         for (let node of nodes) {
           if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
-            if (safe === !0)
+            if (safe2 === !0)
               return null;
             if (protoAction === "error")
               throw new SyntaxError("Object contains forbidden prototype property");
             delete node.__proto__;
           }
           if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && node.constructor !== null && typeof node.constructor == "object" && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
-            if (safe === !0)
+            if (safe2 === !0)
               return null;
             if (constructorAction === "error")
               throw new SyntaxError("Object contains forbidden prototype property");
@@ -31799,8 +31800,8 @@ var require_parse = __commonJS({
           break;
         case "timestamp": {
           parseString(cxt);
-          let vts = (0, util_1.useFunc)(gen, timestamp_1.default), { allowDate, parseDate } = self2.opts, notValid = allowDate ? (0, codegen_1._)`!${vts}(${data}, true)` : (0, codegen_1._)`!${vts}(${data})`, fail2 = parseDate ? (0, codegen_1.or)(notValid, (0, codegen_1._)`(${data} = new Date(${data}), false)`, (0, codegen_1._)`isNaN(${data}.valueOf())`) : notValid;
-          gen.if(fail2, () => parsingError(cxt, (0, codegen_1.str)`invalid timestamp`));
+          let vts = (0, util_1.useFunc)(gen, timestamp_1.default), { allowDate, parseDate } = self2.opts, notValid = allowDate ? (0, codegen_1._)`!${vts}(${data}, true)` : (0, codegen_1._)`!${vts}(${data})`, fail3 = parseDate ? (0, codegen_1.or)(notValid, (0, codegen_1._)`(${data} = new Date(${data}), false)`, (0, codegen_1._)`isNaN(${data}.valueOf())`) : notValid;
+          gen.if(fail3, () => parsingError(cxt, (0, codegen_1.str)`invalid timestamp`));
           break;
         }
         case "float32":
@@ -31834,10 +31835,10 @@ var require_parse = __commonJS({
       let { gen } = cxt;
       skipWhitespace(cxt), gen.if((0, codegen_1._)`"-0123456789".indexOf(${jsonSlice(1)}) < 0`, () => jsonSyntaxError(cxt), () => parseWith(cxt, parseJson_1.parseJsonNumber, maxDigits));
     }
-    function parseBooleanToken(bool, fail2) {
+    function parseBooleanToken(bool, fail3) {
       return (cxt) => {
         let { gen, data } = cxt;
-        tryParseToken(cxt, `${bool}`, () => fail2(cxt), () => gen.assign(data, bool));
+        tryParseToken(cxt, `${bool}`, () => fail3(cxt), () => gen.assign(data, bool));
       };
     }
     function parseRef(cxt) {
@@ -31865,11 +31866,11 @@ var require_parse = __commonJS({
     function parseToken(cxt, tok) {
       tryParseToken(cxt, tok, jsonSyntaxError);
     }
-    function tryParseToken(cxt, tok, fail2, success) {
+    function tryParseToken(cxt, tok, fail3, success) {
       let { gen } = cxt, n = tok.length;
       skipWhitespace(cxt), gen.if((0, codegen_1._)`${jsonSlice(n)} === ${tok}`, () => {
         gen.add(names_1.default.jsonPos, n), success?.(cxt);
-      }, () => fail2(cxt));
+      }, () => fail3(cxt));
     }
     function skipWhitespace({ gen, char: c }) {
       gen.code((0, codegen_1._)`while((${c}=${names_1.default.json}[${names_1.default.jsonPos}],${c}===" "||${c}==="\\n"||${c}==="\\r"||${c}==="\\t"))${names_1.default.jsonPos}++;`);
@@ -32686,10 +32687,10 @@ var require_serializer2 = __commonJS({
         return "" + integer;
       }
       asNumber(i) {
-        let num = Number(i);
-        if (num !== num)
+        let num2 = Number(i);
+        if (num2 !== num2)
           throw new Error(`The value "${i}" cannot be converted to a number.`);
-        return num === 1 / 0 || num === -1 / 0 ? "null" : "" + num;
+        return num2 === 1 / 0 || num2 === -1 / 0 ? "null" : "" + num2;
       }
       asBoolean(bool) {
         return bool && "true" || "false";
@@ -34861,8 +34862,8 @@ var require_re = __commonJS({
         value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
       return value;
     }, createToken = (name21, value, isGlobal) => {
-      let safe = makeSafeRegex(value), index = R++;
-      debug(name21, index, value), t[name21] = index, src[index] = value, safeSrc[index] = safe, re2[index] = new RegExp(value, isGlobal ? "g" : void 0), safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+      let safe2 = makeSafeRegex(value), index = R++;
+      debug(name21, index, value), t[name21] = index, src[index] = value, safeSrc[index] = safe2, re2[index] = new RegExp(value, isGlobal ? "g" : void 0), safeRe[index] = new RegExp(safe2, isGlobal ? "g" : void 0);
     };
     createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
     createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
@@ -34967,9 +34968,9 @@ var require_semver = __commonJS({
           throw new TypeError("Invalid patch version");
         m[4] ? this.prerelease = m[4].split(".").map((id) => {
           if (/^[0-9]+$/.test(id)) {
-            let num = +id;
-            if (num >= 0 && num < MAX_SAFE_INTEGER)
-              return num;
+            let num2 = +id;
+            if (num2 >= 0 && num2 < MAX_SAFE_INTEGER)
+              return num2;
           }
           return id;
         }) : this.prerelease = [], this.build = m[5] ? m[5].split(".") : [], this.format();
@@ -43451,8 +43452,8 @@ var require_parse4 = __commonJS({
         tokens
       };
       input = utils2.removePrefix(input, state), len = input.length;
-      let extglobs = [], braces = [], stack = [], prev = bos, value, eos = () => state.index === len - 1, peek = state.peek = (n = 1) => input[state.index + n], advance = state.advance = () => input[++state.index] || "", remaining = () => input.slice(state.index + 1), consume = (value2 = "", num = 0) => {
-        state.consumed += value2, state.index += num;
+      let extglobs = [], braces = [], stack = [], prev = bos, value, eos = () => state.index === len - 1, peek = state.peek = (n = 1) => input[state.index + n], advance = state.advance = () => input[++state.index] || "", remaining = () => input.slice(state.index + 1), consume = (value2 = "", num2 = 0) => {
+        state.consumed += value2, state.index += num2;
       }, append = (token) => {
         state.output += token.output != null ? token.output : token.value, consume(token.value);
       }, negate = () => {
@@ -45114,10 +45115,10 @@ function base58btcEncode(data) {
   let zeros = 0;
   for (let i = 0; i < data.length && data[i] === 0; i++)
     zeros++;
-  let num = BigInt("0x" + (data.length > 0 ? data.toString("hex") : "0")), chars = [];
-  for (; num > 0n; ) {
-    let remainder = Number(num % 58n);
-    num = num / 58n, chars.push(BASE58_ALPHABET[remainder]);
+  let num2 = BigInt("0x" + (data.length > 0 ? data.toString("hex") : "0")), chars = [];
+  for (; num2 > 0n; ) {
+    let remainder = Number(num2 % 58n);
+    num2 = num2 / 58n, chars.push(BASE58_ALPHABET[remainder]);
   }
   for (let i = 0; i < zeros; i++)
     chars.push("1");
@@ -45147,18 +45148,18 @@ function rawPublicKeyToSpki(rawKey) {
   return Buffer.concat([header, rawKey]);
 }
 function base58btcDecode(str2) {
-  let num = 0n;
+  let num2 = 0n;
   for (let char of str2) {
     let idx = BASE58_ALPHABET.indexOf(char);
     if (idx === -1) throw new Error(`Invalid base58 character: ${char}`);
-    num = num * 58n + BigInt(idx);
+    num2 = num2 * 58n + BigInt(idx);
   }
   let leadingZeros = 0;
   for (let char of str2) {
     if (char !== "1") break;
     leadingZeros++;
   }
-  let hex = num === 0n ? "" : num.toString(16), paddedHex = hex.length % 2 ? "0" + hex : hex, dataBytes = Buffer.from(paddedHex, "hex"), zeros = Buffer.alloc(leadingZeros);
+  let hex = num2 === 0n ? "" : num2.toString(16), paddedHex = hex.length % 2 ? "0" + hex : hex, dataBytes = Buffer.from(paddedHex, "hex"), zeros = Buffer.alloc(leadingZeros);
   return Buffer.concat([zeros, dataBytes]);
 }
 function didToPublicKey(did) {
@@ -46680,8 +46681,15 @@ CREATE INDEX IF NOT EXISTS idx_adf_logs_origin ON adf_logs(origin);
       return _AdfDatabase.peekReadonly(filePath, (db) => {
         let row = db.prepare("SELECT config_json FROM adf_config WHERE id = 1").get();
         if (!row) return null;
-        let config = JSON.parse(row.config_json);
+        let config = JSON.parse(row.config_json), did;
+        try {
+          let meta = db.prepare("SELECT value FROM adf_meta WHERE key = 'adf_did'").get();
+          did = (meta ? Buffer.isBuffer(meta.value) ? meta.value.toString("utf-8") : String(meta.value) : "") || void 0;
+        } catch {
+          did = void 0;
+        }
         return {
+          did,
           id: config.id,
           name: config.name,
           receive: config.messaging?.receive ?? !1,
@@ -47940,6 +47948,7 @@ CREATE INDEX IF NOT EXISTS idx_adf_logs_origin ON adf_logs(origin);
 // src/main/adf/adf-workspace.ts
 import { brotliCompress, brotliCompressSync, brotliDecompressSync as brotliDecompressSync2, constants as zlibConstants } from "zlib";
 import { promisify } from "util";
+import { createPrivateKey as createPrivateKey3, createPublicKey as createPublicKey3 } from "crypto";
 
 // src/main/adf/skill-indexer.ts
 init_execution_context();
@@ -48425,13 +48434,25 @@ var LoopCompactionSupersededError = class extends Error {
     super(`compactLoop: source seq ${seq} no longer exists \u2014 another compaction or clear landed first`), this.name = "LoopCompactionSupersededError";
   }
 }, LOOP_REVISION_CHANGED = /* @__PURE__ */ Symbol("adf:loop-revision-changed");
-var CONTEXT_BASELINE_META_KEY = "context_baseline_tokens", ENVELOPE_NAMES = ["identity", "credentials"], ENVELOPE_PURPOSE_PREFIX = "crypto:envelope:", MCP_OAUTH_PURPOSE_RE = /^mcp:[^:]+:oauth$/, MCP_CREDENTIAL_FILE_PURPOSE_RE = /^mcp:[^:]+:file:/;
+var CONTEXT_BASELINE_META_KEY = "context_baseline_tokens", ENVELOPE_NAMES = ["identity", "credentials"], ENVELOPE_PURPOSE_PREFIX = "crypto:envelope:";
+function numberedPath(path, n) {
+  if (n <= 1) return path;
+  let slash = path.lastIndexOf("/"), dot = path.lastIndexOf(".");
+  return dot <= slash + 1 ? `${path}-${n}` : `${path.slice(0, dot)}-${n}${path.slice(dot)}`;
+}
+var MCP_OAUTH_PURPOSE_RE = /^mcp:[^:]+:oauth$/, MCP_CREDENTIAL_FILE_PURPOSE_RE = /^mcp:[^:]+:file:/;
 function isReservedMcpRuntimePurpose(purpose) {
   return MCP_OAUTH_PURPOSE_RE.test(purpose) || MCP_CREDENTIAL_FILE_PURPOSE_RE.test(purpose);
 }
 function mcpRuntimeIdentityAccess(purpose) {
   return isReservedMcpRuntimePurpose(purpose) ? { readUnlocked: !1, writeUnlocked: !1 } : { readUnlocked: !0, writeUnlocked: !0 };
 }
+function assertEd25519Pair(privateKey, publicKey) {
+  let priv = createPrivateKey3({ key: privateKey, format: "der", type: "pkcs8" });
+  if (priv.asymmetricKeyType !== "ed25519") throw new Error("Adopted identity key is not Ed25519");
+  let derived = createPublicKey3(priv).export({ type: "spki", format: "der" });
+  if (!Buffer.from(derived).equals(publicKey)) throw new Error("Adopted identity public key does not match its private key");
+}
 var AdfWorkspace = class _AdfWorkspace {
   db;
   filePath;
@@ -48975,9 +48996,15 @@ var AdfWorkspace = class _AdfWorkspace {
   /**
    * Generate Ed25519 key pair + DID for an ADF that doesn't have one.
    * If a password is active, the new keys are encrypted with the given derivedKey.
-   */
-  generateIdentityKeys(derivedKey) {
-    let keyPair = generateEd25519KeyPair(), rawPubKey = extractRawPublicKey(keyPair.publicKey), did = publicKeyToDid(rawPubKey), identityDek = this.envelopeDeks.get("identity");
+   *
+   * `adopt` stores a keypair minted earlier (an identity draft from the create
+   * screen) instead of a fresh one. The rows, sealing, and adf_did are exactly
+   * what a fresh mint writes. The pair is checked first: the public key must
+   * be the Ed25519 public half of the private key.
+   */
+  generateIdentityKeys(derivedKey, adopt) {
+    adopt && assertEd25519Pair(adopt.privateKey, adopt.publicKey);
+    let keyPair = adopt ?? generateEd25519KeyPair(), rawPubKey = extractRawPublicKey(keyPair.publicKey), did = publicKeyToDid(rawPubKey), identityDek = this.envelopeDeks.get("identity");
     if (identityDek)
       this.db.setIdentityRaw("crypto:signing:private_key", sealWithDek(keyPair.privateKey, identityDek), envelopeAlgo("identity"), null, null), this.db.setIdentityRaw("crypto:signing:public_key", keyPair.publicKey, "plain", null, null);
     else if (derivedKey) {
@@ -49737,6 +49764,22 @@ var AdfWorkspace = class _AdfWorkspace {
     let existed = this.db.fileExists(relativePath), previous = this.onFileChangeCallback ? this.db.readFile(relativePath)?.content : void 0, protection = relativePath === "mind.md" || relativePath === "README.md" || relativePath === "document.md" ? "no_delete" : "none";
     this.db.writeFile(relativePath, content, mimeType, protection), this.emitUmbilical("file.written", { path: relativePath, bytes: content.length }), this.emitFileChange(relativePath, existed ? "modified" : "created", content, previous, this.fileChangeMeta(relativePath));
   }
+  /**
+   * Write a file without replacing a different one already at that path.
+   * A taken name gets a number before its extension (`report.pdf` →
+   * `report-2.pdf`). The same bytes already stored under the name or one of
+   * its numbered copies are reused rather than written again, so a re-delivered
+   * attachment or a re-uploaded file does not pile up copies.
+   * Returns the path the content lives at.
+   */
+  writeFileBufferUnique(relativePath, content, mimeType) {
+    for (let n = 1; ; n++) {
+      let candidate = numberedPath(relativePath, n), existing = this.db.readFile(candidate);
+      if (!existing)
+        return this.writeFileBuffer(candidate, content, mimeType), candidate;
+      if (existing.content.equals(content)) return candidate;
+    }
+  }
   /** File metadata for a change event — skipped entirely when no sink is registered. */
   fileChangeMeta(path) {
     return this.onFileChangeCallback ? this.getFileMeta(path) : null;
@@ -52526,6 +52569,26 @@ var ToolRegistry = class _ToolRegistry {
     let result = this.tools.delete(name21);
     return result && this.toolCache.clear(), result;
   }
+  /** Host-built tools that exist while their declaration does (provideDeclared). */
+  declaredFactories = /* @__PURE__ */ new Map();
+  /**
+   * Register `name` for as long as the agent config declares it (enabled or
+   * not), now and again on every config change via syncDeclared. For host
+   * tools whose registration follows declaration presence — sys_code,
+   * sys_lambda, npm_install, npm_uninstall. Without the re-sync, a tool the
+   * owner declared on a running agent stayed unregistered ("not available")
+   * until a restart. Access is still gated by the declaration on every call
+   * path; this only decides whether an instance exists to be gated.
+   */
+  provideDeclared(name21, make, declarations) {
+    this.declaredFactories.set(name21, make), this.syncDeclared(declarations);
+  }
+  /** Re-apply provideDeclared against a new config's declarations. */
+  syncDeclared(declarations) {
+    let declared = new Set(declarations.map((d) => d.name));
+    for (let [name21, make] of this.declaredFactories)
+      declared.has(name21) ? this.tools.has(name21) || this.register(make()) : this.unregister(name21);
+  }
   get(name21) {
     return this.tools.get(name21);
   }
@@ -53724,8 +53787,8 @@ var InputSchema = external_exports.object({
     let entry = workspace.getDatabase().readFile(path);
     if (!entry)
       return { content: `File not found: "${path}"`, isError: !0 };
-    let isText = isTextMime(entry.mime_type), fileContent;
-    if (isText) {
+    let isText2 = isTextMime(entry.mime_type), fileContent;
+    if (isText2) {
       let text2 = entry.content.toString("utf-8");
       if (start_line || end_line) {
         let lines = text2.split(`
@@ -57372,6 +57435,8 @@ var WARM_IDLE_TTL_MS = 5 * 6e4, COLD_IDLE_TTL_MS = 6e4, ADMISSION_MAX_WAIT_MS =
   stdlibModules = [];
   userPkgBasePath = null;
   userPkgModules = [];
+  /** Per-agent package lists, keyed by owning agent (see setAgentPackageSource). */
+  agentPackageSources = /* @__PURE__ */ new Map();
   /** Sandbox ids each agent has created, so destroyForAgent() reaps exactly
    *  those. Prefix matching used to do this, but sandbox ids are absolute
    *  Windows paths — an agent whose `.adf` declares `id: "C"` made
@@ -57392,13 +57457,48 @@ var WARM_IDLE_TTL_MS = 5 * 6e4, COLD_IDLE_TTL_MS = 6e4, ADMISSION_MAX_WAIT_MS =
   setStdlib(basePath, modules) {
     this.stdlibBasePath = basePath, this.stdlibModules = modules;
   }
-  /** Configure user-installed package path and visible module names for the sandbox. */
+  /**
+   * Configure the installed-package path and the RUNTIME packages (Settings >
+   * Packages), which every agent's sandboxes can import. Pass a reader to
+   * follow the setting live; it runs at each execution. An agent's own
+   * packages come on top of these, from setAgentPackageSource.
+   */
   setUserPackages(basePath, modules) {
     this.userPkgBasePath = basePath, this.userPkgModules = modules;
   }
-  /** Module names currently visible to sandboxed code (process-wide). */
-  getUserPackageModules() {
-    return [...this.userPkgModules];
+  runtimePackageModules() {
+    if (typeof this.userPkgModules != "function") return this.userPkgModules;
+    try {
+      return this.userPkgModules();
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * The packages one agent installed (its code_execution.packages), importable
+   * only by sandboxes that agent owns. `read` runs at each execution, so a
+   * package the agent just installed is importable on its next run with no
+   * refresh step. `keys` are every id the agent's sandboxes are owned under —
+   * the `agent` execute option, which is the file path for most callers and
+   * the config id for some (mesh routes, middleware).
+   */
+  setAgentPackageSource(keys, read) {
+    for (let key of keys) this.agentPackageSources.set(key, read);
+  }
+  clearAgentPackageSource(keys, read) {
+    for (let key of keys)
+      read && this.agentPackageSources.get(key) !== read || this.agentPackageSources.delete(key);
+  }
+  /** Module names visible to `agent`'s sandboxes: runtime packages plus its own. */
+  getUserPackageModules(agent) {
+    let runtime2 = this.runtimePackageModules(), read = agent ? this.agentPackageSources.get(agent) : void 0;
+    if (!read) return [...runtime2];
+    let own = [];
+    try {
+      own = read();
+    } catch {
+    }
+    return [.../* @__PURE__ */ new Set([...runtime2, ...own])];
   }
   /**
    * Set the global ceiling on concurrent cold-lambda workers (user setting —
@@ -57459,7 +57559,9 @@ var WARM_IDLE_TTL_MS = 5 * 6e4, COLD_IDLE_TTL_MS = 6e4, ADMISSION_MAX_WAIT_MS =
       stdlibBasePath: this.stdlibBasePath,
       stdlibModules: this.stdlibModules,
       userPkgBasePath: this.userPkgBasePath,
-      userPkgModules: this.userPkgModules
+      // Per execution: a worker serves one owner, but the list must follow
+      // that agent's installs and the runtime list as they change.
+      userPkgModules: this.getUserPackageModules(options?.agent ?? agentId)
     });
     let execId = `exec_${++this.execCounter}`, isAuthorized = options?.handlerAuthorized ?? toolConfig?.isAuthorized ?? !1;
     entry.authLevels.add(isAuthorized), entry.inflight++;
@@ -58861,15 +58963,15 @@ function estimateObjectChars(obj) {
   if (typeof obj == "string") return obj.length + 2;
   if (typeof obj == "number" || typeof obj == "boolean") return 5;
   if (Array.isArray(obj)) {
-    let sum = 2;
-    for (let item of obj) sum += estimateObjectChars(item) + 1;
-    return sum;
+    let sum2 = 2;
+    for (let item of obj) sum2 += estimateObjectChars(item) + 1;
+    return sum2;
   }
   if (typeof obj == "object") {
-    let sum = 2;
+    let sum2 = 2;
     for (let key of Object.keys(obj))
-      sum += key.length + estimateObjectChars(obj[key]) + 2;
-    return sum;
+      sum2 += key.length + estimateObjectChars(obj[key]) + 2;
+    return sum2;
   }
   return 10;
 }
@@ -59119,9 +59221,9 @@ function escapeAttr(value) {
 function renderInjectedFile(path, content) {
   if (content === MISSING_FILE_SENTINEL)
     return `<${INJECTED_TAG} path="${escapeAttr(path)}" missing="true"/>`;
-  let safe = content.split(`</${INJECTED_TAG}`).join(`<\\/${INJECTED_TAG}`);
+  let safe2 = content.split(`</${INJECTED_TAG}`).join(`<\\/${INJECTED_TAG}`);
   return `<${INJECTED_TAG} path="${escapeAttr(path)}">
-${safe}
+${safe2}
 </${INJECTED_TAG}>`;
 }
 function collectInjectedFiles(sources, read, snapshot) {
@@ -59391,9 +59493,17 @@ var LLM_PRICING = {
   }
 };
 function estimateLlmCallCostUsd(metadata) {
-  let pricing = LLM_PRICING[metadata.model];
+  return estimateTokenCostUsd(metadata.model, {
+    input: metadata.input_tokens,
+    output: metadata.output_tokens,
+    cache_read: metadata.cache_read_tokens,
+    cache_write: metadata.cache_write_tokens
+  });
+}
+function estimateTokenCostUsd(model, tokens) {
+  let pricing = LLM_PRICING[model];
   if (!pricing) return;
-  let cacheRead = metadata.cache_read_tokens ?? 0, cacheWrite = metadata.cache_write_tokens ?? 0, inputCost = Math.max(0, metadata.input_tokens - cacheRead - cacheWrite) * pricing.input_per_million / 1e6, cacheCost = cacheRead * (pricing.cache_read_per_million ?? pricing.input_per_million) / 1e6 + cacheWrite * (pricing.cache_write_per_million ?? pricing.input_per_million) / 1e6, outputCost = metadata.output_tokens * pricing.output_per_million / 1e6;
+  let cacheRead = tokens.cache_read ?? 0, cacheWrite = tokens.cache_write ?? 0, inputCost = Math.max(0, (tokens.input ?? 0) - cacheRead - cacheWrite) * pricing.input_per_million / 1e6, cacheCost = cacheRead * (pricing.cache_read_per_million ?? pricing.input_per_million) / 1e6 + cacheWrite * (pricing.cache_write_per_million ?? pricing.input_per_million) / 1e6, outputCost = (tokens.output ?? 0) * pricing.output_per_million / 1e6;
   return Number((inputCost + cacheCost + outputCost).toFixed(8));
 }
 
@@ -62182,8 +62292,8 @@ Retry error: ${String(retryError)}
     let content = row.content;
     if (!content) return result;
     let lines = content.split(`
-`), totalLines = lines.length, totalChars = content.length, approxTokens = Math.ceil(totalChars / 4), maxTokens = this.config.limits?.max_file_read_tokens ?? 3e4;
-    if (approxTokens > maxTokens) {
+`), totalLines = lines.length, totalChars = content.length, approxTokens2 = Math.ceil(totalChars / 4), maxTokens = this.config.limits?.max_file_read_tokens ?? 3e4;
+    if (approxTokens2 > maxTokens) {
       let maxChars = maxTokens * 4, truncatedLines = content.slice(0, maxChars).split(`
 `);
       return truncatedLines.pop(), row.content = truncatedLines.join(`
@@ -62195,7 +62305,7 @@ Use start_line/end_line to read specific sections.`, { ...result, content: JSON.
     if (totalLines > 300) {
       let sizeStr = formatSize(Buffer.byteLength(content, "utf8")), preview = lines.slice(0, 50).join(`
 `);
-      return row.content = `[Large file: ${totalLines} lines, ${sizeStr}, ~${approxTokens.toLocaleString()} tokens]
+      return row.content = `[Large file: ${totalLines} lines, ${sizeStr}, ~${approxTokens2.toLocaleString()} tokens]
 Use start_line/end_line to read sections (e.g. start_line=1, end_line=100).
 
 --- Preview (first 50 lines) ---
@@ -65339,12 +65449,134 @@ var execFileAsync = promisify2(execFile), IS_WIN = process.platform === "win32",
 var inputSchema = external_exports.object({
   name: external_exports.string().min(1).describe('npm package name (e.g. "lodash", "vega-lite", "@resvg/resvg-wasm")'),
   version: external_exports.string().optional().describe('Semver version or range (e.g. "^5.30.0", "4.17.21"). Defaults to "latest".')
-});
+}), MAX_PACKAGES = 50, NpmInstallTool = class {
+  constructor(packagesService, onPackageInstalled) {
+    this.packagesService = packagesService;
+    this.onPackageInstalled = onPackageInstalled;
+  }
+  packagesService;
+  onPackageInstalled;
+  name = "npm_install";
+  description = 'Install an npm package for use in code execution (sys_code / sys_lambda). Pure JavaScript packages only \u2014 native addons are blocked. The package becomes available to import starting next turn. Example: npm_install({ name: "vega-lite", version: "^5.21.0" })';
+  inputSchema = inputSchema;
+  category = "system";
+  async execute(input, workspace) {
+    let { name: name21, version } = input, currentPackages = workspace.getAgentConfig().code_execution?.packages ?? [];
+    if (currentPackages.length >= MAX_PACKAGES)
+      return {
+        content: JSON.stringify({
+          success: !1,
+          error: "package_limit",
+          message: `Maximum ${MAX_PACKAGES} packages allowed. Remove unused packages with npm_uninstall first.`
+        }),
+        isError: !0
+      };
+    let existing = currentPackages.find((p) => p.name === name21);
+    if (existing && version && existing.version === version)
+      return {
+        content: JSON.stringify({
+          success: !0,
+          name: name21,
+          version: existing.version,
+          already_installed: !0
+        }),
+        isError: !1
+      };
+    try {
+      let agentName = workspace.getAgentConfig().name, result = await this.packagesService.install(name21, version, void 0, agentName), freshConfig = workspace.getAgentConfig(), packages = (freshConfig.code_execution?.packages ?? []).filter((p) => p.name !== name21);
+      return packages.push({ name: name21, version: result.version }), workspace.setAgentConfig({
+        ...freshConfig,
+        code_execution: {
+          ...freshConfig.code_execution,
+          packages
+        }
+      }), this.onPackageInstalled?.(name21, result.version), {
+        content: JSON.stringify({
+          success: !0,
+          name: name21,
+          version: result.version,
+          size_mb: result.size_mb,
+          already_installed: result.already_installed
+        }),
+        isError: !1
+      };
+    } catch (error) {
+      return error instanceof NativeAddonError ? {
+        content: JSON.stringify({
+          success: !1,
+          error: "native_addon",
+          message: "Package requires native code and cannot run in the sandbox."
+        }),
+        isError: !0
+      } : error instanceof SizeLimitError ? {
+        content: JSON.stringify({
+          success: !1,
+          error: "size_limit",
+          message: error.message
+        }),
+        isError: !0
+      } : {
+        content: JSON.stringify({
+          success: !1,
+          error: "npm_error",
+          message: String(error instanceof Error ? error.message : error)
+        }),
+        isError: !0
+      };
+    }
+  }
+  toProviderFormat() {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: zodToJsonSchema(this.inputSchema)
+    };
+  }
+};
 
 // src/main/tools/built-in/npm-uninstall.tool.ts
 var inputSchema2 = external_exports.object({
   name: external_exports.string().min(1).describe('npm package name to remove (e.g. "lodash")')
-});
+}), NpmUninstallTool = class {
+  constructor(onPackageRemoved) {
+    this.onPackageRemoved = onPackageRemoved;
+  }
+  onPackageRemoved;
+  name = "npm_uninstall";
+  description = "Remove an npm package from this agent's available packages. The package becomes unavailable to import starting next turn. Does not delete the package from disk (other agents may use it).";
+  inputSchema = inputSchema2;
+  category = "system";
+  async execute(input, workspace) {
+    let { name: name21 } = input, config = workspace.getAgentConfig(), packages = config.code_execution?.packages ?? [];
+    if (packages.findIndex((p) => p.name === name21) === -1)
+      return {
+        content: JSON.stringify({
+          success: !1,
+          error: "not_found",
+          message: `Package "${name21}" is not in this agent's installed packages.`
+        }),
+        isError: !0
+      };
+    let updated = packages.filter((p) => p.name !== name21);
+    return workspace.setAgentConfig({
+      ...config,
+      code_execution: {
+        ...config.code_execution,
+        packages: updated
+      }
+    }), this.onPackageRemoved?.(name21), {
+      content: JSON.stringify({ success: !0, name: name21 }),
+      isError: !1
+    };
+  }
+  toProviderFormat() {
+    return {
+      name: this.name,
+      description: this.description,
+      input_schema: zodToJsonSchema(this.inputSchema)
+    };
+  }
+};
 
 // src/main/tools/built-in/fs-transfer.tool.ts
 import {
@@ -66206,8 +66438,8 @@ function isHostPortFree(port2, host2) {
   });
 }
 function isolatedContainerName(agentName, agentId) {
-  let safe = agentName.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 30), shortId = agentId.slice(0, 8);
-  return `adf-${safe || shortId}-${shortId}`;
+  let safe2 = agentName.toLowerCase().replace(/[^a-z0-9]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 30), shortId = agentId.slice(0, 8);
+  return `adf-${safe2 || shortId}-${shortId}`;
 }
 function containerWorkspacePath(isolated, agentId) {
   return isolated ? "/workspace" : `/workspace/${agentId}`;
@@ -69821,6 +70053,8 @@ function assembleAgent(options) {
     })));
   }
   adfCallHandler?.attachSession(session);
+  let packageKeys = [workspace.getFilePath(), config.id].filter((key) => !!key), readAgentPackages = () => (workspace.getAgentConfig().code_execution?.packages ?? []).map((pkg) => pkg.name);
+  codeSandboxService2?.setAgentPackageSource(packageKeys, readAgentPackages);
   let preLlmHookRunner = codeSandboxService2 && adfCallHandler ? new PreLlmHookRunner(workspace, codeSandboxService2, adfCallHandler, config.id) : null, executor = new AgentExecutor(
     config,
     provider,
@@ -69842,7 +70076,7 @@ function assembleAgent(options) {
       toolPrompts: options.toolPrompts ?? {},
       compactionPrompt: options.compactionPrompt,
       sources,
-      sandboxModules: codeSandboxService2?.getUserPackageModules()
+      sandboxModules: codeSandboxService2?.getUserPackageModules(packageKeys[0])
     }));
   };
   refreshEffectiveRuntime(), options.effectiveRuntime && executor.setProviderChangeListener(() => refreshEffectiveRuntime()), options.systemScopeHandler && executor.setSystemScopeHandler(options.systemScopeHandler);
@@ -70087,7 +70321,7 @@ ${json2.slice(0, room)}${note}`;
   };
   syncLoopToolRegistration(config);
   let sysUpdateTool = registry3.get("sys_update_config"), applyConfigChange = (updatedConfig, configOptions) => {
-    if (stripLoopNameMarker(updatedConfig), rawConfig = updatedConfig, snapshotConfig = updatedConfig, executor.updateConfig(updatedConfig), triggerEvaluator.updateConfig(updatedConfig), adfCallHandler?.updateConfig(updatedConfig), syncLoopToolRegistration(updatedConfig), loopPool.reconcile(updatedConfig), refreshEffectiveRuntime(), configOptions?.notifyHost !== !1)
+    if (stripLoopNameMarker(updatedConfig), rawConfig = updatedConfig, snapshotConfig = updatedConfig, executor.updateConfig(updatedConfig), triggerEvaluator.updateConfig(updatedConfig), adfCallHandler?.updateConfig(updatedConfig), syncLoopToolRegistration(updatedConfig), registry3.syncDeclared(updatedConfig.tools ?? []), loopPool.reconcile(updatedConfig), refreshEffectiveRuntime(), configOptions?.notifyHost !== !1)
       for (let bindings of hostBindings()) bindings.onConfigChanged?.(updatedConfig);
   }, sysUpdateOnConfigChanged = (updatedConfig) => {
     applyConfigChange(updatedConfig);
@@ -70143,7 +70377,7 @@ ${json2.slice(0, room)}${note}`;
         adapterManager?.off("inbound", onAdapterInbound);
       } catch {
       }
-      executor.onToolCallIntercepted = void 0, executor.onTaskCreated = void 0, executor.onTaskCompleted = void 0, executor.onLlmCall = void 0, adfCallHandler && (adfCallHandler.onEvent = void 0, adfCallHandler.onTaskCompleted = void 0, adfCallHandler.onLambdaToolEndTurn = void 0, adfCallHandler.onHilApproved = void 0, adfCallHandler.requestProtectionApproval = void 0, adfCallHandler.onLlmCall = void 0), sysUpdateTool && sysUpdateTool.onConfigChanged === sysUpdateOnConfigChanged && (sysUpdateTool.onConfigChanged = void 0), createAdfTool && createAdfTool.onAutostartChild === createAdfOnAutostartChild && (createAdfTool.onAutostartChild = void 0), shellTool && (shellTool.onToolCallIntercepted === shellOnToolCallIntercepted && (shellTool.onToolCallIntercepted = void 0), shellTool.onApprovalRequired === shellOnApprovalRequired && (shellTool.onApprovalRequired = void 0), shellTool.onProtectionBlocked === shellOnProtectionBlocked && (shellTool.onProtectionBlocked = void 0)), activeHost = null, executor.removeAllListeners();
+      codeSandboxService2?.clearAgentPackageSource(packageKeys, readAgentPackages), executor.onToolCallIntercepted = void 0, executor.onTaskCreated = void 0, executor.onTaskCompleted = void 0, executor.onLlmCall = void 0, adfCallHandler && (adfCallHandler.onEvent = void 0, adfCallHandler.onTaskCompleted = void 0, adfCallHandler.onLambdaToolEndTurn = void 0, adfCallHandler.onHilApproved = void 0, adfCallHandler.requestProtectionApproval = void 0, adfCallHandler.onLlmCall = void 0), sysUpdateTool && sysUpdateTool.onConfigChanged === sysUpdateOnConfigChanged && (sysUpdateTool.onConfigChanged = void 0), createAdfTool && createAdfTool.onAutostartChild === createAdfOnAutostartChild && (createAdfTool.onAutostartChild = void 0), shellTool && (shellTool.onToolCallIntercepted === shellOnToolCallIntercepted && (shellTool.onToolCallIntercepted = void 0), shellTool.onApprovalRequired === shellOnApprovalRequired && (shellTool.onApprovalRequired = void 0), shellTool.onProtectionBlocked === shellOnProtectionBlocked && (shellTool.onProtectionBlocked = void 0)), activeHost = null, executor.removeAllListeners();
     }
   }, teardownPromise = null, teardown = () => teardownPromise || (teardownPromise = (async () => {
     try {
@@ -70348,7 +70582,7 @@ var Pipeline = class {
 };
 
 // src/main/crypto/message-crypto.ts
-import { hkdfSync as hkdfSync2, diffieHellman as diffieHellman2, createPrivateKey as createPrivateKey3, createPublicKey as createPublicKey3 } from "crypto";
+import { hkdfSync as hkdfSync2, diffieHellman as diffieHellman2, createPrivateKey as createPrivateKey4, createPublicKey as createPublicKey4 } from "crypto";
 
 // node_modules/@noble/hashes/utils.js
 function isBytes(a) {
@@ -70452,12 +70686,12 @@ function kdfInputToBytes(data, errorTitle = "") {
   return typeof data == "string" ? utf8ToBytes(data) : abytes(data, void 0, errorTitle);
 }
 function concatBytes(...arrays) {
-  let sum = 0;
+  let sum2 = 0;
   for (let i = 0; i < arrays.length; i++) {
     let a = arrays[i];
-    abytes(a), sum += a.length;
+    abytes(a), sum2 += a.length;
   }
-  let res = new Uint8Array(sum);
+  let res = new Uint8Array(sum2);
   for (let i = 0, pad = 0; i < arrays.length; i++) {
     let a = arrays[i];
     res.set(a, pad), pad += a.length;
@@ -71060,7 +71294,7 @@ function tonelliShanks(P) {
 function FpSqrt(P) {
   return P % _4n === _3n ? sqrt3mod4 : P % _8n === _5n ? sqrt5mod8 : P % _16n === _9n ? sqrt9mod16(P) : tonelliShanks(P);
 }
-var isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n2) === _1n2, FIELD_FIELDS = [
+var isNegativeLE = (num2, modulo) => (mod(num2, modulo) & _1n2) === _1n2, FIELD_FIELDS = [
   "create",
   "isValid",
   "is0",
@@ -71091,22 +71325,22 @@ function validateField(field) {
     throw new Error("invalid field: expected ORDER > 1, got " + field.ORDER);
   return field;
 }
-function FpPow(Fp2, num, power) {
+function FpPow(Fp2, num2, power) {
   let F = Fp2;
   if (power < _0n2)
     throw new Error("invalid exponent, negatives unsupported");
   if (power === _0n2)
     return F.ONE;
   if (power === _1n2)
-    return num;
-  let p = F.ONE, d = num;
+    return num2;
+  let p = F.ONE, d = num2;
   for (; power > _0n2; )
     power & _1n2 && (p = F.mul(p, d)), d = F.sqr(d), power >>= _1n2;
   return p;
 }
 function FpInvertBatch(Fp2, nums, passZero = !1) {
-  let F = Fp2, inverted = new Array(nums.length).fill(passZero ? F.ZERO : void 0), multipliedAcc = nums.reduce((acc, num, i) => F.is0(num) ? acc : (inverted[i] = acc, F.mul(acc, num)), F.ONE), invertedAcc = F.inv(multipliedAcc);
-  return nums.reduceRight((acc, num, i) => F.is0(num) ? acc : (inverted[i] = F.mul(acc, inverted[i]), F.mul(acc, num)), invertedAcc), inverted;
+  let F = Fp2, inverted = new Array(nums.length).fill(passZero ? F.ZERO : void 0), multipliedAcc = nums.reduce((acc, num2, i) => F.is0(num2) ? acc : (inverted[i] = acc, F.mul(acc, num2)), F.ONE), invertedAcc = F.inv(multipliedAcc);
+  return nums.reduceRight((acc, num2, i) => F.is0(num2) ? acc : (inverted[i] = F.mul(acc, inverted[i]), F.mul(acc, num2)), invertedAcc), inverted;
 }
 function FpLegendre(Fp2, n) {
   let F = Fp2, p1mod2 = (F.ORDER - _1n2) / _2n, powered = F.pow(n, p1mod2), yes = F.eql(powered, F.ONE), zero = F.eql(powered, F.ZERO), no = F.eql(powered, F.neg(F.ONE));
@@ -71144,32 +71378,32 @@ var FIELD_SQRT = /* @__PURE__ */ new WeakMap(), _Field = class {
       throw new Error("invalid field: expected ORDER of <= 2048 bytes");
     this.ORDER = ORDER, this.BITS = nBitLength, this.BYTES = nByteLength, Object.freeze(this);
   }
-  create(num) {
-    return mod(num, this.ORDER);
+  create(num2) {
+    return mod(num2, this.ORDER);
   }
-  isValid(num) {
-    if (typeof num != "bigint")
-      throw new TypeError("invalid field element: expected bigint, got " + typeof num);
-    return _0n2 <= num && num < this.ORDER;
+  isValid(num2) {
+    if (typeof num2 != "bigint")
+      throw new TypeError("invalid field element: expected bigint, got " + typeof num2);
+    return _0n2 <= num2 && num2 < this.ORDER;
   }
-  is0(num) {
-    return num === _0n2;
+  is0(num2) {
+    return num2 === _0n2;
   }
   // is valid and invertible
-  isValidNot0(num) {
-    return !this.is0(num) && this.isValid(num);
+  isValidNot0(num2) {
+    return !this.is0(num2) && this.isValid(num2);
   }
-  isOdd(num) {
-    return (num & _1n2) === _1n2;
+  isOdd(num2) {
+    return (num2 & _1n2) === _1n2;
   }
-  neg(num) {
-    return mod(-num, this.ORDER);
+  neg(num2) {
+    return mod(-num2, this.ORDER);
   }
   eql(lhs, rhs) {
     return lhs === rhs;
   }
-  sqr(num) {
-    return mod(num * num, this.ORDER);
+  sqr(num2) {
+    return mod(num2 * num2, this.ORDER);
   }
   add(lhs, rhs) {
     return mod(lhs + rhs, this.ORDER);
@@ -71180,15 +71414,15 @@ var FIELD_SQRT = /* @__PURE__ */ new WeakMap(), _Field = class {
   mul(lhs, rhs) {
     return mod(lhs * rhs, this.ORDER);
   }
-  pow(num, power) {
-    return FpPow(this, num, power);
+  pow(num2, power) {
+    return FpPow(this, num2, power);
   }
   div(lhs, rhs) {
     return mod(lhs * invert(rhs, this.ORDER), this.ORDER);
   }
   // Same as above, but doesn't normalize
-  sqrN(num) {
-    return num * num;
+  sqrN(num2) {
+    return num2 * num2;
   }
   addN(lhs, rhs) {
     return lhs + rhs;
@@ -71199,15 +71433,15 @@ var FIELD_SQRT = /* @__PURE__ */ new WeakMap(), _Field = class {
   mulN(lhs, rhs) {
     return lhs * rhs;
   }
-  inv(num) {
-    return invert(num, this.ORDER);
+  inv(num2) {
+    return invert(num2, this.ORDER);
   }
-  sqrt(num) {
+  sqrt(num2) {
     let sqrt = FIELD_SQRT.get(this);
-    return sqrt || FIELD_SQRT.set(this, sqrt = FpSqrt(this.ORDER)), sqrt(this, num);
+    return sqrt || FIELD_SQRT.set(this, sqrt = FpSqrt(this.ORDER)), sqrt(this, num2);
   }
-  toBytes(num) {
-    return this.isLE ? numberToBytesLE(num, this.BYTES) : numberToBytesBE(num, this.BYTES);
+  toBytes(num2) {
+    return this.isLE ? numberToBytesLE(num2, this.BYTES) : numberToBytesBE(num2, this.BYTES);
   }
   fromBytes(bytes, skipValidation = !1) {
     abytes2(bytes);
@@ -71999,8 +72233,8 @@ function encryptPayloadForDid(payload, recipientDid) {
     return null;
   }
   let ephemeral = generateX25519KeyPair(), ephemeralPubRaw = extractRawX25519PublicKey(ephemeral.publicKey), sharedSecret = diffieHellman2({
-    privateKey: createPrivateKey3({ key: ephemeral.privateKey, format: "der", type: "pkcs8" }),
-    publicKey: createPublicKey3({ key: rawX25519PublicToSpki(recipientXPub), format: "der", type: "spki" })
+    privateKey: createPrivateKey4({ key: ephemeral.privateKey, format: "der", type: "pkcs8" }),
+    publicKey: createPublicKey4({ key: rawX25519PublicToSpki(recipientXPub), format: "der", type: "spki" })
   }), key = deriveMessageKey(sharedSecret, ephemeralPubRaw), sealed = sealWithDek(Buffer.from(JSON.stringify(payload), "utf-8"), key), enc = { v: 1, alg: "x25519-hkdf-aes256gcm", epk: ephemeralPubRaw.toString("base64") };
   return {
     content: sealed.toString("base64"),
@@ -72016,8 +72250,8 @@ function decryptPayloadWithEd25519(payload, ed25519PrivatePkcs8) {
   if (!isEncryptedPayload(payload) || typeof payload.content != "string") return null;
   try {
     let enc = payload.meta.enc, ephemeralPubRaw = Buffer.from(enc.epk, "base64"), xPriv = ed25519PrivateToX25519Pkcs8(ed25519PrivatePkcs8), sharedSecret = diffieHellman2({
-      privateKey: createPrivateKey3({ key: xPriv, format: "der", type: "pkcs8" }),
-      publicKey: createPublicKey3({ key: rawX25519PublicToSpki(ephemeralPubRaw), format: "der", type: "spki" })
+      privateKey: createPrivateKey4({ key: xPriv, format: "der", type: "pkcs8" }),
+      publicKey: createPublicKey4({ key: rawX25519PublicToSpki(ephemeralPubRaw), format: "der", type: "spki" })
     }), key = deriveMessageKey(sharedSecret, ephemeralPubRaw), plain = openWithDek(Buffer.from(payload.content, "base64"), key);
     return plain ? JSON.parse(plain.toString("utf-8")) : null;
   } catch {
@@ -76448,9 +76682,7 @@ var ChannelAdapterManager = class extends EventEmitter7 {
         }
         return { ingested: state.ingested, deduped: state.deduped };
       },
-      writeAttachment: (path, data, mimeType) => {
-        workspace.writeFileBuffer(path, data, mimeType);
-      },
+      writeAttachment: (path, data, mimeType) => workspace.writeFileBufferUnique(path, data, mimeType),
       getConfig: () => config,
       getCredential: (key) => workspace.getIdentityDecrypted(`adapter:${type}:${key}`, derivedKey) ?? null,
       log: (level, message) => {
@@ -76528,11 +76760,11 @@ var ChannelAdapterManager = class extends EventEmitter7 {
 
 // src/main/adapters/built-in-loaders.ts
 var BUILT_IN_ADAPTER_LOADERS = {
-  telegram: async () => (await import("./telegram-V4VH4PNE.mjs")).createAdapter,
-  email: async () => (await import("./email-V4Q4VJON.mjs")).createAdapter,
-  discord: async () => (await import("./discord-IWDQJA7A.mjs")).createAdapter,
-  slack: async () => (await import("./slack-3L5QTDZX.mjs")).createAdapter,
-  whatsapp: async () => (await import("./whatsapp-RDOC54X5.mjs")).createAdapter
+  telegram: async () => (await import("./telegram-YI2OHNTD.mjs")).createAdapter,
+  email: async () => (await import("./email-BRG7KUO2.mjs")).createAdapter,
+  discord: async () => (await import("./discord-DSP4HUWI.mjs")).createAdapter,
+  slack: async () => (await import("./slack-OCNNF4DX.mjs")).createAdapter,
+  whatsapp: async () => (await import("./whatsapp-AVKT3CTJ.mjs")).createAdapter
 };
 async function loadBuiltInAdapter(adapterType) {
   let loader = BUILT_IN_ADAPTER_LOADERS[adapterType];
@@ -76931,6 +77163,7 @@ function buildOAuthProviderFactory(resolveStore, io = SILENT_OAUTH_IO, resolveOp
 var MCP_CONNECT_BUDGET_MS = 25e3, AgentRuntimeBuilder = class {
   settings;
   codeSandboxService;
+  sandboxPackagesService;
   podmanService;
   wsConnectionManager;
   mcpPackageResolver;
@@ -76943,7 +77176,7 @@ var MCP_CONNECT_BUDGET_MS = 25e3, AgentRuntimeBuilder = class {
   mcpAuthPreflight;
   credentialEnvelopeLockedHint;
   constructor(opts = {}) {
-    this.settings = opts.settings, this.codeSandboxService = opts.codeSandboxService ?? null, this.podmanService = opts.podmanService ?? null, this.wsConnectionManager = opts.wsConnectionManager ?? null, this.mcpPackageResolver = opts.mcpPackageResolver ?? new PackageResolver("mcp-servers"), this.adapterPackageResolver = opts.adapterPackageResolver ?? new PackageResolver("channel-adapters"), this.uvxPackageResolver = opts.uvxPackageResolver ?? null, this.uvManager = opts.uvManager ?? null, this.basePrompt = opts.basePrompt ?? "", this.toolPrompts = opts.toolPrompts ?? {}, this.compactionPrompt = opts.compactionPrompt, this.mcpAuthPreflight = opts.mcpAuthPreflight ?? createHeadlessMcpAuthPreflight(), this.credentialEnvelopeLockedHint = opts.credentialEnvelopeLockedHint;
+    this.settings = opts.settings, this.codeSandboxService = opts.codeSandboxService ?? null, this.sandboxPackagesService = opts.sandboxPackagesService ?? null, this.podmanService = opts.podmanService ?? null, this.wsConnectionManager = opts.wsConnectionManager ?? null, this.mcpPackageResolver = opts.mcpPackageResolver ?? new PackageResolver("mcp-servers"), this.adapterPackageResolver = opts.adapterPackageResolver ?? new PackageResolver("channel-adapters"), this.uvxPackageResolver = opts.uvxPackageResolver ?? null, this.uvManager = opts.uvManager ?? null, this.basePrompt = opts.basePrompt ?? "", this.toolPrompts = opts.toolPrompts ?? {}, this.compactionPrompt = opts.compactionPrompt, this.mcpAuthPreflight = opts.mcpAuthPreflight ?? createHeadlessMcpAuthPreflight(), this.credentialEnvelopeLockedHint = opts.credentialEnvelopeLockedHint;
   }
   async build(opts) {
     let { workspace, filePath, config, provider } = opts, agentId = filePath ?? config.id;
@@ -77118,17 +77351,21 @@ var MCP_CONNECT_BUDGET_MS = 25e3, AgentRuntimeBuilder = class {
     });
   }
   registerCodeTools(registry3, config, agentId, adfCallHandler) {
-    this.codeSandboxService && (config.tools.some((t) => t.name === "sys_code") && registry3.register(new SysCodeTool(
-      this.codeSandboxService,
+    let sandbox = this.codeSandboxService;
+    if (!sandbox) return;
+    registry3.provideDeclared("sys_code", () => new SysCodeTool(
+      sandbox,
       agentId,
       adfCallHandler ?? void 0,
       config.limits?.execution_timeout_ms
-    )), adfCallHandler && config.tools.some((t) => t.name === "sys_lambda") && registry3.register(new SysLambdaTool(
-      this.codeSandboxService,
+    ), config.tools), adfCallHandler && registry3.provideDeclared("sys_lambda", () => new SysLambdaTool(
+      sandbox,
       adfCallHandler,
       agentId,
       config.limits?.execution_timeout_ms
-    )));
+    ), config.tools);
+    let packages = this.sandboxPackagesService;
+    packages && (registry3.provideDeclared("npm_install", () => new NpmInstallTool(packages), config.tools), registry3.provideDeclared("npm_uninstall", () => new NpmUninstallTool(), config.tools));
   }
   registerComputeTools(registry3, config, filePath) {
     let agentHostAllowed = !!config.compute?.host_access, computeSettings = this.settings?.get("compute"), runtimeHostAllowed = this.getComputeRoutingSettings().hostAccessEnabled, hostInfo = agentHostAllowed && runtimeHostAllowed ? describeHostEnv() : void 0, targetSelection = resolveAgentComputeTargetSelection(computeSettings, config.compute), caps = {
@@ -78747,6 +78984,26 @@ var RuntimeLoopError = class extends Error {
   listAgents() {
     return Array.from(this.agents.values()).map((managed) => this.toSummary(managed));
   }
+  /**
+   * Loaded file-backed agents with their live executor state, context gauge
+   * and open workspace. Agent vitals reads a running agent out of this
+   * workspace instead of reopening its file.
+   */
+  listLiveAgents() {
+    let out = [];
+    for (let managed of this.agents.values()) {
+      if (!managed.filePath) continue;
+      let executor = managed.agent.executor;
+      out.push({
+        agentId: managed.id,
+        filePath: managed.filePath,
+        executorState: executor.getState(),
+        workspace: managed.agent.workspace,
+        getContextGauge: () => executor.getContextGauge()
+      });
+    }
+    return out;
+  }
   on(event, listener) {
     return super.on(event, listener);
   }
@@ -100700,45 +100957,67 @@ data: {"cursor":42,"event":{"seq":7,"event_type":"agent.state.changed","turn_id"
         }
       }
     },
-    "/agents/{id}/start": {
-      post: {
+    "/agents/{id}/vitals": {
+      get: {
         tags: [
           "Agents"
         ],
-        summary: "Start an agent, loading it from a tracked folder when needed",
-        description: "`id` may also name an agent that is not loaded: an .adf path, or an id / handle / name found in the tracked folders. The daemon loads it (review gate applies: 403) and starts it; `loaded` says whether it did. `startupTriggered` is true when the agent's start state fired its startup event. An identifier that matches several files answers 409 `ambiguous_agent` with the `candidates`: start one by its file path. No body.",
-        operationId: "startAgent",
+        summary: "Agent vitals",
+        description: "Studio's overview card for one agent: header facts (context size, next wake, 7-day cost, model, age) and four levelled stats: Reach, Access and Autonomy (levels from config points, with the factors behind them) and Experience (a level from maturity counts). `{id}` names a loaded agent (id, handle or name, as every /agents/{id} route) or, when no loaded agent matches, a tracked agent that is not loaded (agent id or handle from its file). A loaded agent is read from its open workspace (`live: true`); any other file is read with a readonly open. Results are cached: a live agent's for at most 2 s and until its database changes, any other file's until its mtime or size changes. `force=1` skips the cache. `agentsSpawned` counts tracked agents whose parent DID names this agent, from a fleet scan at most 30 s old (`force=1` rescans). `contextTokens` and `contextThreshold` are present only for a loaded agent whose executor has reported usage; `cost7dUsd` only when some adf_loop row of the last 7 local days has a price (the row's recorded `cost_usd`; rows from before 2026-08-27 without one are priced from Studio's pricing table).",
+        operationId: "getAgentVitals",
         parameters: [
           {
             $ref: "#/components/parameters/AgentIdPath"
+          },
+          {
+            name: "force",
+            in: "query",
+            required: !1,
+            description: "Skip the cache: `1` or `true`. `0` and `false` are accepted and change nothing.",
+            schema: {
+              type: "string",
+              enum: [
+                "1",
+                "0",
+                "true",
+                "false"
+              ]
+            }
           }
         ],
         responses: {
           "200": {
-            description: "Started",
+            description: "Vitals",
             content: {
               "application/json": {
                 schema: {
-                  $ref: "#/components/schemas/StartAgentResponse"
+                  $ref: "#/components/schemas/AgentVitals"
                 }
               }
             }
           },
+          "400": {
+            $ref: "#/components/responses/BadRequest"
+          },
           "401": {
             $ref: "#/components/responses/Unauthorized"
           },
           "403": {
-            $ref: "#/components/responses/ReviewRequired"
+            $ref: "#/components/responses/Forbidden"
           },
           "404": {
             $ref: "#/components/responses/NotFound"
           },
           "409": {
-            description: "The identifier matches several agent files (`ambiguous_agent`)",
+            description: "The agent is loaded without an .adf file; vitals are read from the file",
             content: {
               "application/json": {
                 schema: {
-                  $ref: "#/components/schemas/AmbiguousAgentResponse"
+                  $ref: "#/components/schemas/ErrorResponse"
+                },
+                example: {
+                  error: "Agent has no .adf file; vitals are read from the file.",
+                  code: "conflict"
                 }
               }
             }
@@ -100749,30 +101028,48 @@ data: {"cursor":42,"event":{"seq":7,"event_type":"agent.state.changed","turn_id"
         }
       }
     },
-    "/agents/{id}/stop": {
-      post: {
+    "/agents/{id}/activity": {
+      get: {
         tags: [
           "Agents"
         ],
-        summary: "Stop and unload an agent",
-        description: "Graceful: a running turn gets a 5 s grace period, then the agent is unloaded (its file stays on disk). No body.",
-        operationId: "stopAgent",
+        summary: "Agent activity",
+        description: "The lower sections of Studio's agent overview: the next three timer wakes (raw lambda and input, or loop and prompt), 14 local days of messages and cost per day, and what the file holds (`mind/` files and skills with approximate tokens, `local_*` tables with rows). `{id}` resolves as in `GET /agents/{id}/vitals`. Everything is read from the .adf file. Messages per day: `adf_loop` rows of every role by `created_at`, plus compacted rows archived in `adf_audit` (metadata only, never the archived data): each archive's `entry_count` is spread evenly over an estimated span ending at its `created_at` and at most 24 h long, and days that include such counts have `estimated: true`. Cost per day: the sum of the day's priced loop rows; `costPartial` when some call had no recorded price or was compacted. The first read scans the window's loop rows once; later reads add only new rows. Skills follow the vitals rule: written more than 10 s after `adf_created_at`, `skills-registry.json` excluded. Cached like vitals (and per local day); `force=1` skips the cache. Pending approvals, asks and unread counts are not here: read `GET /agents/{id}/asks` and `GET /agents/{id}/inbox`.",
+        operationId: "getAgentActivity",
         parameters: [
           {
             $ref: "#/components/parameters/AgentIdPath"
+          },
+          {
+            name: "force",
+            in: "query",
+            required: !1,
+            description: "Skip the cache: `1` or `true`. `0` and `false` are accepted and change nothing.",
+            schema: {
+              type: "string",
+              enum: [
+                "1",
+                "0",
+                "true",
+                "false"
+              ]
+            }
           }
         ],
         responses: {
           "200": {
-            description: "Stopped and unloaded",
+            description: "Activity",
             content: {
               "application/json": {
                 schema: {
-                  $ref: "#/components/schemas/SuccessResponse"
+                  $ref: "#/components/schemas/AgentActivity"
                 }
               }
             }
           },
+          "400": {
+            $ref: "#/components/responses/BadRequest"
+          },
           "401": {
             $ref: "#/components/responses/Unauthorized"
           },
@@ -100782,20 +101079,34 @@ data: {"cursor":42,"event":{"seq":7,"event_type":"agent.state.changed","turn_id"
           "404": {
             $ref: "#/components/responses/NotFound"
           },
+          "409": {
+            description: "The agent is loaded without an .adf file; activity is read from the file",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/ErrorResponse"
+                },
+                example: {
+                  error: "Agent has no .adf file; activity is read from the file.",
+                  code: "conflict"
+                }
+              }
+            }
+          },
           "500": {
             $ref: "#/components/responses/ServerError"
           }
         }
       }
     },
-    "/agents/{id}/unload": {
+    "/agents/{id}/start": {
       post: {
         tags: [
           "Agents"
         ],
-        summary: "Unload an agent (alias of stop)",
-        description: "No body.",
-        operationId: "unloadAgent",
+        summary: "Start an agent, loading it from a tracked folder when needed",
+        description: "`id` may also name an agent that is not loaded: an .adf path, or an id / handle / name found in the tracked folders. The daemon loads it (review gate applies: 403) and starts it; `loaded` says whether it did. `startupTriggered` is true when the agent's start state fired its startup event. An identifier that matches several files answers 409 `ambiguous_agent` with the `candidates`: start one by its file path. No body.",
+        operationId: "startAgent",
         parameters: [
           {
             $ref: "#/components/parameters/AgentIdPath"
@@ -100803,11 +101114,11 @@ data: {"cursor":42,"event":{"seq":7,"event_type":"agent.state.changed","turn_id"
         ],
         responses: {
           "200": {
-            description: "Unloaded",
+            description: "Started",
             content: {
               "application/json": {
                 schema: {
-                  $ref: "#/components/schemas/SuccessResponse"
+                  $ref: "#/components/schemas/StartAgentResponse"
                 }
               }
             }
@@ -100816,51 +101127,86 @@ data: {"cursor":42,"event":{"seq":7,"event_type":"agent.state.changed","turn_id"
             $ref: "#/components/responses/Unauthorized"
           },
           "403": {
-            $ref: "#/components/responses/Forbidden"
+            $ref: "#/components/responses/ReviewRequired"
           },
           "404": {
             $ref: "#/components/responses/NotFound"
           },
+          "409": {
+            description: "The identifier matches several agent files (`ambiguous_agent`)",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/AmbiguousAgentResponse"
+                }
+              }
+            }
+          },
           "500": {
             $ref: "#/components/responses/ServerError"
           }
         }
       }
     },
-    "/agents/{id}/abort": {
+    "/agents/{id}/stop": {
       post: {
         tags: [
           "Agents"
         ],
-        summary: "Abort the current turn without unloading",
-        description: "A hard stop: the executor of main (or the named inner loop) is left `stopped` and runs no further turns, triggers or timers until the agent is reloaded. To end a turn and keep working, use /interrupt. Chats still queued behind the turn are discarded, never silently: a `chat.discarded` event names their `turnId`s and a System notice lands in the loop. Unknown loop 404; a loop with no running executor 409.",
-        operationId: "abortAgent",
+        summary: "Stop and unload an agent",
+        description: "Graceful: a running turn gets a 5 s grace period, then the agent is unloaded (its file stays on disk). No body.",
+        operationId: "stopAgent",
         parameters: [
           {
             $ref: "#/components/parameters/AgentIdPath"
-          },
-          {
-            $ref: "#/components/parameters/LoopQuery"
           }
         ],
-        requestBody: {
-          required: !1,
-          description: "Optional; `?loop=` wins.",
-          content: {
-            "application/json": {
-              schema: {
-                $ref: "#/components/schemas/LoopBody"
+        responses: {
+          "200": {
+            description: "Stopped and unloaded",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/SuccessResponse"
+                }
               }
             }
+          },
+          "401": {
+            $ref: "#/components/responses/Unauthorized"
+          },
+          "403": {
+            $ref: "#/components/responses/Forbidden"
+          },
+          "404": {
+            $ref: "#/components/responses/NotFound"
+          },
+          "500": {
+            $ref: "#/components/responses/ServerError"
           }
-        },
+        }
+      }
+    },
+    "/agents/{id}/unload": {
+      post: {
+        tags: [
+          "Agents"
+        ],
+        summary: "Unload an agent (alias of stop)",
+        description: "No body.",
+        operationId: "unloadAgent",
+        parameters: [
+          {
+            $ref: "#/components/parameters/AgentIdPath"
+          }
+        ],
         responses: {
           "200": {
-            description: "Aborted",
+            description: "Unloaded",
             content: {
               "application/json": {
                 schema: {
-                  $ref: "#/components/schemas/AbortResponse"
+                  $ref: "#/components/schemas/SuccessResponse"
                 }
               }
             }
@@ -100874,23 +101220,76 @@ data: {"cursor":42,"event":{"seq":7,"event_type":"agent.state.changed","turn_id"
           "404": {
             $ref: "#/components/responses/NotFound"
           },
-          "409": {
-            $ref: "#/components/responses/Conflict"
-          },
           "500": {
             $ref: "#/components/responses/ServerError"
           }
         }
       }
     },
-    "/agents/{id}/interrupt": {
+    "/agents/{id}/abort": {
       post: {
         tags: [
           "Agents"
         ],
-        summary: "Interrupt the running turn and leave the loop idle",
-        description: "Ends main's (or the named loop's) running turn and sets that executor idle; it keeps accepting chats, triggers and timers. Unlike /abort it never stops the executor, and chats queued behind the turn are kept and run next. `interrupted` is false when nothing was running; 409 when the loop is stopped or errored.",
-        operationId: "interruptAgent",
+        summary: "Abort the current turn without unloading",
+        description: "A hard stop: the executor of main (or the named inner loop) is left `stopped` and runs no further turns, triggers or timers until the agent is reloaded. To end a turn and keep working, use /interrupt. Chats still queued behind the turn are discarded, never silently: a `chat.discarded` event names their `turnId`s and a System notice lands in the loop. Unknown loop 404; a loop with no running executor 409.",
+        operationId: "abortAgent",
+        parameters: [
+          {
+            $ref: "#/components/parameters/AgentIdPath"
+          },
+          {
+            $ref: "#/components/parameters/LoopQuery"
+          }
+        ],
+        requestBody: {
+          required: !1,
+          description: "Optional; `?loop=` wins.",
+          content: {
+            "application/json": {
+              schema: {
+                $ref: "#/components/schemas/LoopBody"
+              }
+            }
+          }
+        },
+        responses: {
+          "200": {
+            description: "Aborted",
+            content: {
+              "application/json": {
+                schema: {
+                  $ref: "#/components/schemas/AbortResponse"
+                }
+              }
+            }
+          },
+          "401": {
+            $ref: "#/components/responses/Unauthorized"
+          },
+          "403": {
+            $ref: "#/components/responses/Forbidden"
+          },
+          "404": {
+            $ref: "#/components/responses/NotFound"
+          },
+          "409": {
+            $ref: "#/components/responses/Conflict"
+          },
+          "500": {
+            $ref: "#/components/responses/ServerError"
+          }
+        }
+      }
+    },
+    "/agents/{id}/interrupt": {
+      post: {
+        tags: [
+          "Agents"
+        ],
+        summary: "Interrupt the running turn and leave the loop idle",
+        description: "Ends main's (or the named loop's) running turn and sets that executor idle; it keeps accepting chats, triggers and timers. Unlike /abort it never stops the executor, and chats queued behind the turn are kept and run next. `interrupted` is false when nothing was running; 409 when the loop is stopped or errored.",
+        operationId: "interruptAgent",
         parameters: [
           {
             $ref: "#/components/parameters/AgentIdPath"
@@ -117808,6 +118207,645 @@ data: {"cursor":42,"event":{"seq":7,"event_type":"agent.state.changed","turn_id"
             }
           ]
         }
+      },
+      AgentVitals: {
+        type: "object",
+        required: [
+          "filePath",
+          "computedAt",
+          "live",
+          "handle",
+          "ageDays",
+          "public",
+          "ownerVerified",
+          "stats",
+          "maturity",
+          "metrics"
+        ],
+        properties: {
+          filePath: {
+            type: "string"
+          },
+          computedAt: {
+            type: "number",
+            description: "When the stats and counts were computed (ms epoch)"
+          },
+          live: {
+            type: "boolean",
+            description: "True when read from the workspace of a loaded agent"
+          },
+          handle: {
+            type: "string",
+            example: "agent-1"
+          },
+          name: {
+            type: "string"
+          },
+          did: {
+            type: "string"
+          },
+          agentId: {
+            type: "string"
+          },
+          model: {
+            type: "string"
+          },
+          createdAt: {
+            type: "string",
+            description: "adf_created_at (ISO 8601)"
+          },
+          ageDays: {
+            type: "number"
+          },
+          status: {
+            type: "string",
+            description: "The agent's own status line (adf_meta `status`); absent when unset"
+          },
+          description: {
+            type: "string",
+            description: "config.description, as on the ALF card; absent when blank"
+          },
+          public: {
+            type: "boolean",
+            description: "config.serving.public.enabled, the ALF card's `public`"
+          },
+          ownerVerified: {
+            type: "boolean",
+            description: "An owner attestation about the current DID is stored, unexpired and its signature verifies (whether or not the card publishes it)"
+          },
+          contextTokens: {
+            type: "integer",
+            description: "Last API-reported context size (loaded agents only)"
+          },
+          contextThreshold: {
+            type: "integer",
+            description: "Compact threshold (present with contextTokens)"
+          },
+          nextWakeAt: {
+            type: "number",
+            description: "Earliest next_wake_at among non-expired timers (ms epoch)"
+          },
+          cost7dUsd: {
+            type: "number",
+            description: "USD over the last 7 local days, summed from the agent's priced adf_loop rows (the activity read's daily cost)"
+          },
+          cost7dPartial: {
+            type: "boolean",
+            description: "True when some calls in the window had no recorded price or were compacted (cost7dUsd is a lower bound)"
+          },
+          metrics: {
+            type: "array",
+            description: 'adf_meta rows whose key starts with `metric:`, by key, at most 20. A value is a plain string, or a JSON object `{"value": number|string, "label"?, "unit"?, "min"?, "max"?, "target"?}`; parsed fields are returned beside `raw`. A value that is not such an object is returned as `value` = `raw`. Not part of any stat.',
+            items: {
+              type: "object",
+              required: [
+                "name",
+                "label",
+                "value",
+                "raw"
+              ],
+              properties: {
+                name: {
+                  type: "string",
+                  description: "Key without the `metric:` prefix",
+                  example: "weight"
+                },
+                label: {
+                  type: "string",
+                  description: "The object's `label` when given, else `name`",
+                  example: "Weight"
+                },
+                value: {
+                  oneOf: [
+                    {
+                      type: "number"
+                    },
+                    {
+                      type: "string"
+                    }
+                  ],
+                  description: "The object's `value`, or the raw string when the stored value is not a metric object",
+                  example: 82.4
+                },
+                unit: {
+                  type: "string",
+                  example: "kg"
+                },
+                min: {
+                  type: "number",
+                  description: "Bar start when `max` is set (default 0)"
+                },
+                max: {
+                  type: "number",
+                  example: 100
+                },
+                target: {
+                  type: "number",
+                  example: 78
+                },
+                raw: {
+                  type: "string",
+                  description: "The stored adf_meta value as is",
+                  example: '{"value":82.4,"label":"Weight","unit":"kg","target":78}'
+                }
+              }
+            }
+          },
+          stats: {
+            type: "object",
+            required: [
+              "reach",
+              "access",
+              "autonomy",
+              "experience"
+            ],
+            properties: {
+              reach: {
+                $ref: "#/components/schemas/AgentPowerStat"
+              },
+              access: {
+                $ref: "#/components/schemas/AgentPowerStat"
+              },
+              autonomy: {
+                $ref: "#/components/schemas/AgentPowerStat"
+              },
+              experience: {
+                $ref: "#/components/schemas/AgentExperienceStat"
+              }
+            }
+          },
+          maturity: {
+            $ref: "#/components/schemas/AgentMaturity"
+          }
+        }
+      },
+      AgentPowerStat: {
+        type: "object",
+        description: "Reach, Access or Autonomy: a capped level on a 1-20 scale. fill = clamp(points / max, 0, 1); level = 1 + round(19 * fill), so an empty config is Lv 1 and a maxed-out one Lv 20. `max` is the sum of every capped positive factor of the stat (counts such as MCP servers and chat adapters only count their heaviest few). Gated points count toward the level. `points` is `open` + `gated`.",
+        required: [
+          "level",
+          "points",
+          "max",
+          "fill",
+          "open",
+          "gated",
+          "high",
+          "rawPoints",
+          "factors"
+        ],
+        properties: {
+          level: {
+            type: "integer",
+            minimum: 1,
+            maximum: 20
+          },
+          points: {
+            type: "number",
+            minimum: 0,
+            description: "Points behind the level, after mitigations"
+          },
+          max: {
+            type: "number",
+            exclusiveMinimum: 0,
+            description: "Points of a maxed-out config for this stat"
+          },
+          fill: {
+            type: "number",
+            minimum: 0,
+            maximum: 1,
+            description: "points / max, clamped: how much of the possible power the agent has"
+          },
+          open: {
+            type: "number",
+            description: "Points whose capability runs without approval (mitigations come off these first)"
+          },
+          gated: {
+            type: "number",
+            description: "Points whose capability needs approval"
+          },
+          high: {
+            type: "boolean",
+            description: "True when open / max >= 0.6 (open level 12 or more): much of this runs without anyone asking"
+          },
+          rawPoints: {
+            type: "number",
+            description: "Sum of factor points, mitigations included"
+          },
+          factors: {
+            type: "array",
+            items: {
+              $ref: "#/components/schemas/AgentStatFactor"
+            }
+          }
+        }
+      },
+      AgentStatFactor: {
+        type: "object",
+        description: "One line of a stat breakdown.",
+        required: [
+          "id",
+          "label",
+          "points",
+          "gated",
+          "configPath"
+        ],
+        properties: {
+          id: {
+            type: "string",
+            description: "Stable id, e.g. `tool:compute_exec`, `mcp:github`, `visibility`",
+            example: "tool:compute_exec"
+          },
+          label: {
+            type: "string"
+          },
+          points: {
+            type: "number",
+            description: "Points this factor adds; negative for mitigations; 0 for an item past its kind's cap (7th MCP server, 4th chat adapter), listed but not counted"
+          },
+          gated: {
+            type: "boolean",
+            description: "True when the capability needs human approval"
+          },
+          configPath: {
+            type: "string",
+            description: "Config path (or table) that controls this factor"
+          }
+        }
+      },
+      AgentExperienceStat: {
+        type: "object",
+        description: "Experience. xpForLevel(L) = 5 * (L - 1)^2.25; level = largest L with xpForLevel(L) <= score.",
+        required: [
+          "level",
+          "progress",
+          "score",
+          "levelStart",
+          "nextLevelAt",
+          "breakdown",
+          "nextLevel"
+        ],
+        properties: {
+          level: {
+            type: "integer",
+            minimum: 1
+          },
+          progress: {
+            type: "number",
+            minimum: 0,
+            maximum: 1,
+            description: "Progress within the current level"
+          },
+          score: {
+            type: "number",
+            description: "Total XP (sum of signal XP)"
+          },
+          levelStart: {
+            type: "number",
+            description: "XP at which the current level starts"
+          },
+          nextLevelAt: {
+            type: "number",
+            description: "XP at which the next level starts"
+          },
+          breakdown: {
+            type: "array",
+            items: {
+              type: "object",
+              required: [
+                "id",
+                "label",
+                "value",
+                "xp"
+              ],
+              properties: {
+                id: {
+                  type: "string",
+                  enum: [
+                    "contextsWorked",
+                    "memoryTokens",
+                    "skills",
+                    "localTables",
+                    "localRows",
+                    "filesWritten",
+                    "agentsSpawned",
+                    "messages",
+                    "ageDays"
+                  ]
+                },
+                label: {
+                  type: "string"
+                },
+                value: {
+                  type: "number",
+                  description: "Raw count"
+                },
+                xp: {
+                  type: "number",
+                  description: "XP this signal adds"
+                }
+              }
+            }
+          },
+          nextLevel: {
+            type: "object",
+            description: "What one more level takes (xp = nextLevelAt - score), in units of the cheapest signals",
+            required: [
+              "xp",
+              "contexts",
+              "memoryTokens",
+              "skills",
+              "hint"
+            ],
+            properties: {
+              xp: {
+                type: "number"
+              },
+              contexts: {
+                type: "integer",
+                description: "Contexts of work worth the remaining XP"
+              },
+              memoryTokens: {
+                type: "integer",
+                description: "Memory tokens worth the remaining XP"
+              },
+              skills: {
+                type: "integer",
+                description: "Skills worth the remaining XP"
+              },
+              hint: {
+                type: "string"
+              }
+            }
+          }
+        }
+      },
+      AgentMaturity: {
+        type: "object",
+        description: "Raw maturity counts read from the agent's file.",
+        required: [
+          "contextsWorked",
+          "filesWritten",
+          "memoryTokens",
+          "localTables",
+          "localRows",
+          "skills",
+          "agentsSpawned",
+          "messages",
+          "ageDays"
+        ],
+        properties: {
+          contextsWorked: {
+            type: "number",
+            minimum: 0,
+            description: "Contexts of work over every loop (main, side, deleted): archived loop snapshots in adf_audit (one context at half the loop's compaction threshold or more, else its share) or live compaction summaries when loop audit is off, plus each live loop's current fill as a 0..1 share of its compaction threshold"
+          },
+          filesWritten: {
+            type: "integer",
+            description: "adf_files rows changed after the agent was created, `mind/` excluded"
+          },
+          memoryTokens: {
+            type: "integer",
+            description: "Approximate tokens in `mind/` files: total bytes, less the seeded `mind/log.md` header, / 4"
+          },
+          localTables: {
+            type: "integer",
+            description: "`local_*` tables"
+          },
+          localRows: {
+            type: "integer",
+            description: "Rows across `local_*` tables (the first 50 by name)"
+          },
+          skills: {
+            type: "integer",
+            description: "Distinct skills the agent installed or changed"
+          },
+          agentsSpawned: {
+            type: [
+              "integer",
+              "null"
+            ],
+            description: "Tracked agents whose adf_parent_did names this agent; null when no fleet scan has run"
+          },
+          messages: {
+            type: "integer",
+            description: "Loop messages ever written, every loop current and past (adf_loop's shared AUTOINCREMENT high-water mark; compaction, clears and loop deletion do not lower it)"
+          },
+          ageDays: {
+            type: "number",
+            description: "Days since adf_created_at"
+          }
+        }
+      },
+      AgentActivity: {
+        type: "object",
+        required: [
+          "filePath",
+          "computedAt",
+          "live",
+          "upcoming",
+          "daily",
+          "contents"
+        ],
+        properties: {
+          filePath: {
+            type: "string"
+          },
+          computedAt: {
+            type: "number",
+            description: "When this read was computed (ms epoch)"
+          },
+          live: {
+            type: "boolean",
+            description: "True when read from the workspace of a loaded agent"
+          },
+          upcoming: {
+            type: "array",
+            maxItems: 3,
+            description: "Next non-expired timers, soonest first",
+            items: {
+              $ref: "#/components/schemas/AgentUpcomingWake"
+            }
+          },
+          daily: {
+            type: "array",
+            minItems: 14,
+            maxItems: 14,
+            description: "14 local days, oldest first; the last is today",
+            items: {
+              $ref: "#/components/schemas/AgentActivityDay"
+            }
+          },
+          contents: {
+            type: "object",
+            description: "What the file holds, in three groups. Tokens are approximate (bytes / 4, rounded) and given for mind and skills only: table data is rarely read into context.",
+            required: [
+              "mind",
+              "skills",
+              "tables"
+            ],
+            properties: {
+              mind: {
+                type: "object",
+                description: "Files under mind/",
+                required: [
+                  "files",
+                  "tokens",
+                  "updatedThisWeek",
+                  "strata"
+                ],
+                properties: {
+                  files: {
+                    type: "integer"
+                  },
+                  tokens: {
+                    type: "integer",
+                    description: "SUM(size) / 4, rounded, the seeded mind/log.md header taken off that file"
+                  },
+                  updatedThisWeek: {
+                    type: "integer",
+                    description: "mind/ files whose updated_at is within the last 7 days"
+                  },
+                  strata: {
+                    type: "object",
+                    description: "Current mind/ tokens (size / 4, rounded, the seeded mind/log.md header taken off that file) split by each file's updated_at. A boundary belongs to the younger band.",
+                    required: [
+                      "older",
+                      "quarter",
+                      "month",
+                      "week"
+                    ],
+                    properties: {
+                      older: {
+                        type: "integer",
+                        description: "Last updated more than 90 days ago"
+                      },
+                      quarter: {
+                        type: "integer",
+                        description: "Last updated more than 30 and at most 90 days ago"
+                      },
+                      month: {
+                        type: "integer",
+                        description: "Last updated more than 7 and at most 30 days ago"
+                      },
+                      week: {
+                        type: "integer",
+                        description: "Last updated at most 7 days ago"
+                      }
+                    }
+                  }
+                }
+              },
+              skills: {
+                type: "object",
+                description: "Skills the agent installed or changed (the Experience stat rule)",
+                required: [
+                  "count",
+                  "tokens"
+                ],
+                properties: {
+                  count: {
+                    type: "integer"
+                  },
+                  tokens: {
+                    type: "integer",
+                    description: "Size of every file under those skills' directories / 4; registry entries without files add 0"
+                  }
+                }
+              },
+              tables: {
+                type: "object",
+                description: "local_* tables (at most 50 read)",
+                required: [
+                  "count",
+                  "rows"
+                ],
+                properties: {
+                  count: {
+                    type: "integer",
+                    maximum: 50
+                  },
+                  rows: {
+                    type: "integer",
+                    description: "Total rows"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      AgentUpcomingWake: {
+        type: "object",
+        description: "One timer due soon, as raw pieces. `system` timers carry `lambda` and `input`; `agent` timers carry `loop` and `prompt`. Both texts are the timer payload as stored, cut to 1000 characters (ending in an ellipsis).",
+        required: [
+          "id",
+          "at",
+          "scope"
+        ],
+        properties: {
+          id: {
+            type: "integer"
+          },
+          at: {
+            type: "number",
+            description: "next_wake_at (ms epoch)"
+          },
+          scope: {
+            type: "string",
+            enum: [
+              "system",
+              "agent"
+            ],
+            description: "`system` runs a lambda; `agent` wakes a loop"
+          },
+          lambda: {
+            type: "string",
+            description: "system: lambda reference, e.g. `lib/sync.ts:run`"
+          },
+          input: {
+            type: "string",
+            maxLength: 1e3,
+            description: "system: payload passed to the lambda"
+          },
+          loop: {
+            type: "string",
+            description: "agent: loop the wake dispatches to (`main` when the timer names none)"
+          },
+          prompt: {
+            type: "string",
+            maxLength: 1e3,
+            description: "agent: payload the loop wakes with"
+          }
+        }
+      },
+      AgentActivityDay: {
+        type: "object",
+        required: [
+          "date",
+          "messages"
+        ],
+        properties: {
+          date: {
+            type: "string",
+            description: "Local YYYY-MM-DD"
+          },
+          messages: {
+            type: "integer",
+            description: "adf_loop rows of every role created that day, plus the day's estimated share of compacted rows archived in adf_audit"
+          },
+          estimated: {
+            type: "boolean",
+            description: "Some of the day's messages are compacted history whose timing is estimated (spread evenly over a span ending at the archive's creation)"
+          },
+          costUsd: {
+            type: "number",
+            description: "USD of the day's priced adf_loop rows (cost_usd in the row's usage record); absent when none had a price"
+          },
+          costPartial: {
+            type: "boolean",
+            description: "Some calls that day had no recorded price, or were compacted (their cost is not recorded); costUsd is a lower bound"
+          }
+        }
       }
     }
   }
@@ -117837,7 +118875,7 @@ import { createHash as createHash6 } from "crypto";
 import { dirname as dirname16, join as join35, resolve as resolve12 } from "path";
 
 // src/main/crypto/mnemonic-identity.ts
-import { createHmac, createPrivateKey as createPrivateKey4, createPublicKey as createPublicKey4 } from "crypto";
+import { createHmac, createPrivateKey as createPrivateKey5, createPublicKey as createPublicKey5 } from "crypto";
 
 // node_modules/@noble/hashes/hmac.js
 var _HMAC = class {
@@ -118073,16 +119111,16 @@ function convertRadix2(data, from, to, padding2) {
   return padding2 && pos > 0 && res.push(carry >>> 0), res;
 }
 // @__NO_SIDE_EFFECTS__
-function radix(num) {
-  anumber3(num);
+function radix(num2) {
+  anumber3(num2);
   let _256 = 2 ** 8;
   return {
     encode: (bytes) => {
       if (!isBytes3(bytes))
         throw new TypeError("radix.encode input should be Uint8Array");
-      return convertRadix(Array.from(bytes), _256, num);
+      return convertRadix(Array.from(bytes), _256, num2);
     },
-    decode: (digits) => (anumArr("radix.decode", digits), Uint8Array.from(convertRadix(digits, num, _256)))
+    decode: (digits) => (anumArr("radix.decode", digits), Uint8Array.from(convertRadix(digits, num2, _256)))
   };
 }
 // @__NO_SIDE_EFFECTS__
@@ -118109,8 +119147,8 @@ function checksum(len, fn) {
     encode(data) {
       if (!isBytes3(data))
         throw new TypeError("checksum.encode: input should be Uint8Array");
-      let sum = _fn(data).slice(0, len), res = new Uint8Array(data.length + len);
-      return res.set(data), res.set(sum, data.length), res;
+      let sum2 = _fn(data).slice(0, len), res = new Uint8Array(data.length + len);
+      return res.set(data), res.set(sum2, data.length), res;
     },
     decode(data) {
       if (!isBytes3(data))
@@ -120276,11 +121314,11 @@ function rawEd25519SeedToPkcs8(seed32) {
   return Buffer.concat([header, seed32]);
 }
 function deriveOwnerIdentity(mnemonic) {
-  let seed = mnemonicToSeed(mnemonic), { key } = slip10DeriveEd25519(seed, OWNER_KEY_PATH), privateKeyPkcs8 = rawEd25519SeedToPkcs8(key), keyObject = createPrivateKey4({ key: privateKeyPkcs8, format: "der", type: "pkcs8" }), publicKeySpki = createPublicKey4(keyObject).export({ format: "der", type: "spki" }), did = publicKeyToDid(extractRawPublicKey(Buffer.from(publicKeySpki)));
+  let seed = mnemonicToSeed(mnemonic), { key } = slip10DeriveEd25519(seed, OWNER_KEY_PATH), privateKeyPkcs8 = rawEd25519SeedToPkcs8(key), keyObject = createPrivateKey5({ key: privateKeyPkcs8, format: "der", type: "pkcs8" }), publicKeySpki = createPublicKey5(keyObject).export({ format: "der", type: "spki" }), did = publicKeyToDid(extractRawPublicKey(Buffer.from(publicKeySpki)));
   return { privateKeyPkcs8, publicKeySpki: Buffer.from(publicKeySpki), did };
 }
 function deriveOwnerEncryptionKey(mnemonic) {
-  let seed = mnemonicToSeed(mnemonic), { key } = slip10DeriveEd25519(seed, OWNER_ENCRYPTION_KEY_PATH), privateKeyPkcs8 = rawX25519PrivateToPkcs8(key), keyObject = createPrivateKey4({ key: privateKeyPkcs8, format: "der", type: "pkcs8" }), publicKeySpki = createPublicKey4(keyObject).export({ format: "der", type: "spki" });
+  let seed = mnemonicToSeed(mnemonic), { key } = slip10DeriveEd25519(seed, OWNER_ENCRYPTION_KEY_PATH), privateKeyPkcs8 = rawX25519PrivateToPkcs8(key), keyObject = createPrivateKey5({ key: privateKeyPkcs8, format: "der", type: "pkcs8" }), publicKeySpki = createPublicKey5(keyObject).export({ format: "der", type: "spki" });
   return { privateKeyPkcs8, publicKeyRaw: extractRawX25519PublicKey(Buffer.from(publicKeySpki)) };
 }
 
@@ -120291,13 +121329,13 @@ import { join as join34 } from "path";
 // src/main/daemon/daemon-enc-key.ts
 import { chmodSync as chmodSync2, existsSync as existsSync18, mkdirSync as mkdirSync14, readFileSync as readFileSync12, writeFileSync as writeFileSync13 } from "fs";
 import { join as join33 } from "path";
-import { createHash as createHash5, createPrivateKey as createPrivateKey5, createPublicKey as createPublicKey5 } from "crypto";
+import { createHash as createHash5, createPrivateKey as createPrivateKey6, createPublicKey as createPublicKey6 } from "crypto";
 var KEY_FILENAME = "runtime-enc-key";
 function daemonEncKeyLabel(publicKeyRaw) {
   return `daemon:${createHash5("sha256").update(publicKeyRaw).digest("hex").slice(0, 16)}`;
 }
 function publicFromPrivate(privateKeyPkcs8) {
-  let pub = createPublicKey5(createPrivateKey5({ key: privateKeyPkcs8, format: "der", type: "pkcs8" }));
+  let pub = createPublicKey6(createPrivateKey6({ key: privateKeyPkcs8, format: "der", type: "pkcs8" }));
   return extractRawX25519PublicKey(pub.export({ format: "der", type: "spki" }));
 }
 function ensureDaemonEncKey(settingsDir) {
@@ -120723,6 +121761,11 @@ var OWNER_SEED_DERIVED_KEY = "ownerDidSeedDerived", OwnerIdentityService = class
    * a stripped-identity file is untrusted (anyone can strip and reshare), and
    * stamping our owner DID into it before the user accepts review would make
    * rejection meaningless. Minting happens on review-accept instead.
+   *
+   * adoptKeys: when keys are minted, store this pair instead of a fresh one
+   * (an identity draft from the create screen). Everything else is the same
+   * as a fresh mint: envelopes, sealing, stamps, attestations. Ignored when
+   * the file already has signing keys, so it can never replace an identity.
    */
   ensureWorkspaceIdentity(workspace, opts = {}) {
     if (workspace.isPasswordProtected())
@@ -120739,7 +121782,7 @@ var OWNER_SEED_DERIVED_KEY = "ownerDidSeedDerived", OwnerIdentityService = class
         runtimePrivateKey: this.getRuntimeSigningKey()
       });
     }, signingRow = workspace.getIdentityRow("crypto:signing:private_key");
-    signingRow === null ? (workspace.generateIdentityKeys(null), keysGenerated = !0, stampAndAttest()) : signingRow.encryption_algo === "plain" && workspace.getDid() && !workspace.getMeta("adf_owner_did") && this.getOwnerSigningKey() && stampAndAttest();
+    signingRow === null ? (workspace.generateIdentityKeys(null, opts.adoptKeys), keysGenerated = !0, stampAndAttest()) : signingRow.encryption_algo === "plain" && workspace.getDid() && !workspace.getMeta("adf_owner_did") && this.getOwnerSigningKey() && stampAndAttest();
     let sealed = workspace.sealPlainRowsIntoEnvelopes();
     return { keysGenerated, sealed };
   }
@@ -122174,8 +123217,1323 @@ function fail(reply, err) {
   return err instanceof RuntimeLoopError ? reply.code(err.statusCode).send({ ...err.details ?? {}, error: err.message, code: err.code ?? (err.statusCode === 404 ? "not_found" : err.statusCode === 409 ? "conflict" : err.statusCode === 502 ? "upstream_error" : "bad_request") }) : reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
 }
 
+// src/main/services/agent-vitals.ts
+import { promises as fsp4, statSync as statSync10 } from "fs";
+
+// src/shared/types/agent-vitals.types.ts
+var MEMORY_STRATA_DAYS = { week: 7, month: 30, quarter: 90 };
+
+// src/shared/utils/agent-stats.ts
+var EXPERIENCE_CURVE = { scale: 5, exponent: 2.25 }, POWER_LEVEL_MAX = 20, POWER_HIGH_OPEN_SHARE = 0.6;
+function powerLevel(points, max) {
+  return 1 + Math.round((POWER_LEVEL_MAX - 1) * powerFill(points, max));
+}
+function powerFill(points, max) {
+  return !(max > 0) || !Number.isFinite(points) ? 0 : Math.min(1, Math.max(0, points / max));
+}
+function xpForLevel(level, curve) {
+  return level > 1 ? curve.scale * (level - 1) ** curve.exponent : 0;
+}
+function levelForXp(xp, curve) {
+  if (!(xp > 0) || !Number.isFinite(xp)) return 1;
+  let level = 1 + Math.floor((xp / curve.scale) ** (1 / curve.exponent));
+  for (; xpForLevel(level + 1, curve) <= xp; ) level++;
+  for (; level > 1 && xpForLevel(level, curve) > xp; ) level--;
+  return level;
+}
+function levelPosition(xp, curve) {
+  let x = Number.isFinite(xp) && xp > 0 ? xp : 0, level = levelForXp(x, curve), levelStart = xpForLevel(level, curve), nextLevelAt = xpForLevel(level + 1, curve), progress = Math.min(1, Math.max(0, (x - levelStart) / (nextLevelAt - levelStart)));
+  return { level, progress, levelStart, nextLevelAt };
+}
+var ACCESS_TOOL_POINTS = {
+  fs_read: { points: 0.25, label: "Reads its own files" },
+  fs_write: { points: 0.25, label: "Writes its own files" },
+  fs_delete: { points: 0.25, label: "Deletes its own files" },
+  sys_code: { points: 0.5, label: "Runs code in the sandbox" },
+  sys_lambda: { points: 0.25, label: "Runs stored lambdas" },
+  sys_fetch: { points: 0.5, label: "Fetches URLs over HTTP" },
+  db_execute: { points: 0.25, label: "Writes to its database tables" },
+  adf_shell: { points: 0.5, label: "Runs shell commands in its workspace" },
+  ws_connect: { points: 0.5, label: "Opens WebSocket connections" },
+  stream_bind: { points: 0.5, label: "Binds network streams" },
+  fs_transfer: { points: 0.5, label: "Transfers files to other agents" },
+  mcp_install: { points: 1, label: "Installs MCP servers" },
+  compute_exec: { points: 1, label: "Runs commands on compute targets" }
+}, ACCESS_POINTS = {
+  mcpServer: 0.5,
+  mcpCredentials: 0.25,
+  /** Servers that count: the heaviest (server + credentials) six; open first on a tie. */
+  mcpServerCap: 6,
+  npmPackage: 0.25,
+  npmPackageCap: 1,
+  codeNetwork: 1,
+  computeEnabled: 0.5,
+  hostAccess: 2,
+  computeHostTarget: 1.5,
+  credential: 0.25,
+  credentialCap: 1.5,
+  privateKeyPlain: 1,
+  privateKeySealed: 0.5
+}, VISIBILITY_POINTS = {
+  off: 0,
+  directory: 0.5,
+  localhost: 1,
+  lan: 2,
+  public: 4
+}, REACH_POINTS = {
+  sendProactive: 1,
+  sendRespondOnly: 0.5,
+  publicPage: 3,
+  apiRoute: 0.5,
+  apiRouteCap: 3,
+  sharedFiles: 1,
+  adapter: 2.5,
+  adapterRestrictedDm: 1,
+  /** Adapters that count: the heaviest three. */
+  adapterCap: 3,
+  wsConnection: 0.5,
+  wsConnectionCap: 2,
+  /** Mitigation: messages must be signed. */
+  signedOnly: -0.5
+}, AUTONOMY_POINTS = {
+  autonomous: 3,
+  autostart: 2,
+  timers: 1,
+  timerFast: 2,
+  // fastest interval <= 5 min
+  timerHourly: 1,
+  // fastest interval <= 1 h
+  trigger: 0.25,
+  triggerCap: 1.5,
+  proactive: 0.5,
+  createAgents: 3,
+  updateConfig: 1,
+  sideLoop: 0.5,
+  sideLoopCap: 1.5,
+  /** Mitigation per enabled restricted tool. */
+  restrictedTool: -0.25,
+  restrictedToolCap: -1
+}, sum = (ns) => ns.reduce((s, n) => s + n, 0), POWER_MAX = {
+  access: sum(Object.values(ACCESS_TOOL_POINTS).map((t) => t.points)) + ACCESS_POINTS.computeHostTarget + ACCESS_POINTS.computeEnabled + ACCESS_POINTS.hostAccess + ACCESS_POINTS.codeNetwork + ACCESS_POINTS.npmPackageCap + ACCESS_POINTS.mcpServerCap * (ACCESS_POINTS.mcpServer + ACCESS_POINTS.mcpCredentials) + ACCESS_POINTS.credentialCap + Math.max(ACCESS_POINTS.privateKeyPlain, ACCESS_POINTS.privateKeySealed),
+  reach: Math.max(...Object.values(VISIBILITY_POINTS)) + Math.max(REACH_POINTS.sendProactive, REACH_POINTS.sendRespondOnly) + REACH_POINTS.publicPage + REACH_POINTS.apiRouteCap + REACH_POINTS.sharedFiles + REACH_POINTS.adapterCap * Math.max(REACH_POINTS.adapter, REACH_POINTS.adapterRestrictedDm) + REACH_POINTS.wsConnectionCap,
+  autonomy: AUTONOMY_POINTS.autonomous + AUTONOMY_POINTS.autostart + AUTONOMY_POINTS.timers + Math.max(AUTONOMY_POINTS.timerFast, AUTONOMY_POINTS.timerHourly) + AUTONOMY_POINTS.triggerCap + AUTONOMY_POINTS.proactive + AUTONOMY_POINTS.createAgents + AUTONOMY_POINTS.updateConfig + AUTONOMY_POINTS.sideLoopCap
+};
+function toPowerStat(factors, max) {
+  let open3 = 0, gated = 0, mitigation = 0;
+  for (let f of factors)
+    f.points < 0 ? mitigation += f.points : f.gated ? gated += f.points : open3 += f.points;
+  open3 += mitigation, open3 < 0 && (gated = Math.max(0, gated + open3), open3 = 0);
+  let points = open3 + gated, rawPoints = factors.reduce((s, f) => s + f.points, 0);
+  return {
+    level: powerLevel(points, max),
+    points,
+    max,
+    fill: powerFill(points, max),
+    open: open3,
+    gated,
+    high: powerFill(open3, max) >= POWER_HIGH_OPEN_SHARE,
+    rawPoints,
+    factors
+  };
+}
+function countedIndices(items, cap, weight, gated) {
+  let order = items.map((t, i) => ({ i, w: weight(t), g: gated(t) })).sort((a, b) => b.w - a.w || Number(a.g) - Number(b.g) || a.i - b.i);
+  return new Set(order.slice(0, cap).map((o) => o.i));
+}
+function toolMap(inputs) {
+  let map = /* @__PURE__ */ new Map();
+  for (let t of inputs.tools) t.enabled && map.set(t.name, { restricted: !!t.restricted });
+  return map;
+}
+function plural(n, one, many = `${one}s`) {
+  return `${n} ${n === 1 ? one : many}`;
+}
+function formatInterval(ms) {
+  return ms < 6e4 ? `${Math.round(ms / 1e3)}s` : ms < 36e5 ? `${Math.round(ms / 6e4)} min` : `${Math.round(ms / 36e5)} h`;
+}
+function scoreAccess(inputs) {
+  let tools = toolMap(inputs), factors = [];
+  for (let [name21, def] of Object.entries(ACCESS_TOOL_POINTS)) {
+    let t = tools.get(name21);
+    t && factors.push({
+      id: `tool:${name21}`,
+      label: t.restricted ? `${def.label} (needs approval)` : def.label,
+      points: def.points,
+      gated: t.restricted,
+      configPath: `tools.${name21}`
+    });
+  }
+  let exec2 = tools.get("compute_exec");
+  exec2 && inputs.compute.allowedTargets.includes("host") && factors.push({
+    id: "compute:host_target",
+    label: "Runs commands on the host machine",
+    points: ACCESS_POINTS.computeHostTarget,
+    gated: exec2.restricted,
+    configPath: "compute.allowed_targets"
+  }), inputs.compute.enabled && factors.push({
+    id: "compute:enabled",
+    label: "Has its own compute container",
+    points: ACCESS_POINTS.computeEnabled,
+    gated: !1,
+    configPath: "compute.enabled"
+  }), inputs.compute.hostAccess && factors.push({
+    id: "compute:host_access",
+    label: "May run MCP servers on the host machine",
+    points: ACCESS_POINTS.hostAccess,
+    gated: !1,
+    configPath: "compute.host_access"
+  }), inputs.codeNetwork && factors.push({
+    id: "code:network",
+    label: "Sandbox code has direct network access",
+    points: ACCESS_POINTS.codeNetwork,
+    gated: !1,
+    configPath: "code_execution.network"
+  }), inputs.npmPackageCount > 0 && factors.push({
+    id: "code:packages",
+    label: `${plural(inputs.npmPackageCount, "npm package")} installed`,
+    points: Math.min(ACCESS_POINTS.npmPackageCap, inputs.npmPackageCount * ACCESS_POINTS.npmPackage),
+    gated: !1,
+    configPath: "code_execution.packages"
+  });
+  let countedMcp = countedIndices(
+    inputs.mcpServers,
+    ACCESS_POINTS.mcpServerCap,
+    (s) => ACCESS_POINTS.mcpServer + (s.hasCredentials ? ACCESS_POINTS.mcpCredentials : 0),
+    (s) => s.restricted
+  );
+  inputs.mcpServers.forEach((s, i) => {
+    let counts = countedMcp.has(i);
+    factors.push({
+      id: `mcp:${s.name}`,
+      label: s.restricted ? `MCP server ${s.name} (tools need approval)` : `MCP server ${s.name}`,
+      points: counts ? ACCESS_POINTS.mcpServer : 0,
+      gated: s.restricted,
+      configPath: "mcp.servers"
+    }), s.hasCredentials && factors.push({
+      id: `mcp:${s.name}:credentials`,
+      label: `MCP server ${s.name} holds credentials`,
+      points: counts ? ACCESS_POINTS.mcpCredentials : 0,
+      gated: s.restricted,
+      configPath: "mcp.servers"
+    });
+  });
+  let credBudget = ACCESS_POINTS.credentialCap, credPoints = (n) => {
+    let p = Math.min(credBudget, n * ACCESS_POINTS.credential);
+    return credBudget -= p, p;
+  };
+  return inputs.credentials.plain > 0 && factors.push({
+    id: "identity:credentials_plain",
+    label: `${plural(inputs.credentials.plain, "stored credential")}, unsealed`,
+    points: credPoints(inputs.credentials.plain),
+    gated: !1,
+    configPath: "adf_identity"
+  }), inputs.credentials.sealed > 0 && factors.push({
+    id: "identity:credentials_sealed",
+    label: `${plural(inputs.credentials.sealed, "stored credential")}, sealed`,
+    points: credPoints(inputs.credentials.sealed),
+    gated: !0,
+    configPath: "adf_identity"
+  }), inputs.privateKey === "plain" ? factors.push({
+    id: "identity:private_key",
+    label: "Signing key stored unsealed",
+    points: ACCESS_POINTS.privateKeyPlain,
+    gated: !1,
+    configPath: "adf_identity.crypto:signing:private_key"
+  }) : inputs.privateKey === "sealed" && factors.push({
+    id: "identity:private_key",
+    label: "Signing key (sealed)",
+    points: ACCESS_POINTS.privateKeySealed,
+    gated: !0,
+    configPath: "adf_identity.crypto:signing:private_key"
+  }), toPowerStat(factors, POWER_MAX.access);
+}
+function scoreReach(inputs) {
+  let tools = toolMap(inputs), factors = [], m = inputs.messaging, inbound = m.receive ? VISIBILITY_POINTS[m.visibility] ?? 0 : 0;
+  inbound > 0 && (factors.push({
+    id: "messaging:visibility",
+    label: `Receives messages from ${m.visibility === "directory" ? "agents in its directory" : `the ${m.visibility} tier`}`,
+    points: inbound,
+    gated: !1,
+    configPath: "messaging.visibility"
+  }), m.allowListCount > 0 && factors.push({
+    id: "messaging:allow_list",
+    label: `Inbox limited to ${plural(m.allowListCount, "allowed sender")}`,
+    points: -inbound / 2,
+    gated: !1,
+    configPath: "messaging.allow_list"
+  }), (!inputs.security.allowUnsigned || inputs.security.requireSignature) && factors.push({
+    id: "security:signed_only",
+    label: "Only accepts signed messages",
+    points: REACH_POINTS.signedOnly,
+    gated: !1,
+    configPath: inputs.security.requireSignature ? "security.require_signature" : "security.allow_unsigned"
+  }));
+  let send = tools.get("msg_send");
+  if (send && m.mode !== "listen_only") {
+    let proactive = m.mode === "proactive";
+    factors.push({
+      id: "messaging:send",
+      label: proactive ? "Sends messages on its own" : "Replies to messages it receives",
+      points: proactive ? REACH_POINTS.sendProactive : REACH_POINTS.sendRespondOnly,
+      gated: send.restricted,
+      configPath: "messaging.mode"
+    });
+  }
+  inputs.serving.publicEnabled && factors.push({
+    id: "serving:public",
+    label: "Serves a public web page",
+    points: REACH_POINTS.publicPage,
+    gated: !1,
+    configPath: "serving.public.enabled"
+  }), inputs.serving.apiRouteCount > 0 && factors.push({
+    id: "serving:api",
+    label: `${plural(inputs.serving.apiRouteCount, "HTTP API route")}`,
+    points: Math.min(REACH_POINTS.apiRouteCap, inputs.serving.apiRouteCount * REACH_POINTS.apiRoute),
+    gated: !1,
+    configPath: "serving.api"
+  }), inputs.serving.sharedEnabled && factors.push({
+    id: "serving:shared",
+    label: "Shares files with peers",
+    points: REACH_POINTS.sharedFiles,
+    gated: !1,
+    configPath: "serving.shared.enabled"
+  });
+  let adapterPoints = (a) => a.restrictedDm ? REACH_POINTS.adapterRestrictedDm : REACH_POINTS.adapter, countedAdapters = countedIndices(inputs.adapters, REACH_POINTS.adapterCap, adapterPoints, () => !1);
+  return inputs.adapters.forEach((a, i) => {
+    factors.push({
+      id: `adapter:${a.type}`,
+      label: a.restrictedDm ? `${a.type} adapter (DMs restricted)` : `${a.type} adapter`,
+      points: countedAdapters.has(i) ? adapterPoints(a) : 0,
+      gated: !1,
+      configPath: `adapters.${a.type}`
+    });
+  }), inputs.wsConnectionCount > 0 && factors.push({
+    id: "ws_connections",
+    label: `${plural(inputs.wsConnectionCount, "standing WebSocket connection")}`,
+    points: Math.min(REACH_POINTS.wsConnectionCap, inputs.wsConnectionCount * REACH_POINTS.wsConnection),
+    gated: !1,
+    configPath: "ws_connections"
+  }), toPowerStat(factors, POWER_MAX.reach);
+}
+function scoreAutonomy(inputs) {
+  let tools = toolMap(inputs), factors = [];
+  if (inputs.autonomous && factors.push({ id: "autonomous", label: "Acts without waiting for a human", points: AUTONOMY_POINTS.autonomous, gated: !1, configPath: "autonomous" }), inputs.autostart && factors.push({ id: "autostart", label: "Starts when the runtime starts", points: AUTONOMY_POINTS.autostart, gated: !1, configPath: "autostart" }), inputs.timers.active > 0) {
+    factors.push({ id: "timers", label: `${plural(inputs.timers.active, "active timer")}`, points: AUTONOMY_POINTS.timers, gated: !1, configPath: "adf_timers" });
+    let fastest = inputs.timers.fastestIntervalMs;
+    fastest !== void 0 && fastest <= 36e5 && factors.push({
+      id: "timers:fastest",
+      label: `Wakes every ${formatInterval(fastest)}`,
+      points: fastest <= 3e5 ? AUTONOMY_POINTS.timerFast : AUTONOMY_POINTS.timerHourly,
+      gated: !1,
+      configPath: "adf_timers"
+    });
+  }
+  let triggerTargets = inputs.triggers.reduce((s, t) => s + t.targets, 0);
+  triggerTargets > 0 && factors.push({
+    id: "triggers",
+    label: `Wakes on ${plural(inputs.triggers.length, "event type")} (${inputs.triggers.map((t) => t.type).join(", ")})`,
+    points: Math.min(AUTONOMY_POINTS.triggerCap, triggerTargets * AUTONOMY_POINTS.trigger),
+    gated: !1,
+    configPath: "triggers"
+  });
+  let send = tools.get("msg_send");
+  send && inputs.messaging.mode === "proactive" && factors.push({ id: "messaging:proactive", label: "Starts conversations", points: AUTONOMY_POINTS.proactive, gated: send.restricted, configPath: "messaging.mode" });
+  let spawn5 = tools.get("sys_create_adf");
+  spawn5 && factors.push({ id: "tool:sys_create_adf", label: spawn5.restricted ? "Creates new agents (needs approval)" : "Creates new agents", points: AUTONOMY_POINTS.createAgents, gated: spawn5.restricted, configPath: "tools.sys_create_adf" });
+  let update = tools.get("sys_update_config");
+  update && factors.push({ id: "tool:sys_update_config", label: update.restricted ? "Changes its own config (needs approval)" : "Changes its own config", points: AUTONOMY_POINTS.updateConfig, gated: update.restricted, configPath: "tools.sys_update_config" }), inputs.sideLoopCount > 0 && factors.push({
+    id: "loops",
+    label: `${plural(inputs.sideLoopCount, "inner loop")}`,
+    points: Math.min(AUTONOMY_POINTS.sideLoopCap, inputs.sideLoopCount * AUTONOMY_POINTS.sideLoop),
+    gated: !1,
+    configPath: "loops"
+  });
+  let restricted = [...tools.values()].filter((t) => t.restricted).length;
+  return restricted > 0 && factors.push({
+    id: "tools:restricted",
+    label: `${plural(restricted, "tool")} need${restricted === 1 ? "s" : ""} approval`,
+    points: Math.max(AUTONOMY_POINTS.restrictedToolCap, restricted * AUTONOMY_POINTS.restrictedTool),
+    gated: !1,
+    configPath: "tools[].restricted"
+  }), toPowerStat(factors, POWER_MAX.autonomy);
+}
+var EXPERIENCE_WEIGHTS = {
+  /** Per context worked: one compaction, or a loop's current fill as a share of its compaction threshold. */
+  contextsWorked: 10,
+  /**
+   * Multiplied by sqrt(approximate tokens in `mind/` files), so 10x memory is
+   * about 3.2x the XP and a bulk dump cannot buy levels (1M tokens alone is
+   * Lv 17). 2.6 keeps the first-session anchor (300 tokens) at Lv 3 with
+   * margin; skills, rows and children carry the heavy anchor instead.
+   */
+  memoryTokensSqrt: 2.6,
+  /** Per skill installed or changed. */
+  skills: 80,
+  /** Per `local_*` table. */
+  localTables: 10,
+  /** Multiplied by sqrt(total local rows). */
+  localRowsSqrt: 7,
+  /** Per file written or changed after creation. */
+  filesWritten: 2,
+  /** Per child agent. */
+  agentsSpawned: 75,
+  /** Per loop message ever written (all loops, current and past). Small: volume alone must not level an agent. */
+  messages: 0.01,
+  /** Per day of age, scaled by activity = min(1, contextsWorked / ageActivityContexts) so an idle file does not level up by waiting. */
+  ageDays: 0.5,
+  ageActivityContexts: 10
+}, EXPERIENCE_LABELS = {
+  contextsWorked: "Contexts of work",
+  filesWritten: "Files written",
+  memoryTokens: "Memory tokens",
+  skills: "Skills",
+  localTables: "Database tables",
+  localRows: "Database rows",
+  agentsSpawned: "Agents created",
+  messages: "Messages",
+  ageDays: "Days active"
+};
+function experienceSignals(inputs) {
+  let w = EXPERIENCE_WEIGHTS, n = (v) => typeof v == "number" && Number.isFinite(v) && v > 0 ? v : 0, activity = Math.min(1, n(inputs.contextsWorked) / w.ageActivityContexts), signals = [
+    { id: "contextsWorked", label: EXPERIENCE_LABELS.contextsWorked, value: n(inputs.contextsWorked), xp: n(inputs.contextsWorked) * w.contextsWorked },
+    { id: "memoryTokens", label: EXPERIENCE_LABELS.memoryTokens, value: n(inputs.memoryTokens), xp: Math.sqrt(n(inputs.memoryTokens)) * w.memoryTokensSqrt },
+    { id: "skills", label: EXPERIENCE_LABELS.skills, value: n(inputs.skills), xp: n(inputs.skills) * w.skills },
+    { id: "localTables", label: EXPERIENCE_LABELS.localTables, value: n(inputs.localTables), xp: n(inputs.localTables) * w.localTables },
+    { id: "localRows", label: EXPERIENCE_LABELS.localRows, value: n(inputs.localRows), xp: Math.sqrt(n(inputs.localRows)) * w.localRowsSqrt },
+    { id: "filesWritten", label: EXPERIENCE_LABELS.filesWritten, value: n(inputs.filesWritten), xp: n(inputs.filesWritten) * w.filesWritten }
+  ];
+  return inputs.agentsSpawned !== null && signals.push({ id: "agentsSpawned", label: EXPERIENCE_LABELS.agentsSpawned, value: n(inputs.agentsSpawned), xp: n(inputs.agentsSpawned) * w.agentsSpawned }), signals.push(
+    { id: "messages", label: EXPERIENCE_LABELS.messages, value: n(inputs.messages), xp: n(inputs.messages) * w.messages },
+    { id: "ageDays", label: EXPERIENCE_LABELS.ageDays, value: Math.floor(n(inputs.ageDays)), xp: n(inputs.ageDays) * w.ageDays * activity }
+  ), signals;
+}
+function ceilCount(n) {
+  if (n < 1e3) return String(n);
+  let k = Math.ceil(n / 100) / 10;
+  return `${k % 1 === 0 ? k.toFixed(0) : k.toFixed(1)}k`;
+}
+function scoreExperience(inputs) {
+  let breakdown = experienceSignals(inputs), score = breakdown.reduce((s, b) => s + b.xp, 0), pos = levelPosition(score, EXPERIENCE_CURVE), xp = Math.max(0, pos.nextLevelAt - score), w = EXPERIENCE_WEIGHTS, contexts = Math.ceil(xp / w.contextsWorked), memoryNow = typeof inputs.memoryTokens == "number" && Number.isFinite(inputs.memoryTokens) && inputs.memoryTokens > 0 ? inputs.memoryTokens : 0, memoryXpNow = Math.sqrt(memoryNow) * w.memoryTokensSqrt, memoryTokens = Math.max(0, Math.ceil(((memoryXpNow + xp) / w.memoryTokensSqrt) ** 2 - memoryNow)), skills = Math.ceil(xp / w.skills);
+  return {
+    level: pos.level,
+    progress: pos.progress,
+    score,
+    levelStart: pos.levelStart,
+    nextLevelAt: pos.nextLevelAt,
+    breakdown,
+    nextLevel: {
+      xp,
+      contexts,
+      memoryTokens,
+      skills,
+      hint: `Lv ${pos.level + 1} needs ${Math.ceil(xp)} more XP: about ${plural(contexts, "context")} of work, ${ceilCount(memoryTokens)} memory tokens or ${plural(skills, "skill")}`
+    }
+  };
+}
+function scheduleIntervalMs(schedule) {
+  if (schedule) {
+    if (schedule.mode === "interval") return schedule.every_ms > 0 ? schedule.every_ms : void 0;
+    if (schedule.mode === "cron") {
+      let minute = schedule.cron.trim().split(/\s+/)[0] ?? "";
+      if (minute === "*") return 6e4;
+      let step = /^\*\/(\d+)$/.exec(minute);
+      return step ? Number(step[1]) * 6e4 : void 0;
+    }
+  }
+}
+function powerInputsFromConfig(config, tables) {
+  let triggers = [];
+  for (let [type, t] of Object.entries(config.triggers ?? {})) {
+    if (type === "on_chat" || !t?.enabled) continue;
+    let targets = Array.isArray(t.targets) ? t.targets.length : 0;
+    targets > 0 && triggers.push({ type, targets });
+  }
+  let mcpServers = (config.mcp?.servers ?? []).map((s) => ({
+    name: s.name,
+    restricted: !!s.restricted,
+    hasCredentials: !!(s.oauth || s.bearer_token_env_var || s.env_keys && s.env_keys.length > 0 || s.env_schema && s.env_schema.length > 0 || s.header_env && s.header_env.length > 0 || s.credential_files && s.credential_files.length > 0)
+  })), adapters = Object.entries(config.adapters ?? {}).filter(([, a]) => a?.enabled).map(([type, a]) => ({ type, restrictedDm: a.policy?.dm === "allowlist" || a.policy?.dm === "none" })), allowedTargets = [...config.compute?.allowed_targets ?? []];
+  return config.compute?.target && !allowedTargets.includes(config.compute.target) && allowedTargets.push(config.compute.target), {
+    tools: (config.tools ?? []).map((t) => ({ name: t.name, enabled: !!t.enabled, restricted: !!t.restricted })),
+    autonomous: !!config.autonomous,
+    autostart: !!config.autostart,
+    messaging: {
+      receive: config.messaging?.receive ?? !1,
+      mode: config.messaging?.mode ?? "proactive",
+      visibility: config.messaging?.visibility ?? "localhost",
+      allowListCount: config.messaging?.allow_list?.length ?? 0
+    },
+    security: {
+      allowUnsigned: config.security?.allow_unsigned ?? !0,
+      requireSignature: !!config.security?.require_signature
+    },
+    serving: {
+      publicEnabled: !!config.serving?.public?.enabled,
+      apiRouteCount: config.serving?.api?.length ?? 0,
+      sharedEnabled: !!config.serving?.shared?.enabled
+    },
+    adapters,
+    wsConnectionCount: (config.ws_connections ?? []).filter((c) => c?.enabled).length,
+    mcpServers,
+    npmPackageCount: config.code_execution?.packages?.length ?? 0,
+    codeNetwork: !!config.code_execution?.network,
+    compute: {
+      enabled: !!config.compute?.enabled,
+      hostAccess: !!config.compute?.host_access,
+      allowedTargets
+    },
+    triggers,
+    sideLoopCount: config.loops?.length ?? 0,
+    credentials: tables.credentials,
+    privateKey: tables.privateKey,
+    timers: tables.timers
+  };
+}
+function scoreAgent(power, experience) {
+  return {
+    reach: scoreReach(power),
+    access: scoreAccess(power),
+    autonomy: scoreAutonomy(power),
+    experience: scoreExperience(experience)
+  };
+}
+
+// src/shared/utils/agent-activity.ts
+var ACTIVITY_DAYS = 14;
+function localDayKeys(now2, days = ACTIVITY_DAYS) {
+  let d = new Date(now2), out = [];
+  for (let i = days - 1; i >= 0; i--)
+    out.push(localDateKey(new Date(d.getFullYear(), d.getMonth(), d.getDate() - i)));
+  return out;
+}
+function windowStartMs(now2, days = ACTIVITY_DAYS) {
+  let d = new Date(now2);
+  return new Date(d.getFullYear(), d.getMonth(), d.getDate() - (days - 1)).getTime();
+}
+
+// src/main/services/agent-daily.ts
+function rowsOf(q, sql, params) {
+  try {
+    return q(sql, params);
+  } catch {
+    return null;
+  }
+}
+var num = (v) => typeof v == "number" && Number.isFinite(v) ? v : null, DAY_MS = 1440 * 60 * 1e3, LOOP_COST_RECORDED_SINCE_MS = Date.UTC(2026, 7, 27);
+function rowCost(model, tokens, createdAt) {
+  if (tokens == null || tokens === "") return { kind: "none" };
+  let usage = tokens;
+  if (typeof tokens == "string")
+    try {
+      usage = JSON.parse(tokens);
+    } catch {
+      return { kind: "unpriced" };
+    }
+  if (!usage || typeof usage != "object" || Array.isArray(usage)) return { kind: "unpriced" };
+  let u = usage, recorded = num(u.cost_usd);
+  if (recorded !== null) return { kind: "priced", usd: recorded };
+  if (createdAt >= LOOP_COST_RECORDED_SINCE_MS || typeof model != "string" || !model) return { kind: "unpriced" };
+  let usd = estimateTokenCostUsd(model, {
+    input: num(u.input) ?? void 0,
+    output: num(u.output) ?? void 0,
+    cache_read: num(u.cache_read) ?? void 0,
+    cache_write: num(u.cache_write) ?? void 0
+  });
+  return usd === void 0 ? { kind: "unpriced" } : { kind: "priced", usd };
+}
+function maxLoopSeq(q) {
+  return num(rowsOf(q, "SELECT MAX(seq) AS n FROM adf_loop")?.[0]?.n) ?? 0;
+}
+function firstSeqSince(q, since, maxSeq = maxLoopSeq(q)) {
+  let probe = (seq) => {
+    let r = rowsOf(q, "SELECT seq, created_at AS t FROM adf_loop WHERE seq >= ? ORDER BY seq LIMIT 1", [seq])?.[0];
+    return r ? { seq: r.seq, t: num(r.t) ?? 0 } : null;
+  }, lo = 0, hi = maxSeq + 1;
+  for (; lo < hi; ) {
+    let mid = Math.floor((lo + hi) / 2), row = probe(mid);
+    !row || row.seq >= hi || row.t >= since ? hi = mid : lo = row.seq + 1;
+  }
+  return lo;
+}
+function startLoopDayScan(q, since) {
+  let startSeq = firstSeqSince(q, since);
+  return { since, startSeq, lastSeq: startSeq - 1, rows: /* @__PURE__ */ new Map() };
+}
+function addRows(scan, rows) {
+  for (let r of rows) {
+    let t = num(r.t) ?? 0, cost = rowCost(r.model, r.tokens, t);
+    scan.rows.set(r.seq, cost.kind === "priced" ? { t, usd: cost.usd } : cost.kind === "unpriced" ? { t, unpriced: !0 } : { t });
+  }
+}
+function scanLoopRows(q, scan, upTo) {
+  if (upTo <= scan.lastSeq) return scan;
+  let rows = rowsOf(q, "SELECT seq, created_at AS t, model, tokens FROM adf_loop WHERE seq > ? AND seq <= ?", [scan.lastSeq, upTo]) ?? rowsOf(q, "SELECT seq, created_at AS t, NULL AS model, NULL AS tokens FROM adf_loop WHERE seq > ? AND seq <= ?", [scan.lastSeq, upTo]) ?? [];
+  return addRows(scan, rows), scan.lastSeq = upTo, scan;
+}
+function seqRangeRows(q, select, from, to) {
+  return rowsOf(q, `SELECT ${select} FROM adf_loop INDEXED BY idx_adf_loop_loop_seq WHERE seq BETWEEN ? AND ?`, [from, to]) ?? rowsOf(q, `SELECT ${select} FROM adf_loop WHERE seq BETWEEN ? AND ?`, [from, to]);
+}
+function refreshLoopDayScan(q, since, prior) {
+  let maxSeq = maxLoopSeq(q);
+  if (!prior || prior.since !== since || prior.lastSeq > maxSeq) return scanLoopRows(q, startLoopDayScan(q, since), maxSeq);
+  let scan = prior;
+  if (scan.lastSeq >= scan.startSeq) {
+    let count = num(seqRangeRows(q, "COUNT(*) AS n", scan.startSeq, scan.lastSeq)?.[0]?.n);
+    if (count !== null && count !== scan.rows.size) {
+      let alive = new Set((seqRangeRows(q, "seq", scan.startSeq, scan.lastSeq) ?? []).map((r) => r.seq));
+      for (let seq of scan.rows.keys()) alive.has(seq) || scan.rows.delete(seq);
+      let missing = [...alive].filter((seq) => !scan.rows.has(seq));
+      missing.length > 0 && addRows(scan, rowsOf(q, "SELECT seq, created_at AS t, model, tokens FROM adf_loop WHERE seq IN (SELECT value FROM json_each(?))", [JSON.stringify(missing)]) ?? []);
+    }
+  }
+  return scanLoopRows(q, scan, maxSeq);
+}
+var LOOP_AUDIT_WHERE = "(source = 'loop' OR source LIKE 'loop:%')", ARCHIVE_SPREAD_MAX_MS = DAY_MS, loopOfSource = (source) => source === "loop" ? "main" : source.slice(5) || "main";
+function firstAuditIdSince(q, at) {
+  let bounds = rowsOf(q, "SELECT MIN(id) AS lo, MAX(id) AS hi FROM adf_audit")?.[0], minId = num(bounds?.lo), maxId = num(bounds?.hi);
+  if (minId === null || maxId === null) return null;
+  let lo = minId, hi = maxId + 1;
+  for (; lo < hi; ) {
+    let mid = Math.floor((lo + hi) / 2), row = rowsOf(q, "SELECT id, created_at AS t FROM adf_audit WHERE id >= ? ORDER BY id LIMIT 1", [mid])?.[0];
+    !row || row.id >= hi || (num(row.t) ?? 0) >= at ? hi = mid : lo = row.id + 1;
+  }
+  return lo;
+}
+function readArchiveSpans(q, since) {
+  let firstId = firstAuditIdSince(q, since - ARCHIVE_SPREAD_MAX_MS);
+  if (firstId === null) return [];
+  let cols = (seqCols) => `SELECT id, source, ${seqCols}, entry_count, created_at FROM adf_audit WHERE id >= ? AND ${LOOP_AUDIT_WHERE} ORDER BY id`, archives = rowsOf(q, cols("start_seq, end_seq"), [firstId]) ?? rowsOf(q, cols("NULL AS start_seq, NULL AS end_seq"), [firstId]) ?? [], liveAt = (sql, seq) => num(rowsOf(q, sql, [seq])?.[0]?.t), liveInRange = (loop, from, to) => num(rowsOf(q, "SELECT COUNT(*) AS n FROM adf_loop WHERE loop = ? AND seq BETWEEN ? AND ?", [loop, from, to])?.[0]?.n) ?? (loop === "main" ? num(rowsOf(q, "SELECT COUNT(*) AS n FROM adf_loop WHERE seq BETWEEN ? AND ?", [from, to])?.[0]?.n) ?? 0 : 0), spans = [], prevCreated = /* @__PURE__ */ new Map();
+  return archives.forEach((a, i) => {
+    let loop = loopOfSource(a.source), created = num(a.created_at) ?? 0, prev = prevCreated.get(loop);
+    if (prevCreated.set(loop, created), created < since) return;
+    let startSeq = num(a.start_seq), endSeq = num(a.end_seq), hasRange = startSeq !== null && endSeq !== null;
+    if (hasRange && archives.slice(i + 1).some((b) => loopOfSource(b.source) === loop && num(b.start_seq) !== null && num(b.start_seq) <= startSeq && (num(b.end_seq) ?? -1 / 0) >= endSeq)) return;
+    let count = num(a.entry_count) ?? 0;
+    if (hasRange && (count -= liveInRange(loop, startSeq, endSeq)), count <= 0) return;
+    let to = created, after = hasRange ? liveAt("SELECT created_at AS t FROM adf_loop WHERE seq > ? ORDER BY seq LIMIT 1", endSeq) : null;
+    after !== null && after < to && (to = after);
+    let from = to - ARCHIVE_SPREAD_MAX_MS;
+    prev !== void 0 && (from = Math.max(from, prev));
+    let before = hasRange ? liveAt("SELECT created_at AS t FROM adf_loop WHERE seq < ? ORDER BY seq DESC LIMIT 1", startSeq) : null;
+    before !== null && (from = Math.max(from, before)), spans.push({ loop, from: Math.min(from, to), to, count });
+  }), spans;
+}
+function spreadSpans(spans, dayStarts) {
+  let out = new Array(dayStarts.length - 1).fill(0);
+  for (let s of spans) {
+    let width = s.to - s.from;
+    for (let i = 0; i < out.length; i++) {
+      let a = dayStarts[i], b = dayStarts[i + 1];
+      if (width <= 0) {
+        s.to >= a && s.to < b && (out[i] += s.count);
+        continue;
+      }
+      let overlap = Math.min(b, s.to) - Math.max(a, s.from);
+      overlap > 0 && (out[i] += s.count * overlap / width);
+    }
+  }
+  return out;
+}
+function windowDayStarts(now2, days) {
+  let d = new Date(now2), out = [];
+  for (let i = days - 1; i >= -1; i--) out.push(new Date(d.getFullYear(), d.getMonth(), d.getDate() - i).getTime());
+  return out;
+}
+function buildDailyActivity(scan, spans, now2, days) {
+  let keys = localDayKeys(now2, days), starts = windowDayStarts(now2, keys.length), live = keys.map(() => ({ messages: 0, usd: 0, priced: !1, unpriced: !1 }));
+  for (let r of scan.rows.values()) {
+    if (r.t < starts[0] || r.t >= starts[starts.length - 1]) continue;
+    let i = 0;
+    for (; r.t >= starts[i + 1]; ) i++;
+    let day = live[i];
+    day.messages++, r.usd !== void 0 && (day.usd += r.usd, day.priced = !0), r.unpriced && (day.unpriced = !0);
+  }
+  let archived = spreadSpans(spans, starts);
+  return keys.map((date, i) => {
+    let extra = Math.round(archived[i]), d = live[i];
+    return {
+      date,
+      messages: d.messages + extra,
+      ...extra > 0 ? { estimated: !0 } : {},
+      ...d.priced ? { costUsd: Number(d.usd.toFixed(8)) } : {},
+      ...d.unpriced || extra > 0 ? { costPartial: !0 } : {}
+    };
+  });
+}
+function readDailyActivity(q, now2, prior) {
+  let since = windowStartMs(now2), scan = refreshLoopDayScan(q, since, prior);
+  return { daily: buildDailyActivity(scan, readArchiveSpans(q, since), now2), scan };
+}
+function recentCost(daily, days = 7) {
+  let recent = daily.slice(-days);
+  if (recent.some((d) => d.costUsd !== void 0))
+    return {
+      usd: Number(recent.reduce((s, d) => s + (d.costUsd ?? 0), 0).toFixed(8)),
+      partial: recent.some((d) => d.costPartial === !0)
+    };
+}
+
+// src/shared/utils/agent-metrics.ts
+var isNum = (v) => typeof v == "number" && Number.isFinite(v), isText = (v) => typeof v == "string" && v.trim() !== "";
+function parseMetric(name21, raw) {
+  let text2 = raw == null ? "" : String(raw), plain = { name: name21, label: name21, value: text2, raw: text2 };
+  if (!text2.trimStart().startsWith("{")) return plain;
+  let o;
+  try {
+    o = JSON.parse(text2);
+  } catch {
+    return plain;
+  }
+  if (!o || typeof o != "object" || Array.isArray(o)) return plain;
+  let r = o;
+  return !isNum(r.value) && typeof r.value != "string" ? plain : {
+    name: name21,
+    label: isText(r.label) ? r.label : name21,
+    value: r.value,
+    ...isText(r.unit) ? { unit: r.unit } : {},
+    ...isNum(r.min) ? { min: r.min } : {},
+    ...isNum(r.max) ? { max: r.max } : {},
+    ...isNum(r.target) ? { target: r.target } : {},
+    raw: text2
+  };
+}
+
+// src/main/services/agent-vitals.ts
+var MIND_LOG_SEED_BYTES = Buffer.byteLength(DEFAULT_MIND_LOG_CONTENT);
+function memoryBytes(path, size) {
+  let bytes = typeof size == "number" && Number.isFinite(size) ? size : 0;
+  return path === "mind/log.md" ? Math.max(0, bytes - MIND_LOG_SEED_BYTES) : bytes;
+}
+function overlayLiveStates(meshAgents, live) {
+  let byPath = /* @__PURE__ */ new Map();
+  for (let l of live)
+    byPath.set(l.filePath, { state: l.state, activeLoops: l.activeLoops ?? byPath.get(l.filePath)?.activeLoops });
+  return meshAgents.map((a) => {
+    let l = byPath.get(a.filePath);
+    return l ? l.activeLoops === void 0 ? { ...a, state: l.state } : { ...a, state: l.state, activeLoops: l.activeLoops } : a;
+  });
+}
+function parseDidHistory(raw) {
+  if (!raw) return [];
+  try {
+    let parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed.filter((d) => typeof d == "string" && d) : [];
+  } catch {
+    return [];
+  }
+}
+function liveFleetMeta(workspace) {
+  try {
+    let config = workspace.getAgentConfig();
+    return {
+      handle: workspace.getMeta("adf_handle") || config?.handle || null,
+      name: workspace.getMeta("adf_name") || config?.name || null,
+      icon: config?.icon ?? null,
+      model: config?.model?.model_id || null,
+      status: workspace.getMeta("status") ?? null,
+      did: workspace.getMeta("adf_did") || null,
+      didHistory: parseDidHistory(workspace.getMeta("adf_did_history")),
+      agentId: config?.id ?? null,
+      parentDid: workspace.getMeta("adf_parent_did") || null,
+      createdAt: workspace.getMeta("adf_created_at") || config?.metadata?.created_at || null
+    };
+  } catch {
+    return null;
+  }
+}
+function safe(q, sql, map, fallback, params) {
+  try {
+    return map(q(sql, params));
+  } catch {
+    return fallback;
+  }
+}
+function safeOr(q, sql, map, orElse, params) {
+  try {
+    return map(q(sql, params));
+  } catch {
+    return orElse();
+  }
+}
+var firstNumber2 = (rows, col = "n") => {
+  let v = rows[0]?.[col];
+  return typeof v == "number" && Number.isFinite(v) ? v : 0;
+}, DERIVED_FILES = /* @__PURE__ */ new Set(["skills-registry.json"]), SKILL_FILE = /^skills\/([^/]+)\//, CREATION_GRACE_MS = 1e4;
+function agentWriteCutoff(createdAt) {
+  let createdMs = createdAt ? Date.parse(createdAt) : NaN;
+  return Number.isFinite(createdMs) ? new Date(createdMs + CREATION_GRACE_MS).toISOString() : "";
+}
+function classifyFiles(files, cutoff, registrySkills = []) {
+  let mine = [], agentSkills = /* @__PURE__ */ new Set(), starterSkills = /* @__PURE__ */ new Set();
+  for (let f of files) {
+    if (DERIVED_FILES.has(f.path)) continue;
+    let own = !cutoff || f.updated_at > cutoff, skill = SKILL_FILE.exec(f.path)?.[1];
+    own ? (mine.push(f), skill && agentSkills.add(skill)) : skill && starterSkills.add(skill);
+  }
+  for (let name21 of registrySkills) starterSkills.has(name21) || agentSkills.add(name21);
+  return { mine, agentSkills };
+}
+function readRegistrySkills(q) {
+  return safe(
+    q,
+    "SELECT content FROM adf_files WHERE path = 'skills-registry.json'",
+    (rows) => {
+      let c = rows[0]?.content;
+      if (!c) return [];
+      let skills = JSON.parse(Buffer.isBuffer(c) ? c.toString("utf-8") : String(c)).skills;
+      return Array.isArray(skills) ? skills.map((s) => s?.name).filter((n) => typeof n == "string") : skills && typeof skills == "object" ? Object.keys(skills) : [];
+    },
+    []
+  );
+}
+var MAX_TABLES = 50;
+function listLocalTables(q) {
+  return safe(
+    q,
+    "SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'local\\_%' ESCAPE '\\' ORDER BY name",
+    (rows) => rows.map((r) => r.name).filter((n) => /^local_[A-Za-z0-9_]+$/.test(n)),
+    []
+  );
+}
+var LOOP_AUDIT_WHERE2 = "(source = 'loop' OR source LIKE 'loop:%')", FULL_SNAPSHOT_SHARE = 0.5, BASELINE_KEY = "context_baseline_tokens", loopOfSource2 = (source) => source === "loop" ? "main" : source.slice(5) || "main", clamp01 = (x) => Number.isFinite(x) ? Math.min(1, Math.max(0, x)) : 0;
+function readSummaryScan(q, prior, upTo = 1 / 0) {
+  let maxSeq = Math.min(upTo, safe(q, "SELECT MAX(seq) AS n FROM adf_loop", (r) => firstNumber2(r), 0)), base = prior && prior.lastSeq <= maxSeq ? prior : null, sql = (loopCol) => `SELECT seq, ${loopCol} AS loop FROM adf_loop WHERE seq > ? AND seq <= ? AND role = 'user' AND content_json LIKE '%[Loop Compacted%'`, params = [base ? base.lastSeq : 0, maxSeq], fresh = safeOr(q, sql("loop"), (r) => r, () => safe(q, sql("'main'"), (r) => r, [], params), params), kept = [];
+  if (base && base.hits.length > 0) {
+    let alive = new Set(safe(
+      q,
+      "SELECT seq FROM adf_loop WHERE seq IN (SELECT value FROM json_each(?))",
+      (r) => r.map((x) => x.seq),
+      [],
+      [JSON.stringify(base.hits.map((h) => h.seq))]
+    ));
+    kept = base.hits.filter((h) => alive.has(h.seq));
+  }
+  return { lastSeq: maxSeq, hits: [...kept, ...fresh.map((h) => ({ seq: h.seq, loop: h.loop || "main" }))] };
+}
+function readContextsWorked(q, config, summaryScan = readSummaryScan(q)) {
+  let threshold = (loop) => resolveLoopThreshold(config, loop), loops = /* @__PURE__ */ new Set(["main", ...(config.loops ?? []).map((l) => l?.name).filter((n) => typeof n == "string" && !!n)]), live = safeOr(
+    q,
+    "SELECT loop, COUNT(*) AS n FROM adf_loop GROUP BY loop",
+    (r) => r,
+    () => safe(q, "SELECT 'main' AS loop, COUNT(*) AS n FROM adf_loop", (r) => r, [])
+  ), liveRows = /* @__PURE__ */ new Map();
+  for (let r of live) {
+    let name21 = r.loop || "main";
+    liveRows.set(name21, (liveRows.get(name21) ?? 0) + r.n), loops.add(name21);
+  }
+  let archived = /* @__PURE__ */ new Map();
+  for (let r of safe(q, `SELECT source, size_bytes AS bytes FROM adf_audit WHERE ${LOOP_AUDIT_WHERE2}`, (rows) => rows, [])) {
+    let name21 = loopOfSource2(r.source);
+    loops.add(name21);
+    let bytes = typeof r.bytes == "number" ? r.bytes : 0;
+    archived.set(name21, (archived.get(name21) ?? 0) + clamp01(bytes / 4 / (threshold(name21) * FULL_SNAPSHOT_SHARE)));
+  }
+  let summaries = /* @__PURE__ */ new Map();
+  for (let h of summaryScan.hits) summaries.set(h.loop, (summaries.get(h.loop) ?? 0) + 1);
+  let baselines = /* @__PURE__ */ new Map();
+  for (let r of safe(q, `SELECT key, value FROM adf_meta WHERE key = '${BASELINE_KEY}' OR key LIKE '${BASELINE_KEY}:%'`, (rows) => rows, []))
+    try {
+      let tokens = JSON.parse(r.value).tokens;
+      typeof tokens == "number" && Number.isFinite(tokens) && baselines.set(r.key === BASELINE_KEY ? "main" : r.key.slice(BASELINE_KEY.length + 1), tokens);
+    } catch {
+    }
+  let total = 0;
+  for (let loop of loops) {
+    if (total += Math.max(archived.get(loop) ?? 0, summaries.get(loop) ?? 0), !liveRows.get(loop)) continue;
+    let tokens = baselines.get(loop);
+    if (tokens === void 0) {
+      let bytesSql = (where) => `SELECT SUM(octet_length(content_json)) AS n FROM adf_loop ${where}`;
+      tokens = (loop === "main" ? safeOr(q, bytesSql("WHERE loop = 'main'"), (r) => firstNumber2(r), () => safe(q, bytesSql(""), (r) => firstNumber2(r), 0)) : safe(q, bytesSql("WHERE loop = ?"), (r) => firstNumber2(r), 0, [loop])) / 4;
+    }
+    total += clamp01(tokens / threshold(loop));
+  }
+  return Math.round(total * 100) / 100;
+}
+function readOwnerVerified(q, did) {
+  if (!did) return !1;
+  let rows = safe(q, "SELECT raw_json FROM adf_attestations", (r) => r, []);
+  for (let r of rows) {
+    let att = null;
+    try {
+      att = JSON.parse(r.raw_json);
+    } catch {
+      att = null;
+    }
+    if (att && att.role === "owner" && verifyAttestation(att, { expectedSubject: did })) return !0;
+  }
+  return !1;
+}
+function readVitalsCheapPart(q) {
+  let config = safe(
+    q,
+    "SELECT config_json FROM adf_config WHERE id = 1",
+    (rows) => {
+      let raw = rows[0]?.config_json;
+      return raw ? JSON.parse(raw) : {};
+    },
+    {}
+  ), metaMap = safe(
+    q,
+    "SELECT key, value FROM adf_meta WHERE key IN ('adf_handle','adf_name','status','adf_did','adf_did_history','adf_parent_did','adf_created_at')",
+    (rows) => new Map(rows.map((r) => [r.key, r.value])),
+    /* @__PURE__ */ new Map()
+  ), getMeta = (k) => metaMap.get(k) ?? null, meta = {
+    handle: getMeta("adf_handle") || config.handle || null,
+    name: getMeta("adf_name") || config.name || null,
+    icon: config.icon ?? null,
+    model: config.model?.model_id || null,
+    status: getMeta("status"),
+    did: getMeta("adf_did") || null,
+    didHistory: parseDidHistory(getMeta("adf_did_history")),
+    agentId: config.id ?? null,
+    parentDid: getMeta("adf_parent_did") || null,
+    createdAt: getMeta("adf_created_at") || config.metadata?.created_at || null
+  }, identity = safe(
+    q,
+    "SELECT purpose, encryption_algo FROM adf_identity",
+    (rows) => rows,
+    []
+  ), credentials = { plain: 0, sealed: 0 }, privateKey = "none";
+  for (let r of identity) {
+    let sealed = !!r.encryption_algo && r.encryption_algo !== "plain";
+    if (r.purpose === "crypto:signing:private_key") privateKey = sealed ? "sealed" : "plain";
+    else {
+      if (r.purpose.startsWith("crypto:")) continue;
+      sealed ? credentials.sealed++ : credentials.plain++;
+    }
+  }
+  let timerRows = safeOr(
+    q,
+    "SELECT schedule_json, next_wake_at FROM adf_timers WHERE expired = 0",
+    (rows) => rows,
+    () => safe(q, "SELECT schedule_json, next_wake_at FROM adf_timers", (rows) => rows, [])
+  ), fastestIntervalMs, nextWakeAt;
+  for (let t of timerRows) {
+    typeof t.next_wake_at == "number" && (nextWakeAt === void 0 || t.next_wake_at < nextWakeAt) && (nextWakeAt = t.next_wake_at);
+    let schedule = null;
+    try {
+      schedule = JSON.parse(t.schedule_json);
+    } catch {
+      schedule = null;
+    }
+    let every = scheduleIntervalMs(schedule);
+    every !== void 0 && (fastestIntervalMs === void 0 || every < fastestIntervalMs) && (fastestIntervalMs = every);
+  }
+  let messages = Math.max(
+    safe(q, "SELECT seq AS n FROM sqlite_sequence WHERE name = 'adf_loop'", (r) => firstNumber2(r), 0),
+    safe(q, "SELECT MAX(seq) AS n FROM adf_loop", (r) => firstNumber2(r), 0)
+  ), metrics = safe(
+    q,
+    "SELECT key, value FROM adf_meta WHERE key LIKE 'metric:%' ORDER BY key LIMIT 20",
+    (rows) => rows.map((r) => parseMetric(r.key.slice(7), r.value)),
+    []
+  );
+  return {
+    config,
+    meta,
+    power: powerInputsFromConfig(config, {
+      credentials,
+      privateKey,
+      timers: { active: timerRows.length, fastestIntervalMs }
+    }),
+    messages,
+    metrics,
+    nextWakeAt,
+    card: {
+      ...config.description?.trim() ? { description: config.description.trim() } : {},
+      public: config.serving?.public?.enabled ?? !1,
+      ownerVerified: readOwnerVerified(q, meta.did)
+    }
+  };
+}
+function readVitalsHeavyPart(q, cheap, prior) {
+  let cutoff = agentWriteCutoff(cheap.meta.createdAt), { mine, agentSkills } = classifyFiles(
+    safe(q, "SELECT path, updated_at FROM adf_files", (rows) => rows, []),
+    cutoff,
+    readRegistrySkills(q)
+  ), filesWritten = mine.filter((f) => !f.path.startsWith("mind/")).length, mindFiles = safe(q, "SELECT path, size FROM adf_files WHERE path LIKE 'mind/%'", (rows) => rows, []), memoryTokens = Math.round(mindFiles.reduce((n, f) => n + memoryBytes(f.path, f.size), 0) / 4), tables = listLocalTables(q), localRows = 0;
+  for (let t of tables.slice(0, MAX_TABLES)) localRows += safe(q, `SELECT COUNT(*) AS n FROM "${t}"`, (r) => firstNumber2(r), 0);
+  let summaryScan = readSummaryScan(q, prior);
+  return {
+    maturity: {
+      contextsWorked: readContextsWorked(q, cheap.config, summaryScan),
+      filesWritten,
+      memoryTokens,
+      localTables: tables.length,
+      localRows,
+      skills: agentSkills.size
+    },
+    summaryScan
+  };
+}
+var WEEK_MS = 10080 * 60 * 1e3, approxTokens = (bytes) => Math.round(bytes / 4), DAY_MS2 = 1440 * 60 * 1e3;
+function readMemoryStrata(q, now2 = Date.now()) {
+  let since = (days) => new Date(now2 - days * DAY_MS2).toISOString(), week = since(MEMORY_STRATA_DAYS.week), month = since(MEMORY_STRATA_DAYS.month), quarter = since(MEMORY_STRATA_DAYS.quarter), bytes = { older: 0, quarter: 0, month: 0, week: 0 }, rows = safe(q, "SELECT path, size, updated_at FROM adf_files WHERE path LIKE 'mind/%'", (r) => r, []);
+  for (let r of rows) {
+    let at = String(r.updated_at ?? ""), band = at >= week ? "week" : at >= month ? "month" : at >= quarter ? "quarter" : "older";
+    bytes[band] += memoryBytes(r.path, r.size);
+  }
+  return { older: approxTokens(bytes.older), quarter: approxTokens(bytes.quarter), month: approxTokens(bytes.month), week: approxTokens(bytes.week) };
+}
+function readContents(q, files, agentSkills, now2 = Date.now()) {
+  let weekAgo = now2 - WEEK_MS, mindFiles = 0, mindBytes = 0, mindRecent = 0, skillBytes = 0;
+  for (let f of files) {
+    let size = typeof f.size == "number" && Number.isFinite(f.size) ? f.size : 0;
+    if (f.path.startsWith("mind/")) {
+      mindFiles++, mindBytes += memoryBytes(f.path, size), Date.parse(f.updated_at) >= weekAgo && mindRecent++;
+      continue;
+    }
+    let skill = SKILL_FILE.exec(f.path)?.[1];
+    skill && agentSkills.has(skill) && (skillBytes += size);
+  }
+  let tables = listLocalTables(q).slice(0, MAX_TABLES), rows = 0;
+  for (let t of tables) rows += safe(q, `SELECT COUNT(*) AS n FROM "${t}"`, (r) => firstNumber2(r), 0);
+  return {
+    mind: { files: mindFiles, tokens: approxTokens(mindBytes), updatedThisWeek: mindRecent, strata: readMemoryStrata(q, now2) },
+    skills: { count: agentSkills.size, tokens: approxTokens(skillBytes) },
+    tables: { count: tables.length, rows }
+  };
+}
+function upcomingText(v) {
+  if (!(typeof v != "string" || !v.trim()))
+    return v.length > 1e3 ? `${v.slice(0, 999)}\u2026` : v;
+}
+function readUpcoming(q) {
+  let readTimers = (cols, where) => safe(q, `SELECT ${cols} FROM adf_timers ${where} ORDER BY next_wake_at LIMIT 3`, (r) => r, null);
+  return (readTimers("id, next_wake_at, scope, payload, lambda, loop", "WHERE expired = 0") ?? readTimers("id, next_wake_at, scope, payload, lambda, NULL AS loop", "WHERE expired = 0") ?? readTimers("id, next_wake_at, scope, payload, lambda, NULL AS loop", "") ?? []).map((t) => {
+    let scope = "system";
+    try {
+      let parsed = JSON.parse(t.scope ?? "[]");
+      Array.isArray(parsed) && parsed[0] === "agent" && (scope = "agent");
+    } catch {
+    }
+    let text2 = upcomingText(t.payload);
+    return scope === "agent" ? { id: t.id, at: t.next_wake_at, scope, loop: t.loop || "main", ...text2 ? { prompt: text2 } : {} } : { id: t.id, at: t.next_wake_at, scope, ...t.lambda ? { lambda: t.lambda } : {}, ...text2 ? { input: text2 } : {} };
+  });
+}
+function readActivityHeavy(q, now2, prior) {
+  let createdAt = safe(
+    q,
+    "SELECT COALESCE((SELECT value FROM adf_meta WHERE key = 'adf_created_at'), (SELECT json_extract(config_json, '$.metadata.created_at') FROM adf_config WHERE id = 1)) AS v",
+    (r) => r[0]?.v ?? null,
+    null
+  ), cutoff = agentWriteCutoff(createdAt), files = safe(q, "SELECT path, updated_at, size FROM adf_files", (rows) => rows, []), { agentSkills } = classifyFiles(files, cutoff, readRegistrySkills(q)), { daily, scan } = readDailyActivity(q, now2, prior);
+  return { daily, contents: readContents(q, files, agentSkills, now2), dayScan: scan };
+}
+var LIVE_MIN_INTERVAL_MS = 2e3, HEAVY_MIN_AGE_MS = 3e4, SUMMARY_SCAN_CHUNK = 2e3, DAY_SCAN_CHUNK = 2e3, FORCE_MIN_INTERVAL_MS = 2e3, AgentVitalsService = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  // Ghost metadata cache, keyed by file path. Two jobs:
+  // 1. Perf — the 5s fleet poll would otherwise open every offline agent's
+  //    SQLite each cycle; unchanged mtime serves from memory.
+  // 2. Stability — a peek can fail transiently (SQLITE_BUSY while an agent
+  //    is mass-starting and writing its own file). Serving the last good
+  //    meta instead of dropping the entry stops agents blinking off the map.
+  fleetMetaCache = /* @__PURE__ */ new Map();
+  // First-observed time of each agent's current status line (for status age)
+  statusSinceMap = /* @__PURE__ */ new Map();
+  /** Last fleet result, for the spawned-children count. */
+  lastFleet = null;
+  lastFleetAt = 0;
+  slowCache = /* @__PURE__ */ new Map();
+  activityCache = /* @__PURE__ */ new Map();
+  /**
+   * Per-row adf_loop scan of the activity window per file, shared by the
+   * vitals (7-day cost) and activity (per-day chart) reads; makes the next
+   * one incremental.
+   */
+  dayScans = /* @__PURE__ */ new Map();
+  /** In-flight cold day scans, so a vitals and an activity read share one. */
+  dayScanWarming = /* @__PURE__ */ new Map();
+  /** Last compaction-summary scan per file; makes the next one incremental. */
+  summaryScans = /* @__PURE__ */ new Map();
+  workspaceIds = /* @__PURE__ */ new WeakMap();
+  nextWorkspaceId = 1;
+  now() {
+    return this.deps.now ? this.deps.now() : Date.now();
+  }
+  peekFleetMetaCached(filePath) {
+    let mtimeMs;
+    try {
+      mtimeMs = statSync10(filePath).mtimeMs;
+    } catch {
+      return this.fleetMetaCache.delete(filePath), null;
+    }
+    let cached = this.fleetMetaCache.get(filePath);
+    if (cached && cached.mtimeMs === mtimeMs) return cached.meta;
+    let meta = AdfDatabase.peekFleetMeta(filePath);
+    return meta ? (this.fleetMetaCache.set(filePath, { mtimeMs, meta }), meta) : cached?.meta ?? null;
+  }
+  // Fleet map: live mesh agents plus on-disk .adf files in tracked
+  // directories that have no running executor ("ghost" nodes). Works even
+  // with the mesh disabled — every on-disk agent is then a ghost.
+  async getFleetStatus() {
+    let deps = this.deps, running = deps.isMeshRunning(), agents = deps.getLiveMeshAgents().map((a) => {
+      let ctx = deps.getContextGauge(a.filePath);
+      return {
+        ...a,
+        online: !0,
+        contextTokens: ctx && ctx.tokens > 0 ? ctx.tokens : void 0,
+        contextThreshold: ctx && ctx.tokens > 0 ? ctx.threshold : void 0,
+        // Standing boundary links — open WS pipes render as dashed channel
+        // edges to the perimeter, distinct from request traffic
+        wsConnections: deps.getWsConnectionCount(a.filePath)
+      };
+    }), trackedDirs2 = deps.getTrackedDirectories(), maxDepth = deps.getMaxScanDepth(), seen = new Set(agents.map((a) => canonicalizePath(a.filePath))), findGhostTrackedDirRoot = (filePath) => {
+      let canonFile = canonicalizePath(filePath), longestMatch, longestLen = -1;
+      for (let dir of trackedDirs2) {
+        let canonDir = canonicalizePath(dir);
+        containsPath(canonDir, canonFile) && canonDir.length > longestLen && (longestMatch = dir, longestLen = canonDir.length);
+      }
+      return longestMatch;
+    }, liveExecStates = /* @__PURE__ */ new Map();
+    for (let s of deps.getLiveExecStates()) liveExecStates.set(canonicalizePath(s.filePath), s.state);
+    let liveWorkspaces = /* @__PURE__ */ new Map();
+    for (let w of deps.getOpenWorkspaces()) liveWorkspaces.set(canonicalizePath(w.filePath), w.workspace);
+    for (let dir of trackedDirs2) {
+      let filePaths = await deps.listAdfFiles(dir, maxDepth);
+      for (let filePath of filePaths) {
+        let canon2 = canonicalizePath(filePath);
+        if (seen.has(canon2)) continue;
+        seen.add(canon2);
+        let openWorkspace = liveWorkspaces.get(canon2), meta = (openWorkspace ? liveFleetMeta(openWorkspace) : null) ?? this.peekFleetMetaCached(filePath);
+        if (!meta) continue;
+        let live = liveExecStates.get(canon2), isLive = live !== void 0 && live !== "off", ctx = isLive ? deps.getContextGauge(filePath) : void 0;
+        agents.push({
+          filePath,
+          handle: meta.handle || deriveHandle(filePath),
+          did: meta.did ?? void 0,
+          agentId: meta.agentId ?? void 0,
+          parentDid: meta.parentDid ?? void 0,
+          didHistory: meta.didHistory.length > 0 ? meta.didHistory : void 0,
+          icon: meta.icon ?? void 0,
+          state: isLive ? live : "off",
+          status: meta.status ?? void 0,
+          model: meta.model ?? void 0,
+          trackedDirRoot: findGhostTrackedDirRoot(filePath),
+          createdAt: meta.createdAt ?? void 0,
+          participating: !1,
+          online: isLive,
+          contextTokens: ctx && ctx.tokens > 0 ? ctx.tokens : void 0,
+          contextThreshold: ctx && ctx.tokens > 0 ? ctx.threshold : void 0
+        });
+      }
+    }
+    let now2 = this.now();
+    for (let a of agents) {
+      if (!a.status) {
+        this.statusSinceMap.delete(a.filePath);
+        continue;
+      }
+      let prev = this.statusSinceMap.get(a.filePath);
+      (!prev || prev.value !== a.status) && this.statusSinceMap.set(a.filePath, { value: a.status, since: now2 }), a.statusSince = this.statusSinceMap.get(a.filePath).since;
+    }
+    return this.lastFleet = agents, this.lastFleetAt = now2, { running, agents };
+  }
+  /**
+   * Redo the fleet scan behind agentsSpawned when it is missing or older than
+   * `maxAgeMs` (always when `force`). Studio's fleet map polls it anyway; a
+   * vitals read with the map closed, or from the daemon, refreshes it here so
+   * the Experience level does not depend on which screen was opened first.
+   */
+  async ensureFleetScan(maxAgeMs, force = !1) {
+    !force && this.lastFleet && this.now() - this.lastFleetAt <= maxAgeMs || await this.getFleetStatus();
+  }
+  findOpenWorkspace(filePath) {
+    let canon2 = canonicalizePath(filePath), found;
+    for (let w of this.deps.getOpenWorkspaces())
+      canonicalizePath(w.filePath) === canon2 && (found = w.workspace);
+    return found;
+  }
+  workspaceId(ws) {
+    let id = this.workspaceIds.get(ws);
+    return id === void 0 && (id = this.nextWorkspaceId++, this.workspaceIds.set(ws, id)), id;
+  }
+  /** Drop the cached slow part (e.g. after a config change made elsewhere). */
+  invalidate(filePath) {
+    filePath ? (this.slowCache.delete(filePath), this.activityCache.delete(filePath), this.dayScans.delete(filePath), this.summaryScans.delete(filePath)) : (this.slowCache.clear(), this.activityCache.clear(), this.dayScans.clear(), this.summaryScans.clear());
+  }
+  /**
+   * One cached read in two parts against one connection. Live agents: keyed by
+   * the connection's total_changes() (any write — a finished turn, a config
+   * change — bumps it), re-read at most every LIVE_MIN_INTERVAL_MS. Files
+   * nobody has open: keyed by the file's and its WAL's mtime/size, read with
+   * one readonly peek. A new key re-reads `cheap`; `heavy` (the scans) is
+   * reused until it is HEAVY_MIN_AGE_MS old. `force` re-reads `cheap` always
+   * and `heavy` unless it is younger than FORCE_MIN_INTERVAL_MS. `salt` (the
+   * activity read's local day) drops both when it changes.
+   */
+  async splitRead(cache2, filePath, force, readCheap, readHeavy, salt = "") {
+    await new Promise((resolve15) => setImmediate(resolve15));
+    let ws = this.findOpenWorkspace(filePath), cached = cache2.get(filePath), fresh = cached && cached.salt === salt ? cached : void 0, now2 = this.now(), key;
+    if (ws) {
+      if (!force && fresh?.key.startsWith("live:") && now2 - fresh.at < LIVE_MIN_INTERVAL_MS) return { entry: fresh, live: !0 };
+      let changes = safe(ws.querySQL.bind(ws), "SELECT total_changes() AS n", (r) => firstNumber2(r), -1);
+      key = `live:${this.workspaceId(ws)}:${changes}`;
+    } else {
+      let [main, wal] = await Promise.all([
+        fsp4.stat(filePath),
+        fsp4.stat(`${filePath}-wal`).catch(() => null)
+      ]);
+      key = `file:${main.mtimeMs}:${main.size}:${wal?.mtimeMs ?? 0}:${wal?.size ?? 0}`;
+    }
+    if (!force && fresh && fresh.key === key)
+      return ws && (fresh.at = now2), { entry: fresh, live: !!ws };
+    let heavyAge = fresh ? now2 - fresh.heavyAt : 1 / 0, reuseHeavy = fresh !== void 0 && heavyAge < (force ? FORCE_MIN_INTERVAL_MS : HEAVY_MIN_AGE_MS), run2 = (q) => {
+      let cheap = readCheap(q);
+      return { cheap, heavy: reuseHeavy ? fresh.heavy : readHeavy(q, cheap) };
+    };
+    try {
+      let { cheap, heavy } = ws ? run2((sql, params) => ws.querySQL(sql, params)) : AdfDatabase.peek(filePath, (db) => run2((sql, params) => db.prepare(sql).all(...params ?? []))), at = this.now(), entry = { key, salt, at, cheap, heavy, heavyAt: reuseHeavy ? fresh.heavyAt : at };
+      return cache2.set(filePath, entry), { entry, live: !!ws };
+    } catch (err) {
+      if (cached) return { entry: cached, live: !!ws };
+      throw err;
+    }
+  }
+  /**
+   * A live agent's first compaction-summary scan, in SUMMARY_SCAN_CHUNK seq
+   * ranges with the event loop free between them: the LIKE reads every user
+   * row's content, which on a long unbroken loop is tens of milliseconds.
+   * Later scans only read rows above the high-water mark.
+   */
+  async warmSummaryScan(filePath, ws) {
+    let q = (sql, params) => ws.querySQL(sql, params), maxSeq = safe(q, "SELECT MAX(seq) AS n FROM adf_loop", (r) => firstNumber2(r), 0), scan = { lastSeq: 0, hits: [] };
+    for (; scan.lastSeq < maxSeq; )
+      if (scan = readSummaryScan(q, scan, scan.lastSeq + SUMMARY_SCAN_CHUNK), await new Promise((resolve15) => setImmediate(resolve15)), this.findOpenWorkspace(filePath) !== ws) return;
+    this.summaryScans.has(filePath) || this.summaryScans.set(filePath, scan);
+  }
+  /**
+   * The first day scan of a file for the current window, in DAY_SCAN_CHUNK
+   * seq ranges with the event loop free between them: reading created_at
+   * walks each row's content overflow, about 3 ms per 1 000 rows. A live
+   * agent is read through its workspace; a closed file through one readonly
+   * peek per chunk. Later reads are incremental (refreshLoopDayScan).
+   * Concurrent callers share one warm-up.
+   */
+  warmDayScan(filePath) {
+    let since = windowStartMs(this.now());
+    if (this.dayScans.get(filePath)?.since === since) return Promise.resolve();
+    let warming = this.dayScanWarming.get(filePath);
+    return warming || (warming = this.runDayScanWarmUp(filePath, since).catch(() => {
+    }).finally(() => this.dayScanWarming.delete(filePath)), this.dayScanWarming.set(filePath, warming)), warming;
+  }
+  async runDayScanWarmUp(filePath, since) {
+    let ws = this.findOpenWorkspace(filePath), run2 = (read) => ws ? read((sql, params) => ws.querySQL(sql, params)) : AdfDatabase.peek(filePath, (db) => read((sql, params) => db.prepare(sql).all(...params ?? []))), scan = run2((q) => startLoopDayScan(q, since)), maxSeq = run2(maxLoopSeq);
+    for (; scan.lastSeq < maxSeq; ) {
+      if (await new Promise((resolve15) => setImmediate(resolve15)), this.findOpenWorkspace(filePath) !== ws) return;
+      let upTo = Math.min(maxSeq, scan.lastSeq + DAY_SCAN_CHUNK);
+      scan = run2((q) => scanLoopRows(q, scan, upTo));
+    }
+    this.dayScans.get(filePath)?.since !== since && this.dayScans.set(filePath, scan);
+  }
+  /** Children in the last fleet scan whose parent reference names this agent. */
+  countSpawned(meta) {
+    if (!this.lastFleet) return null;
+    let ids = /* @__PURE__ */ new Set([...meta.did ? [meta.did] : [], ...meta.didHistory, ...meta.agentId ? [meta.agentId] : []]);
+    return ids.size === 0 ? 0 : this.lastFleet.filter((a) => a.parentDid && ids.has(a.parentDid)).length;
+  }
+  async getAgentVitals(filePath, opts) {
+    let ws = this.findOpenWorkspace(filePath);
+    ws && !this.summaryScans.has(filePath) && await this.warmSummaryScan(filePath, ws), await this.warmDayScan(filePath);
+    let { entry, live } = await this.splitRead(
+      this.slowCache,
+      filePath,
+      !!opts?.force,
+      readVitalsCheapPart,
+      (q, cheap2) => {
+        let heavy2 = readVitalsHeavyPart(q, cheap2, this.summaryScans.get(filePath));
+        this.summaryScans.set(filePath, heavy2.summaryScan);
+        let { daily, scan } = readDailyActivity(q, this.now(), this.dayScans.get(filePath));
+        this.dayScans.set(filePath, scan);
+        let cost7d = recentCost(daily);
+        return cost7d ? { ...heavy2, cost7d } : heavy2;
+      }
+    ), { cheap, heavy } = entry, now2 = this.now(), createdMs = cheap.meta.createdAt ? Date.parse(cheap.meta.createdAt) : NaN, ageDays = Number.isFinite(createdMs) ? Math.max(0, (now2 - createdMs) / 864e5) : 0, maturity = {
+      ...heavy.maturity,
+      messages: cheap.messages,
+      agentsSpawned: this.countSpawned(cheap.meta),
+      ageDays
+    }, ctx = live ? this.deps.getContextGauge(filePath) : void 0, cost = heavy.cost7d;
+    return {
+      filePath,
+      computedAt: entry.at,
+      live,
+      handle: cheap.meta.handle || deriveHandle(filePath),
+      name: cheap.meta.name ?? void 0,
+      did: cheap.meta.did ?? void 0,
+      agentId: cheap.meta.agentId ?? void 0,
+      model: cheap.meta.model ?? void 0,
+      createdAt: cheap.meta.createdAt ?? void 0,
+      ageDays,
+      ...cheap.meta.status?.trim() ? { status: cheap.meta.status.trim() } : {},
+      ...cheap.card.description ? { description: cheap.card.description } : {},
+      public: cheap.card.public,
+      ownerVerified: cheap.card.ownerVerified,
+      contextTokens: ctx && ctx.tokens > 0 ? ctx.tokens : void 0,
+      contextThreshold: ctx && ctx.tokens > 0 ? ctx.threshold : void 0,
+      nextWakeAt: cheap.nextWakeAt,
+      cost7dUsd: cost ? cost.usd : void 0,
+      cost7dPartial: cost ? cost.partial : void 0,
+      metrics: cheap.metrics,
+      stats: scoreAgent(cheap.power, maturity),
+      maturity
+    };
+  }
+  /**
+   * The overview's lower sections: next wakes, 14 days of messages and cost
+   * per day (agent-daily.ts, from the file alone), and what the file holds
+   * (mind and skills with approximate tokens, local tables with rows). Cached
+   * like the vitals: wakes are the cheap part, days and contents the heavy one.
+   */
+  async getAgentActivity(filePath, opts) {
+    let now2 = this.now();
+    await this.warmDayScan(filePath);
+    let { entry, live } = await this.splitRead(
+      this.activityCache,
+      filePath,
+      !!opts?.force,
+      (q) => ({ upcoming: readUpcoming(q) }),
+      (q) => {
+        let { dayScan, ...read } = readActivityHeavy(q, this.now(), this.dayScans.get(filePath));
+        return this.dayScans.set(filePath, dayScan), read;
+      },
+      localDateKey(new Date(now2))
+    );
+    return { filePath, computedAt: entry.at, live, upcoming: entry.cheap.upcoming, ...entry.heavy };
+  }
+};
+
+// src/main/runtime/display-state.ts
+function toDisplayState(executorState) {
+  switch (executorState) {
+    case "thinking":
+    case "tool_use":
+      return "active";
+    case "idle":
+      return "idle";
+    case "awaiting_approval":
+    case "awaiting_ask":
+    case "suspended":
+      return "suspended";
+    case "error":
+      return "error";
+    case "stopped":
+      return "off";
+    // ADF display states (pass-through from sys_set_state target)
+    case "active":
+    case "hibernate":
+    case "off":
+      return executorState;
+    default:
+      return "off";
+  }
+}
+
 // src/main/daemon/tracked-dirs.ts
-import { existsSync as existsSync21, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync21, statSync as statSync11 } from "node:fs";
 import { basename as basename12, isAbsolute as isAbsolute6 } from "node:path";
 var TrackedDirError = class extends Error {
   constructor(message, statusCode, details) {
@@ -122204,7 +124562,7 @@ function sameDir(a, b) {
 }
 function isDirectory(p) {
   try {
-    return existsSync21(p) && statSync10(p).isDirectory();
+    return existsSync21(p) && statSync11(p).isDirectory();
   } catch {
     return !1;
   }
@@ -122226,7 +124584,7 @@ function loadedUnder(runtime2, dir) {
 var PEEK_CACHE_MAX = 2e3, peekCache = /* @__PURE__ */ new Map();
 function statStamp(path) {
   try {
-    let st = statSync10(path);
+    let st = statSync11(path);
     return `${st.mtimeMs}:${st.size}`;
   } catch {
     return "-";
@@ -122380,6 +124738,76 @@ async function untrackDir(runtime2, settings2, input, opts = {}, onChanged) {
   return { removed: match, directories, unloaded };
 }
 
+// src/main/daemon/vitals-routes.ts
+var FLEET_SCAN_MAX_AGE_MS = 3e4;
+function canon(filePath) {
+  try {
+    return canonicalizePath(filePath);
+  } catch {
+    return filePath;
+  }
+}
+function createDaemonVitalsDeps(src) {
+  let live = () => src.runtime.listLiveAgents(), liveStates = () => live().map((a) => ({ filePath: a.filePath, state: toDisplayState(a.executorState) }));
+  return {
+    isMeshRunning: () => !!src.mesh?.isEnabled(),
+    getLiveMeshAgents: () => src.mesh?.isEnabled() ? overlayLiveStates(src.mesh.getAgentStatuses(), liveStates()) : [],
+    getTrackedDirectories: () => src.settings ? storedDirs(src.settings) : [],
+    getMaxScanDepth: () => src.settings ? maxDepthOf(src.settings) : 5,
+    listAdfFiles: async (dir, maxDepth) => src.runtime.scanAdfFiles([dir], maxDepth),
+    getContextGauge: (filePath) => {
+      let key = canon(filePath);
+      return live().find((a) => canon(a.filePath) === key)?.getContextGauge();
+    },
+    getWsConnectionCount: (filePath) => src.ws && src.ws.getConnections(filePath).length || void 0,
+    getLiveExecStates: liveStates,
+    getOpenWorkspaces: () => live().map((a) => ({ filePath: a.filePath, workspace: a.workspace }))
+  };
+}
+function resolveVitalsFile(id, runtime2, vitals, settings2) {
+  let loaded = runtime2.getAgent(id);
+  if (loaded) return { filePath: loaded.filePath };
+  if (!settings2) return;
+  let files = runtime2.scanAdfFiles(storedDirs(settings2), maxDepthOf(settings2)), byHandle;
+  for (let filePath of files) {
+    let meta = vitals.peekFleetMetaCached(filePath);
+    if (meta) {
+      if (meta.agentId === id) return { filePath };
+      !byHandle && meta.handle === id && (byHandle = filePath);
+    }
+  }
+  return byHandle ? { filePath: byHandle } : void 0;
+}
+function registerVitalsRoutes(server, deps) {
+  let target = (request, reply, what) => {
+    let force = request.query.force;
+    if (force !== void 0 && !["1", "0", "true", "false"].includes(force))
+      return reply.code(400).send({ error: "force must be 1, 0, true or false", code: "bad_request" }), null;
+    let found = resolveVitalsFile(request.params.id, deps.runtime, deps.vitals, deps.settings);
+    return found ? found.filePath ? { filePath: found.filePath, forced: force === "1" || force === "true" } : (reply.code(409).send({ error: `Agent has no .adf file; ${what} read from the file.`, code: "conflict" }), null) : (reply.code(404).send({ error: `Unknown agent "${request.params.id}"`, code: "not_found" }), null);
+  };
+  server.get("/agents/:id/vitals", async (request, reply) => {
+    let t = target(request, reply, "vitals are");
+    if (!t) return reply;
+    try {
+      return await deps.vitals.ensureFleetScan(FLEET_SCAN_MAX_AGE_MS, t.forced), await deps.vitals.getAgentVitals(t.filePath, { force: t.forced });
+    } catch (err) {
+      return fail2(reply, err);
+    }
+  }), server.get("/agents/:id/activity", async (request, reply) => {
+    let t = target(request, reply, "activity is");
+    if (!t) return reply;
+    try {
+      return await deps.vitals.getAgentActivity(t.filePath, { force: t.forced });
+    } catch (err) {
+      return fail2(reply, err);
+    }
+  });
+}
+function fail2(reply, err) {
+  return reply.code(500).send({ error: err instanceof Error ? err.message : String(err) });
+}
+
 // src/main/daemon/http-api.ts
 var AdapterAttachRequestSchema = external_exports.object({
   adapterType: external_exports.string(),
@@ -122469,7 +124897,16 @@ function createDaemonHttpApi(runtime2, opts = {}) {
     behindProxy: opts.security?.behindProxy ?? behindProxyFromEnv(),
     localProof: opts.security?.localProof ?? null
   };
-  server.post("/daemon/shutdown", async (request, reply) => requireLocalCaller(request, reply, localAccess, "The daemon can be stopped") ? opts.requestShutdown ? (setTimeout(() => opts.requestShutdown?.(), 50), reply.code(202).send({ accepted: !0, pid: process.pid })) : methodNotAllowed(reply, "Shutdown is not available on this daemon.") : reply), registerIdentityRoutes(server, { identity: opts.identity, agentFactory: opts.agentFactory, localAccess }), registerTemplateRoutes(server, { agentFactory: opts.agentFactory }), registerProviderRoutes(server, { settingsStore: opts.settingsStore, providerKeys: opts.providerKeys }), registerContextRoutes(server, runtime2), server.get("/events", async (request, reply) => {
+  server.post("/daemon/shutdown", async (request, reply) => requireLocalCaller(request, reply, localAccess, "The daemon can be stopped") ? opts.requestShutdown ? (setTimeout(() => opts.requestShutdown?.(), 50), reply.code(202).send({ accepted: !0, pid: process.pid })) : methodNotAllowed(reply, "Shutdown is not available on this daemon.") : reply), registerIdentityRoutes(server, { identity: opts.identity, agentFactory: opts.agentFactory, localAccess }), registerTemplateRoutes(server, { agentFactory: opts.agentFactory }), registerProviderRoutes(server, { settingsStore: opts.settingsStore, providerKeys: opts.providerKeys }), registerContextRoutes(server, runtime2), registerVitalsRoutes(server, {
+    runtime: runtime2,
+    settings: opts.settingsStore,
+    vitals: new AgentVitalsService(createDaemonVitalsDeps({
+      runtime: runtime2,
+      settings: opts.settingsStore,
+      mesh: opts.mesh,
+      ws: opts.wsService
+    }))
+  }), server.get("/events", async (request, reply) => {
     if (!opts.eventBus) return unavailable2(reply, "Event bus is not configured.");
     let bus = opts.eventBus, lastEventId = single2(request.headers["last-event-id"])?.trim(), sinceText = request.query.since ?? (lastEventId || void 0), since = parseOptionalInteger(sinceText);
     if (sinceText !== void 0 && since === void 0)
@@ -124013,6 +126450,7 @@ var DaemonHost = class {
   eventBus;
   wsService;
   networkService;
+  mesh;
   mcpPackageService;
   mcpPythonPackageService;
   adapterPackageService;
@@ -124029,7 +126467,7 @@ var DaemonHost = class {
   signalHandlersInstalled = !1;
   stopping = null;
   constructor(opts) {
-    this.runtime = opts.runtime, this.host = opts.host ?? "127.0.0.1", this.port = opts.port ?? 7385, this.token = opts.token ?? process.env.ADF_DAEMON_TOKEN ?? null, this.allowedHosts = opts.allowedHosts ?? parseAllowedHostsEnv(process.env.ADF_DAEMON_ALLOWED_HOSTS), this.behindProxy = opts.behindProxy, this.localProof = opts.localProof ?? null, this.pidFile = opts.pidFile, this.logger = opts.logger ?? !1, this.shutdownAgentTimeoutMs = opts.shutdownAgentTimeoutMs ?? envShutdownTimeoutMs() ?? DEFAULT_AGENT_UNLOAD_TIMEOUT_MS, this.computeService = opts.computeService, this.settingsStore = opts.settingsStore, this.eventBus = opts.eventBus, this.wsService = opts.wsService, this.networkService = opts.networkService, this.mcpPackageService = opts.mcpPackageService, this.mcpPythonPackageService = opts.mcpPythonPackageService, this.adapterPackageService = opts.adapterPackageService, this.sandboxPackageService = opts.sandboxPackageService, this.identity = opts.identity, this.providerKeys = opts.providerKeys, this.agentFactory = opts.agentFactory, this.requestShutdown = opts.requestShutdown, this.onTrackedDirectoriesChanged = opts.onTrackedDirectoriesChanged, this.onShutdownStart = opts.onShutdownStart ?? [], this.onShutdown = opts.onShutdown ?? [], this.shouldInstallSignalHandlers = opts.installSignalHandlers ?? !0;
+    this.runtime = opts.runtime, this.host = opts.host ?? "127.0.0.1", this.port = opts.port ?? 7385, this.token = opts.token ?? process.env.ADF_DAEMON_TOKEN ?? null, this.allowedHosts = opts.allowedHosts ?? parseAllowedHostsEnv(process.env.ADF_DAEMON_ALLOWED_HOSTS), this.behindProxy = opts.behindProxy, this.localProof = opts.localProof ?? null, this.pidFile = opts.pidFile, this.logger = opts.logger ?? !1, this.shutdownAgentTimeoutMs = opts.shutdownAgentTimeoutMs ?? envShutdownTimeoutMs() ?? DEFAULT_AGENT_UNLOAD_TIMEOUT_MS, this.computeService = opts.computeService, this.settingsStore = opts.settingsStore, this.eventBus = opts.eventBus, this.wsService = opts.wsService, this.networkService = opts.networkService, this.mesh = opts.mesh, this.mcpPackageService = opts.mcpPackageService, this.mcpPythonPackageService = opts.mcpPythonPackageService, this.adapterPackageService = opts.adapterPackageService, this.sandboxPackageService = opts.sandboxPackageService, this.identity = opts.identity, this.providerKeys = opts.providerKeys, this.agentFactory = opts.agentFactory, this.requestShutdown = opts.requestShutdown, this.onTrackedDirectoriesChanged = opts.onTrackedDirectoriesChanged, this.onShutdownStart = opts.onShutdownStart ?? [], this.onShutdown = opts.onShutdown ?? [], this.shouldInstallSignalHandlers = opts.installSignalHandlers ?? !0;
   }
   async start() {
     if (this.server) return { host: this.host, port: this.port };
@@ -124045,6 +126483,7 @@ var DaemonHost = class {
       eventBus: this.eventBus,
       wsService: this.wsService,
       networkService: this.networkService,
+      mesh: this.mesh,
       mcpPackageService: this.mcpPackageService,
       mcpPythonPackageService: this.mcpPythonPackageService,
       adapterPackageService: this.adapterPackageService,
@@ -124251,7 +126690,7 @@ var DaemonEventBus = class {
 
 // src/main/daemon/file-settings-store.ts
 import { dirname as dirname17, join as join37 } from "node:path";
-import { existsSync as existsSync23, mkdirSync as mkdirSync17, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync17, statSync as statSync12 } from "node:fs";
 
 // src/shared/constants/compute-defaults.ts
 var DEFAULT_COMPUTE_SETTINGS = {
@@ -124324,11 +126763,17 @@ function createSettingsDefaults() {
     uiFontCustom: "",
     // Electron zoom factor for the whole window (1 = 100%).
     uiScale: 1,
+    // Small agent avatars: 'orbital' (generated from the DID) or 'emoji'
+    // (config.icon). The home and Overview orbitals ignore it.
+    agentAvatars: "orbital",
     globalSystemPrompt: DEFAULT_BASE_PROMPT,
     // Dynamic instruction templates share the toolPrompts record (dyn_ keys)
     // so they ride the existing settings→executor plumbing.
     toolPrompts: { ...DEFAULT_TOOL_PROMPTS, ...DEFAULT_DYNAMIC_PROMPTS },
     compactionPrompt: DEFAULT_COMPACTION_PROMPT,
+    // On = a release that changes any shipped prompt overwrites all three
+    // prompt keys above (settings-migrations applyPromptUpdates).
+    autoApplyPromptUpdates: !1,
     trackedDirectories: [],
     // Empty = built-in default (Documents/adf-agents), resolved on demand.
     agentsFolder: "",
@@ -124336,6 +126781,9 @@ function createSettingsDefaults() {
     // focused. On by default: an agent blocked on a human the user cannot see
     // is exactly the failure this exists to prevent.
     nativeNotificationsEnabled: !0,
+    // macOS menu bar icon: running agents, requests waiting on the user, and
+    // today's tokens, reachable with the window closed.
+    menuBarEnabled: !0,
     // Owner opt-outs for traffic Studio starts on its own: the background
     // update check (GitHub Releases), the MCP / agent registry fetches (GitHub
     // raw), and provider connection checks. Off = no request; see docs/NETWORK.md.
@@ -124374,9 +126822,29 @@ Your private working memory (\`mind.md\`), snapshotted at the start of each sess
 function applySettingsMigrations(data) {
   let changedKeys = /* @__PURE__ */ new Set();
   migrateBuiltInAdapters(data) && changedKeys.add("adapters"), migrateComputeDefaults(data) && changedKeys.add("compute"), migrateToolPrompts(data) && changedKeys.add("toolPrompts"), migrateSkillsPromptPlaceholder(data) && changedKeys.add("toolPrompts"), migrateGlobalSystemPromptSoul(data) && changedKeys.add("globalSystemPrompt"), migrateGlobalSystemPromptMind(data) && changedKeys.add("globalSystemPrompt");
+  for (let key of applyPromptUpdates(data)) changedKeys.add(key);
   for (let key of migrateUiFontBrandDefault(data)) changedKeys.add(key);
   return { changed: changedKeys.size > 0, changedKeys: [...changedKeys] };
 }
+var PROMPT_AUTO_UPDATE_KEY = "autoApplyPromptUpdates", PROMPT_DEFAULTS_APPLIED_KEY = "promptDefaultsApplied";
+function currentPromptDefaults() {
+  return {
+    globalSystemPrompt: DEFAULT_BASE_PROMPT,
+    compactionPrompt: DEFAULT_COMPACTION_PROMPT,
+    toolPrompts: { ...DEFAULT_TOOL_PROMPTS, ...DEFAULT_DYNAMIC_PROMPTS }
+  };
+}
+function promptDefaultsFingerprint() {
+  let text2 = JSON.stringify(currentPromptDefaults()), hash = 2166136261;
+  for (let i = 0; i < text2.length; i++)
+    hash ^= text2.charCodeAt(i), hash = Math.imul(hash, 16777619);
+  return (hash >>> 0).toString(16).padStart(8, "0") + ":" + text2.length;
+}
+function applyPromptUpdates(data) {
+  if (data[PROMPT_AUTO_UPDATE_KEY] !== !0) return [];
+  let fingerprint = promptDefaultsFingerprint();
+  return data[PROMPT_DEFAULTS_APPLIED_KEY] === fingerprint ? [] : (Object.assign(data, currentPromptDefaults()), data[PROMPT_DEFAULTS_APPLIED_KEY] = fingerprint, console.log("[Settings] Applied updated default prompts"), ["globalSystemPrompt", "compactionPrompt", "toolPrompts", PROMPT_DEFAULTS_APPLIED_KEY]);
+}
 var UI_FONT_BRAND_MIGRATION_KEY = "uiFontBrandDefaultApplied";
 function migrateUiFontBrandDefault(data) {
   return data[UI_FONT_BRAND_MIGRATION_KEY] === !0 ? [] : (data[UI_FONT_BRAND_MIGRATION_KEY] = !0, data.uiFont === void 0 || data.uiFont === "system" ? (data.uiFont = "inter-tight", [UI_FONT_BRAND_MIGRATION_KEY, "uiFont"]) : [UI_FONT_BRAND_MIGRATION_KEY]);
@@ -124452,7 +126920,7 @@ function recordQuarantine(originalPath, quarantinedTo) {
 }
 function fileFingerprint(path) {
   try {
-    let s = statSync11(path);
+    let s = statSync12(path);
     return { mtimeMs: s.mtimeMs, size: s.size };
   } catch {
     return { mtimeMs: 0, size: 0 };
@@ -124696,7 +127164,9 @@ setMandatoryReasoningPersister((modelId) => {
 });
 var basePrompt = settings.get("globalSystemPrompt") ?? "", toolPrompts = settings.get("toolPrompts") ?? {}, compactionPrompt = settings.get("compactionPrompt") ?? void 0, trackedDirs = settings.get("trackedDirectories") ?? [], codeSandboxService = new CodeSandboxService();
 codeSandboxService.setMaxWorkers(settings.get("sandboxMaxWorkers"));
-var sandboxPackagesService = new SandboxPackagesService(), sandboxStdlibService = new SandboxStdlibService(), podmanService = new PodmanService();
+var sandboxPackagesService = new SandboxPackagesService();
+codeSandboxService.setUserPackages(sandboxPackagesService.getBasePath(), () => (settings.get("sandboxPackages") ?? []).map((p) => p.name));
+var sandboxStdlibService = new SandboxStdlibService(), podmanService = new PodmanService();
 setManagedBrowserEnsurer((containerName) => podmanService.ensureManagedBrowserUp(containerName));
 podmanService.setSettingsAccessor(() => readComputeSettings(settings.get("compute")));
 var uvManager = new UvManager(), mcpPackageResolver = new PackageResolver("mcp-servers"), adapterPackageResolver = new PackageResolver("channel-adapters"), uvxPackageResolver = new UvxPackageResolver(uvManager);
@@ -124712,6 +127182,7 @@ settings.get("meshEnabled") !== !1 && meshManager.enableMesh();
 var agentRuntimeBuilder = new AgentRuntimeBuilder({
   settings,
   codeSandboxService,
+  sandboxPackagesService,
   podmanService,
   credentialEnvelopeLockedHint: daemonEncKey ? `Make the owner identity available (\`adf identity restore\` / \`adf identity unlock\`, or /identity in the TUI), or add this daemon's runtime key (${daemonEncKey.pubKeyPath}) to Studio's trusted daemon keys (trustedDaemonEncKeys) and open the agent in Studio once.` : void 0,
   wsConnectionManager,
@@ -124772,6 +127243,7 @@ var loadedAgentEvents = /* @__PURE__ */ new Map(), agentFactory = new DaemonAgen
   providerKeys: ownerIdentity.providerKeys,
   eventBus,
   wsService: wsConnectionManager,
+  mesh: meshManager,
   networkService: {
     getStatus: () => ({
       meshEnabled: meshManager.isEnabled(),