@pensar/apex 2.0.0-canary.241920ad → 2.0.0

package/build/{cli-gtepvg8s.js → cli-k8mvghe1.js}

@@ -1,39 +1,47 @@
 import {
   detectOSAndEnhancePrompt
-} from "./cli-4dpc999m.js";
+} from "./cli-mswm4k81.js";
+import {
+  CredentialManager,
+  NotFoundError,
+  RateLimiter,
+  createDir,
+  descending,
+  generateRandomName,
+  generateSessionName,
+  list,
+  read,
+  schema,
+  update,
+  write,
+  writeRaw
+} from "./cli-3knnkdps.js";
 import {
   parseTargetUrl
 } from "./cli-c8131c4q.js";
 import {
-  CredentialManager,
-  NotFoundError,
-  create,
-  createLogger,
+  ToolsetStateSchema,
+  init_toolset
+} from "./cli-s1nckt4k.js";
+import {
+  init_ai
+} from "./cli-1yavz2pb.js";
+import {
   generateObjectResponse,
   getApexTracer,
   hasToolCall,
-  init_ai,
-  init_credentials,
   init_dist,
-  init_lazyLogger,
   init_observability,
-  init_session,
-  init_storage,
-  init_structured,
-  list,
-  read,
   require_tslib,
-  scopedLogger,
-  streamResponse,
-  write
-} from "./cli-5h1kv0v4.js";
+  streamResponse
+} from "./cli-h825qzmd.js";
 import {
   ensureValidToken,
   getPensarApiUrl,
   init_auth,
   init_constants,
   signGatewayRequest
-} from "./cli-78s9w64j.js";
+} from "./cli-948dk60p.js";
 import {
   _enum,
   _null,
@@ -59,12 +67,17 @@ import {
   string,
   tool,
   union,
-  unknown
+  unknown,
+  zod_default
 } from "./cli-e6rgwtpb.js";
 import {
   config,
   init_config
-} from "./cli-rtbry75t.js";
+} from "./cli-h6nw89zf.js";
+import {
+  getCurrentVersion,
+  init_installation
+} from "./cli-a20jcpmp.js";
 import {
   __commonJS,
   __require,
@@ -1094,52 +1107,52 @@ var require_util = __commonJS((exports) => {
     return hash;
   }
   exports.toHash = toHash;
-  function alwaysValidSchema(it, schema) {
-    if (typeof schema == "boolean")
-      return schema;
-    if (Object.keys(schema).length === 0)
+  function alwaysValidSchema(it, schema2) {
+    if (typeof schema2 == "boolean")
+      return schema2;
+    if (Object.keys(schema2).length === 0)
       return true;
-    checkUnknownRules(it, schema);
-    return !schemaHasRules(schema, it.self.RULES.all);
+    checkUnknownRules(it, schema2);
+    return !schemaHasRules(schema2, it.self.RULES.all);
   }
   exports.alwaysValidSchema = alwaysValidSchema;
-  function checkUnknownRules(it, schema = it.schema) {
+  function checkUnknownRules(it, schema2 = it.schema) {
     const { opts, self: self2 } = it;
     if (!opts.strictSchema)
       return;
-    if (typeof schema === "boolean")
+    if (typeof schema2 === "boolean")
       return;
     const rules2 = self2.RULES.keywords;
-    for (const key in schema) {
+    for (const key in schema2) {
       if (!rules2[key])
         checkStrictMode(it, `unknown keyword: "${key}"`);
     }
   }
   exports.checkUnknownRules = checkUnknownRules;
-  function schemaHasRules(schema, rules2) {
-    if (typeof schema == "boolean")
-      return !schema;
-    for (const key in schema)
+  function schemaHasRules(schema2, rules2) {
+    if (typeof schema2 == "boolean")
+      return !schema2;
+    for (const key in schema2)
       if (rules2[key])
         return true;
     return false;
   }
   exports.schemaHasRules = schemaHasRules;
-  function schemaHasRulesButRef(schema, RULES) {
-    if (typeof schema == "boolean")
-      return !schema;
-    for (const key in schema)
+  function schemaHasRulesButRef(schema2, RULES) {
+    if (typeof schema2 == "boolean")
+      return !schema2;
+    for (const key in schema2)
       if (key !== "$ref" && RULES.all[key])
         return true;
     return false;
   }
   exports.schemaHasRulesButRef = schemaHasRulesButRef;
-  function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
+  function schemaRefOrVal({ topSchemaRef, schemaPath }, schema2, keyword, $data) {
     if (!$data) {
-      if (typeof schema == "number" || typeof schema == "boolean")
-        return schema;
-      if (typeof schema == "string")
-        return (0, codegen_1._)`${schema}`;
+      if (typeof schema2 == "number" || typeof schema2 == "boolean")
+        return schema2;
+      if (typeof schema2 == "string")
+        return (0, codegen_1._)`${schema2}`;
     }
     return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
   }
@@ -1399,10 +1412,10 @@ var require_boolSchema = __commonJS((exports) => {
     message: "boolean schema is false"
   };
   function topBoolOrEmptySchema(it) {
-    const { gen, schema, validateName } = it;
-    if (schema === false) {
+    const { gen, schema: schema2, validateName } = it;
+    if (schema2 === false) {
       falseSchemaError(it, false);
-    } else if (typeof schema == "object" && schema.$async === true) {
+    } else if (typeof schema2 == "object" && schema2.$async === true) {
       gen.return(names_1.default.data);
     } else {
       gen.assign((0, codegen_1._)`${validateName}.errors`, null);
@@ -1411,8 +1424,8 @@ var require_boolSchema = __commonJS((exports) => {
   }
   exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
   function boolOrEmptySchema(it, valid) {
-    const { gen, schema } = it;
-    if (schema === false) {
+    const { gen, schema: schema2 } = it;
+    if (schema2 === false) {
       gen.var(valid, false);
       falseSchemaError(it);
     } else {
@@ -1468,18 +1481,18 @@ var require_rules = __commonJS((exports) => {
 var require_applicability = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.shouldUseRule = exports.shouldUseGroup = exports.schemaHasRulesForType = undefined;
-  function schemaHasRulesForType({ schema, self: self2 }, type) {
+  function schemaHasRulesForType({ schema: schema2, self: self2 }, type) {
     const group = self2.RULES.types[type];
-    return group && group !== true && shouldUseGroup(schema, group);
+    return group && group !== true && shouldUseGroup(schema2, group);
   }
   exports.schemaHasRulesForType = schemaHasRulesForType;
-  function shouldUseGroup(schema, group) {
-    return group.rules.some((rule) => shouldUseRule(schema, rule));
+  function shouldUseGroup(schema2, group) {
+    return group.rules.some((rule) => shouldUseRule(schema2, rule));
   }
   exports.shouldUseGroup = shouldUseGroup;
-  function shouldUseRule(schema, rule) {
+  function shouldUseRule(schema2, rule) {
     var _a;
-    return schema[rule.keyword] !== undefined || ((_a = rule.definition.implements) === null || _a === undefined ? undefined : _a.some((kwd) => schema[kwd] !== undefined));
+    return schema2[rule.keyword] !== undefined || ((_a = rule.definition.implements) === null || _a === undefined ? undefined : _a.some((kwd) => schema2[kwd] !== undefined));
   }
   exports.shouldUseRule = shouldUseRule;
 });
@@ -1498,17 +1511,17 @@ var require_dataType = __commonJS((exports) => {
     DataType2[DataType2["Correct"] = 0] = "Correct";
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
-  function getSchemaTypes(schema) {
-    const types = getJSONTypes(schema.type);
+  function getSchemaTypes(schema2) {
+    const types = getJSONTypes(schema2.type);
     const hasNull = types.includes("null");
     if (hasNull) {
-      if (schema.nullable === false)
+      if (schema2.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types.length && schema.nullable !== undefined) {
+      if (!types.length && schema2.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
-      if (schema.nullable === true)
+      if (schema2.nullable === true)
         types.push("null");
     }
     return types;
@@ -1640,8 +1653,8 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.checkDataTypes = checkDataTypes;
   var typeError = {
-    message: ({ schema }) => `must be ${schema}`,
-    params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
+    message: ({ schema: schema2 }) => `must be ${schema2}`,
+    params: ({ schema: schema2, schemaValue }) => typeof schema2 == "string" ? (0, codegen_1._)`{type: ${schema2}}` : (0, codegen_1._)`{type: ${schemaValue}}`
   };
   function reportTypeError(it) {
     const cxt = getTypeErrorContext(it);
@@ -1649,16 +1662,16 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.reportTypeError = reportTypeError;
   function getTypeErrorContext(it) {
-    const { gen, data, schema } = it;
-    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
+    const { gen, data, schema: schema2 } = it;
+    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema2, "type");
     return {
       gen,
       keyword: "type",
       data,
-      schema: schema.type,
+      schema: schema2.type,
       schemaCode,
       schemaValue: schemaCode,
-      parentSchema: schema,
+      parentSchema: schema2,
       params: {},
       it
     };
@@ -1804,15 +1817,15 @@ var require_code2 = __commonJS((exports) => {
   }
   exports.validateArray = validateArray;
   function validateUnion(cxt) {
-    const { gen, schema, keyword, it } = cxt;
-    if (!Array.isArray(schema))
+    const { gen, schema: schema2, keyword, it } = cxt;
+    if (!Array.isArray(schema2))
       throw new Error("ajv implementation error");
-    const alwaysValid = schema.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
+    const alwaysValid = schema2.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
     if (alwaysValid && !it.opts.unevaluated)
       return;
     const valid = gen.let("valid", false);
     const schValid = gen.name("_valid");
-    gen.block(() => schema.forEach((_sch, i) => {
+    gen.block(() => schema2.forEach((_sch, i) => {
       const schCxt = cxt.subschema({
         keyword,
         schemaProp: i,
@@ -1837,8 +1850,8 @@ var require_keyword = __commonJS((exports) => {
   var code_1 = require_code2();
   var errors_1 = require_errors();
   function macroKeywordCode(cxt, def) {
-    const { gen, keyword, schema, parentSchema, it } = cxt;
-    const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
+    const { gen, keyword, schema: schema2, parentSchema, it } = cxt;
+    const macroSchema = def.macro.call(it.self, schema2, parentSchema, it);
     const schemaRef = useKeyword(gen, keyword, macroSchema);
     if (it.opts.validateSchema !== false)
       it.self.validateSchema(macroSchema, true);
@@ -1855,9 +1868,9 @@ var require_keyword = __commonJS((exports) => {
   exports.macroKeywordCode = macroKeywordCode;
   function funcKeywordCode(cxt, def) {
     var _a;
-    const { gen, keyword, schema, parentSchema, $data, it } = cxt;
+    const { gen, keyword, schema: schema2, parentSchema, $data, it } = cxt;
     checkAsyncKeyword(it, def);
-    const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;
+    const validate = !$data && def.compile ? def.compile.call(it.self, schema2, parentSchema, it) : def.validate;
     const validateRef = useKeyword(gen, keyword, validate);
     const valid = gen.let("valid");
     cxt.block$data(valid, validateKeyword);
@@ -1917,20 +1930,20 @@ var require_keyword = __commonJS((exports) => {
       throw new Error(`keyword "${keyword}" failed to compile`);
     return gen.scopeValue("keyword", typeof result == "function" ? { ref: result } : { ref: result, code: (0, codegen_1.stringify)(result) });
   }
-  function validSchemaType(schema, schemaType, allowUndefined = false) {
-    return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema) : st === "object" ? schema && typeof schema == "object" && !Array.isArray(schema) : typeof schema == st || allowUndefined && typeof schema == "undefined");
+  function validSchemaType(schema2, schemaType, allowUndefined = false) {
+    return !schemaType.length || schemaType.some((st) => st === "array" ? Array.isArray(schema2) : st === "object" ? schema2 && typeof schema2 == "object" && !Array.isArray(schema2) : typeof schema2 == st || allowUndefined && typeof schema2 == "undefined");
   }
   exports.validSchemaType = validSchemaType;
-  function validateKeywordUsage({ schema, opts, self: self2, errSchemaPath }, def, keyword) {
+  function validateKeywordUsage({ schema: schema2, opts, self: self2, errSchemaPath }, def, keyword) {
     if (Array.isArray(def.keyword) ? !def.keyword.includes(keyword) : def.keyword !== keyword) {
       throw new Error("ajv implementation error");
     }
     const deps = def.dependencies;
-    if (deps === null || deps === undefined ? undefined : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {
+    if (deps === null || deps === undefined ? undefined : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema2, kwd))) {
       throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
     }
     if (def.validateSchema) {
-      const valid = def.validateSchema(schema[keyword]);
+      const valid = def.validateSchema(schema2[keyword]);
       if (!valid) {
         const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def.validateSchema.errors);
         if (opts.validateSchema === "log")
@@ -1949,8 +1962,8 @@ var require_subschema = __commonJS((exports) => {
   exports.extendSubschemaMode = exports.extendSubschemaData = exports.getSubschema = undefined;
   var codegen_1 = require_codegen();
   var util_1 = require_util();
-  function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
-    if (keyword !== undefined && schema !== undefined) {
+  function getSubschema(it, { keyword, schemaProp, schema: schema2, schemaPath, errSchemaPath, topSchemaRef }) {
+    if (keyword !== undefined && schema2 !== undefined) {
       throw new Error('both "keyword" and "schema" passed, only one allowed');
     }
     if (keyword !== undefined) {
@@ -1965,12 +1978,12 @@ var require_subschema = __commonJS((exports) => {
         errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
       };
     }
-    if (schema !== undefined) {
+    if (schema2 !== undefined) {
       if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {
         throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
       }
       return {
-        schema,
+        schema: schema2,
         schemaPath,
         topSchemaRef,
         errSchemaPath
@@ -2067,7 +2080,7 @@ var require_fast_deep_equal = __commonJS((exports, module) => {
 
 // node_modules/json-schema-traverse/index.js
 var require_json_schema_traverse = __commonJS((exports, module) => {
-  var traverse = module.exports = function(schema, opts, cb) {
+  var traverse = module.exports = function(schema2, opts, cb) {
     if (typeof opts == "function") {
       cb = opts;
       opts = {};
@@ -2075,7 +2088,7 @@ var require_json_schema_traverse = __commonJS((exports, module) => {
     cb = opts.cb || cb;
     var pre = typeof cb == "function" ? cb : cb.pre || function() {};
     var post = cb.post || function() {};
-    _traverse(opts, pre, post, schema, "", schema);
+    _traverse(opts, pre, post, schema2, "", schema2);
   };
   traverse.keywords = {
     additionalItems: true,
@@ -2121,26 +2134,26 @@ var require_json_schema_traverse = __commonJS((exports, module) => {
     maxProperties: true,
     minProperties: true
   };
-  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];
+  function _traverse(opts, pre, post, schema2, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
+    if (schema2 && typeof schema2 == "object" && !Array.isArray(schema2)) {
+      pre(schema2, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      for (var key in schema2) {
+        var sch = schema2[key];
         if (Array.isArray(sch)) {
           if (key 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 + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema2, i);
           }
         } else if (key 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 + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema2, prop);
           }
         } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
-          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
+          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema2);
         }
       }
-      post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      post(schema2, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
     }
   }
   function escapeJsonPtr(str) {
@@ -2173,14 +2186,14 @@ var require_resolve = __commonJS((exports) => {
     "enum",
     "const"
   ]);
-  function inlineRef(schema, limit = true) {
-    if (typeof schema == "boolean")
+  function inlineRef(schema2, limit = true) {
+    if (typeof schema2 == "boolean")
       return true;
     if (limit === true)
-      return !hasRef(schema);
+      return !hasRef(schema2);
     if (!limit)
       return false;
-    return countKeys(schema) <= limit;
+    return countKeys(schema2) <= limit;
   }
   exports.inlineRef = inlineRef;
   var REF_KEYWORDS = new Set([
@@ -2190,11 +2203,11 @@ var require_resolve = __commonJS((exports) => {
     "$dynamicRef",
     "$dynamicAnchor"
   ]);
-  function hasRef(schema) {
-    for (const key in schema) {
+  function hasRef(schema2) {
+    for (const key in schema2) {
       if (REF_KEYWORDS.has(key))
         return true;
-      const sch = schema[key];
+      const sch = schema2[key];
       if (Array.isArray(sch) && sch.some(hasRef))
         return true;
       if (typeof sch == "object" && hasRef(sch))
@@ -2202,16 +2215,16 @@ var require_resolve = __commonJS((exports) => {
     }
     return false;
   }
-  function countKeys(schema) {
+  function countKeys(schema2) {
     let count = 0;
-    for (const key in schema) {
+    for (const key in schema2) {
       if (key === "$ref")
         return Infinity;
       count++;
       if (SIMPLE_INLINED.has(key))
         continue;
-      if (typeof schema[key] == "object") {
-        (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
+      if (typeof schema2[key] == "object") {
+        (0, util_1.eachItem)(schema2[key], (sch) => count += countKeys(sch));
       }
       if (count === Infinity)
         return Infinity;
@@ -2241,16 +2254,16 @@ var require_resolve = __commonJS((exports) => {
   }
   exports.resolveUrl = resolveUrl;
   var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
-  function getSchemaRefs(schema, baseId) {
-    if (typeof schema == "boolean")
+  function getSchemaRefs(schema2, baseId) {
+    if (typeof schema2 == "boolean")
       return {};
     const { schemaId, uriResolver } = this.opts;
-    const schId = normalizeId(schema[schemaId] || baseId);
+    const schId = normalizeId(schema2[schemaId] || baseId);
     const baseIds = { "": schId };
     const pathPrefix = getFullPath(uriResolver, schId, false);
     const localRefs = {};
     const schemaRefs = new Set;
-    traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
+    traverse(schema2, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
       if (parentJsonPtr === undefined)
         return;
       const fullPath = pathPrefix + jsonPtr;
@@ -2328,15 +2341,15 @@ var require_validate = __commonJS((exports) => {
     validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
   }
   exports.validateFunctionCode = validateFunctionCode;
-  function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
+  function validateFunction({ gen, validateName, schema: schema2, schemaEnv, opts }, body) {
     if (opts.code.es5) {
       gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
-        gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
+        gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema2, opts)}`);
         destructureValCxtES5(gen, opts);
         gen.code(body);
       });
     } else {
-      gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
+      gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema2, opts)).code(body));
     }
   }
   function destructureValCxt(opts) {
@@ -2360,9 +2373,9 @@ var require_validate = __commonJS((exports) => {
     });
   }
   function topSchemaObjCode(it) {
-    const { schema, opts, gen } = it;
+    const { schema: schema2, opts, gen } = it;
     validateFunction(it, () => {
-      if (opts.$comment && schema.$comment)
+      if (opts.$comment && schema2.$comment)
         commentKeyword(it);
       checkNoDefault(it);
       gen.let(names_1.default.vErrors, null);
@@ -2380,8 +2393,8 @@ var require_validate = __commonJS((exports) => {
     gen.if((0, codegen_1._)`${it.evaluated}.dynamicProps`, () => gen.assign((0, codegen_1._)`${it.evaluated}.props`, (0, codegen_1._)`undefined`));
     gen.if((0, codegen_1._)`${it.evaluated}.dynamicItems`, () => gen.assign((0, codegen_1._)`${it.evaluated}.items`, (0, codegen_1._)`undefined`));
   }
-  function funcSourceUrl(schema, opts) {
-    const schId = typeof schema == "object" && schema[opts.schemaId];
+  function funcSourceUrl(schema2, opts) {
+    const schId = typeof schema2 == "object" && schema2[opts.schemaId];
     return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
   }
   function subschemaCode(it, valid) {
@@ -2394,10 +2407,10 @@ var require_validate = __commonJS((exports) => {
     }
     (0, boolSchema_1.boolOrEmptySchema)(it, valid);
   }
-  function schemaCxtHasRules({ schema, self: self2 }) {
-    if (typeof schema == "boolean")
-      return !schema;
-    for (const key in schema)
+  function schemaCxtHasRules({ schema: schema2, self: self2 }) {
+    if (typeof schema2 == "boolean")
+      return !schema2;
+    for (const key in schema2)
       if (self2.RULES.all[key])
         return true;
     return false;
@@ -2406,8 +2419,8 @@ var require_validate = __commonJS((exports) => {
     return typeof it.schema != "boolean";
   }
   function subSchemaObjCode(it, valid) {
-    const { schema, gen, opts } = it;
-    if (opts.$comment && schema.$comment)
+    const { schema: schema2, gen, opts } = it;
+    if (opts.$comment && schema2.$comment)
       commentKeyword(it);
     updateContext(it);
     checkAsyncSchema(it);
@@ -2427,14 +2440,14 @@ var require_validate = __commonJS((exports) => {
     schemaKeywords(it, types, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
-    const { schema, errSchemaPath, opts, self: self2 } = it;
-    if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self2.RULES)) {
+    const { schema: schema2, errSchemaPath, opts, self: self2 } = it;
+    if (schema2.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema2, self2.RULES)) {
       self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
     }
   }
   function checkNoDefault(it) {
-    const { schema, opts } = it;
-    if (schema.default !== undefined && opts.useDefaults && opts.strictSchema) {
+    const { schema: schema2, opts } = it;
+    if (schema2.default !== undefined && opts.useDefaults && opts.strictSchema) {
       (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
     }
   }
@@ -2447,8 +2460,8 @@ var require_validate = __commonJS((exports) => {
     if (it.schema.$async && !it.schemaEnv.$async)
       throw new Error("async schema in sync schema");
   }
-  function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
-    const msg = schema.$comment;
+  function commentKeyword({ gen, schemaEnv, schema: schema2, errSchemaPath, opts }) {
+    const msg = schema2.$comment;
     if (opts.$comment === true) {
       gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
     } else if (typeof opts.$comment == "function") {
@@ -2475,9 +2488,9 @@ var require_validate = __commonJS((exports) => {
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
   function schemaKeywords(it, types, typeErrors, errsCount) {
-    const { gen, schema, data, allErrors, opts, self: self2 } = it;
+    const { gen, schema: schema2, data, allErrors, opts, self: self2 } = it;
     const { RULES } = self2;
-    if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
+    if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema2, RULES))) {
       gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
       return;
     }
@@ -2489,7 +2502,7 @@ var require_validate = __commonJS((exports) => {
       groupKeywords(RULES.post);
     });
     function groupKeywords(group) {
-      if (!(0, applicability_1.shouldUseGroup)(schema, group))
+      if (!(0, applicability_1.shouldUseGroup)(schema2, group))
         return;
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
@@ -2507,12 +2520,12 @@ var require_validate = __commonJS((exports) => {
     }
   }
   function iterateKeywords(it, group) {
-    const { gen, schema, opts: { useDefaults } } = it;
+    const { gen, schema: schema2, opts: { useDefaults } } = it;
     if (useDefaults)
       (0, defaults_1.assignDefaults)(it, group.type);
     gen.block(() => {
       for (const rule of group.rules) {
-        if ((0, applicability_1.shouldUseRule)(schema, rule)) {
+        if ((0, applicability_1.shouldUseRule)(schema2, rule)) {
           keywordCode(it, rule.keyword, rule.definition, group.type);
         }
       }
@@ -2851,17 +2864,17 @@ var require_compile = __commonJS((exports) => {
       var _a;
       this.refs = {};
       this.dynamicAnchors = {};
-      let schema;
+      let schema2;
       if (typeof env.schema == "object")
-        schema = env.schema;
+        schema2 = env.schema;
       this.schema = env.schema;
       this.schemaId = env.schemaId;
       this.root = env.root || this;
-      this.baseId = (_a = env.baseId) !== null && _a !== undefined ? _a : (0, resolve_1.normalizeId)(schema === null || schema === undefined ? undefined : schema[env.schemaId || "$id"]);
+      this.baseId = (_a = env.baseId) !== null && _a !== undefined ? _a : (0, resolve_1.normalizeId)(schema2 === null || schema2 === undefined ? undefined : schema2[env.schemaId || "$id"]);
       this.schemaPath = env.schemaPath;
       this.localRefs = env.localRefs;
       this.meta = env.meta;
-      this.$async = schema === null || schema === undefined ? undefined : schema.$async;
+      this.$async = schema2 === null || schema2 === undefined ? undefined : schema2.$async;
       this.refs = {};
     }
   }
@@ -2959,10 +2972,10 @@ var require_compile = __commonJS((exports) => {
       return schOrFunc;
     let _sch = resolve.call(this, root, ref);
     if (_sch === undefined) {
-      const schema = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
+      const schema2 = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
-      if (schema)
-        _sch = new SchemaEnv({ schema, schemaId, root, baseId });
+      if (schema2)
+        _sch = new SchemaEnv({ schema: schema2, schemaId, root, baseId });
     }
     if (_sch === undefined)
       return;
@@ -3010,12 +3023,12 @@ var require_compile = __commonJS((exports) => {
     if (!schOrRef.validate)
       compileSchema.call(this, schOrRef);
     if (id === (0, resolve_1.normalizeId)(ref)) {
-      const { schema } = schOrRef;
+      const { schema: schema2 } = schOrRef;
       const { schemaId } = this.opts;
-      const schId = schema[schemaId];
+      const schId = schema2[schemaId];
       if (schId)
         baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-      return new SchemaEnv({ schema, schemaId, root, baseId });
+      return new SchemaEnv({ schema: schema2, schemaId, root, baseId });
     }
     return getJsonPointer.call(this, p, schOrRef);
   }
@@ -3027,29 +3040,29 @@ var require_compile = __commonJS((exports) => {
     "dependencies",
     "definitions"
   ]);
-  function getJsonPointer(parsedRef, { baseId, schema, root }) {
+  function getJsonPointer(parsedRef, { baseId, schema: schema2, root }) {
     var _a;
     if (((_a = parsedRef.fragment) === null || _a === undefined ? undefined : _a[0]) !== "/")
       return;
     for (const part of parsedRef.fragment.slice(1).split("/")) {
-      if (typeof schema === "boolean")
+      if (typeof schema2 === "boolean")
         return;
-      const partSchema = schema[(0, util_1.unescapeFragment)(part)];
+      const partSchema = schema2[(0, util_1.unescapeFragment)(part)];
       if (partSchema === undefined)
         return;
-      schema = partSchema;
-      const schId = typeof schema === "object" && schema[this.opts.schemaId];
+      schema2 = partSchema;
+      const schId = typeof schema2 === "object" && schema2[this.opts.schemaId];
       if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
         baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
       }
     }
     let env;
-    if (typeof schema != "boolean" && schema.$ref && !(0, util_1.schemaHasRulesButRef)(schema, this.RULES)) {
-      const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema.$ref);
+    if (typeof schema2 != "boolean" && schema2.$ref && !(0, util_1.schemaHasRulesButRef)(schema2, this.RULES)) {
+      const $ref = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schema2.$ref);
       env = resolveSchema.call(this, root, $ref);
     }
     const { schemaId } = this.opts;
-    env = env || new SchemaEnv({ schema, schemaId, root, baseId });
+    env = env || new SchemaEnv({ schema: schema2, schemaId, root, baseId });
     if (env.schema !== env.root.schema)
       return env;
     return;
@@ -3929,16 +3942,16 @@ var require_core = __commonJS((exports) => {
         this.errors = v.errors;
       return valid;
     }
-    compile(schema, _meta) {
-      const sch = this._addSchema(schema, _meta);
+    compile(schema2, _meta) {
+      const sch = this._addSchema(schema2, _meta);
       return sch.validate || this._compileSchemaEnv(sch);
     }
-    compileAsync(schema, meta) {
+    compileAsync(schema2, meta) {
       if (typeof this.opts.loadSchema != "function") {
         throw new Error("options.loadSchema should be a function");
       }
       const { loadSchema } = this.opts;
-      return runCompileAsync.call(this, schema, meta);
+      return runCompileAsync.call(this, schema2, meta);
       async function runCompileAsync(_schema, _meta) {
         await loadMetaSchema.call(this, _schema.$schema);
         const sch = this._addSchema(_schema, _meta);
@@ -3983,34 +3996,34 @@ var require_core = __commonJS((exports) => {
         }
       }
     }
-    addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
-      if (Array.isArray(schema)) {
-        for (const sch of schema)
+    addSchema(schema2, key, _meta, _validateSchema = this.opts.validateSchema) {
+      if (Array.isArray(schema2)) {
+        for (const sch of schema2)
           this.addSchema(sch, undefined, _meta, _validateSchema);
         return this;
       }
       let id;
-      if (typeof schema === "object") {
+      if (typeof schema2 === "object") {
         const { schemaId } = this.opts;
-        id = schema[schemaId];
+        id = schema2[schemaId];
         if (id !== undefined && typeof id != "string") {
           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);
+      this.schemas[key] = this._addSchema(schema2, _meta, key, _validateSchema, true);
       return this;
     }
-    addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
-      this.addSchema(schema, key, true, _validateSchema);
+    addMetaSchema(schema2, key, _validateSchema = this.opts.validateSchema) {
+      this.addSchema(schema2, key, true, _validateSchema);
       return this;
     }
-    validateSchema(schema, throwOrLogError) {
-      if (typeof schema == "boolean")
+    validateSchema(schema2, throwOrLogError) {
+      if (typeof schema2 == "boolean")
         return true;
       let $schema;
-      $schema = schema.$schema;
+      $schema = schema2.$schema;
       if ($schema !== undefined && typeof $schema != "string") {
         throw new Error("$schema must be a string");
       }
@@ -4020,7 +4033,7 @@ var require_core = __commonJS((exports) => {
         this.errors = null;
         return true;
       }
-      const valid = this.validate($schema, schema);
+      const valid = this.validate($schema, schema2);
       if (!valid && throwOrLogError) {
         const message = "schema is invalid: " + this.errorsText();
         if (this.opts.validateSchema === "log")
@@ -4154,9 +4167,9 @@ var require_core = __commonJS((exports) => {
           if (typeof rule != "object")
             continue;
           const { $data } = rule.definition;
-          const schema = keywords[key];
-          if ($data && schema)
-            keywords[key] = schemaOrData(schema);
+          const schema2 = keywords[key];
+          if ($data && schema2)
+            keywords[key] = schemaOrData(schema2);
         }
       }
       return metaSchema;
@@ -4174,23 +4187,23 @@ var require_core = __commonJS((exports) => {
         }
       }
     }
-    _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
+    _addSchema(schema2, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
       let id;
       const { schemaId } = this.opts;
-      if (typeof schema == "object") {
-        id = schema[schemaId];
+      if (typeof schema2 == "object") {
+        id = schema2[schemaId];
       } else {
         if (this.opts.jtd)
           throw new Error("schema must be object");
-        else if (typeof schema != "boolean")
+        else if (typeof schema2 != "boolean")
           throw new Error("schema must be object or boolean");
       }
-      let sch = this._cache.get(schema);
+      let sch = this._cache.get(schema2);
       if (sch !== undefined)
         return sch;
       baseId = (0, resolve_1.normalizeId)(id || baseId);
-      const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
-      sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });
+      const localRefs = resolve_1.getSchemaRefs.call(this, schema2, baseId);
+      sch = new compile_1.SchemaEnv({ schema: schema2, schemaId, meta, baseId, localRefs });
       this._cache.set(sch.schema, sch);
       if (addSchema && !baseId.startsWith("#")) {
         if (baseId)
@@ -4198,7 +4211,7 @@ var require_core = __commonJS((exports) => {
         this.refs[baseId] = sch;
       }
       if (validateSchema)
-        this.validateSchema(schema, true);
+        this.validateSchema(schema2, true);
       return sch;
     }
     _checkUnique(id) {
@@ -4349,8 +4362,8 @@ var require_core = __commonJS((exports) => {
   var $dataRef = {
     $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
   };
-  function schemaOrData(schema) {
-    return { anyOf: [schema, $dataRef] };
+  function schemaOrData(schema2) {
+    return { anyOf: [schema2, $dataRef] };
   }
 });
 
@@ -4625,9 +4638,9 @@ var require_pattern = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { data, $data, schema, schemaCode, it } = cxt;
+      const { data, $data, schema: schema2, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
-      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
+      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema2);
       cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
     }
   };
@@ -4677,11 +4690,11 @@ var require_required = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { gen, schema, schemaCode, data, $data, it } = cxt;
+      const { gen, schema: schema2, schemaCode, data, $data, it } = cxt;
       const { opts } = it;
-      if (!$data && schema.length === 0)
+      if (!$data && schema2.length === 0)
         return;
-      const useLoop = schema.length >= opts.loopRequired;
+      const useLoop = schema2.length >= opts.loopRequired;
       if (it.allErrors)
         allErrorsMode();
       else
@@ -4689,7 +4702,7 @@ var require_required = __commonJS((exports) => {
       if (opts.strictRequired) {
         const props = cxt.parentSchema.properties;
         const { definedProperties } = cxt.it;
-        for (const requiredKey of schema) {
+        for (const requiredKey of schema2) {
           if ((props === null || props === undefined ? undefined : props[requiredKey]) === undefined && !definedProperties.has(requiredKey)) {
             const schemaPath = it.schemaEnv.baseId + it.errSchemaPath;
             const msg = `required property "${requiredKey}" is not defined at "${schemaPath}" (strictRequired)`;
@@ -4701,7 +4714,7 @@ var require_required = __commonJS((exports) => {
         if (useLoop || $data) {
           cxt.block$data(codegen_1.nil, loopAllRequired);
         } else {
-          for (const prop of schema) {
+          for (const prop of schema2) {
             (0, code_1.checkReportMissingProp)(cxt, prop);
           }
         }
@@ -4713,7 +4726,7 @@ var require_required = __commonJS((exports) => {
           cxt.block$data(valid, () => loopUntilMissing(missing, valid));
           cxt.ok(valid);
         } else {
-          gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
+          gen.if((0, code_1.checkMissingProp)(cxt, schema2, missing));
           (0, code_1.reportMissingProp)(cxt, missing);
           gen.else();
         }
@@ -4791,8 +4804,8 @@ var require_uniqueItems = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
-      if (!$data && !schema)
+      const { gen, data, $data, schema: schema2, parentSchema, schemaCode, it } = cxt;
+      if (!$data && !schema2)
         return;
       const valid = gen.let("valid");
       const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
@@ -4852,11 +4865,11 @@ var require_const = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { gen, data, $data, schemaCode, schema } = cxt;
-      if ($data || schema && typeof schema == "object") {
+      const { gen, data, $data, schemaCode, schema: schema2 } = cxt;
+      if ($data || schema2 && typeof schema2 == "object") {
         cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
       } else {
-        cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
+        cxt.fail((0, codegen_1._)`${schema2} !== ${data}`);
       }
     }
   };
@@ -4879,10 +4892,10 @@ var require_enum = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { gen, data, $data, schema, schemaCode, it } = cxt;
-      if (!$data && schema.length === 0)
+      const { gen, data, $data, schema: schema2, schemaCode, it } = cxt;
+      if (!$data && schema2.length === 0)
         throw new Error("enum must have non-empty array");
-      const useLoop = schema.length >= it.opts.loopEnum;
+      const useLoop = schema2.length >= it.opts.loopEnum;
       let eql;
       const getEql = () => eql !== null && eql !== undefined ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
       let valid;
@@ -4890,10 +4903,10 @@ var require_enum = __commonJS((exports) => {
         valid = gen.let("valid");
         cxt.block$data(valid, loopEnum);
       } else {
-        if (!Array.isArray(schema))
+        if (!Array.isArray(schema2))
           throw new Error("ajv implementation error");
         const vSchema = gen.const("vSchema", schemaCode);
-        valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
+        valid = (0, codegen_1.or)(...schema2.map((_x, i) => equalCode(vSchema, i)));
       }
       cxt.pass(valid);
       function loopEnum() {
@@ -4901,7 +4914,7 @@ var require_enum = __commonJS((exports) => {
         gen.forOf("v", schemaCode, (v) => gen.if((0, codegen_1._)`${getEql()}(${data}, ${v})`, () => gen.assign(valid, true).break()));
       }
       function equalCode(vSchema, i) {
-        const sch = schema[i];
+        const sch = schema2[i];
         return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
       }
     }
@@ -4966,13 +4979,13 @@ var require_additionalItems = __commonJS((exports) => {
     }
   };
   function validateAdditionalItems(cxt, items) {
-    const { gen, schema, data, keyword, it } = cxt;
+    const { gen, schema: schema2, data, keyword, it } = cxt;
     it.items = true;
     const len = gen.const("len", (0, codegen_1._)`${data}.length`);
-    if (schema === false) {
+    if (schema2 === false) {
       cxt.setParams({ len: items.length });
       cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
-    } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+    } else if (typeof schema2 == "object" && !(0, util_1.alwaysValidSchema)(it, schema2)) {
       const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
       gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
       cxt.ok(valid);
@@ -5002,11 +5015,11 @@ var require_items = __commonJS((exports) => {
     schemaType: ["object", "array", "boolean"],
     before: "uniqueItems",
     code(cxt) {
-      const { schema, it } = cxt;
-      if (Array.isArray(schema))
-        return validateTuple(cxt, "additionalItems", schema);
+      const { schema: schema2, it } = cxt;
+      if (Array.isArray(schema2))
+        return validateTuple(cxt, "additionalItems", schema2);
       it.items = true;
-      if ((0, util_1.alwaysValidSchema)(it, schema))
+      if ((0, util_1.alwaysValidSchema)(it, schema2))
         return;
       cxt.ok((0, code_1.validateArray)(cxt));
     }
@@ -5075,10 +5088,10 @@ var require_items2020 = __commonJS((exports) => {
     before: "uniqueItems",
     error,
     code(cxt) {
-      const { schema, parentSchema, it } = cxt;
+      const { schema: schema2, parentSchema, it } = cxt;
       const { prefixItems } = parentSchema;
       it.items = true;
-      if ((0, util_1.alwaysValidSchema)(it, schema))
+      if ((0, util_1.alwaysValidSchema)(it, schema2))
         return;
       if (prefixItems)
         (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
@@ -5106,7 +5119,7 @@ var require_contains = __commonJS((exports) => {
     trackErrors: true,
     error,
     code(cxt) {
-      const { gen, schema, parentSchema, data, it } = cxt;
+      const { gen, schema: schema2, parentSchema, data, it } = cxt;
       let min;
       let max;
       const { minContains, maxContains } = parentSchema;
@@ -5127,7 +5140,7 @@ var require_contains = __commonJS((exports) => {
         cxt.fail();
         return;
       }
-      if ((0, util_1.alwaysValidSchema)(it, schema)) {
+      if ((0, util_1.alwaysValidSchema)(it, schema2)) {
         let cond = (0, codegen_1._)`${len} >= ${min}`;
         if (max !== undefined)
           cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
@@ -5208,14 +5221,14 @@ var require_dependencies = __commonJS((exports) => {
       validateSchemaDeps(cxt, schDeps);
     }
   };
-  function splitDependencies({ schema }) {
+  function splitDependencies({ schema: schema2 }) {
     const propertyDeps = {};
     const schemaDeps = {};
-    for (const key in schema) {
+    for (const key in schema2) {
       if (key === "__proto__")
         continue;
-      const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
-      deps[key] = schema[key];
+      const deps = Array.isArray(schema2[key]) ? propertyDeps : schemaDeps;
+      deps[key] = schema2[key];
     }
     return [propertyDeps, schemaDeps];
   }
@@ -5280,8 +5293,8 @@ var require_propertyNames = __commonJS((exports) => {
     schemaType: ["object", "boolean"],
     error,
     code(cxt) {
-      const { gen, schema, data, it } = cxt;
-      if ((0, util_1.alwaysValidSchema)(it, schema))
+      const { gen, schema: schema2, data, it } = cxt;
+      if ((0, util_1.alwaysValidSchema)(it, schema2))
         return;
       const valid = gen.name("valid");
       gen.forIn("key", data, (key) => {
@@ -5324,12 +5337,12 @@ var require_additionalProperties = __commonJS((exports) => {
     trackErrors: true,
     error,
     code(cxt) {
-      const { gen, schema, parentSchema, data, errsCount, it } = cxt;
+      const { gen, schema: schema2, parentSchema, data, errsCount, it } = cxt;
       if (!errsCount)
         throw new Error("ajv implementation error");
       const { allErrors, opts } = it;
       it.props = true;
-      if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
+      if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema2))
         return;
       const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
       const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
@@ -5362,18 +5375,18 @@ var require_additionalProperties = __commonJS((exports) => {
         gen.code((0, codegen_1._)`delete ${data}[${key}]`);
       }
       function additionalPropertyCode(key) {
-        if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
+        if (opts.removeAdditional === "all" || opts.removeAdditional && schema2 === false) {
           deleteAdditional(key);
           return;
         }
-        if (schema === false) {
+        if (schema2 === false) {
           cxt.setParams({ additionalProperty: key });
           cxt.error();
           if (!allErrors)
             gen.break();
           return;
         }
-        if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+        if (typeof schema2 == "object" && !(0, util_1.alwaysValidSchema)(it, schema2)) {
           const valid = gen.name("valid");
           if (opts.removeAdditional === "failing") {
             applyAdditionalSchema(key, valid, false);
@@ -5420,18 +5433,18 @@ var require_properties = __commonJS((exports) => {
     type: "object",
     schemaType: "object",
     code(cxt) {
-      const { gen, schema, parentSchema, data, it } = cxt;
+      const { gen, schema: schema2, parentSchema, data, it } = cxt;
       if (it.opts.removeAdditional === "all" && parentSchema.additionalProperties === undefined) {
         additionalProperties_1.default.code(new validate_1.KeywordCxt(it, additionalProperties_1.default, "additionalProperties"));
       }
-      const allProps = (0, code_1.allSchemaProperties)(schema);
+      const allProps = (0, code_1.allSchemaProperties)(schema2);
       for (const prop of allProps) {
         it.definedProperties.add(prop);
       }
       if (it.opts.unevaluated && allProps.length && it.props !== true) {
         it.props = util_1.mergeEvaluated.props(gen, (0, util_1.toHash)(allProps), it.props);
       }
-      const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
+      const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema2[p]));
       if (properties.length === 0)
         return;
       const valid = gen.name("valid");
@@ -5449,7 +5462,7 @@ var require_properties = __commonJS((exports) => {
         cxt.ok(valid);
       }
       function hasDefault(prop) {
-        return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== undefined;
+        return it.opts.useDefaults && !it.compositeRule && schema2[prop].default !== undefined;
       }
       function applyPropertySchema(prop) {
         cxt.subschema({
@@ -5475,10 +5488,10 @@ var require_patternProperties = __commonJS((exports) => {
     type: "object",
     schemaType: "object",
     code(cxt) {
-      const { gen, schema, data, parentSchema, it } = cxt;
+      const { gen, schema: schema2, data, parentSchema, it } = cxt;
       const { opts } = it;
-      const patterns = (0, code_1.allSchemaProperties)(schema);
-      const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
+      const patterns = (0, code_1.allSchemaProperties)(schema2);
+      const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema2[p]));
       if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) {
         return;
       }
@@ -5543,8 +5556,8 @@ var require_not = __commonJS((exports) => {
     schemaType: ["object", "boolean"],
     trackErrors: true,
     code(cxt) {
-      const { gen, schema, it } = cxt;
-      if ((0, util_1.alwaysValidSchema)(it, schema)) {
+      const { gen, schema: schema2, it } = cxt;
+      if ((0, util_1.alwaysValidSchema)(it, schema2)) {
         cxt.fail();
         return;
       }
@@ -5591,12 +5604,12 @@ var require_oneOf = __commonJS((exports) => {
     trackErrors: true,
     error,
     code(cxt) {
-      const { gen, schema, parentSchema, it } = cxt;
-      if (!Array.isArray(schema))
+      const { gen, schema: schema2, parentSchema, it } = cxt;
+      if (!Array.isArray(schema2))
         throw new Error("ajv implementation error");
       if (it.opts.discriminator && parentSchema.discriminator)
         return;
-      const schArr = schema;
+      const schArr = schema2;
       const valid = gen.let("valid", false);
       const passing = gen.let("passing", null);
       const schValid = gen.name("_valid");
@@ -5639,11 +5652,11 @@ var require_allOf = __commonJS((exports) => {
     keyword: "allOf",
     schemaType: "array",
     code(cxt) {
-      const { gen, schema, it } = cxt;
-      if (!Array.isArray(schema))
+      const { gen, schema: schema2, it } = cxt;
+      if (!Array.isArray(schema2))
         throw new Error("ajv implementation error");
       const valid = gen.name("valid");
-      schema.forEach((sch, i) => {
+      schema2.forEach((sch, i) => {
         if ((0, util_1.alwaysValidSchema)(it, sch))
           return;
         const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid);
@@ -5715,8 +5728,8 @@ var require_if = __commonJS((exports) => {
     }
   };
   function hasSchema(it, keyword) {
-    const schema = it.schema[keyword];
-    return schema !== undefined && !(0, util_1.alwaysValidSchema)(it, schema);
+    const schema2 = it.schema[keyword];
+    return schema2 !== undefined && !(0, util_1.alwaysValidSchema)(it, schema2);
   }
   exports.default = def;
 });
@@ -5794,7 +5807,7 @@ var require_format = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt, ruleType) {
-      const { gen, data, $data, schema, schemaCode, it } = cxt;
+      const { gen, data, $data, schema: schema2, schemaCode, it } = cxt;
       const { opts, errSchemaPath, schemaEnv, self: self2 } = it;
       if (!opts.validateFormats)
         return;
@@ -5824,7 +5837,7 @@ var require_format = __commonJS((exports) => {
         }
       }
       function validateFormat() {
-        const formatDef = self2.formats[schema];
+        const formatDef = self2.formats[schema2];
         if (!formatDef) {
           unknownFormat();
           return;
@@ -5841,12 +5854,12 @@ var require_format = __commonJS((exports) => {
           }
           throw new Error(unknownMsg());
           function unknownMsg() {
-            return `unknown format "${schema}" ignored in schema at path "${errSchemaPath}"`;
+            return `unknown format "${schema2}" ignored in schema at path "${errSchemaPath}"`;
           }
         }
         function getFormat(fmtDef) {
-          const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema)}` : undefined;
-          const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code });
+          const code = fmtDef instanceof RegExp ? (0, codegen_1.regexpCode)(fmtDef) : opts.code.formats ? (0, codegen_1._)`${opts.code.formats}${(0, codegen_1.getProperty)(schema2)}` : undefined;
+          const fmt = gen.scopeValue("formats", { key: schema2, ref: fmtDef, code });
           if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
             return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
           }
@@ -5942,15 +5955,15 @@ var require_discriminator = __commonJS((exports) => {
     schemaType: "object",
     error,
     code(cxt) {
-      const { gen, data, schema, parentSchema, it } = cxt;
+      const { gen, data, schema: schema2, parentSchema, it } = cxt;
       const { oneOf } = parentSchema;
       if (!it.opts.discriminator) {
         throw new Error("discriminator: requires discriminator option");
       }
-      const tagName = schema.propertyName;
+      const tagName = schema2.propertyName;
       if (typeof tagName != "string")
         throw new Error("discriminator: requires propertyName");
-      if (schema.mapping)
+      if (schema2.mapping)
         throw new Error("discriminator: mapping is not supported");
       if (!oneOf)
         throw new Error("discriminator: requires oneOf keyword");
@@ -48401,8 +48414,8 @@ var require_index_cjs2 = __commonJS((exports, module) => {
     this.re = {};
     compile(this);
   }
-  LinkifyIt.prototype.add = function add(schema, definition) {
-    this.__schemas__[schema] = definition;
+  LinkifyIt.prototype.add = function add(schema2, definition) {
+    this.__schemas__[schema2] = definition;
     compile(this);
     return this;
   };
@@ -48464,11 +48477,11 @@ var require_index_cjs2 = __commonJS((exports, module) => {
   LinkifyIt.prototype.pretest = function pretest(text) {
     return this.re.pretest.test(text);
   };
-  LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
-    if (!this.__compiled__[schema.toLowerCase()]) {
+  LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema2, pos) {
+    if (!this.__compiled__[schema2.toLowerCase()]) {
       return 0;
     }
-    return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
+    return this.__compiled__[schema2.toLowerCase()].validate(text, pos, this);
   };
   LinkifyIt.prototype.match = function match(text) {
     const result = [];
@@ -53970,7 +53983,7 @@ var require_logging_utils = __commonJS((exports) => {
   exports.getDebugBackend = getDebugBackend;
   exports.getStructuredBackend = getStructuredBackend;
   exports.setBackend = setBackend;
-  exports.log = log8;
+  exports.log = log;
   var events_1 = __require("events");
   var process3 = __importStar(__require("process"));
   var util = __importStar(__require("util"));
@@ -53997,7 +54010,7 @@ var require_logging_utils = __commonJS((exports) => {
       this.func.info = (...args) => this.invokeSeverity(LogSeverity.INFO, ...args);
       this.func.warn = (...args) => this.invokeSeverity(LogSeverity.WARNING, ...args);
       this.func.error = (...args) => this.invokeSeverity(LogSeverity.ERROR, ...args);
-      this.func.sublog = (namespace2) => log8(namespace2, this.func);
+      this.func.sublog = (namespace2) => log(namespace2, this.func);
     }
     invoke(fields, ...args) {
       if (this.upstream) {
@@ -54158,7 +54171,7 @@ var require_logging_utils = __commonJS((exports) => {
     cachedBackend = backend;
     loggerCache.clear();
   }
-  function log8(namespace, parent) {
+  function log(namespace, parent) {
     if (!cachedBackend) {
       const enablesFlag = process3.env[exports.env.nodeEnables];
       if (!enablesFlag) {
@@ -54298,7 +54311,7 @@ var require_src5 = __commonJS((exports) => {
   exports.HEADER_NAME = "Metadata-Flavor";
   exports.HEADER_VALUE = "Google";
   exports.HEADERS = Object.freeze({ [exports.HEADER_NAME]: exports.HEADER_VALUE });
-  var log8 = logger.log("gcp-metadata");
+  var log = logger.log("gcp-metadata");
   exports.METADATA_SERVER_DETECTION = Object.freeze({
     "assume-present": "don't try to ping the metadata server, but assume it's present",
     none: "don't try to ping the metadata server, but don't try to use it either",
@@ -54361,9 +54374,9 @@ var require_src5 = __commonJS((exports) => {
       responseType: "text",
       timeout: requestTimeout()
     };
-    log8.info("instance request %j", req);
+    log.info("instance request %j", req);
     const res = await requestMethod(req);
-    log8.info("instance metadata is %s", res.data);
+    log.info("instance metadata is %s", res.data);
     const metadataFlavor = res.headers.get(exports.HEADER_NAME);
     if (metadataFlavor !== exports.HEADER_VALUE) {
       throw new RangeError(`Invalid response from metadata service: incorrect ${exports.HEADER_NAME} header. Expected '${exports.HEADER_VALUE}', got ${metadataFlavor ? `'${metadataFlavor}'` : "no header"}`);
@@ -63006,12 +63019,12 @@ var require_endpoint = __commonJS((exports) => {
     constructor(options) {
       this._options = options || {};
     }
-    applySchema(target, rootSchema, schema, context) {
-      this.applyMethodsFromSchema(target, rootSchema, schema, context);
-      if (schema.resources) {
-        for (const resourceName in schema.resources) {
-          if (Object.prototype.hasOwnProperty.call(schema.resources, resourceName)) {
-            const resource = schema.resources[resourceName];
+    applySchema(target, rootSchema, schema2, context) {
+      this.applyMethodsFromSchema(target, rootSchema, schema2, context);
+      if (schema2.resources) {
+        for (const resourceName in schema2.resources) {
+          if (Object.prototype.hasOwnProperty.call(schema2.resources, resourceName)) {
+            const resource = schema2.resources[resourceName];
             if (!target[resourceName]) {
               target[resourceName] = {};
             }
@@ -63020,21 +63033,21 @@ var require_endpoint = __commonJS((exports) => {
         }
       }
     }
-    applyMethodsFromSchema(target, rootSchema, schema, context) {
-      if (schema.methods) {
-        for (const name in schema.methods) {
-          if (Object.prototype.hasOwnProperty.call(schema.methods, name)) {
-            const method = schema.methods[name];
+    applyMethodsFromSchema(target, rootSchema, schema2, context) {
+      if (schema2.methods) {
+        for (const name in schema2.methods) {
+          if (Object.prototype.hasOwnProperty.call(schema2.methods, name)) {
+            const method = schema2.methods[name];
             target[name] = this.makeMethod(rootSchema, method, context);
           }
         }
       }
     }
-    makeMethod(schema, method, context) {
+    makeMethod(schema2, method, context) {
       return (paramsOrCallback, callback) => {
         const params = typeof paramsOrCallback === "function" ? {} : paramsOrCallback;
         callback = typeof paramsOrCallback === "function" ? paramsOrCallback : callback;
-        const schemaUrl = buildurl(schema.rootUrl + schema.servicePath + method.path);
+        const schemaUrl = buildurl(schema2.rootUrl + schema2.servicePath + method.path);
         const parameters = {
           options: {
             url: schemaUrl.substring(1, schemaUrl.length - 1),
@@ -63047,7 +63060,7 @@ var require_endpoint = __commonJS((exports) => {
           context
         };
         if (method.mediaUpload && method.mediaUpload.protocols && method.mediaUpload.protocols.simple && method.mediaUpload.protocols.simple.path) {
-          const mediaUrl = buildurl(schema.rootUrl + method.mediaUpload.protocols.simple.path);
+          const mediaUrl = buildurl(schema2.rootUrl + method.mediaUpload.protocols.simple.path);
           parameters.mediaUrl = mediaUrl.substring(1, mediaUrl.length - 1);
         }
         if (!callback) {
@@ -63094,10 +63107,10 @@ var require_discovery = __commonJS((exports) => {
     constructor(options) {
       this.options = options || {};
     }
-    makeEndpoint(schema) {
+    makeEndpoint(schema2) {
       return (options) => {
         const ep = new endpoint_1.Endpoint(options);
-        ep.applySchema(ep, schema, schema, ep);
+        ep.applySchema(ep, schema2, schema2, ep);
         return ep;
       };
     }
@@ -72118,11 +72131,11 @@ var require_tools = __commonJS((exports, module) => {
       }
     }
   }
-  function buildFormatters(level, bindings, log8) {
+  function buildFormatters(level, bindings, log) {
     return {
       level,
       bindings,
-      log: log8
+      log
     };
   }
   function normalizeDestFileDescriptor(destination) {
@@ -72467,8 +72480,8 @@ var require_proto = __commonJS((exports, module) => {
     } else
       instance[serializersSym] = serializers;
     if (options.hasOwnProperty("formatters")) {
-      const { level, bindings: chindings, log: log8 } = options.formatters;
-      instance[formattersSym] = buildFormatters(level || formatters.level, chindings || resetChildingsFormatter, log8 || formatters.log);
+      const { level, bindings: chindings, log } = options.formatters;
+      instance[formattersSym] = buildFormatters(level || formatters.level, chindings || resetChildingsFormatter, log || formatters.log);
     } else {
       instance[formattersSym] = buildFormatters(formatters.level, resetChildingsFormatter, formatters.log);
     }
@@ -101672,10 +101685,10 @@ var require_mailer = __commonJS((exports, module) => {
         tnx: "create"
       }, "Creating transport: %s", this.getVersionString());
       if (typeof this.transporter.on === "function") {
-        this.transporter.on("log", (log8) => {
+        this.transporter.on("log", (log) => {
           this.logger.debug({
             tnx: "transport"
-          }, "%s: %s", log8.type, log8.message);
+          }, "%s: %s", log.type, log.message);
         });
         this.transporter.on("error", (err) => {
           this.logger.error({
@@ -105623,7 +105636,6 @@ For long-running processes (servers, listeners, watchers), background them with
 var BASE_SYSTEM_PROMPT = buildBaseSystemPrompt();
 
 // src/core/memory/index.ts
-init_storage();
 var MEMORY_CATEGORIES = ["app", "framework", "general"];
 var MEMORIES_PREFIX = "memories";
 function isMemoryEnabled() {
@@ -106828,27 +106840,27 @@ init_core();
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
-  const schema = s;
-  return !!schema._zod;
+  const schema2 = s;
+  return !!schema2._zod;
 }
-function safeParse2(schema, data) {
-  if (isZ4Schema(schema)) {
-    const result2 = safeParse(schema, data);
+function safeParse2(schema2, data) {
+  if (isZ4Schema(schema2)) {
+    const result2 = safeParse(schema2, data);
     return result2;
   }
-  const v3Schema = schema;
+  const v3Schema = schema2;
   const result = v3Schema.safeParse(data);
   return result;
 }
-function getObjectShape(schema) {
-  if (!schema)
+function getObjectShape(schema2) {
+  if (!schema2)
     return;
   let rawShape;
-  if (isZ4Schema(schema)) {
-    const v4Schema = schema;
+  if (isZ4Schema(schema2)) {
+    const v4Schema = schema2;
     rawShape = v4Schema._zod?.def?.shape;
   } else {
-    const v3Schema = schema;
+    const v3Schema = schema2;
     rawShape = v3Schema.shape;
   }
   if (!rawShape)
@@ -106862,9 +106874,9 @@ function getObjectShape(schema) {
   }
   return rawShape;
 }
-function getLiteralValue(schema) {
-  if (isZ4Schema(schema)) {
-    const v4Schema = schema;
+function getLiteralValue(schema2) {
+  if (isZ4Schema(schema2)) {
+    const v4Schema = schema2;
     const def2 = v4Schema._zod?.def;
     if (def2) {
       if (def2.value !== undefined)
@@ -106874,7 +106886,7 @@ function getLiteralValue(schema) {
       }
     }
   }
-  const v3Schema = schema;
+  const v3Schema = schema2;
   const def = v3Schema._def;
   if (def) {
     if (def.value !== undefined)
@@ -106883,7 +106895,7 @@ function getLiteralValue(schema) {
       return def.values[0];
     }
   }
-  const directValue = schema.value;
+  const directValue = schema2.value;
   if (directValue !== undefined)
     return directValue;
   return;
@@ -107732,8 +107744,8 @@ var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use")
 // node_modules/zod-to-json-schema/dist/esm/parsers/string.js
 var ALPHA_NUMERIC = new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
-function getMethodLiteral(schema) {
-  const shape = getObjectShape(schema);
+function getMethodLiteral(schema2) {
+  const shape = getObjectShape(schema2);
   const methodSchema = shape?.method;
   if (!methodSchema) {
     throw new Error("Schema is missing a method literal");
@@ -107744,8 +107756,8 @@ function getMethodLiteral(schema) {
   }
   return value;
 }
-function parseWithCompat(schema, data) {
-  const result = safeParse2(schema, data);
+function parseWithCompat(schema2, data) {
+  const result = safeParse2(schema2, data);
   if (!result.success) {
     throw result.error;
   }
@@ -108594,8 +108606,8 @@ class AjvJsonSchemaValidator {
   constructor(ajv) {
     this._ajv = ajv ?? createDefaultAjvInstance();
   }
-  getValidator(schema) {
-    const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
+  getValidator(schema2) {
+    const ajvValidator = "$id" in schema2 && typeof schema2.$id === "string" ? this._ajv.getSchema(schema2.$id) ?? this._ajv.compile(schema2) : this._ajv.compile(schema2);
     return (input) => {
       const valid = ajvValidator(input);
       if (valid) {
@@ -108717,12 +108729,12 @@ function assertClientRequestTaskCapability(requests, method, entityName) {
 }
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
-function applyElicitationDefaults(schema, data) {
-  if (!schema || data === null || typeof data !== "object")
+function applyElicitationDefaults(schema2, data) {
+  if (!schema2 || data === null || typeof data !== "object")
     return;
-  if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
+  if (schema2.type === "object" && schema2.properties && typeof schema2.properties === "object") {
     const obj = data;
-    const props = schema.properties;
+    const props = schema2.properties;
     for (const key of Object.keys(props)) {
       const propSchema = props[key];
       if (obj[key] === undefined && Object.prototype.hasOwnProperty.call(propSchema, "default")) {
@@ -108733,15 +108745,15 @@ function applyElicitationDefaults(schema, data) {
       }
     }
   }
-  if (Array.isArray(schema.anyOf)) {
-    for (const sub of schema.anyOf) {
+  if (Array.isArray(schema2.anyOf)) {
+    for (const sub of schema2.anyOf) {
       if (typeof sub !== "boolean") {
         applyElicitationDefaults(sub, data);
       }
     }
   }
-  if (Array.isArray(schema.oneOf)) {
-    for (const sub of schema.oneOf) {
+  if (Array.isArray(schema2.oneOf)) {
+    for (const sub of schema2.oneOf) {
       if (typeof sub !== "boolean") {
         applyElicitationDefaults(sub, data);
       }
@@ -110930,11 +110942,8 @@ function checkpointState(ctx) {
 // src/core/agents/offSecAgent/tools/completeAuthentication.ts
 init_dist();
 init_zod();
-init_structured();
-init_lazyLogger();
 import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
 import { join as join6 } from "path";
-var log = scopedLogger(() => createLogger("complete_authentication"));
 var AUTH_DIR = "auth";
 var AUTH_DATA_FILENAME = "auth-data.json";
 function completeAuthentication(ctx) {
@@ -110974,7 +110983,7 @@ This tool marks the end of the authentication flow.`,
       toolCallDescription: exports_external.string().describe("A concise description of what this tool call is doing")
     }),
     execute: async (result) => {
-      log.info(`Authentication complete: ${result.success ? "SUCCESS" : "FAILED"}`);
+      console.log(`Authentication complete: ${result.success ? "SUCCESS" : "FAILED"}`);
       let authDataPath;
       try {
         const authDir = join6(ctx.session.rootPath, AUTH_DIR);
@@ -110993,9 +111002,9 @@ This tool marks the end of the authentication flow.`,
           ...result.authBarrier && { authBarrier: result.authBarrier }
         };
         writeFileSync4(authDataPath, JSON.stringify(authData, null, 2));
-        log.debug(`Auth data persisted to ${authDataPath}`);
+        console.log(`Auth data persisted to ${authDataPath}`);
       } catch (err) {
-        log.error("Failed to persist auth data", err instanceof Error ? err : undefined, { error: String(err) });
+        console.error(`Failed to persist auth data: ${err}`);
       }
       return {
         success: result.success,
@@ -111015,8 +111024,6 @@ This tool marks the end of the authentication flow.`,
 // src/core/agents/offSecAgent/tools/crawlAuthenticated.ts
 init_dist();
 init_zod();
-init_structured();
-init_lazyLogger();
 
 // src/core/agents/specialized/attackSurface/jsExtraction.ts
 async function extractJavascriptEndpoints(params) {
@@ -111091,7 +111098,6 @@ async function extractJavascriptEndpoints(params) {
 }
 
 // src/core/agents/offSecAgent/tools/crawlAuthenticated.ts
-var log2 = scopedLogger(() => createLogger("crawl-authenticated"));
 function crawlAuthenticated(ctx) {
   return tool({
     description: `Recursively crawl web pages starting from a URL to discover links, forms, and JavaScript endpoints.
@@ -111171,7 +111177,7 @@ function crawlAuthenticated(ctx) {
               });
             }
           } catch (error) {
-            log2.error(`Error crawling ${url}`, error instanceof Error ? error : undefined, { error: String(error) });
+            console.error(`Error crawling ${url}:`, error);
           }
         }
         return {
@@ -111239,12 +111245,9 @@ Call this at the END of your analysis with:
 // src/core/agents/offSecAgent/tools/createFile.ts
 init_dist();
 init_zod();
-init_structured();
-init_lazyLogger();
 import { existsSync as existsSync5 } from "fs";
 import { mkdir, writeFile } from "fs/promises";
 import { dirname as dirname3, isAbsolute, resolve } from "path";
-var log3 = scopedLogger(() => createLogger("create_file"));
 var createFileInputSchema = exports_external.object({
   path: exports_external.string().describe("Absolute or relative path for the new file"),
   content: exports_external.string().describe("Content to write to the file"),
@@ -111265,14 +111268,14 @@ Parent directories are created automatically if they don't exist.`,
       content,
       overwrite = false
     }) => {
-      log3.debug(`enter: path=${filePath}, contentLen=${content.length}, overwrite=${overwrite}, sandbox=${!!ctx.sandbox}`);
+      console.error(`[create_file] enter: path=${filePath}, contentLen=${content.length}, overwrite=${overwrite}, sandbox=${!!ctx.sandbox}`);
       const resolved = isAbsolute(filePath) ? filePath : resolve(ctx.agentCwd, filePath);
-      log3.debug(`resolved: ${resolved}`);
+      console.error(`[create_file] resolved: ${resolved}`);
       if (ctx.sandbox) {
         return executeSandboxCreate(ctx, resolved, content, overwrite);
       }
       const result = await executeLocalCreate(resolved, content, overwrite);
-      log3.debug(`done: success=${result.success}, error=${result.error || "(none)"}`);
+      console.error(`[create_file] done: success=${result.success}, error=${result.error || "(none)"}`);
       return result;
     }
   });
@@ -111280,7 +111283,7 @@ Parent directories are created automatically if they don't exist.`,
 async function executeLocalCreate(filePath, content, overwrite) {
   try {
     if (!overwrite && existsSync5(filePath)) {
-      log3.debug(`local: file already exists: ${filePath}`);
+      console.error(`[create_file:local] file already exists: ${filePath}`);
       return {
         success: false,
         error: `File already exists: ${filePath}. Set overwrite=true to replace it.`,
@@ -111288,20 +111291,18 @@ async function executeLocalCreate(filePath, content, overwrite) {
       };
     }
     const dir = dirname3(filePath);
-    log3.debug(`local: mkdir ${dir}`);
+    console.error(`[create_file:local] mkdir ${dir}`);
     await mkdir(dir, { recursive: true });
-    log3.debug(`local: mkdir done, writing ${content.length} bytes`);
+    console.error(`[create_file:local] mkdir done, writing ${content.length} bytes`);
     await writeFile(filePath, content, "utf-8");
-    log3.debug("local: writeFile done");
+    console.error(`[create_file:local] writeFile done`);
     return {
       success: true,
       error: "",
       path: filePath
     };
   } catch (err) {
-    log3.error("local: write failed", err instanceof Error ? err : undefined, {
-      error: String(err)
-    });
+    console.error(`[create_file:local] error: ${err}`);
     return {
       success: false,
       error: err instanceof Error ? err.message : String(err),
@@ -111403,19 +111404,19 @@ function getTask(tasksDir, id) {
     return null;
   }
 }
-function updateTask(tasksDir, id, update) {
+function updateTask(tasksDir, id, update2) {
   const existing = getTask(tasksDir, id);
   if (!existing)
     return null;
   const updated = {
     ...existing,
-    ...update.status !== undefined && { status: update.status },
-    ...update.result !== undefined && { result: update.result },
-    ...update.observation !== undefined && {
-      observation: update.observation
+    ...update2.status !== undefined && { status: update2.status },
+    ...update2.result !== undefined && { result: update2.result },
+    ...update2.observation !== undefined && {
+      observation: update2.observation
     },
-    ...update.metadata !== undefined && {
-      metadata: { ...existing.metadata, ...update.metadata }
+    ...update2.metadata !== undefined && {
+      metadata: { ...existing.metadata, ...update2.metadata }
     },
     updatedAt: new Date().toISOString()
   };
@@ -111530,12 +111531,8 @@ Examples of good tasks:
 // src/core/agents/offSecAgent/tools/delegateAuth.ts
 init_dist();
 init_zod();
-init_credentials();
 import { writeFileSync as writeFileSync7 } from "fs";
 import { join as join9 } from "path";
-init_structured();
-init_lazyLogger();
-var log4 = scopedLogger(() => createLogger("delegate_auth"));
 function mergeAuthCredentials(sessionCreds, explicit) {
   const hasExplicit = explicit.username || explicit.password || explicit.apiKey || explicit.tokens;
   const hasSession = sessionCreds && (sessionCreds.username || sessionCreds.password || sessionCreds.apiKey || sessionCreds.tokens);
@@ -111657,33 +111654,42 @@ When to use delegate_to_auth_subagent vs authenticate_session:
           input: { target, reason },
           parentSubagentId: ctx.subagentId
         });
-        log4.info("Delegating to authentication subagent", {
-          target,
-          reason,
-          username: username || undefined,
-          apiKey: apiKey ? "[PROVIDED]" : undefined,
-          bearerToken: tokens?.bearerToken ? "[PROVIDED]" : undefined,
-          cookies: tokens?.cookies ? "[PROVIDED]" : undefined,
-          customHeaders: tokens?.customHeaders ? Object.keys(tokens.customHeaders) : undefined
-        });
+        console.log(`
+\uD83D\uDD10 Delegating to authentication subagent...`);
+        console.log(`   Target: ${target}`);
+        console.log(`   Reason: ${reason}`);
+        if (username)
+          console.log(`   Username: ${username}`);
+        if (apiKey)
+          console.log(`   API Key: [PROVIDED]`);
+        if (tokens?.bearerToken)
+          console.log(`   Bearer Token: [PROVIDED]`);
+        if (tokens?.cookies)
+          console.log(`   Cookies: [PROVIDED]`);
+        if (tokens?.customHeaders)
+          console.log(`   Custom Headers: ${Object.keys(tokens.customHeaders).join(", ")}`);
         const rawSessionCreds = ctx.session.config?.authCredentials;
         const sessionCreds = rawSessionCreds ? Array.isArray(rawSessionCreds) ? rawSessionCreds[0] : rawSessionCreds : undefined;
         if (sessionCreds && !username && !apiKey && !tokens) {
-          log4.debug("Inheriting session credentials", {
-            sessionUsername: sessionCreds.username || undefined,
-            sessionApiKey: sessionCreds.apiKey ? "[PROVIDED]" : undefined,
-            sessionBearerToken: sessionCreds.tokens?.bearerToken ? "[PROVIDED]" : undefined,
-            sessionCookies: sessionCreds.tokens?.cookies ? "[PROVIDED]" : undefined,
-            sessionCustomHeaders: sessionCreds.tokens?.customHeaders ? Object.keys(sessionCreds.tokens.customHeaders) : undefined
-          });
+          console.log(`   [Inheriting session credentials]`);
+          if (sessionCreds.username)
+            console.log(`   Session Username: ${sessionCreds.username}`);
+          if (sessionCreds.apiKey)
+            console.log(`   Session API Key: [PROVIDED]`);
+          if (sessionCreds.tokens?.bearerToken)
+            console.log(`   Session Bearer Token: [PROVIDED]`);
+          if (sessionCreds.tokens?.cookies)
+            console.log(`   Session Cookies: [PROVIDED]`);
+          if (sessionCreds.tokens?.customHeaders)
+            console.log(`   Session Custom Headers: ${Object.keys(sessionCreds.tokens.customHeaders).join(", ")}`);
         }
         if (authHints) {
-          log4.debug("Auth hints", {
-            authScheme: authHints.authScheme || "unknown",
-            csrfRequired: authHints.csrfRequired || false,
-            browserRequired: authHints.browserRequired || false,
-            protectedEndpoints: authHints.protectedEndpoints?.length ? authHints.protectedEndpoints : undefined
-          });
+          console.log(`   Auth Scheme: ${authHints.authScheme || "unknown"}`);
+          console.log(`   CSRF Required: ${authHints.csrfRequired || false}`);
+          console.log(`   Browser Required: ${authHints.browserRequired || false}`);
+          if (authHints.protectedEndpoints?.length) {
+            console.log(`   Protected Endpoints: ${authHints.protectedEndpoints.join(", ")}`);
+          }
         }
         const credentials = mergeAuthCredentials(sessionCreds, {
           username,
@@ -111698,7 +111704,7 @@ When to use delegate_to_auth_subagent vs authenticate_session:
         if (credentials) {
           ctx.session.credentialManager.addFromAuthCredentials(credentials);
         }
-        const { runAuthenticationAgent } = await import("./authentication-b8p1afqq.js");
+        const { runAuthenticationAgent } = await import("./authentication-0k43jay4.js");
         const localBus = new AgentEventBus;
         AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
         const result = await runAuthenticationAgent({
@@ -112327,9 +112333,6 @@ function validateConcurrency(concurrency) {
 
 // src/core/agents/offSecAgent/tools/threatModelGenerator.ts
 init_zod();
-init_structured();
-init_lazyLogger();
-var log5 = scopedLogger(() => createLogger("threat-model-generator"));
 var THREAT_MODEL_CONCURRENCY = 10;
 var threatModelLimiter = pLimit(THREAT_MODEL_CONCURRENCY);
 var PentestObjectiveSchema = exports_external.object({
@@ -112378,7 +112381,7 @@ async function generateThreatModelForEndpoint(ctx, input) {
   return threatModelLimiter(async () => {
     if (ctx.abortSignal?.aborted)
       return null;
-    const { CodeAgent } = await import("./agent-mjyx1amj.js");
+    const { CodeAgent } = await import("./agent-84enr6xn.js");
     const subagentId = `threat-model-${sanitize(input.appName)}-${sanitize(input.routePath)}`;
     ctx.eventBus?.emit("subagent-spawn", {
       subagentId,
@@ -112433,7 +112436,7 @@ async function generateThreatModelForEndpoint(ctx, input) {
         status: "failed",
         parentSubagentId: ctx.subagentId
       });
-      log5.warn(`Threat model generation failed for ${input.routePath}: ${error instanceof Error ? error.message : String(error)}`);
+      console.error(`Threat model generation failed for ${input.routePath}: ${error instanceof Error ? error.message : String(error)}`);
       return null;
     }
   });
@@ -112832,10 +112835,6 @@ function hasCanonicalName(cwe) {
   return "name" in cwe && typeof cwe.name === "string";
 }
 
-// src/core/agents/offSecAgent/tools/documentFinding.ts
-init_structured();
-init_lazyLogger();
-
 // src/core/agents/specialized/cvssScorer/index.ts
 init_zod();
 
@@ -114223,12 +114222,9 @@ function extractContextSummary(messages) {
 }
 
 // src/core/agents/specialized/findingJudge/index.ts
-init_structured();
-init_lazyLogger();
-var log6 = scopedLogger(() => createLogger("FindingJudge"));
 async function judgeFinding(input, ctx) {
   try {
-    const { FindingJudgeAgent } = await import("./agent-7866ka7b.js");
+    const { FindingJudgeAgent } = await import("./agent-x1tnsg7n.js");
     const agent = new FindingJudgeAgent({
       finding: input,
       model: ctx.model,
@@ -114249,11 +114245,7 @@ async function judgeFinding(input, ctx) {
     return normalizeJudgeResult(result);
   } catch (err) {
     const fallback = createJudgeFailureResult(err, ctx.model);
-    log6.warn("Agentic validation failed", {
-      model: fallback.error?.model,
-      type: fallback.error?.type,
-      message: fallback.error?.message
-    });
+    console.error(`[FindingJudge] Agentic validation failed: model=${fallback.error?.model} type=${fallback.error?.type} message=${fallback.error?.message}`);
     return fallback;
   }
 }
@@ -114307,7 +114299,6 @@ function createJudgeFailureResult(err, model) {
 }
 
 // src/core/agents/offSecAgent/tools/documentFinding.ts
-var log7 = scopedLogger(() => createLogger("document-finding"));
 var documentVulnerabilityInputSchema = exports_external.object({
   title: exports_external.string().describe("Finding title"),
   description: exports_external.string().describe("Detailed description of the finding"),
@@ -114897,7 +114888,9 @@ function preparePoc(input) {
   let pocContent = input.pocContent.trim();
   const portabilityWarnings = validatePocPortability(pocContent, input.pocType);
   if (portabilityWarnings.length > 0) {
-    log7.warn(`PoC portability warnings for ${filename}: ${portabilityWarnings.join("; ")}`);
+    console.warn(`[PoC Portability] Warnings for ${filename}:
+  ${portabilityWarnings.join(`
+  `)}`);
   }
   if (!pocContent.startsWith("#!")) {
     const shebangs = {
@@ -120073,9 +120066,6 @@ function createResponseTool(responseSchema, onResult) {
 // src/core/agents/offSecAgent/tools/runAttackSurface.ts
 init_dist();
 init_zod();
-init_structured();
-init_lazyLogger();
-var log8 = scopedLogger(() => createLogger("run_attack_surface"));
 function runAttackSurface(ctx) {
   return tool({
     description: `Run the attack surface discovery agent to map the target's full attack surface.
@@ -120112,7 +120102,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
       });
       if (cwd) {
         try {
-          const { WhiteboxAttackSurfaceAgent } = await import("./index-tknvj68q.js");
+          const { WhiteboxAttackSurfaceAgent } = await import("./index-54ep0ery.js");
           const localBus = new AgentEventBus;
           AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
           const agent = new WhiteboxAttackSurfaceAgent({
@@ -120131,7 +120121,8 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
             objective: ep.pentestObjectives.join("; "),
             rationale: `${app.framework} ${ep.method} endpoint in ${app.name} (${ep.file}${ep.line ? `:${ep.line}` : ""})`
           })));
-          log8.info(`Whitebox attack surface complete: ${targets.length} targets from ${result.apps.length} apps`);
+          console.log(`
+✓ Whitebox attack surface complete: ${targets.length} targets from ${result.apps.length} apps`);
           ctx.eventBus?.emit("subagent-complete", {
             subagentId,
             status: "completed",
@@ -120147,7 +120138,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
           };
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : String(error);
-          log8.error(`Whitebox attack surface agent failed: ${errorMsg}`);
+          console.error(`✗ Whitebox attack surface agent failed: ${errorMsg}`);
           ctx.eventBus?.emit("subagent-complete", {
             subagentId,
             status: "failed",
@@ -120162,7 +120153,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         }
       }
       try {
-        const { BlackboxAttackSurfaceAgent } = await import("./blackboxAgent-z1h2cgyg.js");
+        const { BlackboxAttackSurfaceAgent } = await import("./blackboxAgent-76tnwwg7.js");
         const localBus = new AgentEventBus;
         AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
         const agent = new BlackboxAttackSurfaceAgent({
@@ -120177,7 +120168,8 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         });
         const result = await agent.consume();
         const targetCount = result.targets.length;
-        log8.info(`Blackbox attack surface complete: ${targetCount} targets identified`);
+        console.log(`
+✓ Blackbox attack surface complete: ${targetCount} targets identified`);
         ctx.eventBus?.emit("subagent-complete", {
           subagentId,
           status: "completed",
@@ -120200,7 +120192,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         };
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        log8.error(`Blackbox attack surface agent failed: ${errorMsg}`);
+        console.error(`✗ Blackbox attack surface agent failed: ${errorMsg}`);
         ctx.eventBus?.emit("subagent-complete", {
           subagentId,
           status: "failed",
@@ -120240,7 +120232,7 @@ Omit \`cwd\` for blackbox mode (live target probing only).`,
       toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing")
     }),
     execute: async ({ target, cwd }) => {
-      const { runPentestWorkflow: workflow } = await import("./pentest-r6hfzf8n.js");
+      const { runPentestWorkflow: workflow } = await import("./pentest-wy4eeagc.js");
       if (!ctx.model) {
         return {
           success: false,
@@ -121816,7 +121808,7 @@ Returns an array of results with the text output from each agent.`,
   });
 }
 async function runSingleCodingAgent(ctx, codebasePath, objective, agentIndex, name) {
-  const { CodeAgent } = await import("./agent-mjyx1amj.js");
+  const { CodeAgent } = await import("./agent-84enr6xn.js");
   const subagentId = `coding-agent-${agentIndex}`;
   ctx.eventBus?.emit("subagent-spawn", {
     subagentId,
@@ -121863,11 +121855,8 @@ async function runSingleCodingAgent(ctx, codebasePath, objective, agentIndex, na
 // src/core/findings/registry.ts
 init_zod();
 init_ai();
-init_structured();
-init_lazyLogger();
 import { existsSync as existsSync16, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "fs";
 import { join as join23 } from "path";
-var log9 = scopedLogger(() => createLogger("findings:registry"));
 var VULN_CLASS_PATTERNS = [
   [/sql\s*injection/i, "sql-injection"],
   [/command\s*injection/i, "command-injection"],
@@ -122046,22 +122035,22 @@ class FindingsRegistry {
     if (!existsSync16(findingsPath))
       return registry;
     const files = readdirSync3(findingsPath).filter((f) => f.endsWith(".json"));
-    log9.debug(`fromDirectory: path=${findingsPath}, jsonFiles=${files.length}`);
+    console.log(`[FindingsRegistry.fromDirectory] path=${findingsPath}, jsonFiles=${files.length}`);
     for (const file of files) {
       try {
         const raw = readFileSync4(join23(findingsPath, file), "utf-8");
         const finding = JSON.parse(raw);
         if (finding && typeof finding.title === "string" && typeof finding.endpoint === "string") {
           registry.indexFinding(finding);
-          log9.debug(`fromDirectory: indexed "${finding.title}" endpoint="${finding.endpoint}" (file=${file})`);
+          console.log(`[FindingsRegistry.fromDirectory]   indexed: "${finding.title}" endpoint="${finding.endpoint}" (file=${file})`);
         } else {
-          log9.debug(`fromDirectory: skipped (missing title/endpoint) file=${file}`);
+          console.log(`[FindingsRegistry.fromDirectory]   skipped (missing title/endpoint): file=${file}`);
         }
       } catch {
-        log9.debug(`fromDirectory: skipped (malformed) file=${file}`);
+        console.log(`[FindingsRegistry.fromDirectory]   skipped (malformed): file=${file}`);
       }
     }
-    log9.debug(`fromDirectory: registry initialized with ${registry.size} findings indexed`);
+    console.log(`[FindingsRegistry.fromDirectory] Registry initialized: ${registry.size} findings indexed`);
     return registry;
   }
   static fromFindings(findings, opts) {
@@ -122092,19 +122081,19 @@ class FindingsRegistry {
     return { duplicate: false };
   }
   async register(finding) {
-    log9.debug(`register: checking "${finding.title}" endpoint="${finding.endpoint}"`);
+    console.log(`[FindingsRegistry.register] Checking: "${finding.title}" endpoint="${finding.endpoint}"`);
     const fastResult = await new Promise((resolve6) => {
       this.mutex = this.mutex.then(() => {
         const check = this.isDuplicate(finding);
         if (check.duplicate) {
-          log9.debug(`register: DUPLICATE (${check.matchType}) "${finding.title}" matched="${check.matchedFinding?.title}"`);
+          console.log(`[FindingsRegistry.register] DUPLICATE (${check.matchType}): "${finding.title}" matched="${check.matchedFinding?.title}"`);
           resolve6(check);
         } else if (!this.model || this.findings.length === 0) {
           this.indexFinding(finding);
-          log9.debug(`register: UNIQUE (Tier 1+2, no LLM needed) "${finding.title}" — registry size=${this.size}`);
+          console.log(`[FindingsRegistry.register] UNIQUE (Tier 1+2, no LLM needed): "${finding.title}" — registry size=${this.size}`);
           resolve6({ duplicate: false });
         } else {
-          log9.debug(`register: Tier 1+2 pass — proceeding to Tier 3 LLM check for "${finding.title}"`);
+          console.log(`[FindingsRegistry.register] Tier 1+2 pass — proceeding to Tier 3 LLM check for "${finding.title}"`);
           resolve6(null);
         }
       });
@@ -122116,21 +122105,21 @@ class FindingsRegistry {
     try {
       semanticResult = await this.semanticDedup(finding, snapshot);
     } catch {
-      log9.warn(`register: Tier 3 LLM error for "${finding.title}" — falling back to Tier 1+2 only`);
+      console.log(`[FindingsRegistry.register] Tier 3 LLM error for "${finding.title}" — falling back to Tier 1+2 only`);
     }
     if (semanticResult.duplicate) {
-      log9.debug(`register: DUPLICATE (semantic/Tier 3) "${finding.title}" matched="${semanticResult.matchedFinding?.title}"`);
+      console.log(`[FindingsRegistry.register] DUPLICATE (semantic/Tier 3): "${finding.title}" matched="${semanticResult.matchedFinding?.title}"`);
       return semanticResult;
     }
     return new Promise((resolve6) => {
       this.mutex = this.mutex.then(() => {
         const recheck = this.isDuplicate(finding);
         if (recheck.duplicate) {
-          log9.debug(`register: DUPLICATE (race re-check, ${recheck.matchType}) "${finding.title}" matched="${recheck.matchedFinding?.title}"`);
+          console.log(`[FindingsRegistry.register] DUPLICATE (race re-check, ${recheck.matchType}): "${finding.title}" matched="${recheck.matchedFinding?.title}"`);
           resolve6(recheck);
         } else {
           this.indexFinding(finding);
-          log9.debug(`register: UNIQUE (all tiers passed) "${finding.title}" — registry size=${this.size}`);
+          console.log(`[FindingsRegistry.register] UNIQUE (all tiers passed): "${finding.title}" — registry size=${this.size}`);
           resolve6({ duplicate: false });
         }
       });
@@ -122187,7 +122176,7 @@ class FindingsRegistry {
         abortSignal: this.abortSignal
       });
     } catch {
-      log9.warn("groupByRootCause: LLM error — skipping root-cause grouping");
+      console.log(`[FindingsRegistry.groupByRootCause] LLM error — skipping root-cause grouping`);
       return [];
     }
     const sanitised = [];
@@ -122299,7 +122288,7 @@ Returns the worker's summary, objective results, and finding count — but NOT t
           message: "spawn_pentest_agent requires a model in the tool context."
         };
       }
-      const { TargetedPentestAgent } = await import("./agent-aj7jpehp.js");
+      const { TargetedPentestAgent } = await import("./agent-z8043nrm.js");
       const findingsRegistry = ctx.findingsRegistry ?? FindingsRegistry.fromDirectory(ctx.session.findingsPath, {
         model: ctx.model,
         authConfig: ctx.authConfig,
@@ -122429,9 +122418,6 @@ ${existingContext}`;
 // src/core/agents/offSecAgent/tools/spawnPentestSwarm.ts
 init_dist();
 init_zod();
-init_structured();
-init_lazyLogger();
-var log10 = scopedLogger(() => createLogger("spawn-pentest-swarm"));
 function spawnPentestSwarm(ctx) {
   return tool({
     description: `Launch a swarm of targeted pentest sub-agents to test multiple targets in parallel.
@@ -122453,7 +122439,7 @@ Pass every target you want tested — the swarm handles concurrency automaticall
       toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing")
     }),
     execute: async ({ targets }) => {
-      const { runPentestSwarm, DEFAULT_CONCURRENCY: DEFAULT_CONCURRENCY2 } = await import("./pentest-r6hfzf8n.js");
+      const { runPentestSwarm, DEFAULT_CONCURRENCY: DEFAULT_CONCURRENCY2 } = await import("./pentest-wy4eeagc.js");
       if (!ctx.model) {
         return {
           success: false,
@@ -122466,7 +122452,8 @@ Pass every target you want tested — the swarm handles concurrency automaticall
         abortSignal: ctx.abortSignal
       });
       const total = targets.length;
-      log10.info(`Spawning pentest swarm: ${total} agents (concurrency: ${DEFAULT_CONCURRENCY2})`);
+      console.log(`
+\uD83D\uDC1D Spawning pentest swarm: ${total} agents (concurrency: ${DEFAULT_CONCURRENCY2})`);
       const swarmResults = await runPentestSwarm({
         targets,
         model: ctx.model,
@@ -122500,9 +122487,6 @@ Pass every target you want tested — the swarm handles concurrency automaticall
 // src/core/agents/offSecAgent/tools/submitPlan.ts
 init_dist();
 init_zod();
-init_structured();
-init_lazyLogger();
-var log11 = scopedLogger(() => createLogger("submit_plan"));
 var submitPlanInputSchema = exports_external.object({
   toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing (e.g., 'Submitting pentest plan for operator review')")
 });
@@ -122519,7 +122503,7 @@ Only call this when the plan is complete and ready for review.`,
     execute: async () => {
       const scopeId = ctx.planSubagentId ?? ctx.subagentId;
       const planPath = planFilePath(ctx.session.rootPath, scopeId);
-      log11.debug(`enter: path=${planPath}`);
+      console.error(`[submit_plan] enter: path=${planPath}`);
       const plan = readPlan(ctx.session.rootPath, scopeId);
       if (!plan || !plan.trim()) {
         return {
@@ -122528,7 +122512,7 @@ Only call this when the plan is complete and ready for review.`,
           path: planPath
         };
       }
-      log11.debug(`done: planLen=${plan.length}`);
+      console.error(`[submit_plan] done: planLen=${plan.length}`);
       return { success: true, error: "", path: planPath };
     }
   });
@@ -123087,12 +123071,9 @@ async function handleSearchResponse(response) {
 // src/core/agents/offSecAgent/tools/writePlan.ts
 init_dist();
 init_zod();
-init_structured();
 import { mkdirSync as mkdirSync12 } from "fs";
 import { writeFile as writeFile5 } from "fs/promises";
 import { dirname as dirname4 } from "path";
-init_lazyLogger();
-var log12 = scopedLogger(() => createLogger("write_plan"));
 var writePlanInputSchema = exports_external.object({
   content: exports_external.string().describe("The full markdown content of the pentest plan"),
   toolCallDescription: exports_external.string().describe("A concise, human-readable description of what this tool call is doing (e.g., 'Writing initial pentest plan with recon findings')")
@@ -123117,15 +123098,13 @@ Required plan sections:
       const scopeId = ctx.planSubagentId ?? ctx.subagentId;
       const planPath = planFilePath(ctx.session.rootPath, scopeId);
       mkdirSync12(dirname4(planPath), { recursive: true });
-      log12.debug(`enter: contentLen=${content.length}, path=${planPath}`);
+      console.error(`[write_plan] enter: contentLen=${content.length}, path=${planPath}`);
       try {
         await writeFile5(planPath, content, "utf-8");
-        log12.debug("done");
+        console.error(`[write_plan] done`);
         return { success: true, error: "", path: planPath };
       } catch (err) {
-        log12.error("write failed", err instanceof Error ? err : undefined, {
-          error: String(err)
-        });
+        console.error(`[write_plan] error: ${err}`);
         return {
           success: false,
           error: err instanceof Error ? err.message : String(err),
@@ -124345,10 +124324,9 @@ class StepTraceWriter {
 // src/core/agents/offSecAgent/offensiveSecurityAgent.ts
 init_dist();
 init_ai();
-import { existsSync as existsSync18, mkdirSync as mkdirSync14 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync14 } from "fs";
 import { writeFile as writeFile6 } from "fs/promises";
 import { join as join25 } from "path";
-init_structured();
 init_observability();
 
 // src/core/operator/approvalGate.ts
@@ -124624,11 +124602,510 @@ var OperatorSettingsObject = exports_external.object({
   initialMode: exports_external.enum(["plan", "manual", "auto"]).default("manual"),
   requireApproval: exports_external.boolean().default(true)
 });
-// src/core/agents/offSecAgent/offensiveSecurityAgent.ts
-init_session();
-init_lazyLogger();
-var log13 = scopedLogger(() => createLogger("approval-gate"));
+// src/core/session/index.ts
+init_zod();
+import { existsSync as existsSync18, readFileSync as readFileSync6 } from "fs";
+import os from "os";
+import path from "path";
+init_installation();
+init_toolset();
+var DEFAULT_OUTCOME_GUIDANCE = "Prove the exploit can be run but do not exfiltrate data or cause any harm to the system. " + "Create proof-of-concept exploits that demonstrate the vulnerability exists without causing damage.";
+var EXFIL_OUTCOME_GUIDANCE = "Exfiltrate data to extract the flag value. " + "Create proof-of-concept exploits that successfully extract the flag from the target system.";
+var DEFAULT_HEADER_RECORD = {
+  "User-Agent": "pensar-apex"
+};
+var AuthCredentialsObject = zod_default.object({
+  username: zod_default.string().optional(),
+  password: zod_default.string().optional(),
+  loginUrl: zod_default.string().optional(),
+  additionalFields: zod_default.record(zod_default.string(), zod_default.string()).optional(),
+  apiKey: zod_default.string().optional(),
+  role: zod_default.string().optional(),
+  context: zod_default.string().optional(),
+  tokens: zod_default.object({
+    bearerToken: zod_default.string().optional(),
+    cookies: zod_default.string().optional(),
+    sessionToken: zod_default.string().optional(),
+    customHeaders: zod_default.record(zod_default.string(), zod_default.string()).optional()
+  }).optional()
+});
+var ScopeConstraintsObject = zod_default.object({
+  allowedHosts: zod_default.string().array().optional(),
+  allowedPorts: zod_default.number().array().optional(),
+  strictScope: zod_default.boolean().optional()
+});
+var SessionHeadersRecord = zod_default.record(zod_default.string(), zod_default.string());
+var OffensiveHeadersConfigObject = zod_default.object({
+  mode: zod_default.enum(["none", "default", "custom"]).optional(),
+  headers: SessionHeadersRecord.optional()
+});
+var OperatorSettingsObject2 = zod_default.object({
+  initialMode: zod_default.enum(["plan", "manual", "auto"]).default("manual"),
+  requireApproval: zod_default.boolean().default(true),
+  enableSuggestions: zod_default.boolean().default(true)
+});
+var EmailInboxConfigObject = zod_default.discriminatedUnion("provider", [
+  zod_default.object({
+    provider: zod_default.literal("gmail"),
+    id: zod_default.string(),
+    name: zod_default.string(),
+    emailAddress: zod_default.string(),
+    accessToken: zod_default.string(),
+    refreshToken: zod_default.string(),
+    clientId: zod_default.string().optional(),
+    clientSecret: zod_default.string().optional(),
+    tokenExpiry: zod_default.number().optional()
+  }),
+  zod_default.object({
+    provider: zod_default.literal("outlook"),
+    id: zod_default.string(),
+    name: zod_default.string(),
+    emailAddress: zod_default.string(),
+    accessToken: zod_default.string(),
+    refreshToken: zod_default.string(),
+    clientId: zod_default.string().optional(),
+    clientSecret: zod_default.string().optional(),
+    tokenExpiry: zod_default.number().optional()
+  }),
+  zod_default.object({
+    provider: zod_default.literal("imap"),
+    id: zod_default.string(),
+    name: zod_default.string(),
+    emailAddress: zod_default.string(),
+    imapHost: zod_default.string(),
+    imapPort: zod_default.number(),
+    username: zod_default.string(),
+    password: zod_default.string(),
+    tls: zod_default.boolean()
+  })
+]);
+var EmailIntegrationConfigObject = zod_default.object({
+  inboxes: zod_default.array(EmailInboxConfigObject)
+});
+var SmtpConfigObject = zod_default.object({
+  host: zod_default.string(),
+  port: zod_default.number(),
+  username: zod_default.string(),
+  password: zod_default.string(),
+  tls: zod_default.boolean().default(true),
+  fromAddress: zod_default.string().optional()
+});
+function resolveSmtpConfig(explicit) {
+  if (explicit)
+    return explicit;
+  const fromAddress = process.env.OUTBOUND_EMAIL;
+  const resendKey = process.env.RESEND_API_KEY;
+  if (resendKey) {
+    return {
+      host: "smtp.resend.com",
+      port: 465,
+      username: "resend",
+      password: resendKey,
+      tls: true,
+      fromAddress
+    };
+  }
+  const host = process.env.SMTP_HOST;
+  const port = process.env.SMTP_PORT;
+  const username = process.env.SMTP_USERNAME;
+  const password = process.env.SMTP_PASSWORD;
+  if (host && port && username && password) {
+    return {
+      host,
+      port: parseInt(port, 10),
+      username,
+      password,
+      tls: process.env.SMTP_TLS !== "false",
+      fromAddress
+    };
+  }
+  return;
+}
+var SessionConfigObject = zod_default.object({
+  headers: SessionHeadersRecord.optional(),
+  offensiveHeaders: OffensiveHeadersConfigObject.optional(),
+  sessionType: zod_default.enum(["web-app"]).optional(),
+  mode: zod_default.enum(["auto", "driver", "operator"]).optional(),
+  outcomeGuidance: zod_default.string().optional(),
+  scopeConstraints: ScopeConstraintsObject.optional(),
+  authCredentials: zod_default.union([AuthCredentialsObject, zod_default.array(AuthCredentialsObject)]).optional(),
+  authenticationInstructions: zod_default.string().optional(),
+  requestsPerSecond: zod_default.number().optional(),
+  operatorSettings: OperatorSettingsObject2.optional(),
+  toolsetState: ToolsetStateSchema.optional(),
+  enumerateSubdomains: zod_default.boolean().optional(),
+  codebasePath: zod_default.string().optional(),
+  emailIntegration: EmailIntegrationConfigObject.optional(),
+  smtpConfig: SmtpConfigObject.optional(),
+  exfilMode: zod_default.boolean().optional(),
+  agentCwd: zod_default.string().optional(),
+  prompt: zod_default.string().optional(),
+  taskDriven: zod_default.boolean().optional(),
+  requirePlan: zod_default.boolean().optional()
+});
+function getPensarDir() {
+  return path.join(os.homedir(), ".pensar");
+}
+function getSessionsDir() {
+  return path.join(getPensarDir(), "sessions");
+}
+function getSessionRoot(id) {
+  return path.join(getSessionsDir(), id);
+}
+async function createSessionDirs(input) {
+  const { session } = input;
+  await createDir(["sessions", session.id]);
+  await createDir(["sessions", session.id, "findings"]);
+  await createDir(["sessions", session.id, "scratchpad"]);
+  await createDir(["sessions", session.id, "logs"]);
+  await createDir(["sessions", session.id, "pocs"]);
+  const startTime = new Date().toISOString();
+  const readme = generateSessionReadme(session);
+  await writeRaw(["sessions", session.id, "README.md"], readme);
+  console.info("created session", session.id);
+}
+function generateSessionReadme(session) {
+  return `# Penetration Test Session
+
+**Session ID:** ${session.id}
+**Target:** ${session.targets}
+**Objective:** ${session.config?.outcomeGuidance}
+**Started:** ${session.time.created}
+
+## Directory Structure
+
+- \`findings/\` - Security findings and vulnerabilities
+- \`scratchpad/\` - Notes and temporary data during testing
+- \`logs/\` - Execution logs and command outputs
+- \`pocs/\` - Proof-of-concept exploit scripts
+- \`session.json\` - Session metadata
+
+## Findings
+
+Security findings will be documented in the \`findings/\` directory as individual files.
+
+## Status
+
+Testing in progress...
+`;
+}
+function normalizeDeprecatedHeaders(config2) {
+  if (!config2)
+    return config2;
+  if (config2.offensiveHeaders == null) {
+    const { offensiveHeaders: _drop, ...rest2 } = config2;
+    return rest2;
+  }
+  const { offensiveHeaders, ...rest } = config2;
+  const restWithHeaders = rest;
+  if (restWithHeaders.headers !== undefined) {
+    return restWithHeaders;
+  }
+  const oh = offensiveHeaders;
+  if (oh.mode === "none") {
+    return { ...restWithHeaders, headers: {} };
+  }
+  let headers = {};
+  if (oh.mode === "default")
+    headers = { ...DEFAULT_HEADER_RECORD };
+  if (oh.headers)
+    headers = { ...headers, ...oh.headers };
+  return { ...restWithHeaders, headers };
+}
+function migrateLegacySessionData(input) {
+  if (!input || typeof input !== "object")
+    return input;
+  const root = input;
+  const config2 = root.config;
+  if (!config2 || typeof config2 !== "object")
+    return input;
+  const cfg = config2;
+  if (!("offensiveHeaders" in cfg))
+    return input;
+  return { ...root, config: normalizeDeprecatedHeaders(cfg) };
+}
+var SessionInfoObject = zod_default.object({
+  id: schema("session"),
+  name: zod_default.string().optional(),
+  version: zod_default.string(),
+  targets: zod_default.array(zod_default.string()),
+  config: SessionConfigObject.optional(),
+  time: zod_default.object({
+    created: zod_default.number(),
+    updated: zod_default.number()
+  }),
+  rootPath: zod_default.string(),
+  logsPath: zod_default.string(),
+  findingsPath: zod_default.string(),
+  scratchpadPath: zod_default.string(),
+  pocsPath: zod_default.string()
+});
+async function create(input) {
+  const name = input.name ?? generateRandomName();
+  const normalizedConfig = normalizeDeprecatedHeaders(input.config);
+  const id = `${input.prefix ? input.prefix : ""}` + descending("session", input.id);
+  const rootPath = getSessionRoot(id);
+  const findingsPath = path.join(rootPath, "findings");
+  const scratchpadPath = path.join(rootPath, "scratchpad");
+  const logsPath = path.join(rootPath, "logs");
+  const pocsPath = path.join(rootPath, "pocs");
+  const rateLimiter = new RateLimiter({
+    requestsPerSecond: normalizedConfig?.requestsPerSecond
+  });
+  let credentialManager;
+  if (normalizedConfig?.authCredentials) {
+    credentialManager = new CredentialManager;
+    const creds = Array.isArray(normalizedConfig.authCredentials) ? normalizedConfig.authCredentials : [normalizedConfig.authCredentials];
+    for (const cred of creds) {
+      credentialManager.addFromAuthCredentials(cred);
+    }
+  }
+  const smtpConfig = resolveSmtpConfig(normalizedConfig?.smtpConfig);
+  let snapshotHeaders;
+  if (normalizedConfig?.headers !== undefined) {
+    snapshotHeaders = { ...normalizedConfig.headers };
+  } else {
+    const { config: appConfig } = await import("./index-2a1x5nnv.js");
+    const cfg = await appConfig.get();
+    snapshotHeaders = cfg.defaultHeaders ? { ...cfg.defaultHeaders } : { ...DEFAULT_HEADER_RECORD };
+  }
+  const result = {
+    id,
+    version: getCurrentVersion(),
+    targets: input.targets,
+    name,
+    time: {
+      created: Date.now(),
+      updated: Date.now()
+    },
+    config: {
+      ...normalizedConfig,
+      mode: normalizedConfig?.mode || "auto",
+      headers: snapshotHeaders,
+      outcomeGuidance: normalizedConfig?.outcomeGuidance || (normalizedConfig?.exfilMode ? EXFIL_OUTCOME_GUIDANCE : DEFAULT_OUTCOME_GUIDANCE),
+      smtpConfig
+    },
+    _rateLimiter: rateLimiter,
+    credentialManager,
+    rootPath,
+    logsPath,
+    pocsPath,
+    scratchpadPath,
+    findingsPath
+  };
+  const { _rateLimiter, credentialManager: _cm, ...sessionData } = result;
+  await createSessionDirs({ session: result });
+  await write(["sessions", result.id, "session"], sessionData);
+  if (!input.name && input.model) {
+    generateSessionName({
+      targets: input.targets,
+      userMessage: input.userMessage,
+      model: input.model,
+      authConfig: input.authConfig
+    }).then((aiName) => {
+      if (aiName) {
+        result.name = aiName;
+        update2(result.id, (s) => {
+          s.name = aiName;
+        }).catch(() => {});
+        input.onNameGenerated?.(aiName);
+      }
+    });
+  }
+  return result;
+}
+var get = async (id) => {
+  const raw = await read(["sessions", id, "session"]);
+  const read2 = migrateLegacySessionData(raw);
+  if (read2.config?.requestsPerSecond) {
+    read2._rateLimiter = new RateLimiter({
+      requestsPerSecond: read2.config.requestsPerSecond
+    });
+  } else {
+    delete read2._rateLimiter;
+  }
+  return read2;
+};
+async function update2(id, editor) {
+  const result = await update(["sessions", id, "session"], (draft) => {
+    editor(draft);
+    draft.time.updated = Date.now();
+  });
+  return result;
+}
+async function* list2() {
+  const sessionsDir = getSessionsDir();
+  let entries;
+  try {
+    entries = await import("fs/promises").then((fsp) => fsp.readdir(sessionsDir, { withFileTypes: true }));
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory())
+      continue;
+    try {
+      yield await read([
+        "sessions",
+        entry.name,
+        "session"
+      ]);
+    } catch {}
+  }
+}
+var RemoveInput = zod_default.object({
+  sessionId: schema("session")
+});
+var remove2 = async (input) => {
+  try {
+    const sessionDir = getSessionRoot(input.sessionId);
+    const fsp = await import("fs/promises");
+    await fsp.rm(sessionDir, { recursive: true, force: true });
+  } catch (e) {
+    console.error(e);
+  }
+};
+var RemoveMsgInput = zod_default.object({
+  sessionId: schema("session"),
+  messageId: schema("message")
+});
+async function loadOperatorState(sessionId) {
+  try {
+    const session = await get(sessionId);
+    const statePath = path.join(session.rootPath, "messages.json");
+    if (!existsSync18(statePath))
+      return null;
+    const data = readFileSync6(statePath, "utf-8");
+    const parsed = JSON.parse(data);
+    if (Array.isArray(parsed)) {
+      return {
+        mode: session.config?.operatorSettings?.initialMode ?? "manual",
+        requireApproval: session.config?.operatorSettings?.requireApproval ?? true,
+        currentStage: "recon",
+        messages: parsed,
+        attackSurface: [],
+        credentials: [],
+        verifiedVulns: [],
+        targetState: null,
+        hypotheses: [],
+        evidence: [],
+        actionHistory: [],
+        pausedAt: new Date().toISOString(),
+        lastRunId: ""
+      };
+    }
+    return parsed;
+  } catch (error) {
+    console.error("Error loading operator state:", error);
+    return null;
+  }
+}
+function hasOperatorState(session) {
+  const statePath = path.join(session.rootPath, "messages.json");
+  return existsSync18(statePath);
+}
+var MAX_RESUME_MESSAGES = 200;
+function getResumeMessages(messages, limit = MAX_RESUME_MESSAGES) {
+  if (messages.length <= limit)
+    return messages;
+  let cutIndex = messages.length - limit;
+  while (cutIndex < messages.length) {
+    if (messages[cutIndex].role === "user")
+      break;
+    cutIndex++;
+  }
+  if (cutIndex >= messages.length) {
+    cutIndex = messages.length - limit;
+  }
+  return messages.slice(cutIndex);
+}
+function normalizeMessages(messages) {
+  if (messages.length <= 1)
+    return fixToolOutputs(messages);
+  const result = [];
+  for (const msg of messages) {
+    const prev = result[result.length - 1];
+    if (prev && prev.role === "user" && msg.role === "user" && typeof prev.content === "string" && typeof msg.content === "string") {
+      result[result.length - 1] = {
+        ...prev,
+        content: `${prev.content}
+
+${msg.content}`
+      };
+    } else if (prev && prev.role === "user" && msg.role === "user") {
+      result[result.length - 1] = msg;
+    } else {
+      result.push(msg);
+    }
+  }
+  return fixToolOutputs(result);
+}
+function fixToolOutputs(messages) {
+  let changed = false;
+  const fixed = messages.map((msg) => {
+    if (msg.role !== "tool" || !Array.isArray(msg.content))
+      return msg;
+    let partChanged = false;
+    const fixedContent = msg.content.map((part) => {
+      if (part.type === "tool-result" && typeof part.output === "string") {
+        partChanged = true;
+        return { ...part, output: { type: "text", value: part.output } };
+      }
+      return part;
+    });
+    if (partChanged) {
+      changed = true;
+      return { ...msg, content: fixedContent };
+    }
+    return msg;
+  });
+  return changed ? fixed : messages;
+}
+async function updateOperatorSettings(sessionId, settings) {
+  return await update2(sessionId, (session) => {
+    if (!session.config) {
+      session.config = {};
+    }
+    if (!session.config.operatorSettings) {
+      session.config.operatorSettings = {
+        initialMode: "manual",
+        requireApproval: true,
+        enableSuggestions: true
+      };
+    }
+    if (settings.initialMode !== undefined) {
+      session.config.operatorSettings.initialMode = settings.initialMode;
+    }
+    if (settings.requireApproval !== undefined) {
+      session.config.operatorSettings.requireApproval = settings.requireApproval;
+    }
+    if (settings.enableSuggestions !== undefined) {
+      session.config.operatorSettings.enableSuggestions = settings.enableSuggestions;
+    }
+  });
+}
+async function updateSessionHeaders(sessionId, headers) {
+  return await update2(sessionId, (session) => {
+    if (!session.config) {
+      session.config = {};
+    }
+    session.config.headers = { ...headers };
+  });
+}
+var sessions = {
+  getSessionRoot,
+  EXFIL_OUTCOME_GUIDANCE,
+  create,
+  get,
+  remove: remove2,
+  loadOperatorState,
+  hasOperatorState,
+  getResumeMessages,
+  updateOperatorSettings,
+  updateSessionHeaders
+};
 
+// src/core/agents/offSecAgent/offensiveSecurityAgent.ts
 class OffensiveSecurityAgent {
   _streamResult = null;
   createStream;
@@ -124761,7 +125238,7 @@ class OffensiveSecurityAgent {
       const planSet = new Set(PLAN_MODE_TOOL_NAMES);
       activeTools = activeTools.filter((t) => planSet.has(t));
     }
-    if (!existsSync18(messagesDir)) {
+    if (!existsSync19(messagesDir)) {
       mkdirSync14(messagesDir, { recursive: true });
     }
     const messagesPath = join25(messagesDir, "messages.json");
@@ -124932,19 +125409,19 @@ function wrapToolsWithApprovalGate(tools, gate, exemptToolNames) {
       ...t,
       execute: async (args, options) => {
         const toolCallId = args.toolCallId ?? `tc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        log13.debug(`${name} (${toolCallId}): checking`);
+        console.error(`[approval-gate] ${name} (${toolCallId}): checking`);
         try {
           await gate.check(name, String(toolCallId), args);
         } catch (err) {
           if (err instanceof ApprovalDeniedError) {
-            log13.debug(`${name} (${toolCallId}): denied`);
+            console.error(`[approval-gate] ${name} (${toolCallId}): denied`);
             return { blocked: true, reason: "Denied by operator" };
           }
           throw err;
         }
-        log13.debug(`${name} (${toolCallId}): approved, executing`);
+        console.error(`[approval-gate] ${name} (${toolCallId}): approved, executing`);
         const result = await originalExecute(args, options);
-        log13.debug(`${name} (${toolCallId}): execute finished`);
+        console.error(`[approval-gate] ${name} (${toolCallId}): execute finished`);
         return result;
       }
     };
@@ -124952,4 +125429,4 @@ function wrapToolsWithApprovalGate(tools, gate, exemptToolNames) {
   return wrapped;
 }
 
-export { AgentEventBus, INTERNAL_ID_PATTERN, ApprovalGate, OPERATOR_MODES, OPERATOR_MODE_CYCLE, createInitialOperatorState, buildProvidedFilesSection, buildSessionWorkspaceSection, buildBaseSystemPrompt, BASE_SYSTEM_PROMPT, isMemoryEnabled, addMemory2 as addMemory, ASK_USER_QUESTIONS_TOOL_NAME, AskUserQuestionSchema, ScopeViolationError, getAllowedHosts, isHostAllowed, extractHostname2 as extractHostname, assertUrlInScope, extractHostsFromCommand, assertCommandInScope, authenticateSession, transformScriptToFunction, parseStorageStateResult, setHeadlessMode, setUserAgent, setViewportSize, PlaywrightMcpSession, createBrowserTools, checkSandboxPlaywright, installSandboxPlaywright, ensureSandboxPlaywright, ensureSandboxBrowser, createSandboxBrowserTools, BROWSER_TOOL_NAMES, createBrowserToolset, checkpointState, completeAuthentication, crawlAuthenticated, createAttackSurfaceReport, createFile, createTask2 as createTask, delegateAuth, detectAuthScheme, documentApp, documentEndpoint, CweEntrySchema, ValidatedCweEntrySchema, hasCanonicalName, documentVulnerability, createEmailToolset, EMAIL_TOOL_NAMES, SEND_EMAIL_TOOL_NAME, executeCommand, extractJsEndpoints, getMemory2 as getMemory, getPage, grep, httpRequest, listFiles, listMemories2 as listMemories, listTasksTool, readTempfileCapped, getApexTmpRoot, extractFallbackStdout, PersistentShell, probeAuthEndpoints, provideComparisonResults, readFile2 as readFile, readSkill, RESPONSE_TOOL_NAME, createResponseTool, runAttackSurface, runPentestWorkflow, runWithBoundedConcurrency, spawnCodingAgent, FindingsRegistry, planFilePath, readPlan, hasPlan, spawnPentestAgent, spawnPentestSwarm, submitPlan, testEndpointVariations, updateFile, updateTask2 as updateTask, validateDiscovery, webSearch, writePlan, createAllTools, ALL_TOOL_NAMES, PLAN_MODE_TOOL_NAMES, SKILL_TOOL_NAMES, StepTraceWriter, OffensiveSecurityAgent };
+export { AgentEventBus, INTERNAL_ID_PATTERN, ApprovalGate, OPERATOR_MODES, OPERATOR_MODE_CYCLE, createInitialOperatorState, list2 as list, normalizeMessages, sessions, buildProvidedFilesSection, buildSessionWorkspaceSection, buildBaseSystemPrompt, BASE_SYSTEM_PROMPT, isMemoryEnabled, addMemory2 as addMemory, ASK_USER_QUESTIONS_TOOL_NAME, AskUserQuestionSchema, ScopeViolationError, getAllowedHosts, isHostAllowed, extractHostname2 as extractHostname, assertUrlInScope, extractHostsFromCommand, assertCommandInScope, authenticateSession, transformScriptToFunction, parseStorageStateResult, setHeadlessMode, setUserAgent, setViewportSize, PlaywrightMcpSession, createBrowserTools, checkSandboxPlaywright, installSandboxPlaywright, ensureSandboxPlaywright, ensureSandboxBrowser, createSandboxBrowserTools, BROWSER_TOOL_NAMES, createBrowserToolset, checkpointState, completeAuthentication, crawlAuthenticated, createAttackSurfaceReport, createFile, createTask2 as createTask, delegateAuth, detectAuthScheme, documentApp, documentEndpoint, CweEntrySchema, ValidatedCweEntrySchema, hasCanonicalName, documentVulnerability, createEmailToolset, EMAIL_TOOL_NAMES, SEND_EMAIL_TOOL_NAME, executeCommand, extractJsEndpoints, getMemory2 as getMemory, getPage, grep, httpRequest, listFiles, listMemories2 as listMemories, listTasksTool, readTempfileCapped, getApexTmpRoot, extractFallbackStdout, PersistentShell, probeAuthEndpoints, provideComparisonResults, readFile2 as readFile, readSkill, RESPONSE_TOOL_NAME, createResponseTool, runAttackSurface, runPentestWorkflow, runWithBoundedConcurrency, spawnCodingAgent, FindingsRegistry, planFilePath, readPlan, hasPlan, spawnPentestAgent, spawnPentestSwarm, submitPlan, testEndpointVariations, updateFile, updateTask2 as updateTask, validateDiscovery, webSearch, writePlan, createAllTools, ALL_TOOL_NAMES, PLAN_MODE_TOOL_NAMES, SKILL_TOOL_NAMES, StepTraceWriter, OffensiveSecurityAgent };