@ours.network/cowork 1.1.3 → 1.1.4

package/dist/daemon.js

@@ -18,9 +18,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;
 };
@@ -69,9 +69,9 @@ var init_util = __esm({
       };
       util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
         const keys = [];
-        for (const key in object) {
-          if (Object.prototype.hasOwnProperty.call(object, key)) {
-            keys.push(key);
+        for (const key2 in object) {
+          if (Object.prototype.hasOwnProperty.call(object, key2)) {
+            keys.push(key2);
           }
         }
         return keys;
@@ -496,10 +496,10 @@ var init_parseUtil = __esm({
       static async mergeObjectAsync(status, pairs) {
         const syncPairs = [];
         for (const pair of pairs) {
-          const key = await pair.key;
+          const key2 = await pair.key;
           const value = await pair.value;
           syncPairs.push({
-            key,
+            key: key2,
             value
           });
         }
@@ -508,17 +508,17 @@ var init_parseUtil = __esm({
       static mergeObjectSync(status, pairs) {
         const finalObject = {};
         for (const pair of pairs) {
-          const { key, value } = pair;
-          if (key.status === "aborted")
+          const { key: key2, value } = pair;
+          if (key2.status === "aborted")
             return INVALID;
           if (value.status === "aborted")
             return INVALID;
-          if (key.status === "dirty")
+          if (key2.status === "dirty")
             status.dirty();
           if (value.status === "dirty")
             status.dirty();
-          if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
-            finalObject[key.value] = value.value;
+          if (key2.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
+            finalObject[key2.value] = value.value;
           }
         }
         return { status: status.value, value: finalObject };
@@ -650,9 +650,9 @@ function floatSafeRemainder(val, step) {
 function deepPartialify(schema) {
   if (schema instanceof ZodObject) {
     const newShape = {};
-    for (const key in schema.shape) {
-      const fieldSchema = schema.shape[key];
-      newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
+    for (const key2 in schema.shape) {
+      const fieldSchema = schema.shape[key2];
+      newShape[key2] = ZodOptional.create(deepPartialify(fieldSchema));
     }
     return new ZodObject({
       ...schema._def,
@@ -680,14 +680,14 @@ function mergeValues(a, b) {
     return { valid: true, data: a };
   } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
     const bKeys = util.objectKeys(b);
-    const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
+    const sharedKeys = util.objectKeys(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 };
       }
-      newObj[key] = sharedValue.data;
+      newObj[key2] = sharedValue.data;
     }
     return { valid: true, data: newObj };
   } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
@@ -754,12 +754,12 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path, key) {
+      constructor(parent, value, path, key2) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
         this._path = path;
-        this._key = key;
+        this._key = key2;
       }
       get path() {
         if (!this._cachedPath.length) {
@@ -2437,29 +2437,29 @@ var init_types = __esm({
         const { shape, keys: shapeKeys } = this._getCached();
         const extraKeys = [];
         if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
-          for (const key in ctx.data) {
-            if (!shapeKeys.includes(key)) {
-              extraKeys.push(key);
+          for (const key2 in ctx.data) {
+            if (!shapeKeys.includes(key2)) {
+              extraKeys.push(key2);
             }
           }
         }
         const pairs = [];
-        for (const key of shapeKeys) {
-          const keyValidator = shape[key];
-          const value = ctx.data[key];
+        for (const key2 of shapeKeys) {
+          const keyValidator = shape[key2];
+          const value = ctx.data[key2];
           pairs.push({
-            key: { status: "valid", value: key },
-            value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
-            alwaysSet: key in ctx.data
+            key: { status: "valid", value: key2 },
+            value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key2)),
+            alwaysSet: key2 in ctx.data
           });
         }
         if (this._def.catchall instanceof ZodNever) {
           const unknownKeys = this._def.unknownKeys;
           if (unknownKeys === "passthrough") {
-            for (const key of extraKeys) {
+            for (const key2 of extraKeys) {
               pairs.push({
-                key: { status: "valid", value: key },
-                value: { status: "valid", value: ctx.data[key] }
+                key: { status: "valid", value: key2 },
+                value: { status: "valid", value: ctx.data[key2] }
               });
             }
           } else if (unknownKeys === "strict") {
@@ -2476,15 +2476,15 @@ var init_types = __esm({
           }
         } else {
           const catchall = this._def.catchall;
-          for (const key of extraKeys) {
-            const value = ctx.data[key];
+          for (const key2 of extraKeys) {
+            const value = ctx.data[key2];
             pairs.push({
-              key: { status: "valid", value: key },
+              key: { status: "valid", value: key2 },
               value: catchall._parse(
-                new ParseInputLazyPath(ctx, value, ctx.path, key)
+                new ParseInputLazyPath(ctx, value, ctx.path, key2)
                 //, ctx.child(key), value, getParsedType(value)
               ),
-              alwaysSet: key in ctx.data
+              alwaysSet: key2 in ctx.data
             });
           }
         }
@@ -2492,10 +2492,10 @@ var init_types = __esm({
           return Promise.resolve().then(async () => {
             const syncPairs = [];
             for (const pair of pairs) {
-              const key = await pair.key;
+              const key2 = await pair.key;
               const value = await pair.value;
               syncPairs.push({
-                key,
+                key: key2,
                 value,
                 alwaysSet: pair.alwaysSet
               });
@@ -2620,8 +2620,8 @@ var init_types = __esm({
       //   }) as any;
       //   return merged;
       // }
-      setKey(key, schema) {
-        return this.augment({ [key]: schema });
+      setKey(key2, schema) {
+        return this.augment({ [key2]: schema });
       }
       // merge<Incoming extends AnyZodObject>(
       //   merging: Incoming
@@ -2652,9 +2652,9 @@ var init_types = __esm({
       }
       pick(mask) {
         const shape = {};
-        for (const key of util.objectKeys(mask)) {
-          if (mask[key] && this.shape[key]) {
-            shape[key] = this.shape[key];
+        for (const key2 of util.objectKeys(mask)) {
+          if (mask[key2] && this.shape[key2]) {
+            shape[key2] = this.shape[key2];
           }
         }
         return new _ZodObject({
@@ -2664,9 +2664,9 @@ var init_types = __esm({
       }
       omit(mask) {
         const shape = {};
-        for (const key of util.objectKeys(this.shape)) {
-          if (!mask[key]) {
-            shape[key] = this.shape[key];
+        for (const key2 of util.objectKeys(this.shape)) {
+          if (!mask[key2]) {
+            shape[key2] = this.shape[key2];
           }
         }
         return new _ZodObject({
@@ -2682,12 +2682,12 @@ var init_types = __esm({
       }
       partial(mask) {
         const newShape = {};
-        for (const key of util.objectKeys(this.shape)) {
-          const fieldSchema = this.shape[key];
-          if (mask && !mask[key]) {
-            newShape[key] = fieldSchema;
+        for (const key2 of util.objectKeys(this.shape)) {
+          const fieldSchema = this.shape[key2];
+          if (mask && !mask[key2]) {
+            newShape[key2] = fieldSchema;
           } else {
-            newShape[key] = fieldSchema.optional();
+            newShape[key2] = fieldSchema.optional();
           }
         }
         return new _ZodObject({
@@ -2697,16 +2697,16 @@ var init_types = __esm({
       }
       required(mask) {
         const newShape = {};
-        for (const key of util.objectKeys(this.shape)) {
-          if (mask && !mask[key]) {
-            newShape[key] = this.shape[key];
+        for (const key2 of util.objectKeys(this.shape)) {
+          if (mask && !mask[key2]) {
+            newShape[key2] = this.shape[key2];
           } else {
-            const fieldSchema = this.shape[key];
+            const fieldSchema = this.shape[key2];
             let newField = fieldSchema;
             while (newField instanceof ZodOptional) {
               newField = newField._def.innerType;
             }
-            newShape[key] = newField;
+            newShape[key2] = newField;
           }
         }
         return new _ZodObject({
@@ -3083,11 +3083,11 @@ var init_types = __esm({
         const pairs = [];
         const keyType = this._def.keyType;
         const valueType = this._def.valueType;
-        for (const key in ctx.data) {
+        for (const key2 in ctx.data) {
           pairs.push({
-            key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
-            value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
-            alwaysSet: key in ctx.data
+            key: keyType._parse(new ParseInputLazyPath(ctx, key2, ctx.path, key2)),
+            value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key2], ctx.path, key2)),
+            alwaysSet: key2 in ctx.data
           });
         }
         if (ctx.common.async) {
@@ -3135,9 +3135,9 @@ var init_types = __esm({
         }
         const keyType = this._def.keyType;
         const valueType = this._def.valueType;
-        const pairs = [...ctx.data.entries()].map(([key, value], index) => {
+        const pairs = [...ctx.data.entries()].map(([key2, value], index) => {
           return {
-            key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+            key: keyType._parse(new ParseInputLazyPath(ctx, key2, ctx.path, [index, "key"])),
             value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
           };
         });
@@ -3145,30 +3145,30 @@ var init_types = __esm({
           const finalMap = /* @__PURE__ */ new Map();
           return Promise.resolve().then(async () => {
             for (const pair of pairs) {
-              const key = await pair.key;
+              const key2 = await pair.key;
               const value = await pair.value;
-              if (key.status === "aborted" || value.status === "aborted") {
+              if (key2.status === "aborted" || value.status === "aborted") {
                 return INVALID;
               }
-              if (key.status === "dirty" || value.status === "dirty") {
+              if (key2.status === "dirty" || value.status === "dirty") {
                 status.dirty();
               }
-              finalMap.set(key.value, value.value);
+              finalMap.set(key2.value, value.value);
             }
             return { status: status.value, value: finalMap };
           });
         } else {
           const finalMap = /* @__PURE__ */ new Map();
           for (const pair of pairs) {
-            const key = pair.key;
+            const key2 = pair.key;
             const value = pair.value;
-            if (key.status === "aborted" || value.status === "aborted") {
+            if (key2.status === "aborted" || value.status === "aborted") {
               return INVALID;
             }
-            if (key.status === "dirty" || value.status === "dirty") {
+            if (key2.status === "dirty" || value.status === "dirty") {
               status.dirty();
             }
-            finalMap.set(key.value, value.value);
+            finalMap.set(key2.value, value.value);
           }
           return { status: status.value, value: finalMap };
         }
@@ -4275,15 +4275,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) {
@@ -4910,11 +4910,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);
           }
@@ -5189,17 +5189,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;
     }
@@ -5207,8 +5207,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;
     }
@@ -5786,8 +5786,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));
@@ -6171,8 +6171,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;
       }
@@ -6244,20 +6244,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);
@@ -6314,10 +6314,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))
@@ -6327,14 +6327,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;
@@ -6523,8 +6523,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;
     }
@@ -8562,7 +8562,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);
@@ -8576,15 +8576,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
@@ -8740,14 +8740,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;
@@ -8820,10 +8820,10 @@ var require_core = __commonJS({
     Ajv2.MissingRefError = ref_error_1.default;
     exports.default = Ajv2;
     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) {
@@ -8837,8 +8837,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) {
@@ -9886,11 +9886,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];
     }
@@ -9967,13 +9967,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), () => {
@@ -10022,38 +10022,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();
@@ -10062,22 +10062,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) {
@@ -10202,19 +10202,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());
               }
@@ -11120,8 +11120,8 @@ var init_consumer_commands = __esm({
         const visit = (value, depth = 0) => {
           if (depth > 16) throw new Error("consumer input schema is too deeply nested");
           if (!value || typeof value !== "object") return;
-          for (const [key, child] of Object.entries(value)) {
-            if (["$ref", "$id", "$async", "pattern", "patternProperties", "format"].includes(key)) {
+          for (const [key2, child] of Object.entries(value)) {
+            if (["$ref", "$id", "$async", "pattern", "patternProperties", "format"].includes(key2)) {
               throw new Error("consumer input schema contains an unsupported keyword");
             }
             visit(child, depth + 1);
@@ -11275,7 +11275,7 @@ function rejectRemovedEnvironment(env) {
 }
 function rejectRemovedConfig(value, path) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) return;
-  const removed = ["brokerUrl", "daemon"].filter((key) => Object.hasOwn(value, key));
+  const removed = ["brokerUrl", "daemon"].filter((key2) => Object.hasOwn(value, key2));
   if (removed.length === 0) return;
   throw new CoworkConfigError(
     `cowork config at ${path} contains removed ${removed.join(" and ")} ${removed.length === 1 ? "key" : "keys"}: ours-cowork now attaches only to the shared ours daemon. Remove those keys and configure the daemon with @ours.network/cli.`
@@ -12240,15 +12240,15 @@ var init_contracts = __esm({
       }
       const seenCommandGrants = /* @__PURE__ */ new Set();
       for (const [index, grant] of room.command_grants.entries()) {
-        const key = `${grant.caller_cid}\0${grant.command}`;
-        if (seenCommandGrants.has(key)) {
+        const key2 = `${grant.caller_cid}\0${grant.command}`;
+        if (seenCommandGrants.has(key2)) {
           context.addIssue({
             code: external_exports.ZodIssueCode.custom,
             path: ["command_grants", index],
             message: "runtime command grants must be unique by caller CID and command"
           });
         }
-        seenCommandGrants.add(key);
+        seenCommandGrants.add(key2);
         if (!room.seats.some((seat) => seat.state === "active" && seat.identity === grant.caller_cid)) {
           context.addIssue({
             code: external_exports.ZodIssueCode.custom,
@@ -14010,6 +14010,70 @@ var init_ulid = __esm({
   }
 });
 
+// src/reply-threading.ts
+async function readReplyRows(store, roomId) {
+  const rows = [];
+  let after = 0;
+  for (; ; ) {
+    const page = await store.read(roomId, { after, limit: 64 });
+    if (page.length === 0) return rows;
+    const last = page[page.length - 1];
+    if (last.seq <= after) throw new Error("reply archive cursor did not advance");
+    for (const r of page) {
+      if (r.room_id !== roomId) throw new Error("reply archive room mismatch");
+      if (r.kind === "message") rows.push({ ...r, text: "" });
+      else if (r.kind === "file") rows.push({ ...r, data_base64: "" });
+      else if (r.kind === "relay_intent" || r.kind === "relay_result") rows.push(r);
+    }
+    after = last.seq;
+  }
+}
+function selectReply(rows, roomId, child, recipientCid) {
+  if (child.room_id !== roomId) throw new Error("reply child room mismatch");
+  const incoming = child.source_reply_to?.wire_id;
+  if (!nonempty(incoming)) return { state: "none" };
+  const local = rows.filter((r) => r.room_id === roomId);
+  const items = local.filter((r) => r.kind === "message" || r.kind === "file");
+  const intents = local.filter((r) => r.kind === "relay_intent");
+  const results = local.filter((r) => r.kind === "relay_result");
+  const copies = (parent2, cid) => results.filter((result) => {
+    if (result.status !== "queued" || result.recipient_identity !== cid || key(result) !== key(parent2) || !parent2.recipient_identities.includes(cid)) return false;
+    const matches = intents.filter((intent2) => intent2.record_id === result.intent_record_id);
+    if (matches.length !== 1) return false;
+    const intent = matches[0];
+    return key(intent) === key(parent2) && intent.recipient_identity === cid && parent2.seq < intent.seq && intent.seq < result.seq;
+  }).sort((a, b) => a.seq - b.seq);
+  const wires = (r, parent2) => [r.wire_id, ...parent2.kind === "file" ? [r.metadata_wire_id] : []].filter(nonempty);
+  const ownersFor = (wireId2, cid) => items.filter((item) => item.author.identity === cid && item.source_wire_id === wireId2 || copies(item, cid).some((result) => wires(result, item).includes(wireId2)));
+  const candidates = items.filter((parent2) => parent2.author.identity === child.author.identity && parent2.source_wire_id === incoming || copies(parent2, child.author.identity).some((result) => wires(result, parent2).includes(incoming)));
+  if (candidates.length === 0) return { state: "unknown_parent" };
+  if (candidates.length !== 1) return { state: "ambiguous_parent" };
+  const parent = candidates[0];
+  if (parent.seq >= child.seq) return { state: "unknown_parent" };
+  const parentKey = key(parent);
+  if (items.filter((item) => key(item) === parentKey).length !== 1) {
+    return { state: "ambiguous_parent" };
+  }
+  const recipientCopies = copies(parent, recipientCid);
+  const sourceWire = parent.author.identity === recipientCid && nonempty(parent.source_wire_id) ? parent.source_wire_id : void 0;
+  const sourceOwners = sourceWire === void 0 ? [] : ownersFor(sourceWire, recipientCid);
+  const wireId = sourceOwners.length === 1 && key(sourceOwners[0]) === parentKey ? sourceWire : recipientCopies.map((copy) => wires(copy, parent)[0]).find(nonempty);
+  if (!nonempty(wireId)) return { state: "missing_copy", parentKey };
+  const owners = ownersFor(wireId, recipientCid);
+  if (owners.length !== 1 || key(owners[0]) !== parentKey) {
+    return { state: "ambiguous_parent", parentKey };
+  }
+  return { state: "linked", parentKey, replyTo: { wire_id: wireId } };
+}
+var key, nonempty;
+var init_reply_threading = __esm({
+  "src/reply-threading.ts"() {
+    "use strict";
+    key = (r) => r.message_id === void 0 === (r.file_id === void 0) ? void 0 : r.message_id === void 0 ? `file:${r.file_id}` : `message:${r.message_id}`;
+    nonempty = (value) => typeof value === "string" && value.length > 0;
+  }
+});
+
 // src/intake.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash as createHash3 } from "node:crypto";
@@ -14018,8 +14082,8 @@ function canonicalJson(value) {
   if (encoded === void 0) throw new TypeError("canonical JSON value is not serializable");
   return encoded;
 }
-async function sendRoomBody(packet, recipientIdentity, unsigned) {
-  return packet.send(recipientIdentity, canonicalJson(unsigned));
+async function sendRoomBody(packet, recipientIdentity, unsigned, replyTo) {
+  return packet.send(recipientIdentity, canonicalJson(unsigned), replyTo);
 }
 function sameReply2(stored, observed) {
   if (stored === void 0 || observed == null) return stored === void 0 && observed == null;
@@ -14044,8 +14108,8 @@ function canonicalValue(value) {
   if (value !== null && typeof value === "object") {
     const input = value;
     const output = {};
-    for (const key of Object.keys(input).sort()) {
-      if (input[key] !== void 0) output[key] = canonicalValue(input[key]);
+    for (const key2 of Object.keys(input).sort()) {
+      if (input[key2] !== void 0) output[key2] = canonicalValue(input[key2]);
     }
     return output;
   }
@@ -14073,6 +14137,7 @@ var init_intake = __esm({
     init_zod();
     init_contracts();
     init_ulid();
+    init_reply_threading();
     JOURNAL_WORK_BATCH_SIZE = 64;
     INTAKE_BATCH_SIZE = 32;
     IntakePump = class {
@@ -14445,6 +14510,10 @@ var init_intake = __esm({
               if (skipped.kind !== "relay_result") throw new Error("storage returned the wrong relay result kind");
               continue;
             }
+            const source = message ?? file;
+            const replyRows = source.source_reply_to === void 0 ? [] : await readReplyRows(this.store, roomId);
+            const decision = selectReply(replyRows, roomId, source, intent.recipient_identity);
+            const replyTo = decision.replyTo;
             if (file !== void 0) {
               const uploader = file.author_alias?.alias ?? file.author.display_name;
               const notice = await sendRoomBody(packet, intent.recipient_identity, {
@@ -14460,7 +14529,7 @@ var init_intake = __esm({
                 },
                 text: `${uploader} sent a file`,
                 at: file.at
-              });
+              }, replyTo);
               if (notice.status === "send_failed") {
                 const failed = await this.store.append(roomId, {
                   version: 1,
@@ -14479,7 +14548,8 @@ var init_intake = __esm({
                 intent.recipient_identity,
                 file.filename,
                 file.mime,
-                Buffer.from(file.data_base64, "base64")
+                Buffer.from(file.data_base64, "base64"),
+                replyTo
               );
               const appended2 = await this.store.append(roomId, {
                 version: 1,
@@ -14514,7 +14584,7 @@ var init_intake = __esm({
               ...message.briefing_version === void 0 ? {} : { briefing_version: message.briefing_version },
               ...message.membership === void 0 ? {} : { membership: message.membership }
             };
-            const outcome = await sendRoomBody(packet, intent.recipient_identity, unsigned);
+            const outcome = await sendRoomBody(packet, intent.recipient_identity, unsigned, replyTo);
             const appended = await this.store.append(roomId, {
               version: 1,
               kind: "relay_result",
@@ -15868,6 +15938,7 @@ var init_service = __esm({
             recipient_identities: _recipients,
             source_msg_id: _sourceMsg,
             source_wire_id: _sourceWire,
+            source_reply_to: _sourceReplyTo,
             ...rest
           } = record;
           return {
@@ -16729,7 +16800,7 @@ var init_storage = __esm({
           "SELECT recipient_identity FROM relay_intent_work WHERE record_seq = ? ORDER BY recipient_identity LIMIT ?"
         ).all(recordSeq, limit).map((row) => row.recipient_identity)));
       }
-      async briefingDeliveryTimes(roomId, key, recipientIdentities) {
+      async briefingDeliveryTimes(roomId, key2, recipientIdentities) {
         const id = this.roomId(roomId);
         if (recipientIdentities.length === 0) return /* @__PURE__ */ new Map();
         return this.mutex(id, () => this.withDatabase(id, (db) => {
@@ -16743,9 +16814,9 @@ var init_storage = __esm({
           for (const recipient of recipientIdentities) {
             const row = lookup.get(
               recipient,
-              key.category,
-              key.briefingRole ?? null,
-              key.briefingVersion
+              key2.category,
+              key2.briefingRole ?? null,
+              key2.briefingVersion
             );
             if (row) deliveries.set(recipient, row.at);
           }
@@ -18052,7 +18123,7 @@ function isIntakeNotification(event) {
 function createDaemonControlRoutes(control) {
   if (!/^[0-9a-f]{32}$/.test(control.session)) throw new TypeError("invalid daemon control session");
   const requireExact = (params2, keys) => {
-    if (Object.keys(params2).length !== keys.length || keys.some((key) => !Object.hasOwn(params2, key))) {
+    if (Object.keys(params2).length !== keys.length || keys.some((key2) => !Object.hasOwn(params2, key2))) {
       throw new TypeError("invalid daemon control parameters");
     }
   };

package/docs/07-messaging-history.md

@@ -56,6 +56,14 @@ In an anonymous room, the notice text names only the room-scoped alias; it inclu
 
 Cowork history records include messages, files, and the durable relay intent/result trail used for restart recovery. This application archive is distinct from the shared daemon's per-identity `history.sqlite3` and immutable blob store; neither is a substitute backup for the other.
 
+## Reply threading
+
+A reply is broadcast to the other active room participants, with no sender echo. The parent author receives a reference to their original source message or file; other participants receive a reference to their own recorded room copy. Multiple recorded copies remain aliases of one logical original. For files, both the metadata notice and binary copy can identify that original.
+
+Cowork derives these relationships from its existing archive. If a parent or a recipient's copy cannot be resolved, it delivers the answer without a transport parent and retains the incoming source reference. It does not replay history or scan SDK history to repair links. Queued records do not guarantee that a recipient still has the parent, and a wire lost before result persistence can remain unresolved. Existing retry behavior can create distinct transport copies.
+
+Reply translation changes transport metadata only. Room JSON bodies and version-one archive formats remain unchanged; incoming sentence references are retained but translated outgoing references use only the selected wire ID. Existing history views retain their logical-record/audit separation; reading history does not send messages. Ordinary clients can use their existing native reply handling without implementing Cowork mapping logic.
+
 The web console projects participant and room-authored messages plus the briefing into Communication. Relay, file, recovery, close, and failure records are excluded from chat and shown in Events; Archive retains the complete ordered record stream, including archived file bytes. Messages appear only after the authoritative history refresh observes them.
 
 Version one polls rather than receiving pushed updates: the room list refreshes every five seconds, while the selected room, participants, and history refresh every two seconds. Polling pauses in a hidden tab, coalesces overlap, and refreshes after confirmed mutations. CLI history remains the fallback when a browser is unavailable.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/cowork",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "Durable ours mission rooms on the shared ours daemon.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",