@runweave/server-darwin-x64 0.1.2 → 0.1.4

package/payload/app-server/index.cjs

@@ -1,4 +1,4 @@
-/* runweave:build-info */var __RUNWEAVE_BUILD_INFO__={"version":"0.1.0","buildId":"20261101T021552392Z-f96ecff6","sourceRevision":"f96ecff6b81b7dfd1d421a0bc3dada24bf1d5fa1","sourceDirty":false,"builtAt":"2026-11-01T02:15:52.392Z","contentSha256":"12d69ee2a5501059b7d0c43f5b9b10f0f3c5a18c5b259c6d8fd2e1ced4285668"};
+/* runweave:build-info */var __RUNWEAVE_BUILD_INFO__={"version":"0.1.0","buildId":"20261107T223319383Z-f6afc191","sourceRevision":"f6afc191b5f9be76aa35a6ee494a0d752c21af08","sourceDirty":false,"builtAt":"2026-11-07T22:33:19.383Z","contentSha256":"c391a00b597ca25406e1b3afa7654d2fa4ecc180b3a685c649dbd2acd40c8900"};
 const __IMPORT_META_URL__ = require('url').pathToFileURL(__filename).href;
 "use strict";
 var __create = Object.create;
@@ -25745,13 +25745,13 @@ var require_view = __commonJS({
     View.prototype.resolve = function resolve2(dir, file) {
       var ext = this.ext;
       var path22 = join(dir, file);
-      var stat2 = tryStat(path22);
-      if (stat2 && stat2.isFile()) {
+      var stat3 = tryStat(path22);
+      if (stat3 && stat3.isFile()) {
         return path22;
       }
       path22 = join(dir, basename(file, ext), "index" + ext);
-      stat2 = tryStat(path22);
-      if (stat2 && stat2.isFile()) {
+      stat3 = tryStat(path22);
+      if (stat3 && stat3.isFile()) {
         return path22;
       }
     };
@@ -26021,9 +26021,9 @@ var require_etag = __commonJS({
       }
       return obj && typeof obj === "object" && "ctime" in obj && toString.call(obj.ctime) === "[object Date]" && "mtime" in obj && toString.call(obj.mtime) === "[object Date]" && "ino" in obj && typeof obj.ino === "number" && "size" in obj && typeof obj.size === "number";
     }
-    function stattag(stat2) {
-      var mtime = stat2.mtime.getTime().toString(16);
-      var size = stat2.size.toString(16);
+    function stattag(stat3) {
+      var mtime = stat3.mtime.getTime().toString(16);
+      var size = stat3.size.toString(16);
       return '"' + size + "-" + mtime + '"';
     }
   }
@@ -26636,8 +26636,8 @@ var require_send = __commonJS({
       this.sendFile(path22);
       return res;
     };
-    SendStream.prototype.send = function send3(path22, stat2) {
-      var len = stat2.size;
+    SendStream.prototype.send = function send3(path22, stat3) {
+      var len = stat3.size;
       var options = this.options;
       var opts = {};
       var res = this.res;
@@ -26649,7 +26649,7 @@ var require_send = __commonJS({
         return;
       }
       debug('pipe "%s"', path22);
-      this.setHeader(path22, stat2);
+      this.setHeader(path22, stat3);
       this.type(path22);
       if (this.isConditionalGET()) {
         if (this.isPreconditionFailure()) {
@@ -26705,14 +26705,14 @@ var require_send = __commonJS({
       var i = 0;
       var self = this;
       debug('stat "%s"', path22);
-      fs.stat(path22, function onstat(err, stat2) {
+      fs.stat(path22, function onstat(err, stat3) {
         if (err && err.code === "ENOENT" && !extname(path22) && path22[path22.length - 1] !== sep) {
           return next(err);
         }
         if (err) return self.onStatError(err);
-        if (stat2.isDirectory()) return self.redirect(path22);
-        self.emit("file", path22, stat2);
-        self.send(path22, stat2);
+        if (stat3.isDirectory()) return self.redirect(path22);
+        self.emit("file", path22, stat3);
+        self.send(path22, stat3);
       });
       function next(err) {
         if (self._extensions.length <= i) {
@@ -26720,11 +26720,11 @@ var require_send = __commonJS({
         }
         var p = path22 + "." + self._extensions[i++];
         debug('stat "%s"', p);
-        fs.stat(p, function(err2, stat2) {
+        fs.stat(p, function(err2, stat3) {
           if (err2) return next(err2);
-          if (stat2.isDirectory()) return next();
-          self.emit("file", p, stat2);
-          self.send(p, stat2);
+          if (stat3.isDirectory()) return next();
+          self.emit("file", p, stat3);
+          self.send(p, stat3);
         });
       }
     };
@@ -26738,11 +26738,11 @@ var require_send = __commonJS({
         }
         var p = join(path22, self._index[i]);
         debug('stat "%s"', p);
-        fs.stat(p, function(err2, stat2) {
+        fs.stat(p, function(err2, stat3) {
           if (err2) return next(err2);
-          if (stat2.isDirectory()) return next();
-          self.emit("file", p, stat2);
-          self.send(p, stat2);
+          if (stat3.isDirectory()) return next();
+          self.emit("file", p, stat3);
+          self.send(p, stat3);
         });
       }
       next();
@@ -26777,9 +26777,9 @@ var require_send = __commonJS({
       debug("content-type %s", type2);
       res.setHeader("Content-Type", type2 + (charset ? "; charset=" + charset : ""));
     };
-    SendStream.prototype.setHeader = function setHeader(path22, stat2) {
+    SendStream.prototype.setHeader = function setHeader(path22, stat3) {
       var res = this.res;
-      this.emit("headers", res, path22, stat2);
+      this.emit("headers", res, path22, stat3);
       if (this._acceptRanges && !res.getHeader("Accept-Ranges")) {
         debug("accept ranges");
         res.setHeader("Accept-Ranges", "bytes");
@@ -26793,12 +26793,12 @@ var require_send = __commonJS({
         res.setHeader("Cache-Control", cacheControl);
       }
       if (this._lastModified && !res.getHeader("Last-Modified")) {
-        var modified = stat2.mtime.toUTCString();
+        var modified = stat3.mtime.toUTCString();
         debug("modified %s", modified);
         res.setHeader("Last-Modified", modified);
       }
       if (this._etag && !res.getHeader("ETag")) {
-        var val = etag(stat2);
+        var val = etag(stat3);
         debug("etag %s", val);
         res.setHeader("ETag", val);
       }
@@ -33560,16 +33560,16 @@ async function scanConversationSource(file, consume, signal) {
   try {
     if (await (0, import_promises.realpath)(file) !== file) return null;
     handle = await (0, import_promises.open)(file, import_node_fs2.constants.O_RDONLY | import_node_fs2.constants.O_NOFOLLOW);
-    const stat2 = await handle.stat();
-    if (!stat2.isFile()) return null;
+    const stat3 = await handle.stat();
+    if (!stat3.isFile()) return null;
     const windowBytes = 64 * 1024 * 1024;
-    const truncated = stat2.size > windowBytes;
+    const truncated = stat3.size > windowBytes;
     let partial = truncated;
     const chunk = Buffer.alloc(256 * 1024);
     const ranges = truncated ? [
-      { start: 0, end: Math.min(chunk.length, stat2.size), header: true },
-      { start: stat2.size - windowBytes, end: stat2.size, header: false }
-    ] : [{ start: 0, end: stat2.size, header: false }];
+      { start: 0, end: Math.min(chunk.length, stat3.size), header: true },
+      { start: stat3.size - windowBytes, end: stat3.size, header: false }
+    ] : [{ start: 0, end: stat3.size, header: false }];
     for (const range of ranges) {
       let position = range.start;
       let lineOffset = position;
@@ -34558,15 +34558,15 @@ var ConfigurationError = class extends Error {
 // packages/config-node/src/private-file.ts
 var import_node_fs4 = require("node:fs");
 function assertPrivateDirectory(directory) {
-  const stat2 = (0, import_node_fs4.lstatSync)(directory);
-  if (!stat2.isDirectory() || stat2.isSymbolicLink() || stat2.mode & 63 || typeof process.getuid === "function" && stat2.uid !== process.getuid()) throw new ConfigurationError("CONFIG_ROOT_PERMISSIONS_INVALID");
+  const stat3 = (0, import_node_fs4.lstatSync)(directory);
+  if (!stat3.isDirectory() || stat3.isSymbolicLink() || stat3.mode & 63 || typeof process.getuid === "function" && stat3.uid !== process.getuid()) throw new ConfigurationError("CONFIG_ROOT_PERMISSIONS_INVALID");
 }
 function assertPrivateDescriptor(fd, maxBytes = 1024 * 1024) {
-  const stat2 = (0, import_node_fs4.fstatSync)(fd);
-  if (!stat2.isFile() || stat2.nlink !== 1) throw new ConfigurationError("CONFIG_FILE_NOT_PRIVATE_REGULAR");
-  if (typeof process.getuid === "function" && stat2.uid !== process.getuid()) throw new ConfigurationError("CONFIG_FILE_OWNER_MISMATCH");
-  if (stat2.mode & 63) throw new ConfigurationError("CONFIG_FILE_PERMISSIONS_INVALID");
-  if (stat2.size > maxBytes) throw new ConfigurationError("CONFIG_FILE_TOO_LARGE");
+  const stat3 = (0, import_node_fs4.fstatSync)(fd);
+  if (!stat3.isFile() || stat3.nlink !== 1) throw new ConfigurationError("CONFIG_FILE_NOT_PRIVATE_REGULAR");
+  if (typeof process.getuid === "function" && stat3.uid !== process.getuid()) throw new ConfigurationError("CONFIG_FILE_OWNER_MISMATCH");
+  if (stat3.mode & 63) throw new ConfigurationError("CONFIG_FILE_PERMISSIONS_INVALID");
+  if (stat3.size > maxBytes) throw new ConfigurationError("CONFIG_FILE_TOO_LARGE");
 }
 function readPrivateFile(file, maxBytes = 1024 * 1024) {
   const fd = (0, import_node_fs4.openSync)(file, import_node_fs4.constants.O_RDONLY | import_node_fs4.constants.O_NOFOLLOW);
@@ -34696,7 +34696,39 @@ function registerStableConfigurationRoot(context) {
     (0, import_node_fs6.closeSync)(registryFd);
   }
 }
+function withUpgradeGate(context, shared, run) {
+  const directory = ownerDirectory(context);
+  const fd = (0, import_node_fs6.openSync)(import_node_path4.default.join(directory, "configuration-upgrade.lock"), import_node_fs6.constants.O_CREAT | import_node_fs6.constants.O_RDWR | import_node_fs6.constants.O_NOFOLLOW, 384);
+  try {
+    assertPrivateDescriptor(fd);
+    if (!(0, import_fs_native_extensions.tryLock)(fd, 0, 0, { shared })) throw new ConfigurationError("CONFIG_UPGRADE_BUSY");
+    return run();
+  } finally {
+    (0, import_node_fs6.closeSync)(fd);
+  }
+}
+function withConfigurationUpgradeOwnership(context, run, ignoredRoles = []) {
+  return withUpgradeGate(context, false, () => {
+    const directory = ownerDirectory(context);
+    const held = [];
+    try {
+      for (const file of (0, import_node_fs6.readdirSync)(directory).filter((name) => name.endsWith(".owner.lock"))) {
+        if (ignoredRoles.includes(file.replace(/\.owner\.lock$/, ""))) continue;
+        const fd = (0, import_node_fs6.openSync)(import_node_path4.default.join(directory, file), import_node_fs6.constants.O_RDWR | import_node_fs6.constants.O_NOFOLLOW);
+        held.push(fd);
+        assertPrivateDescriptor(fd);
+        if (!(0, import_fs_native_extensions.tryLock)(fd)) throw new ConfigurationError("CONFIG_UPGRADE_CONSUMER_RUNNING", [file.replace(/\.owner\.lock$/, "")]);
+      }
+      return run();
+    } finally {
+      for (const fd of held) (0, import_node_fs6.closeSync)(fd);
+    }
+  });
+}
 function acquireConfigurationOwner(context, role) {
+  return withUpgradeGate(context, true, () => acquireOwner(context, role));
+}
+function acquireOwner(context, role) {
   const directory = ownerDirectory(context);
   const fd = (0, import_node_fs6.openSync)(import_node_path4.default.join(directory, `${role}.owner.lock`), import_node_fs6.constants.O_CREAT | import_node_fs6.constants.O_RDWR | import_node_fs6.constants.O_NOFOLLOW, 384);
   let closed = false;
@@ -34717,13 +34749,6 @@ function acquireConfigurationOwner(context, role) {
   }
 }
 
-// packages/config-node/src/store.ts
-var import_node_fs7 = require("node:fs");
-var import_node_path6 = __toESM(require("node:path"), 1);
-var import_node_crypto4 = require("node:crypto");
-var import_yaml = __toESM(require_dist(), 1);
-var import_fs_native_extensions2 = require("fs-native-extensions");
-
 // packages/shared/src/configuration/fields.ts
 var CONFIGURATION_FIELDS = [
   { "path": "screenRecording.analysis.enabled", "type": "boolean", "domain": "screenRecording.analysis", "sensitive": false, "remote": false, "apply": "reload", "description": "\u542F\u7528\u672C\u673A\u5C4F\u5E55\u4E8B\u9879\u5206\u6790\uFF0C\u9ED8\u8BA4\u5173\u95ED", "environmentKeys": [], "owner": "backend/screen-recording-analysis", "scope": "instance", "storage": "settings.yaml", "default": { "value": false }, "migrationSources": ["new-field:no-legacy-source"] },
@@ -34896,14 +34921,18 @@ var CONFIGURATION_FIELDS = [
 ];
 
 // packages/shared/src/configuration/compatibility.ts
+var CONFIGURATION_SCHEMA_VERSION = 1;
+var CONFIGURATION_DOMAIN_VERSIONS = Object.fromEntries(
+  [...new Set(CONFIGURATION_FIELDS.map((field) => field.domain))].map((domain) => [domain, 1])
+);
 var CONFIGURATION_COMPATIBILITY = {
   format: "runweave-yaml",
-  schemaVersions: [1],
-  domainVersions: Object.fromEntries([...new Set(CONFIGURATION_FIELDS.map((field) => field.domain))].map((domain) => [domain, [1]]))
+  schemaVersions: [CONFIGURATION_SCHEMA_VERSION],
+  domainVersions: Object.fromEntries(Object.entries(CONFIGURATION_DOMAIN_VERSIONS).map(([domain, version]) => [domain, [version]]))
 };
 var APP_SERVER_CONFIGURATION_COMPATIBILITY = {
   ...CONFIGURATION_COMPATIBILITY,
-  domainVersions: Object.fromEntries(["appServer", "agents.codex", "agents.traex"].map((domain) => [domain, [1]]))
+  domainVersions: Object.fromEntries(["appServer", "agents.codex", "agents.traex"].map((domain) => [domain, [CONFIGURATION_DOMAIN_VERSIONS[domain]]]))
 };
 function supportsConfiguration(target, value) {
   if (!target || typeof target !== "object") return false;
@@ -34979,6 +35008,66 @@ function configurationPathSegment(key) {
   return key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
 }
 
+// packages/config-node/src/version-migrations.ts
+var CONFIGURATION_VERSION_MIGRATIONS = [];
+function migrateConfigurationDocument(document2) {
+  const steps = [];
+  const ids = /* @__PURE__ */ new Set();
+  const edges = /* @__PURE__ */ new Set();
+  for (const step of CONFIGURATION_VERSION_MIGRATIONS) {
+    const edge = `${step.domain ?? "$schema"}:${step.from}`;
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]+$/.test(step.id) || ids.has(step.id) || edges.has(edge) || !Number.isSafeInteger(step.from) || step.from < 1 || step.to !== step.from + 1 || step.domain !== void 0 && !Object.hasOwn(CONFIGURATION_DOMAIN_VERSIONS, step.domain) || step.to > (step.domain ? CONFIGURATION_DOMAIN_VERSIONS[step.domain] : CONFIGURATION_SCHEMA_VERSION)) {
+      throw new ConfigurationError("CONFIG_UPGRADE_REGISTRY_INVALID");
+    }
+    ids.add(step.id);
+    edges.add(edge);
+  }
+  const advance = (domain, target) => {
+    const versionPath = domain ? ["domainVersions", domain] : ["schemaVersion"];
+    let version = Number(document2.getIn(versionPath) ?? 1);
+    if (version > target) throw new ConfigurationError("CONFIG_UPGRADE_FUTURE_VERSION", [domain ?? "schemaVersion"]);
+    while (version < target) {
+      const step = CONFIGURATION_VERSION_MIGRATIONS.find((item) => item.domain === domain && item.from === version);
+      if (!step) throw new ConfigurationError("CONFIG_UPGRADE_PATH_MISSING", [domain ?? "schemaVersion"]);
+      const before = document2.toJS();
+      try {
+        step.migrate(document2);
+      } catch {
+        throw new ConfigurationError("CONFIG_UPGRADE_STEP_FAILED", [step.id]);
+      }
+      const after = document2.toJS();
+      for (const key of ["schemaVersion", "revision", "kind", "instanceId", "domainVersions", "migrations"]) {
+        if (JSON.stringify(before[key]) !== JSON.stringify(after[key])) throw new ConfigurationError("CONFIG_UPGRADE_METADATA_CHANGED", [step.id]);
+      }
+      if (domain) {
+        const strip = (value) => {
+          const copy = structuredClone(value);
+          const parts = domain.split(".");
+          let parent = copy;
+          for (const key of parts.slice(0, -1)) parent = parent[key] ?? {};
+          delete parent[parts.at(-1)];
+          return copy;
+        };
+        if (JSON.stringify(strip(before)) !== JSON.stringify(strip(after))) throw new ConfigurationError("CONFIG_UPGRADE_SCOPE_CHANGED", [step.id]);
+      }
+      document2.setIn(versionPath, step.to);
+      document2.setIn(["migrations", `version:${step.id}`], { from: step.from, to: step.to, domain: domain ?? "$schema" });
+      steps.push(step.id);
+      version = step.to;
+    }
+  };
+  advance(void 0, CONFIGURATION_SCHEMA_VERSION);
+  for (const [domain, target] of Object.entries(CONFIGURATION_DOMAIN_VERSIONS)) advance(domain, target);
+  return steps;
+}
+
+// packages/config-node/src/store.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_crypto4 = require("node:crypto");
+var import_yaml = __toESM(require_dist(), 1);
+var import_fs_native_extensions2 = require("fs-native-extensions");
+
 // packages/config-node/src/validation.ts
 var import_node_path5 = __toESM(require("node:path"), 1);
 var patterns = CONFIGURATION_FIELDS.map((field) => ({ field, segments: field.path.replace(/\[\]/g, ".#").split(".") }));
@@ -34997,12 +35086,14 @@ function isConfigurationContainer(key, array = false) {
   });
 }
 function domainForPath(key) {
+  const declared = Object.keys(CONFIGURATION_DOMAIN_VERSIONS).find((domain) => key === domain || key.startsWith(`${domain}.`));
+  if (declared) return declared;
   const parts = key.split(".");
   return ["backend", "services", "desktop", "agents"].includes(parts[0]) ? parts.slice(0, 2).join(".") : parts[0];
 }
 function validateEnvelope(value, context) {
   if (!isConfigurationObject(value)) throw new ConfigurationError("CONFIG_ROOT_INVALID");
-  if (value.schemaVersion !== 1) throw new ConfigurationError("CONFIG_SCHEMA_UNSUPPORTED");
+  if (value.schemaVersion !== CONFIGURATION_SCHEMA_VERSION) throw new ConfigurationError("CONFIG_SCHEMA_UNSUPPORTED");
   if (!Number.isSafeInteger(value.revision) || Number(value.revision) < 0) throw new ConfigurationError("CONFIG_REVISION_INVALID");
   if (value.kind !== context.kind || value.instanceId !== context.instanceId) throw new ConfigurationError("CONFIG_IDENTITY_MISMATCH");
   if (!isConfigurationObject(value.domainVersions) || !isConfigurationObject(value.migrations)) throw new ConfigurationError("CONFIG_METADATA_INVALID");
@@ -35024,7 +35115,7 @@ function validateDomains(value, context) {
     if (["schemaVersion", "revision", "kind", "instanceId", "domainVersions", "migrations"].includes(key.split(".")[0])) continue;
     const domain = domainForPath(key);
     if (domain === "agents.team") continue;
-    if (value.domainVersions[domain] !== void 0 && value.domainVersions[domain] !== 1) {
+    if (value.domainVersions[domain] !== void 0 && value.domainVersions[domain] !== CONFIGURATION_DOMAIN_VERSIONS[domain]) {
       issue(key, "CONFIG_DOMAIN_VERSION_UNSUPPORTED");
       continue;
     }
@@ -35099,7 +35190,7 @@ function validateDomains(value, context) {
   }
   for (const [domain, version] of Object.entries(value.domainVersions)) {
     if (domain === "agents.team") continue;
-    if (version !== 1 && !result[domain]) result[domain] = [{ path: domain, code: "CONFIG_DOMAIN_VERSION_UNSUPPORTED" }];
+    if (version !== CONFIGURATION_DOMAIN_VERSIONS[domain] && !result[domain]) result[domain] = [{ path: domain, code: "CONFIG_DOMAIN_VERSION_UNSUPPORTED" }];
   }
   return result;
 }
@@ -35165,11 +35256,11 @@ function parseConfigurationYaml(source, context) {
   return { document: document2, value, digest: (0, import_node_crypto4.createHash)("sha256").update(source).digest("hex"), issues: validateDomains(value, context) };
 }
 function assertPrivateFile(file, fd) {
-  const stat2 = fd === void 0 ? (0, import_node_fs7.lstatSync)(file) : (0, import_node_fs7.fstatSync)(fd);
-  if (!stat2.isFile() || stat2.isSymbolicLink() || stat2.nlink !== 1) throw new ConfigurationError("CONFIG_FILE_NOT_PRIVATE_REGULAR");
-  if (typeof process.getuid === "function" && stat2.uid !== process.getuid()) throw new ConfigurationError("CONFIG_FILE_OWNER_MISMATCH");
-  if ((stat2.mode & 63) !== 0) throw new ConfigurationError("CONFIG_FILE_PERMISSIONS_INVALID");
-  if (stat2.size > MAX_BYTES) throw new ConfigurationError("CONFIG_FILE_TOO_LARGE", [], { line: 1, column: 1 });
+  const stat3 = fd === void 0 ? (0, import_node_fs7.lstatSync)(file) : (0, import_node_fs7.fstatSync)(fd);
+  if (!stat3.isFile() || stat3.isSymbolicLink() || stat3.nlink !== 1) throw new ConfigurationError("CONFIG_FILE_NOT_PRIVATE_REGULAR");
+  if (typeof process.getuid === "function" && stat3.uid !== process.getuid()) throw new ConfigurationError("CONFIG_FILE_OWNER_MISMATCH");
+  if ((stat3.mode & 63) !== 0) throw new ConfigurationError("CONFIG_FILE_PERMISSIONS_INVALID");
+  if (stat3.size > MAX_BYTES) throw new ConfigurationError("CONFIG_FILE_TOO_LARGE", [], { line: 1, column: 1 });
 }
 var ConfigurationStore = class {
   constructor(context) {
@@ -35204,7 +35295,7 @@ var ConfigurationStore = class {
       (0, import_node_fs7.closeSync)(fd);
     }
   }
-  publish(document2, previous) {
+  publish(document2, previous, backupId) {
     const source = document2.toString({ lineWidth: 0 });
     const checked = parseConfigurationYaml(source, this.context);
     registerStableConfigurationRoot(this.context);
@@ -35214,7 +35305,7 @@ var ConfigurationStore = class {
       (0, import_node_fs7.mkdirSync)(backupRoot, { recursive: true, mode: 448 });
       const backupStat = (0, import_node_fs7.lstatSync)(backupRoot);
       if (!backupStat.isDirectory() || backupStat.isSymbolicLink() || backupStat.mode & 63 || typeof process.getuid === "function" && backupStat.uid !== process.getuid()) throw new ConfigurationError("CONFIG_BACKUP_ROOT_INVALID");
-      const backup = import_node_path6.default.join(backupRoot, `${Date.now()}-${(0, import_node_crypto4.randomUUID)()}.yaml`);
+      const backup = import_node_path6.default.join(backupRoot, backupId ?? `${Date.now()}-${(0, import_node_crypto4.randomUUID)()}.yaml`);
       const fd2 = (0, import_node_fs7.openSync)(backup, "wx", 384);
       try {
         (0, import_node_fs7.writeFileSync)(fd2, previous);
@@ -35261,7 +35352,7 @@ var ConfigurationStore = class {
         const segments = configurationPathSegments(key);
         if (!segments.length || segments.some((part) => !part || unsafeKeys.has(part))) throw new ConfigurationError("CONFIG_FIELD_INVALID");
         const domain = domainForPath(key);
-        if (current.value.domainVersions[domain] !== void 0 && current.value.domainVersions[domain] !== 1) throw new ConfigurationError("CONFIG_DOMAIN_VERSION_UNSUPPORTED", [domain]);
+        if (current.value.domainVersions[domain] !== void 0 && current.value.domainVersions[domain] !== CONFIGURATION_DOMAIN_VERSIONS[domain]) throw new ConfigurationError("CONFIG_DOMAIN_VERSION_UNSUPPORTED", [domain]);
         const field = fieldForPath(key);
         if (!field && !(isConfigurationObject(value) && isConfigurationContainer(key)) && !(Array.isArray(value) && isConfigurationContainer(key, true)) && !(value === null && (isConfigurationContainer(key) || isConfigurationContainer(key, true)))) throw new ConfigurationError("CONFIG_FIELD_UNKNOWN", [key]);
         if (options.remote && (!field || !field.remote)) throw new ConfigurationError("CONFIG_FIELD_FORBIDDEN", [key]);
@@ -35271,7 +35362,7 @@ var ConfigurationStore = class {
         for (const segment of segments) target.push((0, import_yaml.isSeq)(current.document.getIn(target, true)) && /^\d+$/.test(segment) ? Number(segment) : segment);
         if (!field && value === null) current.document.deleteIn(target);
         else current.document.setIn(target, value);
-        current.document.setIn(["domainVersions", domain], 1);
+        current.document.setIn(["domainVersions", domain], CONFIGURATION_DOMAIN_VERSIONS[domain]);
         domains.add(domain);
       }
       const revision = Math.max(current.value.revision, options.minimumRevision ?? 0) + 1;
@@ -35309,7 +35400,7 @@ var ConfigurationStore = class {
     const source = readPrivateFile(this.file);
     const { value } = parseYamlDocument(source);
     if (!isConfigurationObject(value) || !Number.isSafeInteger(value.schemaVersion) || Number(value.schemaVersion) < 1) throw new ConfigurationError("CONFIG_SCHEMA_INVALID");
-    validateEnvelope({ ...value, schemaVersion: 1 }, this.context);
+    validateEnvelope({ ...value, schemaVersion: CONFIGURATION_SCHEMA_VERSION }, this.context);
     const backup = this.readBackup(id);
     const before = new Map(flattenConfiguration(value));
     const after = new Map(flattenConfiguration(backup.value));
@@ -35328,6 +35419,89 @@ var ConfigurationStore = class {
   previewRestore(id) {
     return this.prepareRestore(id).preview;
   }
+  /** Upgrade control plane only; business readers must use read(). */
+  readUpgradeSource() {
+    assertPrivateDirectory(this.context.configRoot);
+    const source = readPrivateFile(this.file);
+    const { document: document2, value } = parseYamlDocument(source);
+    if (!isConfigurationObject(value) || !Number.isSafeInteger(value.schemaVersion) || Number(value.schemaVersion) < 1) throw new ConfigurationError("CONFIG_SCHEMA_INVALID");
+    validateEnvelope({ ...value, schemaVersion: CONFIGURATION_SCHEMA_VERSION }, this.context);
+    return { source, document: document2, value, digest: (0, import_node_crypto4.createHash)("sha256").update(source).digest("hex") };
+  }
+  prepareUpgrade() {
+    const { source, document: document2, value, digest } = this.readUpgradeSource();
+    const original = value;
+    const expectedDigest = digest;
+    const steps = migrateConfigurationDocument(document2);
+    const next = parseConfigurationYaml(document2.toString({ lineWidth: 0 }), this.context);
+    const failures = Object.values(next.issues).flat();
+    if (failures.length) throw new ConfigurationError("CONFIG_VALIDATION_FAILED", failures.map((issue) => issue.path));
+    const before = new Map(flattenConfiguration(original));
+    const after = new Map(flattenConfiguration(next.value));
+    const changedFields = [.../* @__PURE__ */ new Set([...before.keys(), ...after.keys()])].filter((key) => JSON.stringify(before.get(key)) !== JSON.stringify(after.get(key))).sort();
+    const preview = {
+      expectedRevision: original.revision,
+      expectedDigest,
+      source: { schemaVersion: original.schemaVersion, domainVersions: original.domainVersions },
+      target: { schemaVersion: next.value.schemaVersion, domainVersions: { ...CONFIGURATION_DOMAIN_VERSIONS, ...next.value.domainVersions } },
+      steps,
+      changedFields,
+      changed: changedFields.length > 0
+    };
+    return { source, document: document2, preview };
+  }
+  previewUpgrade() {
+    return this.prepareUpgrade().preview;
+  }
+  recordUpgrade(value) {
+    const file = import_node_path6.default.join(this.context.configRoot, "config-upgrade.json");
+    const temporary = `${file}.${(0, import_node_crypto4.randomUUID)()}.tmp`;
+    const fd = (0, import_node_fs7.openSync)(temporary, "wx", 384);
+    try {
+      (0, import_node_fs7.writeFileSync)(fd, JSON.stringify(value, null, 2) + "\n");
+      (0, import_node_fs7.fsyncSync)(fd);
+    } finally {
+      (0, import_node_fs7.closeSync)(fd);
+    }
+    try {
+      (0, import_node_fs7.renameSync)(temporary, file);
+      const parent = (0, import_node_fs7.openSync)(this.context.configRoot, "r");
+      try {
+        (0, import_node_fs7.fsyncSync)(parent);
+      } finally {
+        (0, import_node_fs7.closeSync)(parent);
+      }
+    } finally {
+      if ((0, import_node_fs7.existsSync)(temporary)) (0, import_node_fs7.unlinkSync)(temporary);
+    }
+  }
+  upgrade(expected) {
+    return this.locked(() => {
+      const { source, document: document2, preview } = this.prepareUpgrade();
+      if (preview.expectedRevision !== expected.revision || preview.expectedDigest !== expected.digest) throw new ConfigurationError("CONFIG_REVISION_CONFLICT");
+      if (!preview.changed) {
+        const receiptFile = import_node_path6.default.join(this.context.configRoot, "config-upgrade.json");
+        if ((0, import_node_fs7.existsSync)(receiptFile)) {
+          const receipt = JSON.parse(readPrivateFile(receiptFile));
+          if (isConfigurationObject(receipt) && receipt.phase === "prepared" && receipt.plannedDigest === expected.digest)
+            this.recordUpgrade({ ...receipt, phase: "committed", savedRevision: expected.revision, digest: expected.digest });
+        }
+        return { ...preview, savedRevision: expected.revision, digest: expected.digest };
+      }
+      return withConfigurationUpgradeOwnership(this.context, () => {
+        const revision = expected.revision + 1;
+        if (!Number.isSafeInteger(revision)) throw new ConfigurationError("CONFIG_REVISION_INVALID");
+        document2.set("revision", revision);
+        const backupId = `${Date.now()}-${(0, import_node_crypto4.randomUUID)()}.yaml`;
+        const plannedDigest = (0, import_node_crypto4.createHash)("sha256").update(document2.toString({ lineWidth: 0 })).digest("hex");
+        this.recordUpgrade({ ...preview, backupId, plannedDigest, phase: "prepared" });
+        const next = this.publish(document2, source, backupId);
+        const result = { ...preview, savedRevision: next.value.revision, digest: next.digest, backupId };
+        this.recordUpgrade({ ...result, phase: "committed" });
+        return result;
+      });
+    });
+  }
   restoreBackup(id, expected) {
     return this.locked(() => {
       const { source, backup, preview } = this.prepareRestore(id);
@@ -35738,8 +35912,8 @@ var PiSessionReader = class {
     try {
       if (await (0, import_promises4.realpath)(file) !== file) return null;
       handle = await (0, import_promises4.open)(file, "r");
-      const stat2 = await handle.stat();
-      if (!stat2.isFile() || stat2.size > 64 * 1024 * 1024) return null;
+      const stat3 = await handle.stat();
+      if (!stat3.isFile() || stat3.size > 64 * 1024 * 1024) return null;
       const content = await handle.readFile("utf8");
       const lines = content.split("\n");
       lines.pop();
@@ -35869,7 +36043,7 @@ ${entry.summary}`
           preview,
           status: status === "running" ? "active" : status === "idle" ? "idle" : "notLoaded",
           createdAt: String(header.timestamp ?? ""),
-          updatedAt: new Date(stat2.mtimeMs).toISOString(),
+          updatedAt: new Date(stat3.mtimeMs).toISOString(),
           turns
         },
         latest
@@ -36236,15 +36410,15 @@ var ThreadPreviewReader = class {
     }
     const handle = await (0, import_promises6.open)(file, "r");
     try {
-      const stat2 = await handle.stat();
-      if (!stat2.isFile()) {
+      const stat3 = await handle.stat();
+      if (!stat3.isFile()) {
         entry.ready = false;
         entry.availability = "source_missing";
         return;
       }
-      if (entry.file !== file || entry.inode !== stat2.ino || stat2.size < entry.offset) {
+      if (entry.file !== file || entry.inode !== stat3.ino || stat3.size < entry.offset) {
         entry.file = file;
-        entry.inode = stat2.ino;
+        entry.inode = stat3.ino;
         entry.offset = 0;
         entry.pending = Buffer.alloc(0);
         entry.skippingLine = false;
@@ -36256,11 +36430,11 @@ var ThreadPreviewReader = class {
         entry.leaf = null;
         entry.piCursor = null;
       }
-      const buffer = Buffer.alloc(Math.min(READ_BYTES, stat2.size - entry.offset));
+      const buffer = Buffer.alloc(Math.min(READ_BYTES, stat3.size - entry.offset));
       const { bytesRead } = await handle.read(buffer, 0, buffer.length, entry.offset);
       entry.offset += bytesRead;
       this.consume(entry, buffer.subarray(0, bytesRead));
-      if (entry.offset < stat2.size) {
+      if (entry.offset < stat3.size) {
         this.queued.add(entry);
         return;
       }
@@ -37181,6 +37355,7 @@ var import_promises9 = require("node:fs/promises");
 var import_node_os5 = __toESM(require("node:os"), 1);
 var import_node_path16 = __toESM(require("node:path"), 1);
 var ROLLOUT_TAIL_BYTES = 1024 * 1024;
+var ROLLOUT_LOOKBACK_BYTES = 64 * ROLLOUT_TAIL_BYTES;
 var TERMINAL_LIFECYCLE_TYPES = /* @__PURE__ */ new Set([
   "task_started",
   "task_complete",
@@ -37206,13 +37381,11 @@ var CodexRolloutLifecycleReader = class {
     }
     try {
       const previous = this.snapshots.get(threadId);
-      const tail = await readFileTail(filePath, previous?.signature);
-      if (tail.content === null) return previous.lifecycle;
-      const lifecycle = parseLatestLifecycle(tail.content);
+      const snapshot = await readFileLifecycle(filePath, previous);
       this.snapshots.delete(threadId);
-      this.snapshots.set(threadId, { signature: tail.signature, lifecycle });
+      this.snapshots.set(threadId, snapshot);
       if (this.snapshots.size > 128) this.snapshots.delete(this.snapshots.keys().next().value);
-      return lifecycle;
+      return snapshot.lifecycle;
     } catch {
       this.threadPaths.delete(threadId);
       this.snapshots.delete(threadId);
@@ -37245,21 +37418,32 @@ var CodexRolloutLifecycleReader = class {
     return this.threadPaths.get(threadId) ?? [...this.threadPaths].find(([id]) => id.endsWith(`-${threadId}`))?.[1] ?? null;
   }
 };
-async function readFileTail(filePath, previousSignature) {
+async function readFileLifecycle(filePath, previous) {
   const handle = await (0, import_promises9.open)(filePath, "r");
   try {
     const { size, dev, ino, mtimeMs, ctimeMs } = await handle.stat();
     const signature = `${filePath}:${dev}:${ino}:${size}:${mtimeMs}:${ctimeMs}`;
-    if (signature === previousSignature) return { signature, content: null };
-    const start = Math.max(0, size - ROLLOUT_TAIL_BYTES);
-    const buffer = Buffer.alloc(size - start);
-    const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
-    const value = buffer.subarray(0, bytesRead).toString("utf8");
-    if (start === 0) {
-      return { signature, content: value };
-    }
-    const firstNewline = value.indexOf("\n");
-    return { signature, content: firstNewline === -1 ? "" : value.slice(firstNewline + 1) };
+    if (signature === previous?.signature) return previous;
+    const floor = Math.max(0, size - ROLLOUT_LOOKBACK_BYTES);
+    let end = size;
+    let suffix = Buffer.alloc(0);
+    let lifecycle = null;
+    while (end > floor && !lifecycle) {
+      const start = Math.max(floor, end - ROLLOUT_TAIL_BYTES);
+      const buffer = Buffer.alloc(end - start);
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+      if (bytesRead !== buffer.length) return { signature, lifecycle: null };
+      const value = Buffer.concat([buffer, suffix]);
+      const boundary = start > 0 ? value.indexOf(10) : -1;
+      const complete = start === 0 ? value : boundary < 0 ? Buffer.alloc(0) : value.subarray(boundary + 1);
+      lifecycle = parseLatestLifecycle(complete.toString("utf8"));
+      suffix = boundary >= 0 && boundary < ROLLOUT_TAIL_BYTES ? Buffer.from(value.subarray(0, boundary + 1)) : Buffer.alloc(0);
+      end = start;
+    }
+    const current = await (0, import_promises9.stat)(filePath);
+    if (current.dev !== dev || current.ino !== ino || current.size !== size || current.mtimeMs !== mtimeMs || current.ctimeMs !== ctimeMs)
+      return { signature, lifecycle: null };
+    return { signature, lifecycle };
   } finally {
     await handle.close();
   }
@@ -37457,6 +37641,7 @@ var AgentThreadStatusReconciler = class {
   collectCandidates() {
     const cutoff = Date.now() - ACTIVE_WINDOW_MS;
     return this.options.eventCenter.getStateStore().listThreads({ limit: 1e4 }).filter((thread) => RECONCILED_AGENTS.has(thread.agent)).filter((thread) => !thread.threadId.startsWith("unknown-thread:")).filter((thread) => {
+      if (thread.status === "running") return true;
       const lastActivityAtMs = Date.parse(thread.lastActivityAt);
       return !Number.isFinite(lastActivityAtMs) || lastActivityAtMs >= cutoff;
     }).sort(
@@ -37492,8 +37677,19 @@ var AgentThreadStatusReconciler = class {
       const lifecycle2 = await this.options.codexRolloutLifecycleReader.readLatestLifecycle(
         thread.threadId
       );
+      if (lifecycle2?.status === "running" && (thread.status === "running" || !isOlderThanThreadProjection(lifecycle2.timestamp, thread))) {
+        return {
+          status: "running",
+          lifecycleType: `rollout:${lifecycle2.type}`,
+          lifecycleCursor: lifecycle2.cursor,
+          detailStatus: null,
+          preview: null,
+          turnId: lifecycle2.turnId
+        };
+      }
       const sameObservedFailure = lifecycle2?.error && thread.status === "idle" && thread.lastLifecycleType === `rollout:${lifecycle2.type}` && thread.lastLifecycleCursor === lifecycle2.cursor;
-      if (lifecycle2?.status === "idle" && (!isOlderThanThreadProjection(lifecycle2.timestamp, thread) || sameObservedFailure) && // A terminal error is a fact even if a Hook already marked the thread
+      const followsObservedStart = lifecycle2 && thread.lastLifecycleType === "rollout:task_started" && newerRolloutCursor(lifecycle2.cursor, thread.lastLifecycleCursor);
+      if (lifecycle2?.status === "idle" && (!isOlderThanThreadProjection(lifecycle2.timestamp, thread) || sameObservedFailure || followsObservedStart) && // A terminal error is a fact even if a Hook already marked the thread
       // idle, or thread/read still reports active. Never adopt an old turn.
       (lifecycle2.error || thread.status === "running" && status !== "active")) {
         return {
@@ -37612,6 +37808,11 @@ var AgentThreadStatusReconciler = class {
     });
   }
 };
+function newerRolloutCursor(current, previous) {
+  const currentOrdinal = current.match(/^rollout:(\d+)$/)?.[1];
+  const previousOrdinal = previous?.match(/^rollout:(\d+)$/)?.[1];
+  return Boolean(currentOrdinal && previousOrdinal && BigInt(currentOrdinal) > BigInt(previousOrdinal));
+}
 function isOlderThanThreadProjection(observedAt, thread) {
   const observedAtMs = Date.parse(observedAt);
   const projectedAtMs = Date.parse(thread.updatedAt);