zooid 0.15.0 → 0.16.1

package/dist/{chunk-35IKQPC5.js → chunk-HE7DVDJA.js}

@@ -14,9 +14,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -52,13 +52,13 @@ var require_main = __commonJS({
         const r = expression.split(splitter);
         let defaultValue;
         let value2;
-        const key = r.shift();
+        const key2 = r.shift();
         if ([":+", "+"].includes(splitter)) {
-          defaultValue = env[key] ? r.join(splitter) : "";
+          defaultValue = env[key2] ? r.join(splitter) : "";
           value2 = null;
         } else {
           defaultValue = r.join(splitter);
-          value2 = env[key];
+          value2 = env[key2];
         }
         if (value2) {
           if (seen.has(value2)) {
@@ -69,7 +69,7 @@ var require_main = __commonJS({
         } else {
           result = result.replace(template, defaultValue);
         }
-        if (result === runningParsed[key]) {
+        if (result === runningParsed[key2]) {
           break;
         }
         regex.lastIndex = 0;
@@ -82,15 +82,15 @@ var require_main = __commonJS({
       if (options && options.processEnv != null) {
         processEnv = options.processEnv;
       }
-      for (const key in options.parsed) {
-        let value = options.parsed[key];
-        if (processEnv[key] && processEnv[key] !== value) {
-          value = processEnv[key];
+      for (const key2 in options.parsed) {
+        let value = options.parsed[key2];
+        if (processEnv[key2] && processEnv[key2] !== value) {
+          value = processEnv[key2];
         } else {
           value = expandValue(value, processEnv, runningParsed);
         }
-        options.parsed[key] = _resolveEscapeSequences(value);
-        runningParsed[key] = _resolveEscapeSequences(value);
+        options.parsed[key2] = _resolveEscapeSequences(value);
+        runningParsed[key2] = _resolveEscapeSequences(value);
       }
       for (const processKey in options.parsed) {
         processEnv[processKey] = options.parsed[processKey];
@@ -237,15 +237,15 @@ var require_code = __commonJS({
       return JSON.stringify(x).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
     }
     exports.safeStringify = safeStringify;
-    function getProperty(key) {
-      return typeof key == "string" && exports.IDENTIFIER.test(key) ? new _Code(`.${key}`) : _`[${key}]`;
+    function getProperty(key2) {
+      return typeof key2 == "string" && exports.IDENTIFIER.test(key2) ? new _Code(`.${key2}`) : _`[${key2}]`;
     }
     exports.getProperty = getProperty;
-    function getEsmExportName(key) {
-      if (typeof key == "string" && exports.IDENTIFIER.test(key)) {
-        return new _Code(`${key}`);
+    function getEsmExportName(key2) {
+      if (typeof key2 == "string" && exports.IDENTIFIER.test(key2)) {
+        return new _Code(`${key2}`);
       }
-      throw new Error(`CodeGen: invalid export name: ${key}, use explicit $id name mapping`);
+      throw new Error(`CodeGen: invalid export name: ${key2}, use explicit $id name mapping`);
     }
     exports.getEsmExportName = getEsmExportName;
     function regexpCode(rx) {
@@ -520,9 +520,9 @@ var require_codegen = __commonJS({
       }
     };
     var Label = class extends Node {
-      constructor(label) {
+      constructor(label2) {
         super();
-        this.label = label;
+        this.label = label2;
         this.names = {};
       }
       render({ _n }) {
@@ -530,14 +530,14 @@ var require_codegen = __commonJS({
       }
     };
     var Break = class extends Node {
-      constructor(label) {
+      constructor(label2) {
         super();
-        this.label = label;
+        this.label = label2;
         this.names = {};
       }
       render({ _n }) {
-        const label = this.label ? ` ${this.label}` : "";
-        return `break${label};` + _n;
+        const label2 = this.label ? ` ${this.label}` : "";
+        return `break${label2};` + _n;
       }
     };
     var Throw = class extends Node {
@@ -872,11 +872,11 @@ var require_codegen = __commonJS({
       // returns code for object literal for the passed argument list of key-value pairs
       object(...keyValues) {
         const code = ["{"];
-        for (const [key, value] of keyValues) {
+        for (const [key2, value] of keyValues) {
           if (code.length > 1)
             code.push(",");
-          code.push(key);
-          if (key !== value || this.opts.es5) {
+          code.push(key2);
+          if (key2 !== value || this.opts.es5) {
             code.push(":");
             (0, code_1.addCodeArg)(code, value);
           }
@@ -949,12 +949,12 @@ var require_codegen = __commonJS({
         return this._endBlockNode(For);
       }
       // `label` statement
-      label(label) {
-        return this._leafNode(new Label(label));
+      label(label2) {
+        return this._leafNode(new Label(label2));
       }
       // `break` statement
-      break(label) {
-        return this._leafNode(new Break(label));
+      break(label2) {
+        return this._leafNode(new Break(label2));
       }
       // `return` statement
       return(value) {
@@ -1151,17 +1151,17 @@ var require_util = __commonJS({
       if (typeof schema === "boolean")
         return;
       const rules = self.RULES.keywords;
-      for (const key in schema) {
-        if (!rules[key])
-          checkStrictMode(it, `unknown keyword: "${key}"`);
+      for (const key2 in schema) {
+        if (!rules[key2])
+          checkStrictMode(it, `unknown keyword: "${key2}"`);
       }
     }
     exports.checkUnknownRules = checkUnknownRules;
     function schemaHasRules(schema, rules) {
       if (typeof schema == "boolean")
         return !schema;
-      for (const key in schema)
-        if (rules[key])
+      for (const key2 in schema)
+        if (rules[key2])
           return true;
       return false;
     }
@@ -1169,8 +1169,8 @@ var require_util = __commonJS({
     function schemaHasRulesButRef(schema, RULES) {
       if (typeof schema == "boolean")
         return !schema;
-      for (const key in schema)
-        if (key !== "$ref" && RULES.all[key])
+      for (const key2 in schema)
+        if (key2 !== "$ref" && RULES.all[key2])
           return true;
       return false;
     }
@@ -1748,8 +1748,8 @@ var require_defaults = __commonJS({
     function assignDefaults(it, ty) {
       const { properties, items } = it.schema;
       if (ty === "object" && properties) {
-        for (const key in properties) {
-          assignDefault(it, key, properties[key].default);
+        for (const key2 in properties) {
+          assignDefault(it, key2, properties[key2].default);
         }
       } else if (ty === "array" && Array.isArray(items)) {
         items.forEach((sch, i) => assignDefault(it, i, sch.default));
@@ -2133,8 +2133,8 @@ var require_fast_deep_equal = __commonJS({
         for (i = length; i-- !== 0; )
           if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
         for (i = length; i-- !== 0; ) {
-          var key = keys[i];
-          if (!equal(a[key], b[key])) return false;
+          var key2 = keys[i];
+          if (!equal(a[key2], b[key2])) return false;
         }
         return true;
       }
@@ -2206,20 +2206,20 @@ var require_json_schema_traverse = __commonJS({
     function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
       if (schema && typeof schema == "object" && !Array.isArray(schema)) {
         pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
-        for (var key in schema) {
-          var sch = schema[key];
+        for (var key2 in schema) {
+          var sch = schema[key2];
           if (Array.isArray(sch)) {
-            if (key in traverse.arrayKeywords) {
+            if (key2 in traverse.arrayKeywords) {
               for (var i = 0; i < sch.length; i++)
-                _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, i);
+                _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key2 + "/" + i, rootSchema, jsonPtr, key2, schema, i);
             }
-          } else if (key in traverse.propsKeywords) {
+          } else if (key2 in traverse.propsKeywords) {
             if (sch && typeof sch == "object") {
               for (var prop in sch)
-                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
+                _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key2 + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key2, schema, prop);
             }
-          } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
-            _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+          } else if (key2 in traverse.keywords || opts.allKeys && !(key2 in traverse.skipKeywords)) {
+            _traverse(opts, pre, post, sch, jsonPtr + "/" + key2, rootSchema, jsonPtr, key2, schema);
           }
         }
         post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
@@ -2276,10 +2276,10 @@ var require_resolve = __commonJS({
       "$dynamicAnchor"
     ]);
     function hasRef(schema) {
-      for (const key in schema) {
-        if (REF_KEYWORDS.has(key))
+      for (const key2 in schema) {
+        if (REF_KEYWORDS.has(key2))
           return true;
-        const sch = schema[key];
+        const sch = schema[key2];
         if (Array.isArray(sch) && sch.some(hasRef))
           return true;
         if (typeof sch == "object" && hasRef(sch))
@@ -2289,14 +2289,14 @@ var require_resolve = __commonJS({
     }
     function countKeys(schema) {
       let count = 0;
-      for (const key in schema) {
-        if (key === "$ref")
+      for (const key2 in schema) {
+        if (key2 === "$ref")
           return Infinity;
         count++;
-        if (SIMPLE_INLINED.has(key))
+        if (SIMPLE_INLINED.has(key2))
           continue;
-        if (typeof schema[key] == "object") {
-          (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
+        if (typeof schema[key2] == "object") {
+          (0, util_1.eachItem)(schema[key2], (sch) => count += countKeys(sch));
         }
         if (count === Infinity)
           return Infinity;
@@ -2485,8 +2485,8 @@ var require_validate = __commonJS({
     function schemaCxtHasRules({ schema, self }) {
       if (typeof schema == "boolean")
         return !schema;
-      for (const key in schema)
-        if (self.RULES.all[key])
+      for (const key2 in schema)
+        if (self.RULES.all[key2])
           return true;
       return false;
     }
@@ -4215,7 +4215,7 @@ var require_core = __commonJS({
         }
       }
       // Adds schema to the instance
-      addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
+      addSchema(schema, key2, _meta, _validateSchema = this.opts.validateSchema) {
         if (Array.isArray(schema)) {
           for (const sch of schema)
             this.addSchema(sch, void 0, _meta, _validateSchema);
@@ -4229,15 +4229,15 @@ var require_core = __commonJS({
             throw new Error(`schema ${schemaId} must be string`);
           }
         }
-        key = (0, resolve_1.normalizeId)(key || id);
-        this._checkUnique(key);
-        this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
+        key2 = (0, resolve_1.normalizeId)(key2 || id);
+        this._checkUnique(key2);
+        this.schemas[key2] = this._addSchema(schema, _meta, key2, _validateSchema, true);
         return this;
       }
       // Add schema that will be used to validate other schemas
       // options in META_IGNORE_OPTIONS are alway set to false
-      addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
-        this.addSchema(schema, key, true, _validateSchema);
+      addMetaSchema(schema, key2, _validateSchema = this.opts.validateSchema) {
+        this.addSchema(schema, key2, true, _validateSchema);
         return this;
       }
       //  Validate schema against its meta-schema
@@ -4393,14 +4393,14 @@ var require_core = __commonJS({
           let keywords = metaSchema;
           for (const seg of segments)
             keywords = keywords[seg];
-          for (const key in rules) {
-            const rule = rules[key];
+          for (const key2 in rules) {
+            const rule = rules[key2];
             if (typeof rule != "object")
               continue;
             const { $data } = rule.definition;
-            const schema = keywords[key];
+            const schema = keywords[key2];
             if ($data && schema)
-              keywords[key] = schemaOrData(schema);
+              keywords[key2] = schemaOrData(schema);
           }
         }
         return metaSchema;
@@ -4473,10 +4473,10 @@ var require_core = __commonJS({
     Ajv.MissingRefError = ref_error_1.default;
     exports.default = Ajv;
     function checkOptions(checkOpts, options, msg, log = "error") {
-      for (const key in checkOpts) {
-        const opt = key;
+      for (const key2 in checkOpts) {
+        const opt = key2;
         if (opt in options)
-          this.logger[log](`${msg}: option ${key}. ${checkOpts[opt]}`);
+          this.logger[log](`${msg}: option ${key2}. ${checkOpts[opt]}`);
       }
     }
     function getSchEnv(keyRef) {
@@ -4490,8 +4490,8 @@ var require_core = __commonJS({
       if (Array.isArray(optsSchemas))
         this.addSchema(optsSchemas);
       else
-        for (const key in optsSchemas)
-          this.addSchema(optsSchemas[key], key);
+        for (const key2 in optsSchemas)
+          this.addSchema(optsSchemas[key2], key2);
     }
     function addInitialFormats() {
       for (const name in this.opts.formats) {
@@ -5539,11 +5539,11 @@ var require_dependencies = __commonJS({
     function splitDependencies({ schema }) {
       const propertyDeps = {};
       const schemaDeps = {};
-      for (const key in schema) {
-        if (key === "__proto__")
+      for (const key2 in schema) {
+        if (key2 === "__proto__")
           continue;
-        const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
-        deps[key] = schema[key];
+        const deps = Array.isArray(schema[key2]) ? propertyDeps : schemaDeps;
+        deps[key2] = schema[key2];
       }
       return [propertyDeps, schemaDeps];
     }
@@ -5620,13 +5620,13 @@ var require_propertyNames = __commonJS({
         if ((0, util_1.alwaysValidSchema)(it, schema))
           return;
         const valid = gen.name("valid");
-        gen.forIn("key", data, (key) => {
-          cxt.setParams({ propertyName: key });
+        gen.forIn("key", data, (key2) => {
+          cxt.setParams({ propertyName: key2 });
           cxt.subschema({
             keyword: "propertyNames",
-            data: key,
+            data: key2,
             dataTypes: ["string"],
-            propertyName: key,
+            propertyName: key2,
             compositeRule: true
           }, valid);
           gen.if((0, codegen_1.not)(valid), () => {
@@ -5675,38 +5675,38 @@ var require_additionalProperties = __commonJS({
         checkAdditionalProperties();
         cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
         function checkAdditionalProperties() {
-          gen.forIn("key", data, (key) => {
+          gen.forIn("key", data, (key2) => {
             if (!props.length && !patProps.length)
-              additionalPropertyCode(key);
+              additionalPropertyCode(key2);
             else
-              gen.if(isAdditional(key), () => additionalPropertyCode(key));
+              gen.if(isAdditional(key2), () => additionalPropertyCode(key2));
           });
         }
-        function isAdditional(key) {
+        function isAdditional(key2) {
           let definedProp;
           if (props.length > 8) {
             const propsSchema = (0, util_1.schemaRefOrVal)(it, parentSchema.properties, "properties");
-            definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key);
+            definedProp = (0, code_1.isOwnProperty)(gen, propsSchema, key2);
           } else if (props.length) {
-            definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key} === ${p}`));
+            definedProp = (0, codegen_1.or)(...props.map((p) => (0, codegen_1._)`${key2} === ${p}`));
           } else {
             definedProp = codegen_1.nil;
           }
           if (patProps.length) {
-            definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key})`));
+            definedProp = (0, codegen_1.or)(definedProp, ...patProps.map((p) => (0, codegen_1._)`${(0, code_1.usePattern)(cxt, p)}.test(${key2})`));
           }
           return (0, codegen_1.not)(definedProp);
         }
-        function deleteAdditional(key) {
-          gen.code((0, codegen_1._)`delete ${data}[${key}]`);
+        function deleteAdditional(key2) {
+          gen.code((0, codegen_1._)`delete ${data}[${key2}]`);
         }
-        function additionalPropertyCode(key) {
+        function additionalPropertyCode(key2) {
           if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
-            deleteAdditional(key);
+            deleteAdditional(key2);
             return;
           }
           if (schema === false) {
-            cxt.setParams({ additionalProperty: key });
+            cxt.setParams({ additionalProperty: key2 });
             cxt.error();
             if (!allErrors)
               gen.break();
@@ -5715,22 +5715,22 @@ var require_additionalProperties = __commonJS({
           if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
             const valid = gen.name("valid");
             if (opts.removeAdditional === "failing") {
-              applyAdditionalSchema(key, valid, false);
+              applyAdditionalSchema(key2, valid, false);
               gen.if((0, codegen_1.not)(valid), () => {
                 cxt.reset();
-                deleteAdditional(key);
+                deleteAdditional(key2);
               });
             } else {
-              applyAdditionalSchema(key, valid);
+              applyAdditionalSchema(key2, valid);
               if (!allErrors)
                 gen.if((0, codegen_1.not)(valid), () => gen.break());
             }
           }
         }
-        function applyAdditionalSchema(key, valid, errors) {
+        function applyAdditionalSchema(key2, valid, errors) {
           const subschema = {
             keyword: "additionalProperties",
-            dataProp: key,
+            dataProp: key2,
             dataPropType: util_1.Type.Str
           };
           if (errors === false) {
@@ -5855,19 +5855,19 @@ var require_patternProperties = __commonJS({
           }
         }
         function validateProperties(pat) {
-          gen.forIn("key", data, (key) => {
-            gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key})`, () => {
+          gen.forIn("key", data, (key2) => {
+            gen.if((0, codegen_1._)`${(0, code_1.usePattern)(cxt, pat)}.test(${key2})`, () => {
               const alwaysValid = alwaysValidPatterns.includes(pat);
               if (!alwaysValid) {
                 cxt.subschema({
                   keyword: "patternProperties",
                   schemaProp: pat,
-                  dataProp: key,
+                  dataProp: key2,
                   dataPropType: util_2.Type.Str
                 }, valid);
               }
               if (it.opts.unevaluated && props !== true) {
-                gen.assign((0, codegen_1._)`${props}[${key}]`, true);
+                gen.assign((0, codegen_1._)`${props}[${key2}]`, true);
               } else if (!alwaysValid && !it.allErrors) {
                 gen.if((0, codegen_1.not)(valid), () => gen.break());
               }
@@ -7742,9 +7742,9 @@ function floatSafeRemainder(val, step) {
   return ratio - roundedRatio;
 }
 var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object3, key, getter) {
+function defineLazy(object3, key2, getter) {
   let value = void 0;
-  Object.defineProperty(object3, key, {
+  Object.defineProperty(object3, key2, {
     get() {
       if (value === EVALUATING) {
         return void 0;
@@ -7756,7 +7756,7 @@ function defineLazy(object3, key, getter) {
       return value;
     },
     set(v) {
-      Object.defineProperty(object3, key, {
+      Object.defineProperty(object3, key2, {
         value: v
         // configurable: true,
       });
@@ -7789,11 +7789,11 @@ function cloneDef(schema) {
 function getElementAtPath(obj, path) {
   if (!path)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key2) => acc?.[key2], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
+  const promises = keys.map((key2) => promisesObj[key2]);
   return Promise.all(promises).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
@@ -7865,8 +7865,8 @@ function shallowClone(o) {
 }
 function numKeys(data) {
   let keyCount = 0;
-  for (const key in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key)) {
+  for (const key2 in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key2)) {
       keyCount++;
     }
   }
@@ -8016,13 +8016,13 @@ function pick(schema, mask) {
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = {};
-      for (const key in mask) {
-        if (!(key in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key}"`);
+      for (const key2 in mask) {
+        if (!(key2 in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key2}"`);
         }
-        if (!mask[key])
+        if (!mask[key2])
           continue;
-        newShape[key] = currDef.shape[key];
+        newShape[key2] = currDef.shape[key2];
       }
       assignProp(this, "shape", newShape);
       return newShape;
@@ -8041,13 +8041,13 @@ function omit(schema, mask) {
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape = { ...schema._zod.def.shape };
-      for (const key in mask) {
-        if (!(key in currDef.shape)) {
-          throw new Error(`Unrecognized key: "${key}"`);
+      for (const key2 in mask) {
+        if (!(key2 in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key2}"`);
         }
-        if (!mask[key])
+        if (!mask[key2])
           continue;
-        delete newShape[key];
+        delete newShape[key2];
       }
       assignProp(this, "shape", newShape);
       return newShape;
@@ -8064,8 +8064,8 @@ function extend(schema, shape) {
   const hasChecks = checks && checks.length > 0;
   if (hasChecks) {
     const existingShape = schema._zod.def.shape;
-    for (const key in shape) {
-      if (Object.getOwnPropertyDescriptor(existingShape, key) !== void 0) {
+    for (const key2 in shape) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key2) !== void 0) {
         throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
       }
     }
@@ -8121,23 +8121,23 @@ function partial(Class3, schema, mask) {
       const oldShape = schema._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
-        for (const key in mask) {
-          if (!(key in oldShape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
+        for (const key2 in mask) {
+          if (!(key2 in oldShape)) {
+            throw new Error(`Unrecognized key: "${key2}"`);
           }
-          if (!mask[key])
+          if (!mask[key2])
             continue;
-          shape[key] = Class3 ? new Class3({
+          shape[key2] = Class3 ? new Class3({
             type: "optional",
-            innerType: oldShape[key]
-          }) : oldShape[key];
+            innerType: oldShape[key2]
+          }) : oldShape[key2];
         }
       } else {
-        for (const key in oldShape) {
-          shape[key] = Class3 ? new Class3({
+        for (const key2 in oldShape) {
+          shape[key2] = Class3 ? new Class3({
             type: "optional",
-            innerType: oldShape[key]
-          }) : oldShape[key];
+            innerType: oldShape[key2]
+          }) : oldShape[key2];
         }
       }
       assignProp(this, "shape", shape);
@@ -8153,22 +8153,22 @@ function required(Class3, schema, mask) {
       const oldShape = schema._zod.def.shape;
       const shape = { ...oldShape };
       if (mask) {
-        for (const key in mask) {
-          if (!(key in shape)) {
-            throw new Error(`Unrecognized key: "${key}"`);
+        for (const key2 in mask) {
+          if (!(key2 in shape)) {
+            throw new Error(`Unrecognized key: "${key2}"`);
           }
-          if (!mask[key])
+          if (!mask[key2])
             continue;
-          shape[key] = new Class3({
+          shape[key2] = new Class3({
             type: "nonoptional",
-            innerType: oldShape[key]
+            innerType: oldShape[key2]
           });
         }
       } else {
-        for (const key in oldShape) {
-          shape[key] = new Class3({
+        for (const key2 in oldShape) {
+          shape[key2] = new Class3({
             type: "nonoptional",
-            innerType: oldShape[key]
+            innerType: oldShape[key2]
           });
         }
       }
@@ -9949,13 +9949,13 @@ var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handlePropertyResult(result, final, key, input, isOptionalIn, isOptionalOut) {
-  const isPresent = key in input;
+function handlePropertyResult(result, final, key2, input, isOptionalIn, isOptionalOut) {
+  const isPresent = key2 in input;
   if (result.issues.length) {
     if (isOptionalIn && isOptionalOut && !isPresent) {
       return;
     }
-    final.issues.push(...prefixIssues(key, result.issues));
+    final.issues.push(...prefixIssues(key2, result.issues));
   }
   if (!isPresent && !isOptionalIn) {
     if (!result.issues.length) {
@@ -9963,17 +9963,17 @@ function handlePropertyResult(result, final, key, input, isOptionalIn, isOptiona
         code: "invalid_type",
         expected: "nonoptional",
         input: void 0,
-        path: [key]
+        path: [key2]
       });
     }
     return;
   }
   if (result.value === void 0) {
     if (isPresent) {
-      final.value[key] = void 0;
+      final.value[key2] = void 0;
     }
   } else {
-    final.value[key] = result.value;
+    final.value[key2] = result.value;
   }
 }
 function normalizeDef(def) {
@@ -9999,20 +9999,20 @@ function handleCatchall(proms, input, payload, ctx, def, inst) {
   const t = _catchall.def.type;
   const isOptionalIn = _catchall.optin === "optional";
   const isOptionalOut = _catchall.optout === "optional";
-  for (const key in input) {
-    if (key === "__proto__")
+  for (const key2 in input) {
+    if (key2 === "__proto__")
       continue;
-    if (keySet.has(key))
+    if (keySet.has(key2))
       continue;
     if (t === "never") {
-      unrecognized.push(key);
+      unrecognized.push(key2);
       continue;
     }
-    const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+    const r = _catchall.run({ value: input[key2], issues: [] }, ctx);
     if (r instanceof Promise) {
-      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
+      proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalIn, isOptionalOut)));
     } else {
-      handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
+      handlePropertyResult(r, payload, key2, input, isOptionalIn, isOptionalOut);
     }
   }
   if (unrecognized.length) {
@@ -10048,12 +10048,12 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
   defineLazy(inst._zod, "propValues", () => {
     const shape = def.shape;
     const propValues = {};
-    for (const key in shape) {
-      const field = shape[key]._zod;
+    for (const key2 in shape) {
+      const field = shape[key2]._zod;
       if (field.values) {
-        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+        propValues[key2] ?? (propValues[key2] = /* @__PURE__ */ new Set());
         for (const v of field.values)
-          propValues[key].add(v);
+          propValues[key2].add(v);
       }
     }
     return propValues;
@@ -10076,15 +10076,15 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     payload.value = {};
     const proms = [];
     const shape = value.shape;
-    for (const key of value.keys) {
-      const el = shape[key];
+    for (const key2 of value.keys) {
+      const el = shape[key2];
       const isOptionalIn = el._zod.optin === "optional";
       const isOptionalOut = el._zod.optout === "optional";
-      const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+      const r = el._zod.run({ value: input[key2], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key, input, isOptionalIn, isOptionalOut)));
+        proms.push(r.then((r2) => handlePropertyResult(r2, payload, key2, input, isOptionalIn, isOptionalOut)));
       } else {
-        handlePropertyResult(r, payload, key, input, isOptionalIn, isOptionalOut);
+        handlePropertyResult(r, payload, key2, input, isOptionalIn, isOptionalOut);
       }
     }
     if (!catchall) {
@@ -10100,24 +10100,24 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   const generateFastpass = (shape) => {
     const doc = new Doc(["shape", "payload", "ctx"]);
     const normalized = _normalized.value;
-    const parseStr = (key) => {
-      const k = esc(key);
+    const parseStr = (key2) => {
+      const k = esc(key2);
       return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
     };
     doc.write(`const input = payload.value;`);
     const ids = /* @__PURE__ */ Object.create(null);
     let counter = 0;
-    for (const key of normalized.keys) {
-      ids[key] = `key_${counter++}`;
+    for (const key2 of normalized.keys) {
+      ids[key2] = `key_${counter++}`;
     }
     doc.write(`const newResult = {};`);
-    for (const key of normalized.keys) {
-      const id = ids[key];
-      const k = esc(key);
-      const schema = shape[key];
+    for (const key2 of normalized.keys) {
+      const id = ids[key2];
+      const k = esc(key2);
+      const schema = shape[key2];
       const isOptionalIn = schema?._zod?.optin === "optional";
       const isOptionalOut = schema?._zod?.optout === "optional";
-      doc.write(`const ${id} = ${parseStr(key)};`);
+      doc.write(`const ${id} = ${parseStr(key2)};`);
       if (isOptionalIn && isOptionalOut) {
         doc.write(`
         if (${id}.issues.length) {
@@ -10429,17 +10429,17 @@ function mergeValues(a, b) {
   }
   if (isPlainObject(a) && isPlainObject(b)) {
     const bKeys = Object.keys(b);
-    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const sharedKeys = Object.keys(a).filter((key2) => bKeys.indexOf(key2) !== -1);
     const newObj = { ...a, ...b };
-    for (const key of sharedKeys) {
-      const sharedValue = mergeValues(a[key], b[key]);
+    for (const key2 of sharedKeys) {
+      const sharedValue = mergeValues(a[key2], b[key2]);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [key2, ...sharedValue.mergeErrorPath]
         };
       }
-      newObj[key] = sharedValue.data;
+      newObj[key2] = sharedValue.data;
     }
     return { valid: true, data: newObj };
   }
@@ -10574,9 +10574,9 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     return handleTupleResults(itemResults, payload, items, input, optoutStart);
   };
 });
-function getTupleOptStart(items, key) {
+function getTupleOptStart(items, key2) {
   for (let i = items.length - 1; i >= 0; i--) {
-    if (items[i]._zod[key] !== "optional")
+    if (items[i]._zod[key2] !== "optional")
       return i + 1;
   }
   return 0;
@@ -10627,10 +10627,10 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
     if (values) {
       payload.value = {};
       const recordKeys = /* @__PURE__ */ new Set();
-      for (const key of values) {
-        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-          recordKeys.add(typeof key === "number" ? key.toString() : key);
-          const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+      for (const key2 of values) {
+        if (typeof key2 === "string" || typeof key2 === "number" || typeof key2 === "symbol") {
+          recordKeys.add(typeof key2 === "number" ? key2.toString() : key2);
+          const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
           if (keyResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
           }
@@ -10639,34 +10639,34 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
               code: "invalid_key",
               origin: "record",
               issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-              input: key,
-              path: [key],
+              input: key2,
+              path: [key2],
               inst
             });
             continue;
           }
           const outKey = keyResult.value;
-          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
           if (result instanceof Promise) {
             proms.push(result.then((result2) => {
               if (result2.issues.length) {
-                payload.issues.push(...prefixIssues(key, result2.issues));
+                payload.issues.push(...prefixIssues(key2, result2.issues));
               }
               payload.value[outKey] = result2.value;
             }));
           } else {
             if (result.issues.length) {
-              payload.issues.push(...prefixIssues(key, result.issues));
+              payload.issues.push(...prefixIssues(key2, result.issues));
             }
             payload.value[outKey] = result.value;
           }
         }
       }
       let unrecognized;
-      for (const key in input) {
-        if (!recordKeys.has(key)) {
+      for (const key2 in input) {
+        if (!recordKeys.has(key2)) {
           unrecognized = unrecognized ?? [];
-          unrecognized.push(key);
+          unrecognized.push(key2);
         }
       }
       if (unrecognized && unrecognized.length > 0) {
@@ -10679,18 +10679,18 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
       }
     } else {
       payload.value = {};
-      for (const key of Reflect.ownKeys(input)) {
-        if (key === "__proto__")
+      for (const key2 of Reflect.ownKeys(input)) {
+        if (key2 === "__proto__")
           continue;
-        if (!Object.prototype.propertyIsEnumerable.call(input, key))
+        if (!Object.prototype.propertyIsEnumerable.call(input, key2))
           continue;
-        let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        let keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
         if (keyResult instanceof Promise) {
           throw new Error("Async schemas not supported in object keys currently");
         }
-        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
+        const checkNumericKey = typeof key2 === "string" && number.test(key2) && keyResult.issues.length;
         if (checkNumericKey) {
-          const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+          const retryResult = def.keyType._zod.run({ value: Number(key2), issues: [] }, ctx);
           if (retryResult instanceof Promise) {
             throw new Error("Async schemas not supported in object keys currently");
           }
@@ -10700,30 +10700,30 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         }
         if (keyResult.issues.length) {
           if (def.mode === "loose") {
-            payload.value[key] = input[key];
+            payload.value[key2] = input[key2];
           } else {
             payload.issues.push({
               code: "invalid_key",
               origin: "record",
               issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
-              input: key,
-              path: [key],
+              input: key2,
+              path: [key2],
               inst
             });
           }
           continue;
         }
-        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
         if (result instanceof Promise) {
           proms.push(result.then((result2) => {
             if (result2.issues.length) {
-              payload.issues.push(...prefixIssues(key, result2.issues));
+              payload.issues.push(...prefixIssues(key2, result2.issues));
             }
             payload.value[keyResult.value] = result2.value;
           }));
         } else {
           if (result.issues.length) {
-            payload.issues.push(...prefixIssues(key, result.issues));
+            payload.issues.push(...prefixIssues(key2, result.issues));
           }
           payload.value[keyResult.value] = result.value;
         }
@@ -10750,15 +10750,15 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     }
     const proms = [];
     payload.value = /* @__PURE__ */ new Map();
-    for (const [key, value] of input) {
-      const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+    for (const [key2, value] of input) {
+      const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
       const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
       if (keyResult instanceof Promise || valueResult instanceof Promise) {
         proms.push(Promise.all([keyResult, valueResult]).then(([keyResult2, valueResult2]) => {
-          handleMapResult(keyResult2, valueResult2, payload, key, input, inst, ctx);
+          handleMapResult(keyResult2, valueResult2, payload, key2, input, inst, ctx);
         }));
       } else {
-        handleMapResult(keyResult, valueResult, payload, key, input, inst, ctx);
+        handleMapResult(keyResult, valueResult, payload, key2, input, inst, ctx);
       }
     }
     if (proms.length)
@@ -10766,10 +10766,10 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     return payload;
   };
 });
-function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
+function handleMapResult(keyResult, valueResult, final, key2, input, inst, ctx) {
   if (keyResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, keyResult.issues));
+    if (propertyKeyTypes.has(typeof key2)) {
+      final.issues.push(...prefixIssues(key2, keyResult.issues));
     } else {
       final.issues.push({
         code: "invalid_key",
@@ -10781,15 +10781,15 @@ function handleMapResult(keyResult, valueResult, final, key, input, inst, ctx) {
     }
   }
   if (valueResult.issues.length) {
-    if (propertyKeyTypes.has(typeof key)) {
-      final.issues.push(...prefixIssues(key, valueResult.issues));
+    if (propertyKeyTypes.has(typeof key2)) {
+      final.issues.push(...prefixIssues(key2, valueResult.issues));
     } else {
       final.issues.push({
         origin: "map",
         code: "invalid_element",
         input,
         inst,
-        key,
+        key: key2,
         issues: valueResult.issues.map((iss) => finalizeIssue(iss, ctx, config()))
       });
     }
@@ -18550,8 +18550,8 @@ function extractDefs(ctx, schema) {
     if (defId)
       seen.defId = defId;
     const schema2 = seen.schema;
-    for (const key in schema2) {
-      delete schema2[key];
+    for (const key2 in schema2) {
+      delete schema2[key2];
     }
     schema2.$ref = ref;
   };
@@ -18620,20 +18620,20 @@ function finalize(ctx, schema) {
       Object.assign(schema2, _cached);
       const isParentRef = zodSchema._zod.parent === ref;
       if (isParentRef) {
-        for (const key in schema2) {
-          if (key === "$ref" || key === "allOf")
+        for (const key2 in schema2) {
+          if (key2 === "$ref" || key2 === "allOf")
             continue;
-          if (!(key in _cached)) {
-            delete schema2[key];
+          if (!(key2 in _cached)) {
+            delete schema2[key2];
           }
         }
       }
       if (refSchema.$ref && refSeen.def) {
-        for (const key in schema2) {
-          if (key === "$ref" || key === "allOf")
+        for (const key2 in schema2) {
+          if (key2 === "$ref" || key2 === "allOf")
             continue;
-          if (key in refSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(refSeen.def[key])) {
-            delete schema2[key];
+          if (key2 in refSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(refSeen.def[key2])) {
+            delete schema2[key2];
           }
         }
       }
@@ -18645,11 +18645,11 @@ function finalize(ctx, schema) {
       if (parentSeen?.schema.$ref) {
         schema2.$ref = parentSeen.schema.$ref;
         if (parentSeen.def) {
-          for (const key in schema2) {
-            if (key === "$ref" || key === "allOf")
+          for (const key2 in schema2) {
+            if (key2 === "$ref" || key2 === "allOf")
               continue;
-            if (key in parentSeen.def && JSON.stringify(schema2[key]) === JSON.stringify(parentSeen.def[key])) {
-              delete schema2[key];
+            if (key2 in parentSeen.def && JSON.stringify(schema2[key2]) === JSON.stringify(parentSeen.def[key2])) {
+              delete schema2[key2];
             }
           }
         }
@@ -18750,8 +18750,8 @@ function isTransforming(_schema, _ctx) {
     return isTransforming(def.in, ctx) || isTransforming(def.out, ctx);
   }
   if (def.type === "object") {
-    for (const key in def.shape) {
-      if (isTransforming(def.shape[key], ctx))
+    for (const key2 in def.shape) {
+      if (isTransforming(def.shape[key2], ctx))
         return true;
     }
     return false;
@@ -19040,15 +19040,15 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json2.type = "object";
   json2.properties = {};
   const shape = def.shape;
-  for (const key in shape) {
-    json2.properties[key] = process2(shape[key], ctx, {
+  for (const key2 in shape) {
+    json2.properties[key2] = process2(shape[key2], ctx, {
       ...params,
-      path: [...params.path, "properties", key]
+      path: [...params.path, "properties", key2]
     });
   }
   const allKeys = new Set(Object.keys(shape));
-  const requiredKeys = new Set([...allKeys].filter((key) => {
-    const v = def.shape[key]._zod;
+  const requiredKeys = new Set([...allKeys].filter((key2) => {
+    const v = def.shape[key2]._zod;
     if (ctx.io === "input") {
       return v.optin === void 0;
     } else {
@@ -19314,9 +19314,9 @@ function toJSONSchema(input, params) {
     };
     ctx2.external = external;
     for (const entry of registry3._idmap.entries()) {
-      const [key, schema] = entry;
+      const [key2, schema] = entry;
       extractDefs(ctx2, schema);
-      schemas[key] = finalize(ctx2, schema);
+      schemas[key2] = finalize(ctx2, schema);
     }
     if (Object.keys(defs).length > 0) {
       const defsSegment = ctx2.target === "draft-2020-12" ? "$defs" : "definitions";
@@ -19722,14 +19722,14 @@ function _installLazyMethods(inst, group, methods) {
   if (installed.has(group))
     return;
   installed.add(group);
-  for (const key in methods) {
-    const fn = methods[key];
-    Object.defineProperty(proto, key, {
+  for (const key2 in methods) {
+    const fn = methods[key2];
+    Object.defineProperty(proto, key2, {
       configurable: true,
       enumerable: false,
       get() {
         const bound = fn.bind(this);
-        Object.defineProperty(this, key, {
+        Object.defineProperty(this, key2, {
           configurable: true,
           writable: true,
           enumerable: true,
@@ -19738,7 +19738,7 @@ function _installLazyMethods(inst, group, methods) {
         return bound;
       },
       set(v) {
-        Object.defineProperty(this, key, {
+        Object.defineProperty(this, key2, {
           configurable: true,
           writable: true,
           enumerable: true,
@@ -21126,11 +21126,11 @@ function resolveRef(ref, ctx) {
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
   if (path[0] === defsKey) {
-    const key = path[1];
-    if (!key || !ctx.defs[key]) {
+    const key2 = path[1];
+    if (!key2 || !ctx.defs[key2]) {
       throw new Error(`Reference not found: ${ref}`);
     }
-    return ctx.defs[key];
+    return ctx.defs[key2];
   }
   throw new Error(`Reference not found: ${ref}`);
 }
@@ -21316,9 +21316,9 @@ function convertBaseSchema(schema, ctx) {
       const shape = {};
       const properties = schema.properties || {};
       const requiredSet = new Set(schema.required || []);
-      for (const [key, propSchema] of Object.entries(properties)) {
+      for (const [key2, propSchema] of Object.entries(properties)) {
         const propZodSchema = convertSchema(propSchema, ctx);
-        shape[key] = requiredSet.has(key) ? propZodSchema : propZodSchema.optional();
+        shape[key2] = requiredSet.has(key2) ? propZodSchema : propZodSchema.optional();
       }
       if (schema.propertyNames) {
         const keySchema = convertSchema(schema.propertyNames, ctx);
@@ -21459,20 +21459,20 @@ function convertSchema(schema, ctx) {
   }
   const extraMeta = {};
   const coreMetadataKeys = ["$id", "id", "$comment", "$anchor", "$vocabulary", "$dynamicRef", "$dynamicAnchor"];
-  for (const key of coreMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+  for (const key2 of coreMetadataKeys) {
+    if (key2 in schema) {
+      extraMeta[key2] = schema[key2];
     }
   }
   const contentMetadataKeys = ["contentEncoding", "contentMediaType", "contentSchema"];
-  for (const key of contentMetadataKeys) {
-    if (key in schema) {
-      extraMeta[key] = schema[key];
+  for (const key2 of contentMetadataKeys) {
+    if (key2 in schema) {
+      extraMeta[key2] = schema[key2];
     }
   }
-  for (const key of Object.keys(schema)) {
-    if (!RECOGNIZED_KEYS.has(key)) {
-      extraMeta[key] = schema[key];
+  for (const key2 of Object.keys(schema)) {
+    if (!RECOGNIZED_KEYS.has(key2)) {
+      extraMeta[key2] = schema[key2];
     }
   }
   if (Object.keys(extraMeta).length > 0) {
@@ -23911,6 +23911,9 @@ var SessionMap = class {
   delete(k) {
     this.inner.delete(keyOf(k));
   }
+  clear() {
+    this.inner.clear();
+  }
   listForAgent(agentId) {
     const out = [];
     for (const v of this.inner.values()) {
@@ -24287,10 +24290,18 @@ var AcpClient = class {
   store = null;
   storeLoaded = null;
   agentCapabilities = {};
+  lifecycle = /* @__PURE__ */ new Map();
+  replay = /* @__PURE__ */ new Set();
+  permissionCancels = /* @__PURE__ */ new Map();
+  generation = 0;
+  warnedNoClose = false;
   warnedNoStore = false;
   initialized = false;
   turns;
   async start() {
+    this.generation++;
+    this.clearTimers();
+    this.warnedNoClose = false;
     const { command, args } = this.resolveSpawn();
     let stdout;
     let stdin;
@@ -24340,6 +24351,13 @@ var AcpClient = class {
     this.initialized = true;
   }
   async stop() {
+    this.generation++;
+    this.clearTimers();
+    for (const cancels of this.permissionCancels.values()) for (const cancel of cancels) cancel();
+    this.permissionCancels.clear();
+    this.replay.clear();
+    this.sessions.clear();
+    this.lifecycle.clear();
     this.process?.kill();
     this.runtimeChild?.kill("SIGTERM");
     this.process = null;
@@ -24348,14 +24366,27 @@ var AcpClient = class {
     this.initialized = false;
   }
   async ensureSession(threadId, channelId, contextThreadId) {
+    return this.enqueue(
+      threadId,
+      () => this.ensureSessionLocked(threadId, channelId, contextThreadId)
+    );
+  }
+  async ensureSessionLocked(threadId, channelId, contextThreadId) {
     if (!this.connection || !this.initialized) {
       throw new Error("AcpClient.start() must be called before ensureSession()");
     }
+    const generation = this.generation;
     await this.ensureStoreLoaded();
-    const key = { threadId, agentId: this.options.agent.id };
-    const cached3 = this.sessions.get(key);
-    if (cached3) return cached3.sessionId;
+    if (generation !== this.generation) throw new Error("ACP connection changed during session setup");
+    const key2 = { threadId, agentId: this.options.agent.id };
+    const cached3 = this.sessions.get(key2);
+    if (cached3) {
+      this.emitLifecycle(threadId, cached3.sessionId, "recovered", void 0, "cached");
+      this.scheduleIdle(threadId);
+      return cached3.sessionId;
+    }
     const mcpServers = this.options.contextSpawn ? [await this.options.contextSpawn(contextThreadId ?? threadId, channelId, threadId)] : [];
+    if (generation !== this.generation) throw new Error("ACP connection changed during session setup");
     process.stderr.write(
       `[acp-client:${this.options.agent.id}] ensureSession(${threadId}) mcpServers=${mcpServers.length === 0 ? "[]" : JSON.stringify(
         mcpServers.map((s) => ({
@@ -24367,36 +24398,158 @@ var AcpClient = class {
 `
     );
     const persisted = this.store?.get(threadId);
-    if (persisted && this.agentCapabilities.loadSession) {
-      let loaded;
-      try {
-        loaded = await this.connection.loadSession({
-          sessionId: persisted,
-          cwd: pathResolve(this.options.agent.cwd ?? process.cwd()),
-          mcpServers
-        });
-      } catch (err) {
-        console.warn(
-          `[acp-client:${this.options.agent.id}] loadSession(${persisted}) failed; falling back to newSession:`,
-          err
-        );
-        await this.store?.delete(threadId);
-      }
-      if (loaded) {
-        await this.applyMode(persisted, loaded.modes);
-        this.sessions.set(key, { sessionId: persisted, startedAt: Date.now() });
-        return persisted;
+    if (persisted) {
+      const request = {
+        sessionId: persisted,
+        cwd: pathResolve(this.options.agent.cwd ?? process.cwd()),
+        mcpServers
+      };
+      for (const method of ["resume", "load"]) {
+        if (method === "resume" && !this.agentCapabilities.sessionCapabilities?.resume) continue;
+        if (method === "load" && !this.agentCapabilities.loadSession) continue;
+        this.replay.add(`${generation}:${persisted}`);
+        try {
+          const recovered = method === "resume" ? await this.connection.resumeSession(request) : await this.connection.loadSession(request);
+          if (generation !== this.generation) {
+            throw new Error("ACP connection changed during recovery");
+          }
+          await this.applyMode(persisted, recovered.modes);
+          this.sessions.set(key2, { sessionId: persisted, startedAt: Date.now() });
+          this.emitLifecycle(threadId, persisted, "recovered", void 0, method);
+          this.scheduleIdle(threadId);
+          return persisted;
+        } catch (err) {
+          if (generation !== this.generation) throw err;
+          console.warn(
+            `[acp-client:${this.options.agent.id}] ${method}Session(${persisted}) failed for ${threadId}:`,
+            err
+          );
+          this.emitLifecycle(threadId, persisted, "failed", void 0, method);
+        } finally {
+          this.replay.delete(`${generation}:${persisted}`);
+        }
       }
     }
     const { sessionId, modes } = await this.connection.newSession({
       cwd: pathResolve(this.options.agent.cwd ?? process.cwd()),
       mcpServers
     });
+    if (generation !== this.generation) throw new Error("ACP connection changed during session setup");
     await this.applyMode(sessionId, modes);
-    this.sessions.set(key, { sessionId, startedAt: Date.now() });
+    if (generation !== this.generation) throw new Error("ACP connection changed during session setup");
+    this.sessions.set(key2, { sessionId, startedAt: Date.now() });
     await this.store?.set(threadId, sessionId);
+    this.emitLifecycle(threadId, sessionId, "recovered", void 0, "new");
+    this.scheduleIdle(threadId);
     return sessionId;
   }
+  state(threadId) {
+    let state = this.lifecycle.get(threadId);
+    if (!state) {
+      state = {
+        tail: Promise.resolve(),
+        prompts: 0,
+        activeTurns: /* @__PURE__ */ new Set(),
+        humans: 0,
+        resetting: false,
+        closing: false
+      };
+      this.lifecycle.set(threadId, state);
+    }
+    return state;
+  }
+  enqueue(threadId, work) {
+    const state = this.state(threadId);
+    const result = state.tail.then(work, work);
+    state.tail = result.catch(() => {
+    });
+    return result;
+  }
+  clearTimer(threadId) {
+    const state = this.state(threadId);
+    if (state.timer) clearTimeout(state.timer);
+    state.timer = void 0;
+  }
+  clearTimers() {
+    for (const threadId of this.lifecycle.keys()) this.clearTimer(threadId);
+  }
+  scheduleIdle(threadId) {
+    const state = this.state(threadId);
+    this.clearTimer(threadId);
+    const timeout = this.options.sessionIdleTimeoutMs ?? 6e5;
+    if (!timeout || state.prompts || state.humans || state.resetting || state.closing || !this.initialized) return;
+    if (!this.sessions.get({ threadId, agentId: this.options.agent.id })) return;
+    const caps = this.agentCapabilities;
+    if (!caps.sessionCapabilities?.close) {
+      this.warnNoIdleClose("session/close unsupported; adapter resources remain until process exit");
+      return;
+    }
+    if (!caps.sessionCapabilities.resume && !caps.loadSession) {
+      this.warnNoIdleClose("adapter cannot resume or load sessions; idle close disabled to keep context");
+      return;
+    }
+    const generation = this.generation;
+    state.timer = setTimeout(() => {
+      if (generation === this.generation) void this.closeIdleSession(threadId);
+    }, timeout);
+    state.timer.unref?.();
+  }
+  warnNoIdleClose(reason) {
+    if (this.warnedNoClose) return;
+    console.warn(`[acp-client:${this.options.agent.id}] ${reason}`);
+    this.warnedNoClose = true;
+  }
+  emitLifecycle(sessionKey, sessionId, outcome, reason, recoveryMethod) {
+    this.options.onLifecycle?.({
+      agentId: this.options.agent.id,
+      sessionKey,
+      sessionId,
+      reason,
+      outcome,
+      recoveryMethod
+    });
+  }
+  setHumanRequestPending(threadId, pending) {
+    const state = this.state(threadId);
+    state.humans = Math.max(0, state.humans + (pending ? 1 : -1));
+    if (pending) this.clearTimer(threadId);
+    else this.scheduleIdle(threadId);
+  }
+  async closeIdleSession(threadId) {
+    const claim = this.state(threadId);
+    if (claim.prompts || claim.humans || claim.resetting || claim.closing) return;
+    claim.closing = true;
+    return this.enqueue(threadId, async () => {
+      const state = this.state(threadId);
+      this.clearTimer(threadId);
+      try {
+        if (state.humans || state.resetting) return;
+        const key2 = { threadId, agentId: this.options.agent.id };
+        const live = this.sessions.get(key2);
+        if (!live || !this.connection || !this.initialized) return;
+        if (!this.agentCapabilities.sessionCapabilities?.close) {
+          this.warnNoIdleClose("session/close unsupported; adapter resources remain until process exit");
+          this.emitLifecycle(threadId, live.sessionId, "unsupported", "idle");
+          return;
+        }
+        const generation = this.generation;
+        try {
+          await this.connection.closeSession({ sessionId: live.sessionId });
+          this.emitLifecycle(threadId, live.sessionId, "closed", "idle");
+        } catch (err) {
+          console.warn(
+            `[acp-client:${this.options.agent.id}] idle close failed for ${threadId}/${live.sessionId}:`,
+            err
+          );
+          this.emitLifecycle(threadId, live.sessionId, "failed", "idle");
+        } finally {
+          if (generation === this.generation) this.sessions.delete(key2);
+        }
+      } finally {
+        state.closing = false;
+      }
+    });
+  }
   /**
    * Put a freshly created or loaded session into the agent's configured mode.
    * Mode ids are adapter-defined, so an id the adapter doesn't list is a
@@ -24451,31 +24604,94 @@ var AcpClient = class {
     await this.connection.cancel({ sessionId });
   }
   /**
-   * Drop the session for the given thread so the next prompt starts fresh.
-   * No ACP-side cancellation — callers should ensure no prompt is in flight.
+   * Cancel outstanding work, close the live ACP session when supported, and
+   * forget the durable pointer so the next prompt starts fresh.
    */
-  endSession(threadId) {
-    this.sessions.delete({ threadId, agentId: this.options.agent.id });
-    void this.store?.delete(threadId);
+  async endSession(threadId) {
+    const state = this.state(threadId);
+    state.resetting = true;
+    this.clearTimer(threadId);
+    const key2 = { threadId, agentId: this.options.agent.id };
+    const live = this.sessions.get(key2);
+    return this.enqueue(threadId, async () => {
+      try {
+        if (live) {
+          for (const cancel of this.permissionCancels.get(live.sessionId) ?? []) cancel();
+          if (state.activeTurns.size) {
+            try {
+              await this.cancel(live.sessionId);
+            } catch (err) {
+              console.warn(
+                `[acp-client:${this.options.agent.id}] cancel failed for ${threadId}/${live.sessionId}:`,
+                err
+              );
+            }
+            await Promise.allSettled([...state.activeTurns]);
+          }
+        }
+        await this.ensureStoreLoaded();
+        const current = this.sessions.get(key2);
+        if (current && this.connection && this.initialized && this.agentCapabilities.sessionCapabilities?.close) {
+          try {
+            await this.connection.closeSession({ sessionId: current.sessionId });
+            this.emitLifecycle(threadId, current.sessionId, "closed", "clear");
+          } catch (err) {
+            console.warn(
+              `[acp-client:${this.options.agent.id}] clear close failed for ${threadId}/${current.sessionId}:`,
+              err
+            );
+            this.emitLifecycle(threadId, current.sessionId, "failed", "clear");
+          }
+        } else if (current) {
+          this.warnNoIdleClose("session/close unsupported; adapter resources remain until process exit");
+          this.emitLifecycle(threadId, current.sessionId, "unsupported", "clear");
+        }
+        this.sessions.delete(key2);
+        await this.store?.delete(threadId);
+      } finally {
+        state.humans = 0;
+        state.resetting = false;
+      }
+    });
   }
   async prompt(input) {
+    const generation = this.generation;
+    const state = this.state(input.threadId);
+    state.prompts++;
+    this.clearTimer(input.threadId);
     let sessionId = null;
     let turnId = null;
     try {
-      sessionId = await this.ensureSession(input.threadId, input.channelId, input.contextThreadId);
-      const promptText = stringifyPromptForLog(input.content);
-      turnId = this.turns?.startTurn({ sessionId, promptText }) ?? null;
-      debugLog(this.options.agent.id, "prompt \u2192", {
-        sessionId,
-        content: input.content
-      });
-      const result = await this.connection.prompt({
-        sessionId,
-        prompt: input.content
+      const launched = await this.enqueue(input.threadId, async () => {
+        const id = await this.ensureSessionLocked(
+          input.threadId,
+          input.channelId,
+          input.contextThreadId
+        );
+        sessionId = id;
+        const promptText = stringifyPromptForLog(input.content);
+        turnId = this.turns?.startTurn({ sessionId: id, promptText }) ?? null;
+        debugLog(this.options.agent.id, "prompt \u2192", {
+          sessionId: id,
+          content: input.content
+        });
+        let finish;
+        const completed = new Promise((resolve) => {
+          finish = resolve;
+        });
+        const result2 = this.connection.prompt({ sessionId: id, prompt: input.content });
+        state.activeTurns.add(completed);
+        void result2.finally(() => {
+          state.activeTurns.delete(completed);
+          finish();
+        }).catch(() => {
+        });
+        return { id, result: result2 };
       });
-      this.turns?.endTurn({ sessionId, stopReason: result.stopReason });
+      const result = await launched.result;
+      this.turns?.endTurn({ sessionId: launched.id, stopReason: result.stopReason });
       debugLog(this.options.agent.id, "prompt \u2190", {
-        sessionId,
+        sessionId: launched.id,
         stopReason: result.stopReason
       });
       return { stopReason: result.stopReason };
@@ -24494,6 +24710,9 @@ var AcpClient = class {
       });
       if (sessionId) this.turns?.endTurn({ sessionId, stopReason: "error" });
       throw err;
+    } finally {
+      state.prompts--;
+      if (generation === this.generation) this.scheduleIdle(input.threadId);
     }
   }
   resolveSpawn() {
@@ -24508,8 +24727,12 @@ var AcpClient = class {
   }
   buildClient() {
     const agentId = this.options.agent.id;
+    const generation = this.generation;
     return {
       sessionUpdate: async (params) => {
+        if (generation !== this.generation || this.replay.has(`${generation}:${params.sessionId}`)) {
+          return;
+        }
         this.turns?.observeUpdate(params.sessionId, params.update);
         debugLog(agentId, "sessionUpdate", params);
         const event = acpUpdateToAgentEvent(params);
@@ -24517,22 +24740,43 @@ var AcpClient = class {
         else debugLog(agentId, "sessionUpdate dropped (unmapped)", params);
       },
       requestPermission: async (params) => {
+        if (generation !== this.generation) return { outcome: { outcome: "cancelled" } };
         debugLog(agentId, "requestPermission", params);
         const tc = params.toolCall;
-        const decision = await this.options.onApprovalRequest({
-          sessionId: params.sessionId,
-          toolCallId: tc.toolCallId,
-          toolKind: tc.kind,
-          toolTitle: tc.title,
-          toolInput: tc.rawInput,
-          options: params.options.map((o) => ({
-            optionId: o.optionId,
-            name: o.name,
-            kind: o.kind
-          }))
+        const threadId = [...this.lifecycle.keys()].find(
+          (key2) => this.sessions.get({ threadId: key2, agentId })?.sessionId === params.sessionId
+        );
+        if (threadId) this.setHumanRequestPending(threadId, true);
+        let cancel;
+        const cancelled = new Promise((resolve) => {
+          cancel = () => resolve({ decision: "cancel" });
         });
-        debugLog(agentId, "requestPermission \u2190", decision);
-        return approvalDecisionToPermissionResponse(decision);
+        const pending = this.permissionCancels.get(params.sessionId) ?? /* @__PURE__ */ new Set();
+        pending.add(cancel);
+        this.permissionCancels.set(params.sessionId, pending);
+        try {
+          const decision = await Promise.race([
+            this.options.onApprovalRequest({
+              sessionId: params.sessionId,
+              toolCallId: tc.toolCallId,
+              toolKind: tc.kind,
+              toolTitle: tc.title,
+              toolInput: tc.rawInput,
+              options: params.options.map((o) => ({
+                optionId: o.optionId,
+                name: o.name,
+                kind: o.kind
+              }))
+            }),
+            cancelled
+          ]);
+          debugLog(agentId, "requestPermission \u2190", decision);
+          return approvalDecisionToPermissionResponse(decision);
+        } finally {
+          pending.delete(cancel);
+          if (!pending.size) this.permissionCancels.delete(params.sessionId);
+          if (threadId) this.setHumanRequestPending(threadId, false);
+        }
       }
     };
   }
@@ -24544,9 +24788,9 @@ function stringifyPromptForLog(content) {
     return "<unstringifiable>";
   }
 }
-function debugLog(agentId, label, payload) {
+function debugLog(agentId, label2, payload) {
   if (payload === void 0) {
-    process.stderr.write(`[${agentId}] ${label}
+    process.stderr.write(`[${agentId}] ${label2}
 `);
     return;
   }
@@ -24557,7 +24801,7 @@ function debugLog(agentId, label, payload) {
     s = String(payload);
   }
   if (s.length > 2e3) s = s.slice(0, 2e3) + "\u2026";
-  process.stderr.write(`[${agentId}] ${label} ${s}
+  process.stderr.write(`[${agentId}] ${label2} ${s}
 `);
 }
 function forwardStderr(stream, agentId) {
@@ -24585,15 +24829,15 @@ var EnvInterpolationError = class extends Error {
 };
 var isDenied = (name) => name === "ZOOID_TOKEN" || name.startsWith("ZOOID_");
 function interpolateEnv(parsed, processEnv, scope) {
-  for (const [key, val] of Object.entries(parsed)) {
-    if (isDenied(key)) {
+  for (const [key2, val] of Object.entries(parsed)) {
+    if (isDenied(key2)) {
       throw new EnvInterpolationError(
-        `${scope}.${key}: keys in the ZOOID_* namespace are not allowed`
+        `${scope}.${key2}: keys in the ZOOID_* namespace are not allowed`
       );
     }
     if (typeof val !== "string") {
       throw new EnvInterpolationError(
-        `${scope}.${key}: env values must be strings (got ${typeof val})`
+        `${scope}.${key2}: env values must be strings (got ${typeof val})`
       );
     }
     REF_RE.lastIndex = 0;
@@ -24602,14 +24846,14 @@ function interpolateEnv(parsed, processEnv, scope) {
       const ref = m[1] ?? m[2];
       if (isDenied(ref)) {
         throw new EnvInterpolationError(
-          `${scope}.${key}: references to ZOOID_* vars are not allowed (saw \${${ref}})`
+          `${scope}.${key2}: references to ZOOID_* vars are not allowed (saw \${${ref}})`
         );
       }
     }
   }
   const out = {};
-  for (const [key, val] of Object.entries(parsed)) {
-    out[key] = interpolateString(val, processEnv);
+  for (const [key2, val] of Object.entries(parsed)) {
+    out[key2] = interpolateString(val, processEnv);
   }
   return out;
 }
@@ -25896,14 +26140,14 @@ function checkListItem(field, index, value) {
   }
   return void 0;
 }
-function checkMapEntry(field, key, value) {
-  const checkKey = checkScalarValue(field.mapKey)(key);
+function checkMapEntry(field, key2, value) {
+  const checkKey = checkScalarValue(field.mapKey)(key2);
   if (checkKey !== true) {
-    return new FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key, checkKey)}`);
+    return new FieldError(field, `invalid map key: ${reasonSingular({ scalar: field.mapKey }, key2, checkKey)}`);
   }
   const checkVal = checkSingular(field, value);
   if (checkVal !== true) {
-    return new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, checkVal)}`);
+    return new FieldError(field, `map entry ${formatVal(key2)}: ${reasonSingular(field, value, checkVal)}`);
   }
   return void 0;
 }
@@ -26616,18 +26860,18 @@ var ReflectMapImpl = class {
   field() {
     return this._field;
   }
-  set(key, value) {
+  set(key2, value) {
     if (this.check) {
-      const err = checkMapEntry(this._field, key, value);
+      const err = checkMapEntry(this._field, key2, value);
       if (err) {
         throw err;
       }
     }
-    this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
+    this.obj[mapKeyToLocal(key2)] = mapValueToLocal(this._field, value);
     return this;
   }
-  delete(key) {
-    const k = mapKeyToLocal(key);
+  delete(key2) {
+    const k = mapKeyToLocal(key2);
     const has = Object.prototype.hasOwnProperty.call(this.obj, k);
     if (has) {
       delete this.obj[k];
@@ -26635,19 +26879,19 @@ var ReflectMapImpl = class {
     return has;
   }
   clear() {
-    for (const key of Object.keys(this.obj)) {
-      delete this.obj[key];
+    for (const key2 of Object.keys(this.obj)) {
+      delete this.obj[key2];
     }
   }
-  get(key) {
-    let val = this.obj[mapKeyToLocal(key)];
+  get(key2) {
+    let val = this.obj[mapKeyToLocal(key2)];
     if (val !== void 0) {
       val = mapValueToReflect(this._field, val, this.check);
     }
     return val;
   }
-  has(key) {
-    return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key));
+  has(key2) {
+    return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key2));
   }
   *keys() {
     for (const objKey of Object.keys(this.obj)) {
@@ -26728,26 +26972,26 @@ function mapValueToReflect(field, value, check3) {
   }
   return value;
 }
-function mapKeyToLocal(key) {
-  return typeof key == "string" || typeof key == "number" ? key : String(key);
+function mapKeyToLocal(key2) {
+  return typeof key2 == "string" || typeof key2 == "number" ? key2 : String(key2);
 }
-function mapKeyToReflect(key, type) {
+function mapKeyToReflect(key2, type) {
   switch (type) {
     case ScalarType.STRING:
-      return key;
+      return key2;
     case ScalarType.INT32:
     case ScalarType.FIXED32:
     case ScalarType.UINT32:
     case ScalarType.SFIXED32:
     case ScalarType.SINT32: {
-      const n = Number.parseInt(key);
+      const n = Number.parseInt(key2);
       if (Number.isFinite(n)) {
         return n;
       }
       break;
     }
     case ScalarType.BOOL:
-      switch (key) {
+      switch (key2) {
         case "true":
           return true;
         case "false":
@@ -26757,18 +27001,18 @@ function mapKeyToReflect(key, type) {
     case ScalarType.UINT64:
     case ScalarType.FIXED64:
       try {
-        return protoInt64.uParse(key);
+        return protoInt64.uParse(key2);
       } catch (_a3) {
       }
       break;
     default:
       try {
-        return protoInt64.parse(key);
+        return protoInt64.parse(key2);
       } catch (_b) {
       }
       break;
   }
-  return key;
+  return key2;
 }
 function longToReflect(field, value) {
   switch (field.scalar) {
@@ -27677,15 +27921,15 @@ function newField(proto, parentOrFile, reg, oneof, mapEntries) {
     enumerable: true,
     configurable: true
   });
-  const label = proto.label;
+  const label2 = proto.label;
   const type = proto.type;
   const jstype = (_c = proto.options) === null || _c === void 0 ? void 0 : _c.jstype;
-  if (label === LABEL_REPEATED) {
+  if (label2 === LABEL_REPEATED) {
     const mapEntry = type == TYPE_MESSAGE ? mapEntries === null || mapEntries === void 0 ? void 0 : mapEntries.get(trimLeadingDot(proto.typeName)) : void 0;
     if (mapEntry) {
       field.fieldKind = "map";
-      const { key, value } = findMapEntryFields(mapEntry);
-      field.mapKey = key.scalar;
+      const { key: key2, value } = findMapEntryFields(mapEntry);
+      field.mapKey = key2.scalar;
       field.mapKind = value.fieldKind;
       field.message = value.message;
       field.delimitedEncoding = false;
@@ -27859,10 +28103,10 @@ function isPackedField(proto, parent) {
   });
 }
 function findMapEntryFields(mapEntry) {
-  const key = mapEntry.fields.find((f) => f.number === 1);
+  const key2 = mapEntry.fields.find((f) => f.number === 1);
   const value = mapEntry.fields.find((f) => f.number === 2);
-  assert2(key && key.fieldKind == "scalar" && key.scalar != ScalarType.BYTES && key.scalar != ScalarType.FLOAT && key.scalar != ScalarType.DOUBLE && value && value.fieldKind != "list" && value.fieldKind != "map");
-  return { key, value };
+  assert2(key2 && key2.fieldKind == "scalar" && key2.scalar != ScalarType.BYTES && key2.scalar != ScalarType.FLOAT && key2.scalar != ScalarType.DOUBLE && value && value.fieldKind != "list" && value.fieldKind != "map");
+  return { key: key2, value };
 }
 function isEnumOpen(desc) {
   var _a3;
@@ -28401,7 +28645,7 @@ function compileMapFieldReader(field) {
   }
   return (message, reader, ctx) => {
     const record3 = message[localName];
-    let key;
+    let key2;
     let val;
     const len = reader.uint32();
     const end = reader.pos + len;
@@ -28409,20 +28653,20 @@ function compileMapFieldReader(field) {
       const [fieldNo] = reader.tag();
       switch (fieldNo) {
         case 1:
-          key = readKey(reader);
+          key2 = readKey(reader);
           break;
         case 2:
           val = readValue(reader, ctx);
           break;
       }
     }
-    if (key === void 0) {
-      key = keyZero;
+    if (key2 === void 0) {
+      key2 = keyZero;
     }
     if (val === void 0) {
       val = valueDefault();
     }
-    record3[key] = val;
+    record3[key2] = val;
   };
 }
 function compileScalarReader(type, utf8Validation, longAsString) {
@@ -28718,11 +28962,11 @@ function compileMapField(field) {
       const record3 = message[localName];
       const keys = Object.keys(record3);
       for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
+        const key2 = keys[i];
         writer.tag(fieldNo, WireType.LengthDelimited).fork();
-        writeKey(writer, key);
+        writeKey(writer, key2);
         writer.tag(2, WireType.LengthDelimited).fork();
-        writeMessage(writer, opts, toMessage(record3[key]));
+        writeMessage(writer, opts, toMessage(record3[key2]));
         writer.join();
         writer.join();
       }
@@ -28735,11 +28979,11 @@ function compileMapField(field) {
     const record3 = message[localName];
     const keys = Object.keys(record3);
     for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
+      const key2 = keys[i];
       writer.tag(fieldNo, WireType.LengthDelimited).fork();
-      writeKey(writer, key);
+      writeKey(writer, key2);
       writer.tag(2, valueWireType);
-      writeScalar(writer, record3[key]);
+      writeScalar(writer, record3[key2]);
       writer.join();
     }
   };
@@ -28748,40 +28992,40 @@ function compileMapKey(field) {
   const wireType = writeTypeOfScalar(field.mapKey);
   const writeScalar = compileScalarValue(field.mapKey, field.parent.typeName, field.name);
   const convertKey = compileMapKeyConverter(field.mapKey);
-  return (writer, key) => {
+  return (writer, key2) => {
     writer.tag(1, wireType);
-    writeScalar(writer, convertKey(key));
+    writeScalar(writer, convertKey(key2));
   };
 }
 function compileMapKeyConverter(type) {
   switch (type) {
     case ScalarType.STRING:
-      return (key) => key;
+      return (key2) => key2;
     case ScalarType.BOOL:
-      return (key) => key === "true" ? true : key === "false" ? false : key;
+      return (key2) => key2 === "true" ? true : key2 === "false" ? false : key2;
     case ScalarType.UINT64:
     case ScalarType.FIXED64:
-      return (key) => {
+      return (key2) => {
         try {
-          return protoInt64.uParse(key);
+          return protoInt64.uParse(key2);
         } catch (_a3) {
-          return key;
+          return key2;
         }
       };
     case ScalarType.INT64:
     case ScalarType.SFIXED64:
     case ScalarType.SINT64:
-      return (key) => {
+      return (key2) => {
         try {
-          return protoInt64.parse(key);
+          return protoInt64.parse(key2);
         } catch (_a3) {
-          return key;
+          return key2;
         }
       };
     default:
-      return (key) => {
-        const n = Number.parseInt(key);
-        return Number.isFinite(n) ? n : key;
+      return (key2) => {
+        const n = Number.parseInt(key2);
+        return Number.isFinite(n) ? n : key2;
       };
   }
 }
@@ -29057,9 +29301,9 @@ function fieldEquals(f, a, b, opts) {
           return false;
         }
       }
-      for (const key of keys) {
-        const va = mapA.get(key);
-        const vb = mapB.get(key);
+      for (const key2 of keys) {
+        const va = mapA.get(key2);
+        const vb = mapB.get(key2);
         if (va === vb) {
           continue;
         }
@@ -29424,8 +29668,8 @@ function compileMapValue(field) {
     }
     const jsonObject = {};
     for (let i = 0; i < keys.length; i++) {
-      const key = keys[i];
-      jsonObject[key] = writeMapValue(opts, record3[key]);
+      const key2 = keys[i];
+      jsonObject[key2] = writeMapValue(opts, record3[key2]);
     }
     return jsonObject;
   };
@@ -29620,8 +29864,8 @@ function structToJson(val) {
   const json2 = {};
   const keys = Object.keys(val.fields);
   for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    json2[key] = valueToJson(val.fields[key]);
+    const key2 = keys[i];
+    json2[key2] = valueToJson(val.fields[key2]);
   }
   return json2;
 }
@@ -30061,11 +30305,11 @@ function compileMapFieldReader2(field) {
     for (let i = 0; i < jsonMapKeys.length; i++) {
       const jsonMapKey = jsonMapKeys[i];
       const jsonMapValue = json2[jsonMapKey];
-      const key = parseMapKey(jsonMapKey);
-      if (seen.has(key)) {
+      const key2 = parseMapKey(jsonMapKey);
+      if (seen.has(key2)) {
         throw new FieldError(field, `duplicate map key "${jsonMapKey}"`);
       }
-      seen.add(key);
+      seen.add(key2);
       if (jsonMapValue === null && nullResets) {
         throw new FieldError(field, "map value must not be null");
       }
@@ -30073,17 +30317,17 @@ function compileMapFieldReader2(field) {
       if (value === tokenIgnoredUnknownEnum) {
         continue;
       }
-      const checkKey = checkMapKey(key);
+      const checkKey = checkMapKey(key2);
       if (checkKey !== true) {
-        throw new FieldError(field, `invalid map key: ${reasonSingular({ scalar: mapKey }, key, checkKey)}`);
+        throw new FieldError(field, `invalid map key: ${reasonSingular({ scalar: mapKey }, key2, checkKey)}`);
       }
       if (checkValue !== void 0) {
         const check3 = checkValue(value);
         if (check3 !== true) {
-          throw new FieldError(field, `map entry ${formatVal(key)}: ${reasonSingular(field, value, check3)}`);
+          throw new FieldError(field, `map entry ${formatVal(key2)}: ${reasonSingular(field, value, check3)}`);
         }
       }
-      record3[key] = toLocalValue(value);
+      record3[key2] = toLocalValue(value);
     }
   };
 }
@@ -30362,10 +30606,10 @@ function structFromJson(struct, json2, ctx) {
   }
   const keys = Object.keys(json2);
   for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
+    const key2 = keys[i];
     const parsedValue = create(ValueSchema);
-    valueFromJson(parsedValue, json2[key], ctx);
-    struct.fields[key] = parsedValue;
+    valueFromJson(parsedValue, json2[key2], ctx);
+    struct.fields[key2] = parsedValue;
   }
 }
 function valueFromJson(value, json2, ctx) {
@@ -30588,15 +30832,15 @@ var CelScalar = {
 };
 var TIMESTAMP = objectType(TimestampSchema);
 var DURATION = objectType(DurationSchema);
-function mapType(key, value) {
+function mapType(key2, value) {
   return {
     [privateSymbol4]: {},
     kind: "map",
-    key,
+    key: key2,
     value,
     name: "map",
     toString() {
-      return `map(${key}, ${value})`;
+      return `map(${key2}, ${value})`;
     }
   };
 }
@@ -30889,41 +31133,41 @@ var NativeMap = class {
   get size() {
     return this._map.size;
   }
-  get(key) {
-    if (isCelUint(key)) {
-      key = key.value;
+  get(key2) {
+    if (isCelUint(key2)) {
+      key2 = key2.value;
     }
-    if (typeof key === "number") {
-      if (!Number.isInteger(key)) {
+    if (typeof key2 === "number") {
+      if (!Number.isInteger(key2)) {
         return void 0;
       }
-      key = BigInt(key);
+      key2 = BigInt(key2);
     }
-    const value = this._map.get(key);
+    const value = this._map.get(key2);
     if (value !== void 0) {
       return toCel(value);
     }
-    if (typeof key === "bigint") {
+    if (typeof key2 === "bigint") {
       for (const mapKey of this._map.keys()) {
         if (!isCelUint(mapKey)) {
           continue;
         }
-        if (mapKey.value === key) {
+        if (mapKey.value === key2) {
           return toCel(this._map.get(mapKey));
         }
       }
     }
     return void 0;
   }
-  has(key) {
-    return this.get(key) != void 0;
+  has(key2) {
+    return this.get(key2) != void 0;
   }
   forEach(callback, thisArg) {
-    this._map.forEach((value, key, _) => callback.call(thisArg, toCel(value), key, this));
+    this._map.forEach((value, key2, _) => callback.call(thisArg, toCel(value), key2, this));
   }
   *entries() {
-    for (const [key, value] of this._map.entries()) {
-      yield [key, toCel(value)];
+    for (const [key2, value] of this._map.entries()) {
+      yield [key2, toCel(value)];
     }
   }
   keys() {
@@ -30947,30 +31191,30 @@ var ProtoMap = class {
   get size() {
     return this._map.size;
   }
-  get(key) {
-    const value = this._map.get(mapKeyFromCel(this._map.field(), key));
+  get(key2) {
+    const value = this._map.get(mapKeyFromCel(this._map.field(), key2));
     if (value === void 0) {
       return void 0;
     }
     return celFromMapValue(this._map.field(), value);
   }
-  has(key) {
-    return this._map.has(mapKeyFromCel(this._map.field(), key));
+  has(key2) {
+    return this._map.has(mapKeyFromCel(this._map.field(), key2));
   }
   forEach(callback, thisArg) {
-    this._map.forEach((value, key, _) => callback.call(thisArg, celFromMapValue(this._map.field(), value), celFromMapKey(this._map.field(), key), this));
+    this._map.forEach((value, key2, _) => callback.call(thisArg, celFromMapValue(this._map.field(), value), celFromMapKey(this._map.field(), key2), this));
   }
   *entries() {
-    for (const [key, value] of this._map.entries()) {
+    for (const [key2, value] of this._map.entries()) {
       yield [
-        celFromMapKey(this._map.field(), key),
+        celFromMapKey(this._map.field(), key2),
         celFromMapValue(this._map.field(), value)
       ];
     }
   }
   *keys() {
-    for (const key of this._map.keys()) {
-      yield celFromMapKey(this._map.field(), key);
+    for (const key2 of this._map.keys()) {
+      yield celFromMapKey(this._map.field(), key2);
     }
   }
   *values() {
@@ -31714,17 +31958,17 @@ var LazyDecoder = class {
     this.initializer = initializer5;
     this.cache = /* @__PURE__ */ new Map();
   }
-  has(key) {
-    return key in this.initializer;
+  has(key2) {
+    return key2 in this.initializer;
   }
-  get(key) {
-    const cached3 = this.cache.get(key);
-    if (cached3 !== void 0 || this.cache.has(key)) {
+  get(key2) {
+    const cached3 = this.cache.get(key2);
+    if (cached3 !== void 0 || this.cache.has(key2)) {
       return cached3 ?? null;
     }
-    const fn = this.initializer[key];
+    const fn = this.initializer[key2];
     const val = fn ? fn() : null;
-    this.cache.set(key, val);
+    this.cache.set(key2, val);
     return val;
   }
 };
@@ -36368,10 +36612,10 @@ var Builder = class {
     }
     return expr;
   }
-  newMapEntry(offset, key, value) {
+  newMapEntry(offset, key2, value) {
     return this.nextEntry(offset, {
       case: "mapKey",
-      value: key
+      value: key2
     }, value);
   }
   newStructExpr(offset, entries, messageName = "") {
@@ -36946,8 +37190,8 @@ function parse3(input, options = {}) {
     }
     return selector;
   }
-  function item430(offset, key, value) {
-    return builder.newStructEntry(offset(), key, value);
+  function item430(offset, key2, value) {
+    return builder.newStructEntry(offset(), key2, value);
   }
   function item437(offset, dot, name, entries) {
     return builder.newStructExpr(offset(), entries, (dot !== null ? dot : "") + name.join("."));
@@ -36958,8 +37202,8 @@ function parse3(input, options = {}) {
   function item461(offset, elements) {
     return builder.newListExpr(offset(), elements);
   }
-  function item475(offset, key, value) {
-    return builder.newMapEntry(offset(), key, value);
+  function item475(offset, key2, value) {
+    return builder.newMapEntry(offset(), key2, value);
   }
   function item484(offset, entries) {
     return builder.newStructExpr(offset(), entries);
@@ -42318,9 +42562,9 @@ var EvalAccess = class {
   key;
   factory;
   optional;
-  constructor(id, key, factory, optional3) {
+  constructor(id, key2, factory, optional3) {
     this.id = id;
-    this.key = key;
+    this.key = key2;
     this.factory = factory;
     this.optional = optional3;
   }
@@ -42328,30 +42572,30 @@ var EvalAccess = class {
     if (obj === void 0) {
       return obj;
     }
-    const key = this.key.eval(vars);
-    if (isCelError(key)) {
-      return key;
+    const key2 = this.key.eval(vars);
+    if (isCelError(key2)) {
+      return key2;
     }
-    const access = this.factory.newAccess(this.id, key, this.optional);
+    const access = this.factory.newAccess(this.id, key2, this.optional);
     return access.access(vars, obj);
   }
   isPresent(vars, obj) {
     if (obj === void 0) {
       return false;
     }
-    const key = this.key.eval(vars);
-    if (isCelError(key)) {
-      return key;
+    const key2 = this.key.eval(vars);
+    if (isCelError(key2)) {
+      return key2;
     }
-    const access = this.factory.newAccess(this.id, key, this.optional);
+    const access = this.factory.newAccess(this.id, key2, this.optional);
     return access.isPresent(vars, obj);
   }
   accessIfPresent(vars, obj, presenceOnly) {
-    const key = this.key.eval(vars);
-    if (isCelError(key)) {
-      return key;
+    const key2 = this.key.eval(vars);
+    if (isCelError(key2)) {
+      return key2;
     }
-    const access = this.factory.newAccess(this.id, key, this.optional);
+    const access = this.factory.newAccess(this.id, key2, this.optional);
     return access.accessIfPresent(vars, obj, presenceOnly);
   }
   isOptional() {
@@ -42509,16 +42753,16 @@ function copyList(list, cList) {
 function copyMap(map2, cMap) {
   const field = map2.field();
   for (const [k, v] of cMap.entries()) {
-    const key = scalarFromCel(field, field.mapKey, k);
+    const key2 = scalarFromCel(field, field.mapKey, k);
     switch (field.mapKind) {
       case "enum":
-        map2.set(key, enumFromCel(field, v));
+        map2.set(key2, enumFromCel(field, v));
         break;
       case "scalar":
-        map2.set(key, scalarFromCel(field, field.scalar, v));
+        map2.set(key2, scalarFromCel(field, field.scalar, v));
         break;
       case "message":
-        map2.set(key, msgFromCel(field, v));
+        map2.set(key2, msgFromCel(field, v));
         break;
     }
   }
@@ -43209,38 +43453,38 @@ var EvalMap = class {
     }
     entries.set(firstKey, firstVal);
     for (let i = 1; i < this.keys.length; i++) {
-      const key = this.mapKeyOrError(this.keys[i].eval(ctx));
-      if (isCelError(key)) {
-        return key;
+      const key2 = this.mapKeyOrError(this.keys[i].eval(ctx));
+      if (isCelError(key2)) {
+        return key2;
       }
       const val = this.values[i].eval(ctx);
       if (isCelError(val)) {
         return val;
       }
-      if (entries.has(key)) {
-        return celError(`map key conflict: ${key}`, this.id);
+      if (entries.has(key2)) {
+        return celError(`map key conflict: ${key2}`, this.id);
       }
-      if (typeof key === "number" && !Number.isInteger(key)) {
+      if (typeof key2 === "number" && !Number.isInteger(key2)) {
         return unsupportedKeyType(this.id);
       }
-      entries.set(key, val);
+      entries.set(key2, val);
     }
     return celMap(entries);
   }
-  mapKeyOrError(key) {
-    switch (typeof key) {
+  mapKeyOrError(key2) {
+    switch (typeof key2) {
       case "boolean":
       case "bigint":
       case "string":
-        return key;
+        return key2;
       case "object":
-        if (isCelUint(key)) {
-          return key;
+        if (isCelUint(key2)) {
+          return key2;
         }
         return unsupportedKeyType(this.id);
       case "number":
-        if (Number.isInteger(key)) {
-          return BigInt(key);
+        if (Number.isInteger(key2)) {
+          return BigInt(key2);
         }
         return unsupportedKeyType(this.id);
       default:
@@ -43566,6 +43810,17 @@ function parseApprovalTimeout(name, raw) {
   }
   throw new Error("unreachable");
 }
+function parseSessionIdleTimeout(name, raw) {
+  if (raw === void 0) return 6e5;
+  if (raw === 0 || raw === "0") return 0;
+  const match = typeof raw === "string" ? /^(\d+)(s|m|h)$/.exec(raw) : null;
+  const multiplier = match?.[2] === "s" ? 1e3 : match?.[2] === "m" ? 6e4 : 36e5;
+  const milliseconds = match ? Number(match[1]) * multiplier : NaN;
+  if (!Number.isSafeInteger(milliseconds)) {
+    throw new Error(`agents.${name}.session_idle_timeout: expected a duration like "30s", "15m", "2h", or 0`);
+  }
+  return milliseconds;
+}
 function parseAgentContainer(name, raw, processEnv, configDir) {
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
     throw new Error(`agents.${name}.container must be a mapping`);
@@ -44060,6 +44315,7 @@ function parseAgents(raw, runtime2, transports, daemonHooks, processEnv, configD
     }
     const acp = parseAcpBlock(name, entry.acp);
     const approval_timeout_ms = parseApprovalTimeout(name, entry.approval_timeout);
+    const session_idle_timeout_ms = parseSessionIdleTimeout(name, entry.session_idle_timeout);
     if (entry.docker !== void 0) {
       throw new Error(
         `agents.${name}.docker is no longer supported. Move 'image' to agents.${name}.container.image, and 'forward_env' entries to agents.${name}.container.env with \${VAR} interpolation. See [ZOD043].`
@@ -44121,7 +44377,8 @@ See [ZOD043].`
       workdir,
       hooks: agentHooks,
       acp,
-      approval_timeout_ms
+      approval_timeout_ms,
+      session_idle_timeout_ms
     };
     if (containerBlock) agentCfg.container = containerBlock;
     if (binding.matrix) agentCfg.matrix = binding.matrix;
@@ -44242,10 +44499,10 @@ function parseTriggers(raw, agents, transports, validateCron, processEnv, config
   }
   return result;
 }
-function parseDurationMs(label, raw) {
+function parseDurationMs(label2, raw) {
   const m = /^(\d+)(s|m|h)$/.exec(raw);
   if (!m) {
-    throw new Error(`${label}: "${raw}" is not a valid duration (use "<n>s", "<n>m", or "<n>h")`);
+    throw new Error(`${label2}: "${raw}" is not a valid duration (use "<n>s", "<n>m", or "<n>h")`);
   }
   const n = Number(m[1]);
   switch (m[2]) {
@@ -44270,29 +44527,29 @@ function soleMatrixTransport(transports) {
   return matrixTransports[0];
 }
 function parseTriggerMessage(name, index, raw, agents, transports, as, hasWebhook, ttlMs) {
-  const label = `triggers.${name}.messages[${index}]`;
+  const label2 = `triggers.${name}.messages[${index}]`;
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    throw new Error(`${label}: must be a mapping`);
+    throw new Error(`${label2}: must be a mapping`);
   }
   const m = raw;
   if (typeof m.room !== "string" || m.room.length === 0) {
-    throw new Error(`${label}.room: must be a non-empty string`);
+    throw new Error(`${label2}.room: must be a non-empty string`);
   }
   if (!MATRIX_ROOM_IDENT_RE.test(m.room)) {
-    throw new Error(`${label}.room: must start with '#' or '!' (got ${JSON.stringify(m.room)})`);
+    throw new Error(`${label2}.room: must start with '#' or '!' (got ${JSON.stringify(m.room)})`);
   }
   if (typeof m.mention !== "string" || m.mention.length === 0) {
-    throw new Error(`${label}.mention: must be a non-empty string`);
+    throw new Error(`${label2}.mention: must be a non-empty string`);
   }
   if (m.mention.startsWith("@")) {
     if (!MATRIX_USER_ID_RE.test(m.mention)) {
-      throw new Error(`${label}.mention: must be a full MXID (got ${JSON.stringify(m.mention)})`);
+      throw new Error(`${label2}.mention: must be a full MXID (got ${JSON.stringify(m.mention)})`);
     }
     const server = m.mention.slice(m.mention.indexOf(":") + 1);
     const local = deriveServerName(soleMatrixTransport(transports).user_namespace);
     if (server !== local) {
       throw new Error(
-        `${label}.mention: "${m.mention}" is on a different homeserver than this daemon (${local}). A trigger addresses a user on its own homeserver \u2014 see [[ZOD081]] \xA7Non-goals.`
+        `${label2}.mention: "${m.mention}" is on a different homeserver than this daemon (${local}). A trigger addresses a user on its own homeserver \u2014 see [[ZOD081]] \xA7Non-goals.`
       );
     }
     if (as === m.mention) {
@@ -44303,11 +44560,11 @@ function parseTriggerMessage(name, index, raw, agents, transports, as, hasWebhoo
   } else {
     const mentionedAgent = agents[m.mention];
     if (!mentionedAgent) {
-      throw new Error(`${label}.mention: unknown agent "${m.mention}"`);
+      throw new Error(`${label2}.mention: unknown agent "${m.mention}"`);
     }
     if (!mentionedAgent.matrix) {
       throw new Error(
-        `${label}.mention: agent "${m.mention}" has no matrix: binding \u2014 a trigger posts through Matrix, so the mentioned agent must be matrix-bound.`
+        `${label2}.mention: agent "${m.mention}" has no matrix: binding \u2014 a trigger posts through Matrix, so the mentioned agent must be matrix-bound.`
       );
     }
     if (as === mentionedAgent.matrix.user_id) {
@@ -44317,21 +44574,21 @@ function parseTriggerMessage(name, index, raw, agents, transports, as, hasWebhoo
     }
   }
   if (typeof m.text !== "string" || m.text.length === 0) {
-    throw new Error(`${label}.text: must be a non-empty string`);
+    throw new Error(`${label2}.text: must be a non-empty string`);
   }
   const message = { room: m.room, mention: m.mention, text: m.text };
   if (ttlMs !== void 0) message.ttlMs = ttlMs;
   if (m.match !== void 0) {
     if (typeof m.match !== "string" || m.match.length === 0) {
-      throw new Error(`${label}.match: must be a non-empty string`);
+      throw new Error(`${label2}.match: must be a non-empty string`);
     }
     if (!hasWebhook) {
-      throw new Error(`${label}.match: only applies to a webhook: trigger`);
+      throw new Error(`${label2}.match: only applies to a webhook: trigger`);
     }
     try {
       message.match = compileMatch(m.match);
     } catch (err) {
-      throw new Error(`${label}.match: ${err.message}`);
+      throw new Error(`${label2}.match: ${err.message}`);
     }
   }
   return message;
@@ -44603,10 +44860,10 @@ var AcpAgentRegistry = class {
     this.opts.onSessionEstablished?.(name, threadId, sessionId);
     return sessionId;
   }
-  endSession(name, threadId) {
+  async endSession(name, threadId) {
     if (!this.hasAgent(name)) return;
     const client = this.clients.get(name);
-    client?.endSession(threadId);
+    await client?.endSession(threadId);
   }
   async cancelSession(name, sessionId) {
     if (!this.hasAgent(name)) return;
@@ -44653,6 +44910,8 @@ var AcpAgentRegistry = class {
       onEvent: (e) => this.onEvent(name, e),
       onApprovalRequest: (req) => this.onApprovalRequest(name, req),
       onTap: this.opts.onTap ? (e) => this.opts.onTap(name, e) : void 0,
+      onLifecycle: this.opts.onLifecycle ? (e) => this.opts.onLifecycle(name, e) : void 0,
+      sessionIdleTimeoutMs: cfg.session_idle_timeout_ms,
       contextSpawn: this.opts.contextSpawns?.[name]
     });
     await client.start();
@@ -44765,6 +45024,7 @@ var ApprovalCorrelator = class extends EventEmitter2 {
 };
 
 // ../core/src/task-actions.ts
+var HANDOFF_FIELD = "dev.zooid.handoff";
 var NO_PENDING_INPUT = {
   countFor: () => 0,
   cancelFor: () => {
@@ -45319,6 +45579,50 @@ function isExpiredTrigger(evt, now) {
   return now - firedAt > ttlMs;
 }
 
+// ../transport-matrix/src/handoff.ts
+function readHandoff(content) {
+  const h = content?.[HANDOFF_FIELD];
+  if (!h || h.version !== 1) return void 0;
+  if (typeof h.call_id !== "string" || typeof h.caller !== "string" || typeof h.callee !== "string")
+    return void 0;
+  return { version: 1, call_id: h.call_id, caller: h.caller, callee: h.callee };
+}
+function buildHandoffContent(input) {
+  return {
+    ...buildMentionContent({ userId: input.callee, text: input.prompt, msgtype: "m.notice" }),
+    [HANDOFF_FIELD]: {
+      version: 1,
+      call_id: input.callId,
+      caller: input.caller,
+      callee: input.callee
+    }
+  };
+}
+var label = (c) => c.workstation ? `${c.workstation}.${c.name}` : c.name;
+function resolveHandoffTarget(agent, roomId, candidates) {
+  const q = agent.trim();
+  const inRoom = candidates.filter((c) => c.rooms.includes(roomId));
+  const roster = inRoom.map(label).sort().join(", ") || "none";
+  let hits;
+  if (q.startsWith("@") && q.includes(":")) hits = candidates.filter((c) => c.userId === q);
+  else {
+    const bare = q.replace(/^@/, "");
+    hits = candidates.filter((c) => label(c) === bare);
+    if (hits.length === 0) hits = candidates.filter((c) => c.name === bare);
+  }
+  if (hits.length === 0)
+    return { ok: false, reason: `unknown_agent: no agent "${q}" in this workforce. Agents in this room: ${roster}` };
+  if (hits.length > 1)
+    return {
+      ok: false,
+      reason: `ambiguous_agent: "${q}" matches ${hits.map(label).sort().join(", ")} \u2014 use workstation.agent`
+    };
+  const target = hits[0];
+  if (!target.rooms.includes(roomId))
+    return { ok: false, reason: `not_in_room: "${label(target)}" is not in this room. Agents in this room: ${roster}` };
+  return { ok: true, target };
+}
+
 // ../transport-matrix/src/router.ts
 var MEDIA_MSGTYPES = /* @__PURE__ */ new Set(["m.image", "m.file", "m.video", "m.audio"]);
 function isMediaMsgtype(t) {
@@ -45348,6 +45652,7 @@ function route(event, agents, threadStates, task, knownAgentIds) {
   const addressesAgent = [...mentions].some(
     (id) => id !== event.sender && (knownAgentIds?.has(id) === true || agents.some((x) => x.userId === id && x.rooms.some((r) => r.alias === event.room_id)))
   );
+  const handoff = readHandoff(event.content);
   for (const a of agents) {
     if (!a.rooms.some((r) => r.alias === event.room_id)) continue;
     if (task?.isRoot) {
@@ -45355,46 +45660,44 @@ function route(event, agents, threadStates, task, knownAgentIds) {
       continue;
     }
     if (event.sender === a.userId) continue;
+    const called = senderIsAgent && handoff?.caller === event.sender && handoff?.callee === a.userId;
     if (task) {
-      if (mentions.has(a.userId)) {
-        matches2.push(a);
-        continue;
-      }
       if (senderIsAgent) {
+        if (called) matches2.push(a);
         continue;
-      } else if (a.name === task.assignee && !addressesAgent) {
-        matches2.push(a);
       }
+      if (mentions.has(a.userId)) matches2.push(a);
+      else if (a.name === task.assignee && !addressesAgent) matches2.push(a);
       continue;
     }
     if (a.trigger === "any") {
       matches2.push(a);
       continue;
     }
+    if (senderIsAgent) {
+      if (called || isReturnRoute(event, a, threadState)) matches2.push(a);
+      continue;
+    }
     if (mentions.has(a.userId)) {
       matches2.push(a);
       continue;
     }
-    if (threadState) {
-      if (senderIsAgent) {
-        if (isReturnRoute(event, a, agents, threadState)) matches2.push(a);
-      } else if (!addressesAgent) {
-        const lastPoster = threadState.participants.at(-1);
-        if (lastPoster) {
-          if (lastPoster === a.name) matches2.push(a);
-        } else if (threadState.rootMentions.includes(a.name)) {
-          matches2.push(a);
-        }
+    if (threadState && !addressesAgent) {
+      const lastPoster = threadState.participants.at(-1);
+      if (lastPoster) {
+        if (lastPoster === a.name) matches2.push(a);
+      } else if (threadState.rootMentions.includes(a.name)) {
+        matches2.push(a);
       }
     }
   }
   return matches2;
 }
-function isReturnRoute(event, agent, agents, threadState) {
+function isReturnRoute(event, agent, threadState) {
   if (!threadState || agent.trigger !== "mention") return false;
-  const sender = agents.find((x) => x.userId === event.sender);
-  if (!sender || sender.name === agent.name) return false;
-  return threadState.callers[sender.name] === agent.name;
+  const sender = event.sender;
+  if (!sender || sender === agent.userId) return false;
+  return threadState.callers[sender] === agent.userId;
 }
 function wouldCycleCallers(callers, callee, caller) {
   const seen = /* @__PURE__ */ new Set();
@@ -45600,18 +45903,159 @@ function buildUserPowerLevels(asUserId, admins, agents, roomAlias) {
 
 // ../transport-matrix/src/transport.ts
 import { Hono } from "hono";
-import { timingSafeEqual } from "crypto";
+import { timingSafeEqual, randomUUID as randomUUID5 } from "crypto";
 
 // ../transport-matrix/src/session-keys.ts
 var HANDOFF_KEY_SEP = "|";
 function composeHandoffKey(threadRoot, callEventId) {
   return `${threadRoot}${HANDOFF_KEY_SEP}${callEventId}`;
 }
-function sessionKeyFor(agentName, threadRoot, state) {
-  const arc = state?.handoffs[agentName]?.at(-1);
+function sessionKeyFor(agentUserId, threadRoot, state) {
+  const arc = state?.handoffs[agentUserId]?.at(-1);
   return arc ? composeHandoffKey(threadRoot, arc) : threadRoot;
 }
 
+// ../transport-matrix/src/pending-returns.ts
+var PendingReturns = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  pending = /* @__PURE__ */ new Map();
+  running = /* @__PURE__ */ new Map();
+  has(callee, threadRoot) {
+    return this.pending.has(key(callee, threadRoot));
+  }
+  /** An agent→agent call: a fresh pending return, replacing any earlier one. */
+  open(callee, threadRoot, roomId, caller, o = {}) {
+    const k = key(callee, threadRoot);
+    this.drop(k);
+    this.pending.set(k, fresh(callee, threadRoot, roomId, [caller], o.remote === true));
+  }
+  /** A callee message routed as a return: held, never delivered on its own. */
+  hold(callee, threadRoot, roomId, targets, body, o = {}) {
+    const k = key(callee, threadRoot);
+    let p = this.pending.get(k);
+    if (!p) {
+      p = fresh(callee, threadRoot, roomId, targets, o.remote === true);
+      this.pending.set(k, p);
+    } else if (o.remote === true) {
+      p.remote = true;
+    }
+    for (const t of targets) p.targets.set(t.name, t);
+    const text = body?.trim();
+    if (text) p.text = text;
+    p.waiting = false;
+    this.arm(k);
+  }
+  /** The callee's current turn opened a call; its turn end is not a return. */
+  markDelegated(callee, threadRoot) {
+    const p = this.pending.get(key(callee, threadRoot));
+    if (p) p.delegated = true;
+  }
+  /** Sender-attributable liveness (tool calls, plans): re-arms a timed hold. */
+  activity(callee, threadRoot) {
+    const k = key(callee, threadRoot);
+    if (this.pending.get(k)?.timer) this.arm(k);
+  }
+  turnStarted(agent, threadRoot) {
+    const k = key(agent, threadRoot);
+    this.running.set(k, (this.running.get(k) ?? 0) + 1);
+    const p = this.pending.get(k);
+    if (p) {
+      p.waiting = false;
+      disarm(p);
+    }
+  }
+  /** The in-process turn is over; if its turn.end never echoes, the fallback catches it. */
+  turnFinished(agent, threadRoot) {
+    const k = key(agent, threadRoot);
+    const n = (this.running.get(k) ?? 1) - 1;
+    if (n > 0) this.running.set(k, n);
+    else this.running.delete(k);
+    this.arm(k);
+  }
+  /** The callee's `dev.zooid.turn.end`: release, unless the turn delegated. */
+  turnEnded(callee, threadRoot) {
+    const k = key(callee, threadRoot);
+    const p = this.pending.get(k);
+    if (!p) return;
+    if (p.delegated && !p.interrupted) {
+      p.delegated = false;
+      p.waiting = true;
+      p.text = "";
+      disarm(p);
+      return;
+    }
+    this.release(k);
+  }
+  /**
+   * A thread interrupt. Running callees are marked so their (cancelled) turn
+   * end releases; with nothing running there is no turn end coming, so every
+   * pending return in the thread releases now. Call before cancelling
+   * sessions, or a turn that finishes first makes the thread look idle.
+   */
+  interrupt(threadRoot) {
+    const suffix = `::${threadRoot}`;
+    const anyRunning = [...this.running.keys()].some((k) => k.endsWith(suffix));
+    for (const [k, p] of [...this.pending]) {
+      if (p.threadRoot !== threadRoot) continue;
+      if (!anyRunning) this.release(k);
+      else if (this.running.has(k)) p.interrupted = true;
+    }
+  }
+  /** `/clear`: a pre-reset return must never wake anyone later. */
+  dropThread(threadRoot) {
+    for (const [k, p] of [...this.pending]) if (p.threadRoot === threadRoot) this.drop(k);
+  }
+  arm(k) {
+    const p = this.pending.get(k);
+    if (!p) return;
+    disarm(p);
+    if (p.waiting || this.running.has(k)) return;
+    const ms = p.remote ? this.opts.remoteGraceMs ?? this.opts.graceMs : this.opts.graceMs;
+    p.timer = setTimeout(() => this.release(k), ms);
+    p.timer.unref?.();
+  }
+  release(k) {
+    const p = this.pending.get(k);
+    if (!p) return;
+    this.pending.delete(k);
+    disarm(p);
+    this.opts.onRelease({
+      callee: p.callee,
+      roomId: p.roomId,
+      threadRoot: p.threadRoot,
+      targets: [...p.targets.values()],
+      text: p.text
+    });
+  }
+  drop(k) {
+    const p = this.pending.get(k);
+    if (!p) return;
+    disarm(p);
+    this.pending.delete(k);
+  }
+};
+var key = (agent, threadRoot) => `${agent}::${threadRoot}`;
+function fresh(callee, threadRoot, roomId, targets, remote) {
+  return {
+    callee,
+    roomId,
+    threadRoot,
+    targets: new Map(targets.map((t) => [t.name, t])),
+    text: "",
+    delegated: false,
+    waiting: false,
+    interrupted: false,
+    remote
+  };
+}
+function disarm(p) {
+  if (p.timer) clearTimeout(p.timer);
+  p.timer = void 0;
+}
+
 // ../transport-matrix/src/workforce-publisher.ts
 function buildWorkforceRoster(agents) {
   return {
@@ -45655,11 +46099,22 @@ var WorkforceDirectory = class {
   /** Replace one workstation's roster; empty content removes it. */
   apply(stateKey, content) {
     const agents = content?.agents;
-    const ids = Array.isArray(agents) ? agents.map((a) => a?.user_id).filter((id) => typeof id === "string") : [];
-    if (ids.length > 0) this.rosters.set(stateKey, ids);
+    const entries = Array.isArray(agents) ? agents.filter((a) => typeof a?.user_id === "string").map((a) => ({
+      userId: a.user_id,
+      name: typeof a.name === "string" ? a.name : a.user_id,
+      workstation: stateKey || void 0,
+      rooms: Array.isArray(a.rooms) ? a.rooms.filter((r) => typeof r === "string") : []
+    })) : [];
+    if (entries.length > 0) this.rosters.set(stateKey, entries);
     else this.rosters.delete(stateKey);
     this.agentIds.clear();
-    for (const list of this.rosters.values()) for (const id of list) this.agentIds.add(id);
+    for (const list of this.rosters.values()) for (const e of list) this.agentIds.add(e.userId);
+  }
+  entries() {
+    return [...this.rosters.values()].flat();
+  }
+  nameOf(userId) {
+    return this.entries().find((e) => e.userId === userId)?.name;
   }
 };
 
@@ -46246,15 +46701,24 @@ function renderInvocationReturn(c) {
     ...c.output?.text ? ["", c.output.text] : []
   ].join("\n");
 }
+function renderHandoffReturn(r) {
+  const text = r.text.trim();
+  return text ? `[handoff return] from ${r.callee}
+
+${text}` : `[handoff return] from ${r.callee} \u2014 ended its turn without a reply`;
+}
 function renderDelivery(notify) {
   return notify === "caller" ? "Each result returns to you as a new turn when that task completes. End your turn now \u2014 do not read the task thread to wait for it." : "No result returns to you. The task thread is the result surface; thread_id is for later reference, not something to wait on.";
 }
+function renderHandoffDelivery(callee) {
+  return `Handed off to ${callee}. End your turn now \u2014 do not wait, poll, or post follow-ups. You will be woken with \`[handoff return] from ${callee}\` when it finishes.`;
+}
 function renderAssigneeEnvelope(input) {
   return [
     `[task] from ${input.parentAgent} \u2014 you are the assignee of this thread.`,
     "Call zooid_complete_task with a self-contained summary when you are done;",
     "ending your turn without one publishes your last message as the result.",
-    "Sibling task threads are refused here \u2014 @mention an agent in this thread to hand off.",
+    "Sibling task threads are refused here \u2014 call zooid_handoff to hand off in this thread.",
     "",
     input.prompt
   ].join("\n");
@@ -46263,6 +46727,8 @@ function renderAssigneeEnvelope(input) {
 // ../transport-matrix/src/transport.ts
 var STARTUP_GRACE_MS = 5e3;
 var RETURN_GRACE_MS = 9e4;
+var REMOTE_RETURN_GRACE_MS = 30 * 6e4;
+var ACTIVITY_EVENTS = /* @__PURE__ */ new Set(["dev.zooid.tool_call", "dev.zooid.tool_call_update", "dev.zooid.plan"]);
 async function buildMediaBlocks(items, opts) {
   const blocks = [];
   const pathLines = [];
@@ -46367,6 +46833,7 @@ function createMatrixTransport(opts) {
   const drainQuietMs = opts.drainQuietMs ?? DRAIN_QUIET_MS;
   const drainMaxMs = opts.drainMaxMs ?? DRAIN_MAX_MS;
   const returnGraceMs = opts.returnGraceMs ?? RETURN_GRACE_MS;
+  const remoteReturnGraceMs = opts.remoteReturnGraceMs ?? REMOTE_RETURN_GRACE_MS;
   const mediaClient = opts.media;
   const writeAttachmentFn = opts.writeAttachmentFn ?? writeAttachment;
   const pendingMedia = new PendingMediaStore();
@@ -46387,64 +46854,36 @@ function createMatrixTransport(opts) {
   const pendingInput = opts.pendingInput ?? NO_PENDING_INPUT;
   const bindingFor = (name) => bindings.find((b) => b.name === name);
   const turnQueues = /* @__PURE__ */ new Map();
-  const pendingReturns = /* @__PURE__ */ new Map();
-  const returnKey = (agentName, threadRoot) => `${agentName}::${threadRoot}`;
-  function stashReturn(sender, threadRoot, roomId, evt, targets) {
-    const key = returnKey(sender.name, threadRoot);
-    let pending = pendingReturns.get(key);
-    if (!pending) {
-      pending = { roomId, threadRoot, event: evt, texts: [], targets: /* @__PURE__ */ new Map() };
-      pendingReturns.set(key, pending);
-    }
-    pending.event = evt;
-    const body = evt.content?.body?.trim();
-    if (body) pending.texts.push(body);
-    for (const t of targets) pending.targets.set(t.name, t);
-    if (pending.timer) clearTimeout(pending.timer);
-    pending.timer = setTimeout(() => releaseReturn(key), returnGraceMs);
-    pending.timer.unref?.();
-    console.log(
-      `[matrix] holding return ${sender.name} \u2192 ${[...pending.targets.keys()].join(",")} until turn end (thread=${threadRoot})`
-    );
+  const workforce = new WorkforceDirectory();
+  const returns = new PendingReturns({ graceMs: returnGraceMs, remoteGraceMs: remoteReturnGraceMs, onRelease: deliverReturn });
+  const isLocal = (userId) => bindings.some((b) => b.userId === userId);
+  const agentName = (userId) => bindings.find((b) => b.userId === userId)?.name ?? workforce.nameOf(userId) ?? userId;
+  const openHandoffs = /* @__PURE__ */ new Map();
+  const openKey = (caller, threadRoot) => `${caller}::${threadRoot}`;
+  function handoffCandidates() {
+    const byId = /* @__PURE__ */ new Map();
+    for (const e of workforce.entries()) byId.set(e.userId, e);
+    for (const b of bindings)
+      byId.set(b.userId, {
+        userId: b.userId,
+        name: b.name,
+        workstation: byId.get(b.userId)?.workstation,
+        rooms: b.rooms.map((r) => r.alias)
+      });
+    return [...byId.values()];
   }
-  function releaseReturn(key) {
-    const pending = pendingReturns.get(key);
-    if (!pending) return;
-    pendingReturns.delete(key);
-    if (pending.timer) clearTimeout(pending.timer);
-    const promptText = pending.texts.join("\n\n");
-    for (const target of pending.targets.values()) {
-      console.log(`[matrix] \u2192 ${target.name} (${target.userId}) [return]`);
+  function deliverReturn(r) {
+    for (const target of r.targets) {
+      openHandoffs.delete(openKey(target.userId, r.threadRoot));
+      console.log(`[matrix] \u2192 ${target.name} (${target.userId}) [return from ${agentName(r.callee)}]`);
       void enqueueTurn(target, {
-        roomId: pending.roomId,
-        threadRoot: pending.threadRoot,
-        sessionKey: sessionKeyFor(
-          target.name,
-          pending.threadRoot,
-          threadStates.get(pending.threadRoot)
-        ),
-        event: pending.event,
-        ...promptText ? { promptText } : {}
+        roomId: r.roomId,
+        threadRoot: r.threadRoot,
+        sessionKey: sessionKeyFor(target.userId, r.threadRoot, threadStates.get(r.threadRoot)),
+        promptText: renderHandoffReturn({ callee: agentName(r.callee), text: r.text })
       });
     }
   }
-  function dropPendingReturn(threadRoot, agentName) {
-    for (const [key, pending] of pendingReturns) {
-      if (pending.threadRoot !== threadRoot) continue;
-      if (!pending.targets.delete(agentName)) continue;
-      if (pending.targets.size === 0) {
-        if (pending.timer) clearTimeout(pending.timer);
-        pendingReturns.delete(key);
-      }
-    }
-  }
-  function dropThreadReturns(threadRoot) {
-    for (const [key, pending] of pendingReturns) {
-      if (pending.threadRoot !== threadRoot) continue;
-      if (pending.timer) clearTimeout(pending.timer);
-      pendingReturns.delete(key);
-    }
-  }
   const cutoffTs = mode === "client" ? Number.NEGATIVE_INFINITY : Date.now() - STARTUP_GRACE_MS;
   const seenEventIds = /* @__PURE__ */ new Set();
   const flushedCounts = /* @__PURE__ */ new Map();
@@ -46478,21 +46917,14 @@ function createMatrixTransport(opts) {
     lastFlushed.set(sessionId, text);
     flushedCounts.set(sessionId, (flushedCounts.get(sessionId) ?? 0) + 1);
     const content = buildTextContent(text);
-    const pendingInvocations = registerOutgoingHandoffs(sessionId, text);
     const tail = (sendQueue.get(sessionId) ?? Promise.resolve()).then(async () => {
       try {
-        const { event_id } = await client.sendMessage({
+        await client.sendMessage({
           roomId: ctx.roomId,
           asUserId: ctx.agent.userId,
           content,
           threadRoot: ctx.threadRoot
         });
-        for (const invocation of pendingInvocations)
-          invocations.attachCallEvent(
-            invocation.invocationId,
-            event_id,
-            composeHandoffKey(ctx.threadRoot, event_id)
-          );
       } catch (err) {
         console.warn(`[matrix:${ctx.agent.name}] sendMessage flush failed:`, err);
       }
@@ -46500,30 +46932,6 @@ function createMatrixTransport(opts) {
     sendQueue.set(sessionId, tail);
     return true;
   };
-  function registerOutgoingHandoffs(sessionId, text) {
-    const ctx = sessions.get(sessionId);
-    if (!ctx) return [];
-    const task = taskRegistry.taskForRoot(ctx.threadRoot);
-    if (!task || task.phase !== "open") return [];
-    const sessionKey = sessionKeyFor(ctx.agent.name, ctx.threadRoot, threadStates.get(ctx.threadRoot));
-    const opened = [];
-    for (const userId of extractMentions({ content: { body: text } })) {
-      const callee = bindings.find((binding) => binding.userId === userId);
-      if (!callee || callee.name === ctx.agent.name) continue;
-      if (invocations.isOutstandingAncestor(sessionKey, callee.name)) {
-        void client.sendCustomEvent({
-          roomId: ctx.roomId,
-          asUserId: ctx.agent.userId,
-          eventType: "dev.zooid.error",
-          content: { body: `\u26A0 [handoff_circular] Cannot hand off to ${callee.name}: it is waiting on ${ctx.agent.name}`, code: "handoff_circular", message: `Cannot hand off to ${callee.name}: it is waiting on ${ctx.agent.name}`, transient: false, "m.relates_to": { rel_type: "m.thread", event_id: ctx.threadRoot } }
-        });
-        continue;
-      }
-      opened.push(invocations.open({ taskId: task.taskId, callerAgent: ctx.agent.name, callerSessionKey: sessionKey, calleeAgent: callee.name }));
-      taskRegistry.clearSummary(task.taskId);
-    }
-    return opened;
-  }
   agents.onEvent = async (name, event) => {
     const ctx = sessions.get(event.sessionId);
     if (!ctx) {
@@ -46651,8 +47059,8 @@ function createMatrixTransport(opts) {
     }).catch((e) => console.warn(`[matrix:${agent.name}] dev.zooid.error send failed:`, e));
   }
   function enqueueTurn(agent, input) {
-    const key = `${agent.name}::${input.sessionKey}`;
-    const chained = (turnQueues.get(key) ?? Promise.resolve()).then(() => runTurn(agent, input)).then(() => {
+    const key2 = `${agent.name}::${input.sessionKey}`;
+    const chained = (turnQueues.get(key2) ?? Promise.resolve()).then(() => runTurn(agent, input)).then(() => {
       let st = threadStates.get(input.threadRoot);
       if (!st) {
         st = {
@@ -46665,13 +47073,12 @@ function createMatrixTransport(opts) {
       }
       if (st.participants.at(-1) !== agent.name) st.participants.push(agent.name);
     }).catch((err) => reportTurnFailure(agent, input, err));
-    turnQueues.set(key, chained);
+    turnQueues.set(key2, chained);
     void chained.finally(() => {
-      if (turnQueues.get(key) === chained) turnQueues.delete(key);
+      if (turnQueues.get(key2) === chained) turnQueues.delete(key2);
     });
     return chained;
   }
-  const workforce = new WorkforceDirectory();
   let workforceSpaceId;
   async function handleInboundEvent(evt) {
     if (evt.event_id) {
@@ -46716,27 +47123,43 @@ function createMatrixTransport(opts) {
         return;
       }
       console.log(`[matrix] inbound dev.zooid.session_reset in ${evt.room_id} thread=${threadRoot}`);
-      dropThreadReturns(threadRoot);
+      returns.dropThread(threadRoot);
+      for (const k of [...openHandoffs.keys()]) if (k.endsWith(`::${threadRoot}`)) openHandoffs.delete(k);
       if (!threadStates.has(threadRoot) && evt.room_id) {
         try {
           threadStates.set(
             threadRoot,
-            await rebuildThreadState(client, evt.room_id, threadRoot, bindings)
+            await rebuildThreadState(client, evt.room_id, threadRoot, bindings, workforce.agentIds)
           );
         } catch (err) {
           console.warn(`[matrix] failed to rebuild threadState for reset ${threadRoot}:`, err);
         }
       }
       const st = threadStates.get(threadRoot);
+      const cleanup = [];
       for (const a of bindings) {
-        agents.endSession(a.name, threadRoot);
+        cleanup.push({
+          name: a.name,
+          key: threadRoot,
+          result: Promise.resolve().then(() => agents.endSession(a.name, threadRoot))
+        });
         taskRegistry.bumpGeneration(a.name, threadRoot);
-        for (const arc of st?.handoffs[a.name] ?? []) {
-          const key = composeHandoffKey(threadRoot, arc);
-          agents.endSession(a.name, key);
-          taskRegistry.bumpGeneration(a.name, key);
+        for (const arc of st?.handoffs[a.userId] ?? []) {
+          const key2 = composeHandoffKey(threadRoot, arc);
+          cleanup.push({
+            name: a.name,
+            key: key2,
+            result: Promise.resolve().then(() => agents.endSession(a.name, key2))
+          });
+          taskRegistry.bumpGeneration(a.name, key2);
         }
       }
+      const results = await Promise.allSettled(cleanup.map((item) => item.result));
+      results.forEach((result, index) => {
+        if (result.status === "rejected") {
+          console.warn(`[matrix] session reset cleanup failed for ${cleanup[index].name}/${cleanup[index].key}:`, result.reason);
+        }
+      });
       return;
     }
     if (evt.type === "dev.zooid.interrupt") {
@@ -46744,6 +47167,7 @@ function createMatrixTransport(opts) {
       const relates = evt.content?.["m.relates_to"];
       const threadRoot = relates?.rel_type === "m.thread" && relates.event_id ? relates.event_id : void 0;
       if (threadRoot) {
+        returns.interrupt(threadRoot);
         const targets = [];
         for (const [sessionId, ctx2] of sessions) {
           if (ctx2.threadRoot === threadRoot) {
@@ -46780,6 +47204,7 @@ function createMatrixTransport(opts) {
       console.log(
         `[matrix] interrupt session=${content.session_id} agent=${ctx.agent.name}` + (content.reason ? ` reason=${content.reason}` : "")
       );
+      returns.interrupt(ctx.threadRoot);
       await agents.cancelSession(ctx.agent.name, content.session_id).catch((err) => {
         console.error(
           `[matrix] cancelSession(${ctx.agent.name}, ${content.session_id}) failed:`,
@@ -46798,12 +47223,13 @@ function createMatrixTransport(opts) {
     }
     logInbound(evt);
     if (evt.type === "dev.zooid.turn.end") {
-      const agentId = evt.content?.agent_id;
       const endedRoot = inboundThreadRoot2(evt);
-      const senderAgent = bindings.find((binding) => binding.userId === evt.sender);
-      if (agentId && endedRoot && senderAgent?.name === agentId) {
-        releaseReturn(returnKey(agentId, endedRoot));
-      }
+      if (endedRoot && evt.sender) returns.turnEnded(evt.sender, endedRoot);
+      return;
+    }
+    if (ACTIVITY_EVENTS.has(evt.type ?? "")) {
+      const root = inboundThreadRoot2(evt);
+      if (evt.sender && root) returns.activity(evt.sender, root);
       return;
     }
     if (evt.type === "m.room.message" && isMediaMsgtype(evt.content?.msgtype) && evt.room_id && evt.event_id && evt.sender && evt.content?.url && !bindings.some((b) => b.userId === evt.sender)) {
@@ -46854,17 +47280,21 @@ function createMatrixTransport(opts) {
       const invocation = invocations.byCallEvent(evt.event_id);
       matches2 = invocation ? matches2.filter((match) => match.name === invocation.calleeAgent) : [];
     }
-    if (evt.type === "m.room.message" && promotedRoot && evt.room_id) {
-      const senderBinding = bindings.find((b) => b.userId === evt.sender);
-      if (senderBinding) {
+    if (evt.type === "m.room.message" && promotedRoot && evt.room_id && evt.sender) {
+      const senderIsAgentId = isLocal(evt.sender) || workforce.agentIds.has(evt.sender);
+      if (senderIsAgentId) {
         const st = threadStates.get(promotedRoot);
-        const held = matches2.filter((m) => isReturnRoute(evt, m, bindings, st));
+        const held = matches2.filter((m) => isReturnRoute(evt, m, st));
         if (held.length > 0) {
           matches2 = matches2.filter((m) => !held.includes(m));
-          stashReturn(senderBinding, promotedRoot, evt.room_id, evt, held);
+          returns.hold(evt.sender, promotedRoot, evt.room_id, held, evt.content?.body, {
+            remote: !isLocal(evt.sender)
+          });
+          console.log(
+            `[matrix] holding return ${agentName(evt.sender)} \u2192 ${held.map((m) => m.name).join(",")} until turn end (thread=${promotedRoot})`
+          );
         }
       }
-      for (const m of matches2) dropPendingReturn(promotedRoot, m.name);
     }
     const senderIsBot = bindings.some((b) => b.userId === evt.sender);
     if (evt.type === "m.room.message" && matches2.length === 0 && !senderIsBot) {
@@ -46872,7 +47302,9 @@ function createMatrixTransport(opts) {
         `[matrix] no agent matched message in ${evt.room_id} from ${evt.sender} (bindings: ${bindings.map((b) => `${b.name}@${b.userId}[${b.trigger}]`).join(", ")})`
       );
     }
-    if (matches2.length > 0 && promotedRoot) {
+    const handoff = readHandoff(evt.content);
+    const callEdge = handoff && evt.type === "m.room.message" && handoff.caller === evt.sender && promotedRoot ? handoff : void 0;
+    if (promotedRoot && (matches2.length > 0 || callEdge)) {
       let st = threadStates.get(promotedRoot);
       if (!st) {
         st = { participants: [], rootMentions: [], callers: {}, handoffs: {} };
@@ -46881,17 +47313,26 @@ function createMatrixTransport(opts) {
       if (taskCtx?.isRoot) {
         if (!st.rootMentions.includes(taskRec.assignee)) st.rootMentions.push(taskRec.assignee);
       } else {
-        const msgMentions = new Set(extractMentions(evt));
-        const senderAgent = bindings.find((b) => b.userId === evt.sender);
-        for (const a of bindings) {
-          if (!msgMentions.has(a.userId)) continue;
-          if (!st.rootMentions.includes(a.name)) st.rootMentions.push(a.name);
-          if (senderAgent && a.name !== senderAgent.name && !wouldCycleCallers(st.callers, a.name, senderAgent.name)) {
-            st.callers[a.name] = senderAgent.name;
-            if (evt.event_id) {
-              const arcs = st.handoffs[a.name] ??= [];
-              if (!arcs.includes(evt.event_id)) arcs.push(evt.event_id);
-            }
+        const senderIsAgentId = !!evt.sender && (isLocal(evt.sender) || workforce.agentIds.has(evt.sender));
+        if (!senderIsAgentId) {
+          const msgMentions = new Set(extractMentions(evt));
+          for (const a of bindings)
+            if (msgMentions.has(a.userId) && !st.rootMentions.includes(a.name))
+              st.rootMentions.push(a.name);
+        }
+        if (callEdge && callEdge.callee !== callEdge.caller && !wouldCycleCallers(st.callers, callEdge.callee, callEdge.caller)) {
+          st.callers[callEdge.callee] = callEdge.caller;
+          if (evt.event_id) {
+            const arcs = st.handoffs[callEdge.callee] ??= [];
+            if (!arcs.includes(evt.event_id)) arcs.push(evt.event_id);
+          }
+          if (!taskCtx && evt.room_id) {
+            const callerBinding = bindings.find((b) => b.userId === callEdge.caller);
+            if (callerBinding?.trigger === "mention")
+              returns.open(callEdge.callee, promotedRoot, evt.room_id, callerBinding, {
+                remote: !isLocal(callEdge.callee)
+              });
+            returns.markDelegated(callEdge.caller, promotedRoot);
           }
         }
       }
@@ -46899,7 +47340,7 @@ function createMatrixTransport(opts) {
     for (const a of matches2) {
       console.log(`[matrix] \u2192 ${a.name} (${a.userId})`);
       if (!promotedRoot || !evt.room_id) continue;
-      const sessionKey = sessionKeyFor(a.name, promotedRoot, threadStates.get(promotedRoot));
+      const sessionKey = sessionKeyFor(a.userId, promotedRoot, threadStates.get(promotedRoot));
       const taskEnvelope = taskCtx?.isRoot && a.name === taskRec.assignee ? { parentAgent: taskRec.parent.agent } : void 0;
       void enqueueTurn(a, {
         roomId: evt.room_id,
@@ -46947,10 +47388,10 @@ function createMatrixTransport(opts) {
     return c.json({});
   });
   app.get("/healthz", (c) => c.text("ok"));
-  async function runTurn(agent, input) {
+  async function runTurnBody(agent, input) {
     const { roomId, threadRoot, sessionKey } = input;
     const sessionId = await agents.ensureSession(agent.name, sessionKey, roomId, threadRoot);
-    sessions.set(sessionId, { agent, roomId, threadRoot });
+    sessions.set(sessionId, { agent, roomId, threadRoot, sessionKey });
     buffers.set(sessionId, "");
     bufferMessageIds.delete(sessionId);
     flushedCounts.set(sessionId, 0);
@@ -47074,10 +47515,19 @@ function createMatrixTransport(opts) {
       sendQueue.delete(sessionId);
     }
   }
+  async function runTurn(agent, input) {
+    returns.turnStarted(agent.userId, input.threadRoot);
+    try {
+      await runTurnBody(agent, input);
+    } finally {
+      returns.turnFinished(agent.userId, input.threadRoot);
+    }
+  }
   async function finishTask(task, ctx) {
     const threadId = task.threadRoot;
     const completion = ctx.completion;
     if (!taskRegistry.close(task.taskId)) return;
+    for (const k of [...openHandoffs.keys()]) if (k.endsWith(`::${threadId}`)) openHandoffs.delete(k);
     const cancelled = invocations.cancelForTask(task.taskId);
     pendingInput.cancelFor([threadId, ...cancelled.map((i) => i.calleeSessionKey).filter((x) => Boolean(x))]);
     await client.sendCustomEvent({
@@ -47149,7 +47599,7 @@ function createMatrixTransport(opts) {
           results[index] = {
             agent: spec.agent,
             status: "refused",
-            reason: "depth_limit: this thread is itself a delegated task. Do the work here, or @mention another agent in this thread to hand off."
+            reason: "depth_limit: this thread is itself a delegated task. Do the work here, or call zooid_handoff to hand off in this thread."
           };
           continue;
         }
@@ -47266,7 +47716,86 @@ function createMatrixTransport(opts) {
       const openTask = taskRegistry.openTaskFor(caller.agentName, caller.threadRoot);
       return {
         is_task_assignee: openTask !== void 0 && openTask.threadRoot === caller.sessionKey,
-        can_start_task_threads: enclosing === void 0
+        can_start_task_threads: enclosing === void 0,
+        can_handoff: bindingFor(caller.agentName) !== void 0
+      };
+    },
+    async handoff(caller, input) {
+      const callerBinding = bindingFor(caller.agentName);
+      if (!callerBinding) return { status: "refused", reason: "unknown_caller" };
+      const prompt = input.prompt.trim();
+      if (!prompt) return { status: "refused", reason: "prompt must be non-empty" };
+      const resolved = resolveHandoffTarget(input.agent, caller.channelId, handoffCandidates());
+      if (!resolved.ok) return { status: "refused", reason: resolved.reason };
+      const target = resolved.target;
+      if (target.userId === callerBinding.userId)
+        return { status: "refused", reason: "self: you cannot hand off to yourself" };
+      const st = threadStates.get(caller.threadRoot);
+      if (st && wouldCycleCallers(st.callers, target.userId, callerBinding.userId))
+        return {
+          status: "refused",
+          reason: `already_waiting_on_you: ${target.name} is waiting on your result. End your turn \u2014 your result returns to ${target.name} automatically.`
+        };
+      const task = taskRegistry.taskForRoot(caller.threadRoot);
+      const inTask = task?.phase === "open";
+      if (inTask && !isLocal(target.userId))
+        return {
+          status: "refused",
+          reason: "remote_in_task: a task thread hands off only to agents on this workstation"
+        };
+      const key2 = openKey(callerBinding.userId, caller.threadRoot);
+      const busy = inTask ? invocations.outstandingFor(caller.sessionKey).length > 0 : openHandoffs.has(key2);
+      if (busy)
+        return {
+          status: "refused",
+          reason: "already_open: you already have a handoff open in this thread. End your turn and wait for it, or use zooid_start_task_threads for parallel work."
+        };
+      const invocation = inTask ? invocations.open({
+        taskId: task.taskId,
+        callerAgent: callerBinding.name,
+        callerSessionKey: caller.sessionKey,
+        calleeAgent: target.name
+      }) : void 0;
+      if (invocation) taskRegistry.clearSummary(task.taskId);
+      else openHandoffs.set(key2, target.userId);
+      const callId = randomUUID5();
+      const content = buildHandoffContent({
+        callId,
+        caller: callerBinding.userId,
+        callee: target.userId,
+        prompt
+      });
+      const liveSession = [...sessions].find(
+        ([, c]) => c.agent.name === callerBinding.name && c.sessionKey === caller.sessionKey
+      )?.[0];
+      if (liveSession) flushBuffer(liveSession);
+      let eventId;
+      const send = async () => {
+        const { event_id } = await client.sendMessage({
+          roomId: caller.channelId,
+          asUserId: callerBinding.userId,
+          content,
+          threadRoot: caller.threadRoot
+        });
+        eventId = event_id;
+      };
+      const tail = (liveSession ? sendQueue.get(liveSession) ?? Promise.resolve() : Promise.resolve()).then(send);
+      if (liveSession) sendQueue.set(liveSession, tail.catch(() => {
+      }));
+      try {
+        await tail;
+      } catch (err) {
+        openHandoffs.delete(key2);
+        if (invocation) invocations.resolve(invocation.invocationId);
+        return { status: "refused", reason: `post_failed: ${String(err.message)}` };
+      }
+      if (invocation && eventId)
+        invocations.attachCallEvent(invocation.invocationId, eventId, composeHandoffKey(caller.threadRoot, eventId));
+      return {
+        status: "started",
+        call_id: callId,
+        callee: target.userId,
+        delivery: renderHandoffDelivery(target.name)
       };
     }
   };
@@ -47349,43 +47878,35 @@ async function rebuildThreadState(client, roomId, rootEventId, bindings, knownAg
   };
   const asUser = (bindings.find((b) => b.rooms.some((r) => r.alias === roomId)) ?? bindings[0])?.userId;
   if (!asUser) return state;
-  const root = await client.fetchEvent(roomId, rootEventId, asUser);
-  if (root) {
-    const rootMentions = new Set(extractMentions(root));
-    const rootSender = root.sender;
-    const rootSenderAgent = rootSender ? bindings.find((b) => b.userId === rootSender) : void 0;
-    for (const a of bindings) {
-      if (!rootMentions.has(a.userId)) continue;
-      if (!state.rootMentions.includes(a.name)) state.rootMentions.push(a.name);
-      if (rootSenderAgent && a.name !== rootSenderAgent.name && !wouldCycleCallers(state.callers, a.name, rootSenderAgent.name)) {
-        state.callers[a.name] = rootSenderAgent.name;
-        const arcs = state.handoffs[a.name] ??= [];
-        if (!arcs.includes(rootEventId)) arcs.push(rootEventId);
-      }
-    }
-  }
   const { chunk: thread } = await client.fetchThreadRelations({
     roomId,
     rootEventId,
     asUserId: asUser
   });
-  for (const ev of thread) {
-    const mentions = new Set(extractMentions(ev));
+  const root = await client.fetchEvent(roomId, rootEventId, asUser);
+  const events = [...root ? [root] : [], ...thread];
+  for (const ev of events) {
     const evSender = ev.sender;
-    const evSenderAgent = evSender ? bindings.find((b) => b.userId === evSender) : void 0;
     const evId = ev.event_id;
-    for (const a of bindings) {
-      if (!mentions.has(a.userId)) continue;
-      if (!state.rootMentions.includes(a.name)) state.rootMentions.push(a.name);
-      if (evSenderAgent && a.name !== evSenderAgent.name && !wouldCycleCallers(state.callers, a.name, evSenderAgent.name)) {
-        state.callers[a.name] = evSenderAgent.name;
-        if (evId) {
-          const arcs = state.handoffs[a.name] ??= [];
-          if (!arcs.includes(evId)) arcs.push(evId);
-        }
+    const content = ev.content;
+    const senderIsAgentId = !!evSender && (bindings.some((b) => b.userId === evSender) || knownAgentIds?.has(evSender) === true);
+    if (!senderIsAgentId) {
+      const mentions = new Set(extractMentions(ev));
+      for (const a of bindings)
+        if (mentions.has(a.userId) && !state.rootMentions.includes(a.name)) state.rootMentions.push(a.name);
+    }
+    const h = readHandoff(content);
+    if (h && h.caller === evSender && h.callee !== h.caller && !wouldCycleCallers(state.callers, h.callee, h.caller)) {
+      state.callers[h.callee] = h.caller;
+      if (evId) {
+        const arcs = state.handoffs[h.callee] ??= [];
+        if (!arcs.includes(evId)) arcs.push(evId);
       }
     }
+  }
+  for (const ev of thread) {
     const type = ev.type;
+    const evSender = ev.sender;
     if (type === "m.room.message" && evSender) {
       const a = bindings.find((b) => b.userId === evSender);
       const msgtype = ev.content?.msgtype;
@@ -47420,14 +47941,14 @@ function truncate(s, n) {
 }
 
 // ../context-mcp/src/spawn-registry.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 var SpawnRegistry = class {
   bindings = /* @__PURE__ */ new Map();
   spawnByAgentSession = /* @__PURE__ */ new Map();
   spawnByAcpSession = /* @__PURE__ */ new Map();
   tasks;
   register(input) {
-    const spawnId = randomUUID5();
+    const spawnId = randomUUID6();
     this.bindings.set(spawnId, { spawnId, ...input });
     this.spawnByAgentSession.set(this.key(input.agentName, input.sessionKey ?? input.threadRef.threadId), spawnId);
     return spawnId;
@@ -47437,11 +47958,11 @@ var SpawnRegistry = class {
   }
   release(spawnId) {
     this.bindings.delete(spawnId);
-    for (const [key, value] of this.spawnByAgentSession) {
-      if (value === spawnId) this.spawnByAgentSession.delete(key);
+    for (const [key2, value] of this.spawnByAgentSession) {
+      if (value === spawnId) this.spawnByAgentSession.delete(key2);
     }
-    for (const [key, value] of this.spawnByAcpSession) {
-      if (value === spawnId) this.spawnByAcpSession.delete(key);
+    for (const [key2, value] of this.spawnByAcpSession) {
+      if (value === spawnId) this.spawnByAcpSession.delete(key2);
     }
   }
   linkSession(agentName, sessionKey, acpSessionId) {
@@ -47582,7 +48103,7 @@ async function handleLine(line, socket, registry3, callerAgent) {
       result = await binding.provider.sendMessage(
         req.params
       );
-    } else if (req.method === "startTasks" || req.method === "completeTask" || req.method === "describeRole") {
+    } else if (req.method === "startTasks" || req.method === "completeTask" || req.method === "describeRole" || req.method === "handoff") {
       const actions = registry3.taskActions;
       if (!actions) {
         socket.write(
@@ -47599,7 +48120,7 @@ async function handleLine(line, socket, registry3, callerAgent) {
         threadRoot: binding.threadRef.threadId,
         sessionKey: binding.sessionKey ?? binding.threadRef.threadId
       };
-      result = req.method === "startTasks" ? await actions.startTasks(caller, req.params) : req.method === "completeTask" ? await actions.completeTask(caller, req.params) : await actions.describeRole(caller);
+      result = req.method === "startTasks" ? await actions.startTasks(caller, req.params) : req.method === "completeTask" ? await actions.completeTask(caller, req.params) : req.method === "describeRole" ? await actions.describeRole(caller) : await actions.handoff(caller, req.params);
     } else {
       socket.write(
         JSON.stringify({
@@ -47815,19 +48336,19 @@ function floatSafeRemainder2(val, step) {
   const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
   return valInt % stepInt / 10 ** decCount;
 }
-function defineLazy2(object3, key, getter) {
+function defineLazy2(object3, key2, getter) {
   const set2 = false;
-  Object.defineProperty(object3, key, {
+  Object.defineProperty(object3, key2, {
     get() {
       if (!set2) {
         const value = getter();
-        object3[key] = value;
+        object3[key2] = value;
         return value;
       }
       throw new Error("cached value already set");
     },
     set(v) {
-      Object.defineProperty(object3, key, {
+      Object.defineProperty(object3, key2, {
         value: v
         // configurable: true,
       });
@@ -47846,11 +48367,11 @@ function assignProp2(target, prop, value) {
 function getElementAtPath2(obj, path) {
   if (!path)
     return obj;
-  return path.reduce((acc, key) => acc?.[key], obj);
+  return path.reduce((acc, key2) => acc?.[key2], obj);
 }
 function promiseAllObject2(promisesObj) {
   const keys = Object.keys(promisesObj);
-  const promises = keys.map((key) => promisesObj[key]);
+  const promises = keys.map((key2) => promisesObj[key2]);
   return Promise.all(promises).then((results) => {
     const resolvedObj = {};
     for (let i = 0; i < keys.length; i++) {
@@ -47903,8 +48424,8 @@ function isPlainObject2(o) {
 }
 function numKeys2(data) {
   let keyCount = 0;
-  for (const key in data) {
-    if (Object.prototype.hasOwnProperty.call(data, key)) {
+  for (const key2 in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key2)) {
       keyCount++;
     }
   }
@@ -48040,13 +48561,13 @@ var BIGINT_FORMAT_RANGES2 = {
 function pick2(schema, mask) {
   const newShape = {};
   const currDef = schema._zod.def;
-  for (const key in mask) {
-    if (!(key in currDef.shape)) {
-      throw new Error(`Unrecognized key: "${key}"`);
+  for (const key2 in mask) {
+    if (!(key2 in currDef.shape)) {
+      throw new Error(`Unrecognized key: "${key2}"`);
     }
-    if (!mask[key])
+    if (!mask[key2])
       continue;
-    newShape[key] = currDef.shape[key];
+    newShape[key2] = currDef.shape[key2];
   }
   return clone2(schema, {
     ...schema._zod.def,
@@ -48057,13 +48578,13 @@ function pick2(schema, mask) {
 function omit2(schema, mask) {
   const newShape = { ...schema._zod.def.shape };
   const currDef = schema._zod.def;
-  for (const key in mask) {
-    if (!(key in currDef.shape)) {
-      throw new Error(`Unrecognized key: "${key}"`);
+  for (const key2 in mask) {
+    if (!(key2 in currDef.shape)) {
+      throw new Error(`Unrecognized key: "${key2}"`);
     }
-    if (!mask[key])
+    if (!mask[key2])
       continue;
-    delete newShape[key];
+    delete newShape[key2];
   }
   return clone2(schema, {
     ...schema._zod.def,
@@ -48104,23 +48625,23 @@ function partial2(Class3, schema, mask) {
   const oldShape = schema._zod.def.shape;
   const shape = { ...oldShape };
   if (mask) {
-    for (const key in mask) {
-      if (!(key in oldShape)) {
-        throw new Error(`Unrecognized key: "${key}"`);
+    for (const key2 in mask) {
+      if (!(key2 in oldShape)) {
+        throw new Error(`Unrecognized key: "${key2}"`);
       }
-      if (!mask[key])
+      if (!mask[key2])
         continue;
-      shape[key] = Class3 ? new Class3({
+      shape[key2] = Class3 ? new Class3({
         type: "optional",
-        innerType: oldShape[key]
-      }) : oldShape[key];
+        innerType: oldShape[key2]
+      }) : oldShape[key2];
     }
   } else {
-    for (const key in oldShape) {
-      shape[key] = Class3 ? new Class3({
+    for (const key2 in oldShape) {
+      shape[key2] = Class3 ? new Class3({
         type: "optional",
-        innerType: oldShape[key]
-      }) : oldShape[key];
+        innerType: oldShape[key2]
+      }) : oldShape[key2];
     }
   }
   return clone2(schema, {
@@ -48133,22 +48654,22 @@ function required2(Class3, schema, mask) {
   const oldShape = schema._zod.def.shape;
   const shape = { ...oldShape };
   if (mask) {
-    for (const key in mask) {
-      if (!(key in shape)) {
-        throw new Error(`Unrecognized key: "${key}"`);
+    for (const key2 in mask) {
+      if (!(key2 in shape)) {
+        throw new Error(`Unrecognized key: "${key2}"`);
       }
-      if (!mask[key])
+      if (!mask[key2])
         continue;
-      shape[key] = new Class3({
+      shape[key2] = new Class3({
         type: "nonoptional",
-        innerType: oldShape[key]
+        innerType: oldShape[key2]
       });
     }
   } else {
-    for (const key in oldShape) {
-      shape[key] = new Class3({
+    for (const key2 in oldShape) {
+      shape[key2] = new Class3({
         type: "nonoptional",
-        innerType: oldShape[key]
+        innerType: oldShape[key2]
       });
     }
   }
@@ -49344,28 +49865,28 @@ var $ZodArray2 = /* @__PURE__ */ $constructor2("$ZodArray", (inst, def) => {
     return payload;
   };
 });
-function handleObjectResult(result, final, key) {
+function handleObjectResult(result, final, key2) {
   if (result.issues.length) {
-    final.issues.push(...prefixIssues2(key, result.issues));
+    final.issues.push(...prefixIssues2(key2, result.issues));
   }
-  final.value[key] = result.value;
+  final.value[key2] = result.value;
 }
-function handleOptionalObjectResult(result, final, key, input) {
+function handleOptionalObjectResult(result, final, key2, input) {
   if (result.issues.length) {
-    if (input[key] === void 0) {
-      if (key in input) {
-        final.value[key] = void 0;
+    if (input[key2] === void 0) {
+      if (key2 in input) {
+        final.value[key2] = void 0;
       } else {
-        final.value[key] = result.value;
+        final.value[key2] = result.value;
       }
     } else {
-      final.issues.push(...prefixIssues2(key, result.issues));
+      final.issues.push(...prefixIssues2(key2, result.issues));
     }
   } else if (result.value === void 0) {
-    if (key in input)
-      final.value[key] = void 0;
+    if (key2 in input)
+      final.value[key2] = void 0;
   } else {
-    final.value[key] = result.value;
+    final.value[key2] = result.value;
   }
 }
 var $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
@@ -49389,12 +49910,12 @@ var $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
   defineLazy2(inst._zod, "propValues", () => {
     const shape = def.shape;
     const propValues = {};
-    for (const key in shape) {
-      const field = shape[key]._zod;
+    for (const key2 in shape) {
+      const field = shape[key2]._zod;
       if (field.values) {
-        propValues[key] ?? (propValues[key] = /* @__PURE__ */ new Set());
+        propValues[key2] ?? (propValues[key2] = /* @__PURE__ */ new Set());
         for (const v of field.values)
-          propValues[key].add(v);
+          propValues[key2].add(v);
       }
     }
     return propValues;
@@ -49402,22 +49923,22 @@ var $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
   const generateFastpass = (shape) => {
     const doc = new Doc2(["shape", "payload", "ctx"]);
     const normalized = _normalized.value;
-    const parseStr = (key) => {
-      const k = esc2(key);
+    const parseStr = (key2) => {
+      const k = esc2(key2);
       return `shape[${k}]._zod.run({ value: input[${k}], issues: [] }, ctx)`;
     };
     doc.write(`const input = payload.value;`);
     const ids = /* @__PURE__ */ Object.create(null);
     let counter = 0;
-    for (const key of normalized.keys) {
-      ids[key] = `key_${counter++}`;
+    for (const key2 of normalized.keys) {
+      ids[key2] = `key_${counter++}`;
     }
     doc.write(`const newResult = {}`);
-    for (const key of normalized.keys) {
-      if (normalized.optionalKeys.has(key)) {
-        const id = ids[key];
-        doc.write(`const ${id} = ${parseStr(key)};`);
-        const k = esc2(key);
+    for (const key2 of normalized.keys) {
+      if (normalized.optionalKeys.has(key2)) {
+        const id = ids[key2];
+        doc.write(`const ${id} = ${parseStr(key2)};`);
+        const k = esc2(key2);
         doc.write(`
         if (${id}.issues.length) {
           if (input[${k}] === undefined) {
@@ -49439,14 +49960,14 @@ var $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
         }
         `);
       } else {
-        const id = ids[key];
-        doc.write(`const ${id} = ${parseStr(key)};`);
+        const id = ids[key2];
+        doc.write(`const ${id} = ${parseStr(key2)};`);
         doc.write(`
           if (${id}.issues.length) payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
             ...iss,
-            path: iss.path ? [${esc2(key)}, ...iss.path] : [${esc2(key)}]
+            path: iss.path ? [${esc2(key2)}, ...iss.path] : [${esc2(key2)}]
           })));`);
-        doc.write(`newResult[${esc2(key)}] = ${id}.value`);
+        doc.write(`newResult[${esc2(key2)}] = ${id}.value`);
       }
     }
     doc.write(`payload.value = newResult;`);
@@ -49481,16 +50002,16 @@ var $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
     } else {
       payload.value = {};
       const shape = value.shape;
-      for (const key of value.keys) {
-        const el = shape[key];
-        const r = el._zod.run({ value: input[key], issues: [] }, ctx);
+      for (const key2 of value.keys) {
+        const el = shape[key2];
+        const r = el._zod.run({ value: input[key2], issues: [] }, ctx);
         const isOptional = el._zod.optin === "optional" && el._zod.optout === "optional";
         if (r instanceof Promise) {
-          proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key, input) : handleObjectResult(r2, payload, key)));
+          proms.push(r.then((r2) => isOptional ? handleOptionalObjectResult(r2, payload, key2, input) : handleObjectResult(r2, payload, key2)));
         } else if (isOptional) {
-          handleOptionalObjectResult(r, payload, key, input);
+          handleOptionalObjectResult(r, payload, key2, input);
         } else {
-          handleObjectResult(r, payload, key);
+          handleObjectResult(r, payload, key2);
         }
       }
     }
@@ -49501,18 +50022,18 @@ var $ZodObject2 = /* @__PURE__ */ $constructor2("$ZodObject", (inst, def) => {
     const keySet = value.keySet;
     const _catchall = catchall._zod;
     const t = _catchall.def.type;
-    for (const key of Object.keys(input)) {
-      if (keySet.has(key))
+    for (const key2 of Object.keys(input)) {
+      if (keySet.has(key2))
         continue;
       if (t === "never") {
-        unrecognized.push(key);
+        unrecognized.push(key2);
         continue;
       }
-      const r = _catchall.run({ value: input[key], issues: [] }, ctx);
+      const r = _catchall.run({ value: input[key2], issues: [] }, ctx);
       if (r instanceof Promise) {
-        proms.push(r.then((r2) => handleObjectResult(r2, payload, key)));
+        proms.push(r.then((r2) => handleObjectResult(r2, payload, key2)));
       } else {
-        handleObjectResult(r, payload, key);
+        handleObjectResult(r, payload, key2);
       }
     }
     if (unrecognized.length) {
@@ -49674,17 +50195,17 @@ function mergeValues2(a, b) {
   }
   if (isPlainObject2(a) && isPlainObject2(b)) {
     const bKeys = Object.keys(b);
-    const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const sharedKeys = Object.keys(a).filter((key2) => bKeys.indexOf(key2) !== -1);
     const newObj = { ...a, ...b };
-    for (const key of sharedKeys) {
-      const sharedValue = mergeValues2(a[key], b[key]);
+    for (const key2 of sharedKeys) {
+      const sharedValue = mergeValues2(a[key2], b[key2]);
       if (!sharedValue.valid) {
         return {
           valid: false,
-          mergeErrorPath: [key, ...sharedValue.mergeErrorPath]
+          mergeErrorPath: [key2, ...sharedValue.mergeErrorPath]
         };
       }
-      newObj[key] = sharedValue.data;
+      newObj[key2] = sharedValue.data;
     }
     return { valid: true, data: newObj };
   }
@@ -49742,29 +50263,29 @@ var $ZodRecord2 = /* @__PURE__ */ $constructor2("$ZodRecord", (inst, def) => {
     if (def.keyType._zod.values) {
       const values = def.keyType._zod.values;
       payload.value = {};
-      for (const key of values) {
-        if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
-          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+      for (const key2 of values) {
+        if (typeof key2 === "string" || typeof key2 === "number" || typeof key2 === "symbol") {
+          const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
           if (result instanceof Promise) {
             proms.push(result.then((result2) => {
               if (result2.issues.length) {
-                payload.issues.push(...prefixIssues2(key, result2.issues));
+                payload.issues.push(...prefixIssues2(key2, result2.issues));
               }
-              payload.value[key] = result2.value;
+              payload.value[key2] = result2.value;
             }));
           } else {
             if (result.issues.length) {
-              payload.issues.push(...prefixIssues2(key, result.issues));
+              payload.issues.push(...prefixIssues2(key2, result.issues));
             }
-            payload.value[key] = result.value;
+            payload.value[key2] = result.value;
           }
         }
       }
       let unrecognized;
-      for (const key in input) {
-        if (!values.has(key)) {
+      for (const key2 in input) {
+        if (!values.has(key2)) {
           unrecognized = unrecognized ?? [];
-          unrecognized.push(key);
+          unrecognized.push(key2);
         }
       }
       if (unrecognized && unrecognized.length > 0) {
@@ -49777,10 +50298,10 @@ var $ZodRecord2 = /* @__PURE__ */ $constructor2("$ZodRecord", (inst, def) => {
       }
     } else {
       payload.value = {};
-      for (const key of Reflect.ownKeys(input)) {
-        if (key === "__proto__")
+      for (const key2 of Reflect.ownKeys(input)) {
+        if (key2 === "__proto__")
           continue;
-        const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+        const keyResult = def.keyType._zod.run({ value: key2, issues: [] }, ctx);
         if (keyResult instanceof Promise) {
           throw new Error("Async schemas not supported in object keys currently");
         }
@@ -49789,24 +50310,24 @@ var $ZodRecord2 = /* @__PURE__ */ $constructor2("$ZodRecord", (inst, def) => {
             origin: "record",
             code: "invalid_key",
             issues: keyResult.issues.map((iss) => finalizeIssue2(iss, ctx, config2())),
-            input: key,
-            path: [key],
+            input: key2,
+            path: [key2],
             inst
           });
           payload.value[keyResult.value] = keyResult.value;
           continue;
         }
-        const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+        const result = def.valueType._zod.run({ value: input[key2], issues: [] }, ctx);
         if (result instanceof Promise) {
           proms.push(result.then((result2) => {
             if (result2.issues.length) {
-              payload.issues.push(...prefixIssues2(key, result2.issues));
+              payload.issues.push(...prefixIssues2(key2, result2.issues));
             }
             payload.value[keyResult.value] = result2.value;
           }));
         } else {
           if (result.issues.length) {
-            payload.issues.push(...prefixIssues2(key, result.issues));
+            payload.issues.push(...prefixIssues2(key2, result.issues));
           }
           payload.value[keyResult.value] = result.value;
         }
@@ -53083,6 +53604,7 @@ Set agents.<name>.container.image, top-level container.image, or use a preset th
     cwd: cwdByAgent,
     approvals: opts.approvals,
     onTap: opts.onTap,
+    onLifecycle: opts.onLifecycle,
     agentsDir: opts.agentsDir,
     contextSpawns,
     onSessionEstablished: (agentName, sessionKey, sessionId) => opts.contextSpawnRegistry?.linkSession(agentName, sessionKey, sessionId)
@@ -53180,4 +53702,4 @@ export {
   buildAcpRegistry,
   contextEligibleAgents
 };
-//# sourceMappingURL=chunk-35IKQPC5.js.map
+//# sourceMappingURL=chunk-HE7DVDJA.js.map