@pensar/apex 2.0.0 → 2.0.1

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

@@ -1,47 +1,39 @@
 import {
   detectOSAndEnhancePrompt
-} from "./cli-mswm4k81.js";
-import {
-  CredentialManager,
-  NotFoundError,
-  RateLimiter,
-  createDir,
-  descending,
-  generateRandomName,
-  generateSessionName,
-  list,
-  read,
-  schema,
-  update,
-  write,
-  writeRaw
-} from "./cli-3knnkdps.js";
+} from "./cli-cc13ydyx.js";
 import {
   parseTargetUrl
 } from "./cli-c8131c4q.js";
 import {
-  ToolsetStateSchema,
-  init_toolset
-} from "./cli-s1nckt4k.js";
-import {
-  init_ai
-} from "./cli-1yavz2pb.js";
-import {
+  CredentialManager,
+  NotFoundError,
+  create,
+  createLogger,
   generateObjectResponse,
   getApexTracer,
   hasToolCall,
+  init_ai,
+  init_credentials,
   init_dist,
+  init_lazyLogger,
   init_observability,
+  init_session,
+  init_storage,
+  init_structured,
+  list,
+  read,
   require_tslib,
-  streamResponse
-} from "./cli-h825qzmd.js";
+  scopedLogger,
+  streamResponse,
+  write
+} from "./cli-z1dapp7v.js";
 import {
   ensureValidToken,
   getPensarApiUrl,
   init_auth,
   init_constants,
   signGatewayRequest
-} from "./cli-948dk60p.js";
+} from "./cli-8g5cwvbm.js";
 import {
   _enum,
   _null,
@@ -67,17 +59,12 @@ import {
   string,
   tool,
   union,
-  unknown,
-  zod_default
+  unknown
 } from "./cli-e6rgwtpb.js";
 import {
   config,
   init_config
-} from "./cli-h6nw89zf.js";
-import {
-  getCurrentVersion,
-  init_installation
-} from "./cli-a20jcpmp.js";
+} from "./cli-eptabm2j.js";
 import {
   __commonJS,
   __require,
@@ -1107,52 +1094,52 @@ var require_util = __commonJS((exports) => {
     return hash;
   }
   exports.toHash = toHash;
-  function alwaysValidSchema(it, schema2) {
-    if (typeof schema2 == "boolean")
-      return schema2;
-    if (Object.keys(schema2).length === 0)
+  function alwaysValidSchema(it, schema) {
+    if (typeof schema == "boolean")
+      return schema;
+    if (Object.keys(schema).length === 0)
       return true;
-    checkUnknownRules(it, schema2);
-    return !schemaHasRules(schema2, it.self.RULES.all);
+    checkUnknownRules(it, schema);
+    return !schemaHasRules(schema, it.self.RULES.all);
   }
   exports.alwaysValidSchema = alwaysValidSchema;
-  function checkUnknownRules(it, schema2 = it.schema) {
+  function checkUnknownRules(it, schema = it.schema) {
     const { opts, self: self2 } = it;
     if (!opts.strictSchema)
       return;
-    if (typeof schema2 === "boolean")
+    if (typeof schema === "boolean")
       return;
     const rules2 = self2.RULES.keywords;
-    for (const key in schema2) {
+    for (const key in schema) {
       if (!rules2[key])
         checkStrictMode(it, `unknown keyword: "${key}"`);
     }
   }
   exports.checkUnknownRules = checkUnknownRules;
-  function schemaHasRules(schema2, rules2) {
-    if (typeof schema2 == "boolean")
-      return !schema2;
-    for (const key in schema2)
+  function schemaHasRules(schema, rules2) {
+    if (typeof schema == "boolean")
+      return !schema;
+    for (const key in schema)
       if (rules2[key])
         return true;
     return false;
   }
   exports.schemaHasRules = schemaHasRules;
-  function schemaHasRulesButRef(schema2, RULES) {
-    if (typeof schema2 == "boolean")
-      return !schema2;
-    for (const key in schema2)
+  function schemaHasRulesButRef(schema, RULES) {
+    if (typeof schema == "boolean")
+      return !schema;
+    for (const key in schema)
       if (key !== "$ref" && RULES.all[key])
         return true;
     return false;
   }
   exports.schemaHasRulesButRef = schemaHasRulesButRef;
-  function schemaRefOrVal({ topSchemaRef, schemaPath }, schema2, keyword, $data) {
+  function schemaRefOrVal({ topSchemaRef, schemaPath }, schema, keyword, $data) {
     if (!$data) {
-      if (typeof schema2 == "number" || typeof schema2 == "boolean")
-        return schema2;
-      if (typeof schema2 == "string")
-        return (0, codegen_1._)`${schema2}`;
+      if (typeof schema == "number" || typeof schema == "boolean")
+        return schema;
+      if (typeof schema == "string")
+        return (0, codegen_1._)`${schema}`;
     }
     return (0, codegen_1._)`${topSchemaRef}${schemaPath}${(0, codegen_1.getProperty)(keyword)}`;
   }
@@ -1412,10 +1399,10 @@ var require_boolSchema = __commonJS((exports) => {
     message: "boolean schema is false"
   };
   function topBoolOrEmptySchema(it) {
-    const { gen, schema: schema2, validateName } = it;
-    if (schema2 === false) {
+    const { gen, schema, validateName } = it;
+    if (schema === false) {
       falseSchemaError(it, false);
-    } else if (typeof schema2 == "object" && schema2.$async === true) {
+    } else if (typeof schema == "object" && schema.$async === true) {
       gen.return(names_1.default.data);
     } else {
       gen.assign((0, codegen_1._)`${validateName}.errors`, null);
@@ -1424,8 +1411,8 @@ var require_boolSchema = __commonJS((exports) => {
   }
   exports.topBoolOrEmptySchema = topBoolOrEmptySchema;
   function boolOrEmptySchema(it, valid) {
-    const { gen, schema: schema2 } = it;
-    if (schema2 === false) {
+    const { gen, schema } = it;
+    if (schema === false) {
       gen.var(valid, false);
       falseSchemaError(it);
     } else {
@@ -1481,18 +1468,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: schema2, self: self2 }, type) {
+  function schemaHasRulesForType({ schema, self: self2 }, type) {
     const group = self2.RULES.types[type];
-    return group && group !== true && shouldUseGroup(schema2, group);
+    return group && group !== true && shouldUseGroup(schema, group);
   }
   exports.schemaHasRulesForType = schemaHasRulesForType;
-  function shouldUseGroup(schema2, group) {
-    return group.rules.some((rule) => shouldUseRule(schema2, rule));
+  function shouldUseGroup(schema, group) {
+    return group.rules.some((rule) => shouldUseRule(schema, rule));
   }
   exports.shouldUseGroup = shouldUseGroup;
-  function shouldUseRule(schema2, rule) {
+  function shouldUseRule(schema, rule) {
     var _a;
-    return schema2[rule.keyword] !== undefined || ((_a = rule.definition.implements) === null || _a === undefined ? undefined : _a.some((kwd) => schema2[kwd] !== undefined));
+    return schema[rule.keyword] !== undefined || ((_a = rule.definition.implements) === null || _a === undefined ? undefined : _a.some((kwd) => schema[kwd] !== undefined));
   }
   exports.shouldUseRule = shouldUseRule;
 });
@@ -1511,17 +1498,17 @@ var require_dataType = __commonJS((exports) => {
     DataType2[DataType2["Correct"] = 0] = "Correct";
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
-  function getSchemaTypes(schema2) {
-    const types = getJSONTypes(schema2.type);
+  function getSchemaTypes(schema) {
+    const types = getJSONTypes(schema.type);
     const hasNull = types.includes("null");
     if (hasNull) {
-      if (schema2.nullable === false)
+      if (schema.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types.length && schema2.nullable !== undefined) {
+      if (!types.length && schema.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
-      if (schema2.nullable === true)
+      if (schema.nullable === true)
         types.push("null");
     }
     return types;
@@ -1653,8 +1640,8 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.checkDataTypes = checkDataTypes;
   var typeError = {
-    message: ({ schema: schema2 }) => `must be ${schema2}`,
-    params: ({ schema: schema2, schemaValue }) => typeof schema2 == "string" ? (0, codegen_1._)`{type: ${schema2}}` : (0, codegen_1._)`{type: ${schemaValue}}`
+    message: ({ schema }) => `must be ${schema}`,
+    params: ({ schema, schemaValue }) => typeof schema == "string" ? (0, codegen_1._)`{type: ${schema}}` : (0, codegen_1._)`{type: ${schemaValue}}`
   };
   function reportTypeError(it) {
     const cxt = getTypeErrorContext(it);
@@ -1662,16 +1649,16 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.reportTypeError = reportTypeError;
   function getTypeErrorContext(it) {
-    const { gen, data, schema: schema2 } = it;
-    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema2, "type");
+    const { gen, data, schema } = it;
+    const schemaCode = (0, util_1.schemaRefOrVal)(it, schema, "type");
     return {
       gen,
       keyword: "type",
       data,
-      schema: schema2.type,
+      schema: schema.type,
       schemaCode,
       schemaValue: schemaCode,
-      parentSchema: schema2,
+      parentSchema: schema,
       params: {},
       it
     };
@@ -1817,15 +1804,15 @@ var require_code2 = __commonJS((exports) => {
   }
   exports.validateArray = validateArray;
   function validateUnion(cxt) {
-    const { gen, schema: schema2, keyword, it } = cxt;
-    if (!Array.isArray(schema2))
+    const { gen, schema, keyword, it } = cxt;
+    if (!Array.isArray(schema))
       throw new Error("ajv implementation error");
-    const alwaysValid = schema2.some((sch) => (0, util_1.alwaysValidSchema)(it, sch));
+    const alwaysValid = schema.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(() => schema2.forEach((_sch, i) => {
+    gen.block(() => schema.forEach((_sch, i) => {
       const schCxt = cxt.subschema({
         keyword,
         schemaProp: i,
@@ -1850,8 +1837,8 @@ var require_keyword = __commonJS((exports) => {
   var code_1 = require_code2();
   var errors_1 = require_errors();
   function macroKeywordCode(cxt, def) {
-    const { gen, keyword, schema: schema2, parentSchema, it } = cxt;
-    const macroSchema = def.macro.call(it.self, schema2, parentSchema, it);
+    const { gen, keyword, schema, parentSchema, it } = cxt;
+    const macroSchema = def.macro.call(it.self, schema, parentSchema, it);
     const schemaRef = useKeyword(gen, keyword, macroSchema);
     if (it.opts.validateSchema !== false)
       it.self.validateSchema(macroSchema, true);
@@ -1868,9 +1855,9 @@ var require_keyword = __commonJS((exports) => {
   exports.macroKeywordCode = macroKeywordCode;
   function funcKeywordCode(cxt, def) {
     var _a;
-    const { gen, keyword, schema: schema2, parentSchema, $data, it } = cxt;
+    const { gen, keyword, schema, parentSchema, $data, it } = cxt;
     checkAsyncKeyword(it, def);
-    const validate = !$data && def.compile ? def.compile.call(it.self, schema2, parentSchema, it) : def.validate;
+    const validate = !$data && def.compile ? def.compile.call(it.self, schema, parentSchema, it) : def.validate;
     const validateRef = useKeyword(gen, keyword, validate);
     const valid = gen.let("valid");
     cxt.block$data(valid, validateKeyword);
@@ -1930,20 +1917,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(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");
+  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");
   }
   exports.validSchemaType = validSchemaType;
-  function validateKeywordUsage({ schema: schema2, opts, self: self2, errSchemaPath }, def, keyword) {
+  function validateKeywordUsage({ schema, 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(schema2, kwd))) {
+    if (deps === null || deps === undefined ? undefined : deps.some((kwd) => !Object.prototype.hasOwnProperty.call(schema, kwd))) {
       throw new Error(`parent schema must have dependencies of ${keyword}: ${deps.join(",")}`);
     }
     if (def.validateSchema) {
-      const valid = def.validateSchema(schema2[keyword]);
+      const valid = def.validateSchema(schema[keyword]);
       if (!valid) {
         const msg = `keyword "${keyword}" value is invalid at path "${errSchemaPath}": ` + self2.errorsText(def.validateSchema.errors);
         if (opts.validateSchema === "log")
@@ -1962,8 +1949,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: schema2, schemaPath, errSchemaPath, topSchemaRef }) {
-    if (keyword !== undefined && schema2 !== undefined) {
+  function getSubschema(it, { keyword, schemaProp, schema, schemaPath, errSchemaPath, topSchemaRef }) {
+    if (keyword !== undefined && schema !== undefined) {
       throw new Error('both "keyword" and "schema" passed, only one allowed');
     }
     if (keyword !== undefined) {
@@ -1978,12 +1965,12 @@ var require_subschema = __commonJS((exports) => {
         errSchemaPath: `${it.errSchemaPath}/${keyword}/${(0, util_1.escapeFragment)(schemaProp)}`
       };
     }
-    if (schema2 !== undefined) {
+    if (schema !== undefined) {
       if (schemaPath === undefined || errSchemaPath === undefined || topSchemaRef === undefined) {
         throw new Error('"schemaPath", "errSchemaPath" and "topSchemaRef" are required with "schema"');
       }
       return {
-        schema: schema2,
+        schema,
         schemaPath,
         topSchemaRef,
         errSchemaPath
@@ -2080,7 +2067,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(schema2, opts, cb) {
+  var traverse = module.exports = function(schema, opts, cb) {
     if (typeof opts == "function") {
       cb = opts;
       opts = {};
@@ -2088,7 +2075,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, schema2, "", schema2);
+    _traverse(opts, pre, post, schema, "", schema);
   };
   traverse.keywords = {
     additionalItems: true,
@@ -2134,26 +2121,26 @@ var require_json_schema_traverse = __commonJS((exports, module) => {
     maxProperties: true,
     minProperties: true
   };
-  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];
+  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];
         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, schema2, i);
+              _traverse(opts, pre, post, sch[i], jsonPtr + "/" + key + "/" + i, rootSchema, jsonPtr, key, schema, 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, schema2, prop);
+              _traverse(opts, pre, post, sch[prop], jsonPtr + "/" + key + "/" + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
           }
         } else if (key in traverse.keywords || opts.allKeys && !(key in traverse.skipKeywords)) {
-          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema2);
+          _traverse(opts, pre, post, sch, jsonPtr + "/" + key, rootSchema, jsonPtr, key, schema);
         }
       }
-      post(schema2, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
+      post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
     }
   }
   function escapeJsonPtr(str) {
@@ -2186,14 +2173,14 @@ var require_resolve = __commonJS((exports) => {
     "enum",
     "const"
   ]);
-  function inlineRef(schema2, limit = true) {
-    if (typeof schema2 == "boolean")
+  function inlineRef(schema, limit = true) {
+    if (typeof schema == "boolean")
       return true;
     if (limit === true)
-      return !hasRef(schema2);
+      return !hasRef(schema);
     if (!limit)
       return false;
-    return countKeys(schema2) <= limit;
+    return countKeys(schema) <= limit;
   }
   exports.inlineRef = inlineRef;
   var REF_KEYWORDS = new Set([
@@ -2203,11 +2190,11 @@ var require_resolve = __commonJS((exports) => {
     "$dynamicRef",
     "$dynamicAnchor"
   ]);
-  function hasRef(schema2) {
-    for (const key in schema2) {
+  function hasRef(schema) {
+    for (const key in schema) {
       if (REF_KEYWORDS.has(key))
         return true;
-      const sch = schema2[key];
+      const sch = schema[key];
       if (Array.isArray(sch) && sch.some(hasRef))
         return true;
       if (typeof sch == "object" && hasRef(sch))
@@ -2215,16 +2202,16 @@ var require_resolve = __commonJS((exports) => {
     }
     return false;
   }
-  function countKeys(schema2) {
+  function countKeys(schema) {
     let count = 0;
-    for (const key in schema2) {
+    for (const key in schema) {
       if (key === "$ref")
         return Infinity;
       count++;
       if (SIMPLE_INLINED.has(key))
         continue;
-      if (typeof schema2[key] == "object") {
-        (0, util_1.eachItem)(schema2[key], (sch) => count += countKeys(sch));
+      if (typeof schema[key] == "object") {
+        (0, util_1.eachItem)(schema[key], (sch) => count += countKeys(sch));
       }
       if (count === Infinity)
         return Infinity;
@@ -2254,16 +2241,16 @@ var require_resolve = __commonJS((exports) => {
   }
   exports.resolveUrl = resolveUrl;
   var ANCHOR = /^[a-z_][-a-z0-9._]*$/i;
-  function getSchemaRefs(schema2, baseId) {
-    if (typeof schema2 == "boolean")
+  function getSchemaRefs(schema, baseId) {
+    if (typeof schema == "boolean")
       return {};
     const { schemaId, uriResolver } = this.opts;
-    const schId = normalizeId(schema2[schemaId] || baseId);
+    const schId = normalizeId(schema[schemaId] || baseId);
     const baseIds = { "": schId };
     const pathPrefix = getFullPath(uriResolver, schId, false);
     const localRefs = {};
     const schemaRefs = new Set;
-    traverse(schema2, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
+    traverse(schema, { allKeys: true }, (sch, jsonPtr, _, parentJsonPtr) => {
       if (parentJsonPtr === undefined)
         return;
       const fullPath = pathPrefix + jsonPtr;
@@ -2341,15 +2328,15 @@ var require_validate = __commonJS((exports) => {
     validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
   }
   exports.validateFunctionCode = validateFunctionCode;
-  function validateFunction({ gen, validateName, schema: schema2, schemaEnv, opts }, body) {
+  function validateFunction({ gen, validateName, schema, 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(schema2, opts)}`);
+        gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, 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(schema2, opts)).code(body));
+      gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
     }
   }
   function destructureValCxt(opts) {
@@ -2373,9 +2360,9 @@ var require_validate = __commonJS((exports) => {
     });
   }
   function topSchemaObjCode(it) {
-    const { schema: schema2, opts, gen } = it;
+    const { schema, opts, gen } = it;
     validateFunction(it, () => {
-      if (opts.$comment && schema2.$comment)
+      if (opts.$comment && schema.$comment)
         commentKeyword(it);
       checkNoDefault(it);
       gen.let(names_1.default.vErrors, null);
@@ -2393,8 +2380,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(schema2, opts) {
-    const schId = typeof schema2 == "object" && schema2[opts.schemaId];
+  function funcSourceUrl(schema, opts) {
+    const schId = typeof schema == "object" && schema[opts.schemaId];
     return schId && (opts.code.source || opts.code.process) ? (0, codegen_1._)`/*# sourceURL=${schId} */` : codegen_1.nil;
   }
   function subschemaCode(it, valid) {
@@ -2407,10 +2394,10 @@ var require_validate = __commonJS((exports) => {
     }
     (0, boolSchema_1.boolOrEmptySchema)(it, valid);
   }
-  function schemaCxtHasRules({ schema: schema2, self: self2 }) {
-    if (typeof schema2 == "boolean")
-      return !schema2;
-    for (const key in schema2)
+  function schemaCxtHasRules({ schema, self: self2 }) {
+    if (typeof schema == "boolean")
+      return !schema;
+    for (const key in schema)
       if (self2.RULES.all[key])
         return true;
     return false;
@@ -2419,8 +2406,8 @@ var require_validate = __commonJS((exports) => {
     return typeof it.schema != "boolean";
   }
   function subSchemaObjCode(it, valid) {
-    const { schema: schema2, gen, opts } = it;
-    if (opts.$comment && schema2.$comment)
+    const { schema, gen, opts } = it;
+    if (opts.$comment && schema.$comment)
       commentKeyword(it);
     updateContext(it);
     checkAsyncSchema(it);
@@ -2440,14 +2427,14 @@ var require_validate = __commonJS((exports) => {
     schemaKeywords(it, types, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
-    const { schema: schema2, errSchemaPath, opts, self: self2 } = it;
-    if (schema2.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema2, self2.RULES)) {
+    const { schema, errSchemaPath, opts, self: self2 } = it;
+    if (schema.$ref && opts.ignoreKeywordsWithRef && (0, util_1.schemaHasRulesButRef)(schema, self2.RULES)) {
       self2.logger.warn(`$ref: keywords ignored in schema at path "${errSchemaPath}"`);
     }
   }
   function checkNoDefault(it) {
-    const { schema: schema2, opts } = it;
-    if (schema2.default !== undefined && opts.useDefaults && opts.strictSchema) {
+    const { schema, opts } = it;
+    if (schema.default !== undefined && opts.useDefaults && opts.strictSchema) {
       (0, util_1.checkStrictMode)(it, "default is ignored in the schema root");
     }
   }
@@ -2460,8 +2447,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: schema2, errSchemaPath, opts }) {
-    const msg = schema2.$comment;
+  function commentKeyword({ gen, schemaEnv, schema, errSchemaPath, opts }) {
+    const msg = schema.$comment;
     if (opts.$comment === true) {
       gen.code((0, codegen_1._)`${names_1.default.self}.logger.log(${msg})`);
     } else if (typeof opts.$comment == "function") {
@@ -2488,9 +2475,9 @@ var require_validate = __commonJS((exports) => {
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
   function schemaKeywords(it, types, typeErrors, errsCount) {
-    const { gen, schema: schema2, data, allErrors, opts, self: self2 } = it;
+    const { gen, schema, data, allErrors, opts, self: self2 } = it;
     const { RULES } = self2;
-    if (schema2.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema2, RULES))) {
+    if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
       gen.block(() => keywordCode(it, "$ref", RULES.all.$ref.definition));
       return;
     }
@@ -2502,7 +2489,7 @@ var require_validate = __commonJS((exports) => {
       groupKeywords(RULES.post);
     });
     function groupKeywords(group) {
-      if (!(0, applicability_1.shouldUseGroup)(schema2, group))
+      if (!(0, applicability_1.shouldUseGroup)(schema, group))
         return;
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
@@ -2520,12 +2507,12 @@ var require_validate = __commonJS((exports) => {
     }
   }
   function iterateKeywords(it, group) {
-    const { gen, schema: schema2, opts: { useDefaults } } = it;
+    const { gen, schema, 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)(schema2, rule)) {
+        if ((0, applicability_1.shouldUseRule)(schema, rule)) {
           keywordCode(it, rule.keyword, rule.definition, group.type);
         }
       }
@@ -2864,17 +2851,17 @@ var require_compile = __commonJS((exports) => {
       var _a;
       this.refs = {};
       this.dynamicAnchors = {};
-      let schema2;
+      let schema;
       if (typeof env.schema == "object")
-        schema2 = env.schema;
+        schema = 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)(schema2 === null || schema2 === undefined ? undefined : schema2[env.schemaId || "$id"]);
+      this.baseId = (_a = env.baseId) !== null && _a !== undefined ? _a : (0, resolve_1.normalizeId)(schema === null || schema === undefined ? undefined : schema[env.schemaId || "$id"]);
       this.schemaPath = env.schemaPath;
       this.localRefs = env.localRefs;
       this.meta = env.meta;
-      this.$async = schema2 === null || schema2 === undefined ? undefined : schema2.$async;
+      this.$async = schema === null || schema === undefined ? undefined : schema.$async;
       this.refs = {};
     }
   }
@@ -2972,10 +2959,10 @@ var require_compile = __commonJS((exports) => {
       return schOrFunc;
     let _sch = resolve.call(this, root, ref);
     if (_sch === undefined) {
-      const schema2 = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
+      const schema = (_a = root.localRefs) === null || _a === undefined ? undefined : _a[ref];
       const { schemaId } = this.opts;
-      if (schema2)
-        _sch = new SchemaEnv({ schema: schema2, schemaId, root, baseId });
+      if (schema)
+        _sch = new SchemaEnv({ schema, schemaId, root, baseId });
     }
     if (_sch === undefined)
       return;
@@ -3023,12 +3010,12 @@ var require_compile = __commonJS((exports) => {
     if (!schOrRef.validate)
       compileSchema.call(this, schOrRef);
     if (id === (0, resolve_1.normalizeId)(ref)) {
-      const { schema: schema2 } = schOrRef;
+      const { schema } = schOrRef;
       const { schemaId } = this.opts;
-      const schId = schema2[schemaId];
+      const schId = schema[schemaId];
       if (schId)
         baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
-      return new SchemaEnv({ schema: schema2, schemaId, root, baseId });
+      return new SchemaEnv({ schema, schemaId, root, baseId });
     }
     return getJsonPointer.call(this, p, schOrRef);
   }
@@ -3040,29 +3027,29 @@ var require_compile = __commonJS((exports) => {
     "dependencies",
     "definitions"
   ]);
-  function getJsonPointer(parsedRef, { baseId, schema: schema2, root }) {
+  function getJsonPointer(parsedRef, { baseId, schema, 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 schema2 === "boolean")
+      if (typeof schema === "boolean")
         return;
-      const partSchema = schema2[(0, util_1.unescapeFragment)(part)];
+      const partSchema = schema[(0, util_1.unescapeFragment)(part)];
       if (partSchema === undefined)
         return;
-      schema2 = partSchema;
-      const schId = typeof schema2 === "object" && schema2[this.opts.schemaId];
+      schema = partSchema;
+      const schId = typeof schema === "object" && schema[this.opts.schemaId];
       if (!PREVENT_SCOPE_CHANGE.has(part) && schId) {
         baseId = (0, resolve_1.resolveUrl)(this.opts.uriResolver, baseId, schId);
       }
     }
     let env;
-    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);
+    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);
       env = resolveSchema.call(this, root, $ref);
     }
     const { schemaId } = this.opts;
-    env = env || new SchemaEnv({ schema: schema2, schemaId, root, baseId });
+    env = env || new SchemaEnv({ schema, schemaId, root, baseId });
     if (env.schema !== env.root.schema)
       return env;
     return;
@@ -3942,16 +3929,16 @@ var require_core = __commonJS((exports) => {
         this.errors = v.errors;
       return valid;
     }
-    compile(schema2, _meta) {
-      const sch = this._addSchema(schema2, _meta);
+    compile(schema, _meta) {
+      const sch = this._addSchema(schema, _meta);
       return sch.validate || this._compileSchemaEnv(sch);
     }
-    compileAsync(schema2, meta) {
+    compileAsync(schema, meta) {
       if (typeof this.opts.loadSchema != "function") {
         throw new Error("options.loadSchema should be a function");
       }
       const { loadSchema } = this.opts;
-      return runCompileAsync.call(this, schema2, meta);
+      return runCompileAsync.call(this, schema, meta);
       async function runCompileAsync(_schema, _meta) {
         await loadMetaSchema.call(this, _schema.$schema);
         const sch = this._addSchema(_schema, _meta);
@@ -3996,34 +3983,34 @@ var require_core = __commonJS((exports) => {
         }
       }
     }
-    addSchema(schema2, key, _meta, _validateSchema = this.opts.validateSchema) {
-      if (Array.isArray(schema2)) {
-        for (const sch of schema2)
+    addSchema(schema, key, _meta, _validateSchema = this.opts.validateSchema) {
+      if (Array.isArray(schema)) {
+        for (const sch of schema)
           this.addSchema(sch, undefined, _meta, _validateSchema);
         return this;
       }
       let id;
-      if (typeof schema2 === "object") {
+      if (typeof schema === "object") {
         const { schemaId } = this.opts;
-        id = schema2[schemaId];
+        id = schema[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(schema2, _meta, key, _validateSchema, true);
+      this.schemas[key] = this._addSchema(schema, _meta, key, _validateSchema, true);
       return this;
     }
-    addMetaSchema(schema2, key, _validateSchema = this.opts.validateSchema) {
-      this.addSchema(schema2, key, true, _validateSchema);
+    addMetaSchema(schema, key, _validateSchema = this.opts.validateSchema) {
+      this.addSchema(schema, key, true, _validateSchema);
       return this;
     }
-    validateSchema(schema2, throwOrLogError) {
-      if (typeof schema2 == "boolean")
+    validateSchema(schema, throwOrLogError) {
+      if (typeof schema == "boolean")
         return true;
       let $schema;
-      $schema = schema2.$schema;
+      $schema = schema.$schema;
       if ($schema !== undefined && typeof $schema != "string") {
         throw new Error("$schema must be a string");
       }
@@ -4033,7 +4020,7 @@ var require_core = __commonJS((exports) => {
         this.errors = null;
         return true;
       }
-      const valid = this.validate($schema, schema2);
+      const valid = this.validate($schema, schema);
       if (!valid && throwOrLogError) {
         const message = "schema is invalid: " + this.errorsText();
         if (this.opts.validateSchema === "log")
@@ -4167,9 +4154,9 @@ var require_core = __commonJS((exports) => {
           if (typeof rule != "object")
             continue;
           const { $data } = rule.definition;
-          const schema2 = keywords[key];
-          if ($data && schema2)
-            keywords[key] = schemaOrData(schema2);
+          const schema = keywords[key];
+          if ($data && schema)
+            keywords[key] = schemaOrData(schema);
         }
       }
       return metaSchema;
@@ -4187,23 +4174,23 @@ var require_core = __commonJS((exports) => {
         }
       }
     }
-    _addSchema(schema2, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
+    _addSchema(schema, meta, baseId, validateSchema = this.opts.validateSchema, addSchema = this.opts.addUsedSchema) {
       let id;
       const { schemaId } = this.opts;
-      if (typeof schema2 == "object") {
-        id = schema2[schemaId];
+      if (typeof schema == "object") {
+        id = schema[schemaId];
       } else {
         if (this.opts.jtd)
           throw new Error("schema must be object");
-        else if (typeof schema2 != "boolean")
+        else if (typeof schema != "boolean")
           throw new Error("schema must be object or boolean");
       }
-      let sch = this._cache.get(schema2);
+      let sch = this._cache.get(schema);
       if (sch !== undefined)
         return sch;
       baseId = (0, resolve_1.normalizeId)(id || baseId);
-      const localRefs = resolve_1.getSchemaRefs.call(this, schema2, baseId);
-      sch = new compile_1.SchemaEnv({ schema: schema2, schemaId, meta, baseId, localRefs });
+      const localRefs = resolve_1.getSchemaRefs.call(this, schema, baseId);
+      sch = new compile_1.SchemaEnv({ schema, schemaId, meta, baseId, localRefs });
       this._cache.set(sch.schema, sch);
       if (addSchema && !baseId.startsWith("#")) {
         if (baseId)
@@ -4211,7 +4198,7 @@ var require_core = __commonJS((exports) => {
         this.refs[baseId] = sch;
       }
       if (validateSchema)
-        this.validateSchema(schema2, true);
+        this.validateSchema(schema, true);
       return sch;
     }
     _checkUnique(id) {
@@ -4362,8 +4349,8 @@ var require_core = __commonJS((exports) => {
   var $dataRef = {
     $ref: "https://raw.githubusercontent.com/ajv-validator/ajv/master/lib/refs/data.json#"
   };
-  function schemaOrData(schema2) {
-    return { anyOf: [schema2, $dataRef] };
+  function schemaOrData(schema) {
+    return { anyOf: [schema, $dataRef] };
   }
 });
 
@@ -4638,9 +4625,9 @@ var require_pattern = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { data, $data, schema: schema2, schemaCode, it } = cxt;
+      const { data, $data, schema, schemaCode, it } = cxt;
       const u = it.opts.unicodeRegExp ? "u" : "";
-      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema2);
+      const regExp = $data ? (0, codegen_1._)`(new RegExp(${schemaCode}, ${u}))` : (0, code_1.usePattern)(cxt, schema);
       cxt.fail$data((0, codegen_1._)`!${regExp}.test(${data})`);
     }
   };
@@ -4690,11 +4677,11 @@ var require_required = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { gen, schema: schema2, schemaCode, data, $data, it } = cxt;
+      const { gen, schema, schemaCode, data, $data, it } = cxt;
       const { opts } = it;
-      if (!$data && schema2.length === 0)
+      if (!$data && schema.length === 0)
         return;
-      const useLoop = schema2.length >= opts.loopRequired;
+      const useLoop = schema.length >= opts.loopRequired;
       if (it.allErrors)
         allErrorsMode();
       else
@@ -4702,7 +4689,7 @@ var require_required = __commonJS((exports) => {
       if (opts.strictRequired) {
         const props = cxt.parentSchema.properties;
         const { definedProperties } = cxt.it;
-        for (const requiredKey of schema2) {
+        for (const requiredKey of schema) {
           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)`;
@@ -4714,7 +4701,7 @@ var require_required = __commonJS((exports) => {
         if (useLoop || $data) {
           cxt.block$data(codegen_1.nil, loopAllRequired);
         } else {
-          for (const prop of schema2) {
+          for (const prop of schema) {
             (0, code_1.checkReportMissingProp)(cxt, prop);
           }
         }
@@ -4726,7 +4713,7 @@ var require_required = __commonJS((exports) => {
           cxt.block$data(valid, () => loopUntilMissing(missing, valid));
           cxt.ok(valid);
         } else {
-          gen.if((0, code_1.checkMissingProp)(cxt, schema2, missing));
+          gen.if((0, code_1.checkMissingProp)(cxt, schema, missing));
           (0, code_1.reportMissingProp)(cxt, missing);
           gen.else();
         }
@@ -4804,8 +4791,8 @@ var require_uniqueItems = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { gen, data, $data, schema: schema2, parentSchema, schemaCode, it } = cxt;
-      if (!$data && !schema2)
+      const { gen, data, $data, schema, parentSchema, schemaCode, it } = cxt;
+      if (!$data && !schema)
         return;
       const valid = gen.let("valid");
       const itemTypes = parentSchema.items ? (0, dataType_1.getSchemaTypes)(parentSchema.items) : [];
@@ -4865,11 +4852,11 @@ var require_const = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { gen, data, $data, schemaCode, schema: schema2 } = cxt;
-      if ($data || schema2 && typeof schema2 == "object") {
+      const { gen, data, $data, schemaCode, schema } = cxt;
+      if ($data || schema && typeof schema == "object") {
         cxt.fail$data((0, codegen_1._)`!${(0, util_1.useFunc)(gen, equal_1.default)}(${data}, ${schemaCode})`);
       } else {
-        cxt.fail((0, codegen_1._)`${schema2} !== ${data}`);
+        cxt.fail((0, codegen_1._)`${schema} !== ${data}`);
       }
     }
   };
@@ -4892,10 +4879,10 @@ var require_enum = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt) {
-      const { gen, data, $data, schema: schema2, schemaCode, it } = cxt;
-      if (!$data && schema2.length === 0)
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
+      if (!$data && schema.length === 0)
         throw new Error("enum must have non-empty array");
-      const useLoop = schema2.length >= it.opts.loopEnum;
+      const useLoop = schema.length >= it.opts.loopEnum;
       let eql;
       const getEql = () => eql !== null && eql !== undefined ? eql : eql = (0, util_1.useFunc)(gen, equal_1.default);
       let valid;
@@ -4903,10 +4890,10 @@ var require_enum = __commonJS((exports) => {
         valid = gen.let("valid");
         cxt.block$data(valid, loopEnum);
       } else {
-        if (!Array.isArray(schema2))
+        if (!Array.isArray(schema))
           throw new Error("ajv implementation error");
         const vSchema = gen.const("vSchema", schemaCode);
-        valid = (0, codegen_1.or)(...schema2.map((_x, i) => equalCode(vSchema, i)));
+        valid = (0, codegen_1.or)(...schema.map((_x, i) => equalCode(vSchema, i)));
       }
       cxt.pass(valid);
       function loopEnum() {
@@ -4914,7 +4901,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 = schema2[i];
+        const sch = schema[i];
         return typeof sch === "object" && sch !== null ? (0, codegen_1._)`${getEql()}(${data}, ${vSchema}[${i}])` : (0, codegen_1._)`${data} === ${sch}`;
       }
     }
@@ -4979,13 +4966,13 @@ var require_additionalItems = __commonJS((exports) => {
     }
   };
   function validateAdditionalItems(cxt, items) {
-    const { gen, schema: schema2, data, keyword, it } = cxt;
+    const { gen, schema, data, keyword, it } = cxt;
     it.items = true;
     const len = gen.const("len", (0, codegen_1._)`${data}.length`);
-    if (schema2 === false) {
+    if (schema === false) {
       cxt.setParams({ len: items.length });
       cxt.pass((0, codegen_1._)`${len} <= ${items.length}`);
-    } else if (typeof schema2 == "object" && !(0, util_1.alwaysValidSchema)(it, schema2)) {
+    } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
       const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items.length}`);
       gen.if((0, codegen_1.not)(valid), () => validateItems(valid));
       cxt.ok(valid);
@@ -5015,11 +5002,11 @@ var require_items = __commonJS((exports) => {
     schemaType: ["object", "array", "boolean"],
     before: "uniqueItems",
     code(cxt) {
-      const { schema: schema2, it } = cxt;
-      if (Array.isArray(schema2))
-        return validateTuple(cxt, "additionalItems", schema2);
+      const { schema, it } = cxt;
+      if (Array.isArray(schema))
+        return validateTuple(cxt, "additionalItems", schema);
       it.items = true;
-      if ((0, util_1.alwaysValidSchema)(it, schema2))
+      if ((0, util_1.alwaysValidSchema)(it, schema))
         return;
       cxt.ok((0, code_1.validateArray)(cxt));
     }
@@ -5088,10 +5075,10 @@ var require_items2020 = __commonJS((exports) => {
     before: "uniqueItems",
     error,
     code(cxt) {
-      const { schema: schema2, parentSchema, it } = cxt;
+      const { schema, parentSchema, it } = cxt;
       const { prefixItems } = parentSchema;
       it.items = true;
-      if ((0, util_1.alwaysValidSchema)(it, schema2))
+      if ((0, util_1.alwaysValidSchema)(it, schema))
         return;
       if (prefixItems)
         (0, additionalItems_1.validateAdditionalItems)(cxt, prefixItems);
@@ -5119,7 +5106,7 @@ var require_contains = __commonJS((exports) => {
     trackErrors: true,
     error,
     code(cxt) {
-      const { gen, schema: schema2, parentSchema, data, it } = cxt;
+      const { gen, schema, parentSchema, data, it } = cxt;
       let min;
       let max;
       const { minContains, maxContains } = parentSchema;
@@ -5140,7 +5127,7 @@ var require_contains = __commonJS((exports) => {
         cxt.fail();
         return;
       }
-      if ((0, util_1.alwaysValidSchema)(it, schema2)) {
+      if ((0, util_1.alwaysValidSchema)(it, schema)) {
         let cond = (0, codegen_1._)`${len} >= ${min}`;
         if (max !== undefined)
           cond = (0, codegen_1._)`${cond} && ${len} <= ${max}`;
@@ -5221,14 +5208,14 @@ var require_dependencies = __commonJS((exports) => {
       validateSchemaDeps(cxt, schDeps);
     }
   };
-  function splitDependencies({ schema: schema2 }) {
+  function splitDependencies({ schema }) {
     const propertyDeps = {};
     const schemaDeps = {};
-    for (const key in schema2) {
+    for (const key in schema) {
       if (key === "__proto__")
         continue;
-      const deps = Array.isArray(schema2[key]) ? propertyDeps : schemaDeps;
-      deps[key] = schema2[key];
+      const deps = Array.isArray(schema[key]) ? propertyDeps : schemaDeps;
+      deps[key] = schema[key];
     }
     return [propertyDeps, schemaDeps];
   }
@@ -5293,8 +5280,8 @@ var require_propertyNames = __commonJS((exports) => {
     schemaType: ["object", "boolean"],
     error,
     code(cxt) {
-      const { gen, schema: schema2, data, it } = cxt;
-      if ((0, util_1.alwaysValidSchema)(it, schema2))
+      const { gen, schema, data, it } = cxt;
+      if ((0, util_1.alwaysValidSchema)(it, schema))
         return;
       const valid = gen.name("valid");
       gen.forIn("key", data, (key) => {
@@ -5337,12 +5324,12 @@ var require_additionalProperties = __commonJS((exports) => {
     trackErrors: true,
     error,
     code(cxt) {
-      const { gen, schema: schema2, parentSchema, data, errsCount, it } = cxt;
+      const { gen, schema, 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, schema2))
+      if (opts.removeAdditional !== "all" && (0, util_1.alwaysValidSchema)(it, schema))
         return;
       const props = (0, code_1.allSchemaProperties)(parentSchema.properties);
       const patProps = (0, code_1.allSchemaProperties)(parentSchema.patternProperties);
@@ -5375,18 +5362,18 @@ var require_additionalProperties = __commonJS((exports) => {
         gen.code((0, codegen_1._)`delete ${data}[${key}]`);
       }
       function additionalPropertyCode(key) {
-        if (opts.removeAdditional === "all" || opts.removeAdditional && schema2 === false) {
+        if (opts.removeAdditional === "all" || opts.removeAdditional && schema === false) {
           deleteAdditional(key);
           return;
         }
-        if (schema2 === false) {
+        if (schema === false) {
           cxt.setParams({ additionalProperty: key });
           cxt.error();
           if (!allErrors)
             gen.break();
           return;
         }
-        if (typeof schema2 == "object" && !(0, util_1.alwaysValidSchema)(it, schema2)) {
+        if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
           const valid = gen.name("valid");
           if (opts.removeAdditional === "failing") {
             applyAdditionalSchema(key, valid, false);
@@ -5433,18 +5420,18 @@ var require_properties = __commonJS((exports) => {
     type: "object",
     schemaType: "object",
     code(cxt) {
-      const { gen, schema: schema2, parentSchema, data, it } = cxt;
+      const { gen, schema, 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)(schema2);
+      const allProps = (0, code_1.allSchemaProperties)(schema);
       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, schema2[p]));
+      const properties = allProps.filter((p) => !(0, util_1.alwaysValidSchema)(it, schema[p]));
       if (properties.length === 0)
         return;
       const valid = gen.name("valid");
@@ -5462,7 +5449,7 @@ var require_properties = __commonJS((exports) => {
         cxt.ok(valid);
       }
       function hasDefault(prop) {
-        return it.opts.useDefaults && !it.compositeRule && schema2[prop].default !== undefined;
+        return it.opts.useDefaults && !it.compositeRule && schema[prop].default !== undefined;
       }
       function applyPropertySchema(prop) {
         cxt.subschema({
@@ -5488,10 +5475,10 @@ var require_patternProperties = __commonJS((exports) => {
     type: "object",
     schemaType: "object",
     code(cxt) {
-      const { gen, schema: schema2, data, parentSchema, it } = cxt;
+      const { gen, schema, data, parentSchema, it } = cxt;
       const { opts } = it;
-      const patterns = (0, code_1.allSchemaProperties)(schema2);
-      const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema2[p]));
+      const patterns = (0, code_1.allSchemaProperties)(schema);
+      const alwaysValidPatterns = patterns.filter((p) => (0, util_1.alwaysValidSchema)(it, schema[p]));
       if (patterns.length === 0 || alwaysValidPatterns.length === patterns.length && (!it.opts.unevaluated || it.props === true)) {
         return;
       }
@@ -5556,8 +5543,8 @@ var require_not = __commonJS((exports) => {
     schemaType: ["object", "boolean"],
     trackErrors: true,
     code(cxt) {
-      const { gen, schema: schema2, it } = cxt;
-      if ((0, util_1.alwaysValidSchema)(it, schema2)) {
+      const { gen, schema, it } = cxt;
+      if ((0, util_1.alwaysValidSchema)(it, schema)) {
         cxt.fail();
         return;
       }
@@ -5604,12 +5591,12 @@ var require_oneOf = __commonJS((exports) => {
     trackErrors: true,
     error,
     code(cxt) {
-      const { gen, schema: schema2, parentSchema, it } = cxt;
-      if (!Array.isArray(schema2))
+      const { gen, schema, parentSchema, it } = cxt;
+      if (!Array.isArray(schema))
         throw new Error("ajv implementation error");
       if (it.opts.discriminator && parentSchema.discriminator)
         return;
-      const schArr = schema2;
+      const schArr = schema;
       const valid = gen.let("valid", false);
       const passing = gen.let("passing", null);
       const schValid = gen.name("_valid");
@@ -5652,11 +5639,11 @@ var require_allOf = __commonJS((exports) => {
     keyword: "allOf",
     schemaType: "array",
     code(cxt) {
-      const { gen, schema: schema2, it } = cxt;
-      if (!Array.isArray(schema2))
+      const { gen, schema, it } = cxt;
+      if (!Array.isArray(schema))
         throw new Error("ajv implementation error");
       const valid = gen.name("valid");
-      schema2.forEach((sch, i) => {
+      schema.forEach((sch, i) => {
         if ((0, util_1.alwaysValidSchema)(it, sch))
           return;
         const schCxt = cxt.subschema({ keyword: "allOf", schemaProp: i }, valid);
@@ -5728,8 +5715,8 @@ var require_if = __commonJS((exports) => {
     }
   };
   function hasSchema(it, keyword) {
-    const schema2 = it.schema[keyword];
-    return schema2 !== undefined && !(0, util_1.alwaysValidSchema)(it, schema2);
+    const schema = it.schema[keyword];
+    return schema !== undefined && !(0, util_1.alwaysValidSchema)(it, schema);
   }
   exports.default = def;
 });
@@ -5807,7 +5794,7 @@ var require_format = __commonJS((exports) => {
     $data: true,
     error,
     code(cxt, ruleType) {
-      const { gen, data, $data, schema: schema2, schemaCode, it } = cxt;
+      const { gen, data, $data, schema, schemaCode, it } = cxt;
       const { opts, errSchemaPath, schemaEnv, self: self2 } = it;
       if (!opts.validateFormats)
         return;
@@ -5837,7 +5824,7 @@ var require_format = __commonJS((exports) => {
         }
       }
       function validateFormat() {
-        const formatDef = self2.formats[schema2];
+        const formatDef = self2.formats[schema];
         if (!formatDef) {
           unknownFormat();
           return;
@@ -5854,12 +5841,12 @@ var require_format = __commonJS((exports) => {
           }
           throw new Error(unknownMsg());
           function unknownMsg() {
-            return `unknown format "${schema2}" ignored in schema at path "${errSchemaPath}"`;
+            return `unknown format "${schema}" 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)(schema2)}` : undefined;
-          const fmt = gen.scopeValue("formats", { key: schema2, 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)(schema)}` : undefined;
+          const fmt = gen.scopeValue("formats", { key: schema, ref: fmtDef, code });
           if (typeof fmtDef == "object" && !(fmtDef instanceof RegExp)) {
             return [fmtDef.type || "string", fmtDef.validate, (0, codegen_1._)`${fmt}.validate`];
           }
@@ -5955,15 +5942,15 @@ var require_discriminator = __commonJS((exports) => {
     schemaType: "object",
     error,
     code(cxt) {
-      const { gen, data, schema: schema2, parentSchema, it } = cxt;
+      const { gen, data, schema, parentSchema, it } = cxt;
       const { oneOf } = parentSchema;
       if (!it.opts.discriminator) {
         throw new Error("discriminator: requires discriminator option");
       }
-      const tagName = schema2.propertyName;
+      const tagName = schema.propertyName;
       if (typeof tagName != "string")
         throw new Error("discriminator: requires propertyName");
-      if (schema2.mapping)
+      if (schema.mapping)
         throw new Error("discriminator: mapping is not supported");
       if (!oneOf)
         throw new Error("discriminator: requires oneOf keyword");
@@ -48414,8 +48401,8 @@ var require_index_cjs2 = __commonJS((exports, module) => {
     this.re = {};
     compile(this);
   }
-  LinkifyIt.prototype.add = function add(schema2, definition) {
-    this.__schemas__[schema2] = definition;
+  LinkifyIt.prototype.add = function add(schema, definition) {
+    this.__schemas__[schema] = definition;
     compile(this);
     return this;
   };
@@ -48477,11 +48464,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, schema2, pos) {
-    if (!this.__compiled__[schema2.toLowerCase()]) {
+  LinkifyIt.prototype.testSchemaAt = function testSchemaAt(text, schema, pos) {
+    if (!this.__compiled__[schema.toLowerCase()]) {
       return 0;
     }
-    return this.__compiled__[schema2.toLowerCase()].validate(text, pos, this);
+    return this.__compiled__[schema.toLowerCase()].validate(text, pos, this);
   };
   LinkifyIt.prototype.match = function match(text) {
     const result = [];
@@ -53983,7 +53970,7 @@ var require_logging_utils = __commonJS((exports) => {
   exports.getDebugBackend = getDebugBackend;
   exports.getStructuredBackend = getStructuredBackend;
   exports.setBackend = setBackend;
-  exports.log = log;
+  exports.log = log8;
   var events_1 = __require("events");
   var process3 = __importStar(__require("process"));
   var util = __importStar(__require("util"));
@@ -54010,7 +53997,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) => log(namespace2, this.func);
+      this.func.sublog = (namespace2) => log8(namespace2, this.func);
     }
     invoke(fields, ...args) {
       if (this.upstream) {
@@ -54171,7 +54158,7 @@ var require_logging_utils = __commonJS((exports) => {
     cachedBackend = backend;
     loggerCache.clear();
   }
-  function log(namespace, parent) {
+  function log8(namespace, parent) {
     if (!cachedBackend) {
       const enablesFlag = process3.env[exports.env.nodeEnables];
       if (!enablesFlag) {
@@ -54311,7 +54298,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 log = logger.log("gcp-metadata");
+  var log8 = 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",
@@ -54374,9 +54361,9 @@ var require_src5 = __commonJS((exports) => {
       responseType: "text",
       timeout: requestTimeout()
     };
-    log.info("instance request %j", req);
+    log8.info("instance request %j", req);
     const res = await requestMethod(req);
-    log.info("instance metadata is %s", res.data);
+    log8.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"}`);
@@ -63019,12 +63006,12 @@ var require_endpoint = __commonJS((exports) => {
     constructor(options) {
       this._options = options || {};
     }
-    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];
+    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];
             if (!target[resourceName]) {
               target[resourceName] = {};
             }
@@ -63033,21 +63020,21 @@ var require_endpoint = __commonJS((exports) => {
         }
       }
     }
-    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];
+    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];
             target[name] = this.makeMethod(rootSchema, method, context);
           }
         }
       }
     }
-    makeMethod(schema2, method, context) {
+    makeMethod(schema, method, context) {
       return (paramsOrCallback, callback) => {
         const params = typeof paramsOrCallback === "function" ? {} : paramsOrCallback;
         callback = typeof paramsOrCallback === "function" ? paramsOrCallback : callback;
-        const schemaUrl = buildurl(schema2.rootUrl + schema2.servicePath + method.path);
+        const schemaUrl = buildurl(schema.rootUrl + schema.servicePath + method.path);
         const parameters = {
           options: {
             url: schemaUrl.substring(1, schemaUrl.length - 1),
@@ -63060,7 +63047,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(schema2.rootUrl + method.mediaUpload.protocols.simple.path);
+          const mediaUrl = buildurl(schema.rootUrl + method.mediaUpload.protocols.simple.path);
           parameters.mediaUrl = mediaUrl.substring(1, mediaUrl.length - 1);
         }
         if (!callback) {
@@ -63107,10 +63094,10 @@ var require_discovery = __commonJS((exports) => {
     constructor(options) {
       this.options = options || {};
     }
-    makeEndpoint(schema2) {
+    makeEndpoint(schema) {
       return (options) => {
         const ep = new endpoint_1.Endpoint(options);
-        ep.applySchema(ep, schema2, schema2, ep);
+        ep.applySchema(ep, schema, schema, ep);
         return ep;
       };
     }
@@ -72131,11 +72118,11 @@ var require_tools = __commonJS((exports, module) => {
       }
     }
   }
-  function buildFormatters(level, bindings, log) {
+  function buildFormatters(level, bindings, log8) {
     return {
       level,
       bindings,
-      log
+      log: log8
     };
   }
   function normalizeDestFileDescriptor(destination) {
@@ -72480,8 +72467,8 @@ var require_proto = __commonJS((exports, module) => {
     } else
       instance[serializersSym] = serializers;
     if (options.hasOwnProperty("formatters")) {
-      const { level, bindings: chindings, log } = options.formatters;
-      instance[formattersSym] = buildFormatters(level || formatters.level, chindings || resetChildingsFormatter, log || formatters.log);
+      const { level, bindings: chindings, log: log8 } = options.formatters;
+      instance[formattersSym] = buildFormatters(level || formatters.level, chindings || resetChildingsFormatter, log8 || formatters.log);
     } else {
       instance[formattersSym] = buildFormatters(formatters.level, resetChildingsFormatter, formatters.log);
     }
@@ -101685,10 +101672,10 @@ var require_mailer = __commonJS((exports, module) => {
         tnx: "create"
       }, "Creating transport: %s", this.getVersionString());
       if (typeof this.transporter.on === "function") {
-        this.transporter.on("log", (log) => {
+        this.transporter.on("log", (log8) => {
           this.logger.debug({
             tnx: "transport"
-          }, "%s: %s", log.type, log.message);
+          }, "%s: %s", log8.type, log8.message);
         });
         this.transporter.on("error", (err) => {
           this.logger.error({
@@ -105607,6 +105594,17 @@ You can perform the full lifecycle of a penetration test and support a wide rang
 - **spawn_pentest_swarm** — Fan out targeted pentest agents in parallel across multiple endpoints/objectives.
 - **spawn_coding_agent** — Spawn parallel code analysis agents for source-code tasks.
 
+## Pensar CLI (workspace & attack surface)
+
+You run inside Pensar Apex, and the \`pensar\` CLI is available on this machine. Invoke it through \`execute_command\` to perform Console/workspace operations your other tools don't cover — most importantly managing the **attack surface** and triaging results. These commands act on the workspace the user connected with \`pensar login\` and print JSON to stdout, so you can parse and chain them.
+
+- **Attack surface (apps & endpoints)** — \`pensar apps\` (list), \`apps get <appId>\`, \`apps create\`, \`apps update <appId>\`, \`apps delete <appId>\`; endpoints via \`apps endpoints <appId>\`, \`apps endpoint <endpointId>\`, \`apps endpoint-create <appId>\`, \`apps endpoint-update <endpointId>\`, \`apps endpoint-delete <endpointId>\`; and \`apps search <query>\` / \`apps search-endpoints <query>\`.
+- **Issues & fixes** — \`pensar issues [--status --severity --scan --branch]\`, \`issues get <id>\`, \`issues update <id>\`; \`pensar fixes <issueId>\`, \`fixes get <fixId>\`.
+- **Scans** — \`pensar pentests\`, \`pentests get <id>\`, \`pentests dispatch [--branch --level]\`.
+- **Agent logs** — \`pensar logs <issueId>\`, \`logs search <issueId> <query>\`.
+
+Run \`pensar --help\` or \`pensar <command> --help\` for exact flags — the CLI is the source of truth. These commands require the user to be logged in; if one reports it is not authenticated, tell the user to run \`pensar login\` rather than attempting the device flow yourself. Confirm with the user before any mutating command (\`create\`/\`update\`/\`delete\`, \`endpoint-*\`, \`pentests dispatch\`, \`issues update\`). Do NOT launch nested engagements from here (\`pensar pentest\`, \`pensar targeted-pentest\`, \`pensar operator\`, or \`pensar -p\`) — use your own tools for testing.
+
 # How to Work
 
 1. **Execute what the user asks.** If they say "scan this target", scan it. If they say "test this endpoint for SQLi", test it. Carry out the requested task using your tools and present the results.
@@ -105636,6 +105634,7 @@ 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() {
@@ -106840,27 +106839,27 @@ init_core();
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
-  const schema2 = s;
-  return !!schema2._zod;
+  const schema = s;
+  return !!schema._zod;
 }
-function safeParse2(schema2, data) {
-  if (isZ4Schema(schema2)) {
-    const result2 = safeParse(schema2, data);
+function safeParse2(schema, data) {
+  if (isZ4Schema(schema)) {
+    const result2 = safeParse(schema, data);
     return result2;
   }
-  const v3Schema = schema2;
+  const v3Schema = schema;
   const result = v3Schema.safeParse(data);
   return result;
 }
-function getObjectShape(schema2) {
-  if (!schema2)
+function getObjectShape(schema) {
+  if (!schema)
     return;
   let rawShape;
-  if (isZ4Schema(schema2)) {
-    const v4Schema = schema2;
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema;
     rawShape = v4Schema._zod?.def?.shape;
   } else {
-    const v3Schema = schema2;
+    const v3Schema = schema;
     rawShape = v3Schema.shape;
   }
   if (!rawShape)
@@ -106874,9 +106873,9 @@ function getObjectShape(schema2) {
   }
   return rawShape;
 }
-function getLiteralValue(schema2) {
-  if (isZ4Schema(schema2)) {
-    const v4Schema = schema2;
+function getLiteralValue(schema) {
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema;
     const def2 = v4Schema._zod?.def;
     if (def2) {
       if (def2.value !== undefined)
@@ -106886,7 +106885,7 @@ function getLiteralValue(schema2) {
       }
     }
   }
-  const v3Schema = schema2;
+  const v3Schema = schema;
   const def = v3Schema._def;
   if (def) {
     if (def.value !== undefined)
@@ -106895,7 +106894,7 @@ function getLiteralValue(schema2) {
       return def.values[0];
     }
   }
-  const directValue = schema2.value;
+  const directValue = schema.value;
   if (directValue !== undefined)
     return directValue;
   return;
@@ -107744,8 +107743,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(schema2) {
-  const shape = getObjectShape(schema2);
+function getMethodLiteral(schema) {
+  const shape = getObjectShape(schema);
   const methodSchema = shape?.method;
   if (!methodSchema) {
     throw new Error("Schema is missing a method literal");
@@ -107756,8 +107755,8 @@ function getMethodLiteral(schema2) {
   }
   return value;
 }
-function parseWithCompat(schema2, data) {
-  const result = safeParse2(schema2, data);
+function parseWithCompat(schema, data) {
+  const result = safeParse2(schema, data);
   if (!result.success) {
     throw result.error;
   }
@@ -108606,8 +108605,8 @@ class AjvJsonSchemaValidator {
   constructor(ajv) {
     this._ajv = ajv ?? createDefaultAjvInstance();
   }
-  getValidator(schema2) {
-    const ajvValidator = "$id" in schema2 && typeof schema2.$id === "string" ? this._ajv.getSchema(schema2.$id) ?? this._ajv.compile(schema2) : this._ajv.compile(schema2);
+  getValidator(schema) {
+    const ajvValidator = "$id" in schema && typeof schema.$id === "string" ? this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema) : this._ajv.compile(schema);
     return (input) => {
       const valid = ajvValidator(input);
       if (valid) {
@@ -108729,12 +108728,12 @@ function assertClientRequestTaskCapability(requests, method, entityName) {
 }
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/client/index.js
-function applyElicitationDefaults(schema2, data) {
-  if (!schema2 || data === null || typeof data !== "object")
+function applyElicitationDefaults(schema, data) {
+  if (!schema || data === null || typeof data !== "object")
     return;
-  if (schema2.type === "object" && schema2.properties && typeof schema2.properties === "object") {
+  if (schema.type === "object" && schema.properties && typeof schema.properties === "object") {
     const obj = data;
-    const props = schema2.properties;
+    const props = schema.properties;
     for (const key of Object.keys(props)) {
       const propSchema = props[key];
       if (obj[key] === undefined && Object.prototype.hasOwnProperty.call(propSchema, "default")) {
@@ -108745,15 +108744,15 @@ function applyElicitationDefaults(schema2, data) {
       }
     }
   }
-  if (Array.isArray(schema2.anyOf)) {
-    for (const sub of schema2.anyOf) {
+  if (Array.isArray(schema.anyOf)) {
+    for (const sub of schema.anyOf) {
       if (typeof sub !== "boolean") {
         applyElicitationDefaults(sub, data);
       }
     }
   }
-  if (Array.isArray(schema2.oneOf)) {
-    for (const sub of schema2.oneOf) {
+  if (Array.isArray(schema.oneOf)) {
+    for (const sub of schema.oneOf) {
       if (typeof sub !== "boolean") {
         applyElicitationDefaults(sub, data);
       }
@@ -110942,8 +110941,11 @@ 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) {
@@ -110983,7 +110985,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) => {
-      console.log(`Authentication complete: ${result.success ? "SUCCESS" : "FAILED"}`);
+      log.info(`Authentication complete: ${result.success ? "SUCCESS" : "FAILED"}`);
       let authDataPath;
       try {
         const authDir = join6(ctx.session.rootPath, AUTH_DIR);
@@ -111002,9 +111004,9 @@ This tool marks the end of the authentication flow.`,
           ...result.authBarrier && { authBarrier: result.authBarrier }
         };
         writeFileSync4(authDataPath, JSON.stringify(authData, null, 2));
-        console.log(`Auth data persisted to ${authDataPath}`);
+        log.debug(`Auth data persisted to ${authDataPath}`);
       } catch (err) {
-        console.error(`Failed to persist auth data: ${err}`);
+        log.error("Failed to persist auth data", err instanceof Error ? err : undefined, { error: String(err) });
       }
       return {
         success: result.success,
@@ -111024,6 +111026,8 @@ 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) {
@@ -111098,6 +111102,7 @@ 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.
@@ -111177,7 +111182,7 @@ function crawlAuthenticated(ctx) {
               });
             }
           } catch (error) {
-            console.error(`Error crawling ${url}:`, error);
+            log2.error(`Error crawling ${url}`, error instanceof Error ? error : undefined, { error: String(error) });
           }
         }
         return {
@@ -111245,9 +111250,12 @@ 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"),
@@ -111268,14 +111276,14 @@ Parent directories are created automatically if they don't exist.`,
       content,
       overwrite = false
     }) => {
-      console.error(`[create_file] enter: path=${filePath}, contentLen=${content.length}, overwrite=${overwrite}, sandbox=${!!ctx.sandbox}`);
+      log3.debug(`enter: path=${filePath}, contentLen=${content.length}, overwrite=${overwrite}, sandbox=${!!ctx.sandbox}`);
       const resolved = isAbsolute(filePath) ? filePath : resolve(ctx.agentCwd, filePath);
-      console.error(`[create_file] resolved: ${resolved}`);
+      log3.debug(`resolved: ${resolved}`);
       if (ctx.sandbox) {
         return executeSandboxCreate(ctx, resolved, content, overwrite);
       }
       const result = await executeLocalCreate(resolved, content, overwrite);
-      console.error(`[create_file] done: success=${result.success}, error=${result.error || "(none)"}`);
+      log3.debug(`done: success=${result.success}, error=${result.error || "(none)"}`);
       return result;
     }
   });
@@ -111283,7 +111291,7 @@ Parent directories are created automatically if they don't exist.`,
 async function executeLocalCreate(filePath, content, overwrite) {
   try {
     if (!overwrite && existsSync5(filePath)) {
-      console.error(`[create_file:local] file already exists: ${filePath}`);
+      log3.debug(`local: file already exists: ${filePath}`);
       return {
         success: false,
         error: `File already exists: ${filePath}. Set overwrite=true to replace it.`,
@@ -111291,18 +111299,20 @@ async function executeLocalCreate(filePath, content, overwrite) {
       };
     }
     const dir = dirname3(filePath);
-    console.error(`[create_file:local] mkdir ${dir}`);
+    log3.debug(`local: mkdir ${dir}`);
     await mkdir(dir, { recursive: true });
-    console.error(`[create_file:local] mkdir done, writing ${content.length} bytes`);
+    log3.debug(`local: mkdir done, writing ${content.length} bytes`);
     await writeFile(filePath, content, "utf-8");
-    console.error(`[create_file:local] writeFile done`);
+    log3.debug("local: writeFile done");
     return {
       success: true,
       error: "",
       path: filePath
     };
   } catch (err) {
-    console.error(`[create_file:local] error: ${err}`);
+    log3.error("local: write failed", err instanceof Error ? err : undefined, {
+      error: String(err)
+    });
     return {
       success: false,
       error: err instanceof Error ? err.message : String(err),
@@ -111404,19 +111414,19 @@ function getTask(tasksDir, id) {
     return null;
   }
 }
-function updateTask(tasksDir, id, update2) {
+function updateTask(tasksDir, id, update) {
   const existing = getTask(tasksDir, id);
   if (!existing)
     return null;
   const updated = {
     ...existing,
-    ...update2.status !== undefined && { status: update2.status },
-    ...update2.result !== undefined && { result: update2.result },
-    ...update2.observation !== undefined && {
-      observation: update2.observation
+    ...update.status !== undefined && { status: update.status },
+    ...update.result !== undefined && { result: update.result },
+    ...update.observation !== undefined && {
+      observation: update.observation
     },
-    ...update2.metadata !== undefined && {
-      metadata: { ...existing.metadata, ...update2.metadata }
+    ...update.metadata !== undefined && {
+      metadata: { ...existing.metadata, ...update.metadata }
     },
     updatedAt: new Date().toISOString()
   };
@@ -111531,8 +111541,12 @@ 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);
@@ -111654,42 +111668,33 @@ When to use delegate_to_auth_subagent vs authenticate_session:
           input: { target, reason },
           parentSubagentId: ctx.subagentId
         });
-        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(", ")}`);
+        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
+        });
         const rawSessionCreds = ctx.session.config?.authCredentials;
         const sessionCreds = rawSessionCreds ? Array.isArray(rawSessionCreds) ? rawSessionCreds[0] : rawSessionCreds : undefined;
         if (sessionCreds && !username && !apiKey && !tokens) {
-          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(", ")}`);
+          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
+          });
         }
         if (authHints) {
-          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(", ")}`);
-          }
+          log4.debug("Auth hints", {
+            authScheme: authHints.authScheme || "unknown",
+            csrfRequired: authHints.csrfRequired || false,
+            browserRequired: authHints.browserRequired || false,
+            protectedEndpoints: authHints.protectedEndpoints?.length ? authHints.protectedEndpoints : undefined
+          });
         }
         const credentials = mergeAuthCredentials(sessionCreds, {
           username,
@@ -111704,7 +111709,7 @@ When to use delegate_to_auth_subagent vs authenticate_session:
         if (credentials) {
           ctx.session.credentialManager.addFromAuthCredentials(credentials);
         }
-        const { runAuthenticationAgent } = await import("./authentication-0k43jay4.js");
+        const { runAuthenticationAgent } = await import("./authentication-c0aj9zaz.js");
         const localBus = new AgentEventBus;
         AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
         const result = await runAuthenticationAgent({
@@ -112333,6 +112338,9 @@ 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({
@@ -112381,7 +112389,7 @@ async function generateThreatModelForEndpoint(ctx, input) {
   return threatModelLimiter(async () => {
     if (ctx.abortSignal?.aborted)
       return null;
-    const { CodeAgent } = await import("./agent-84enr6xn.js");
+    const { CodeAgent } = await import("./agent-4g69jwmq.js");
     const subagentId = `threat-model-${sanitize(input.appName)}-${sanitize(input.routePath)}`;
     ctx.eventBus?.emit("subagent-spawn", {
       subagentId,
@@ -112436,7 +112444,7 @@ async function generateThreatModelForEndpoint(ctx, input) {
         status: "failed",
         parentSubagentId: ctx.subagentId
       });
-      console.error(`Threat model generation failed for ${input.routePath}: ${error instanceof Error ? error.message : String(error)}`);
+      log5.warn(`Threat model generation failed for ${input.routePath}: ${error instanceof Error ? error.message : String(error)}`);
       return null;
     }
   });
@@ -112835,6 +112843,10 @@ 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();
 
@@ -114222,9 +114234,12 @@ 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-x1tnsg7n.js");
+    const { FindingJudgeAgent } = await import("./agent-6nhperp2.js");
     const agent = new FindingJudgeAgent({
       finding: input,
       model: ctx.model,
@@ -114245,7 +114260,11 @@ async function judgeFinding(input, ctx) {
     return normalizeJudgeResult(result);
   } catch (err) {
     const fallback = createJudgeFailureResult(err, ctx.model);
-    console.error(`[FindingJudge] Agentic validation failed: model=${fallback.error?.model} type=${fallback.error?.type} message=${fallback.error?.message}`);
+    log6.warn("Agentic validation failed", {
+      model: fallback.error?.model,
+      type: fallback.error?.type,
+      message: fallback.error?.message
+    });
     return fallback;
   }
 }
@@ -114299,6 +114318,7 @@ 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"),
@@ -114888,9 +114908,7 @@ function preparePoc(input) {
   let pocContent = input.pocContent.trim();
   const portabilityWarnings = validatePocPortability(pocContent, input.pocType);
   if (portabilityWarnings.length > 0) {
-    console.warn(`[PoC Portability] Warnings for ${filename}:
-  ${portabilityWarnings.join(`
-  `)}`);
+    log7.warn(`PoC portability warnings for ${filename}: ${portabilityWarnings.join("; ")}`);
   }
   if (!pocContent.startsWith("#!")) {
     const shebangs = {
@@ -120066,6 +120084,9 @@ 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.
@@ -120102,7 +120123,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
       });
       if (cwd) {
         try {
-          const { WhiteboxAttackSurfaceAgent } = await import("./index-54ep0ery.js");
+          const { WhiteboxAttackSurfaceAgent } = await import("./index-3cbcjqw1.js");
           const localBus = new AgentEventBus;
           AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
           const agent = new WhiteboxAttackSurfaceAgent({
@@ -120121,8 +120142,7 @@ 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}` : ""})`
           })));
-          console.log(`
-✓ Whitebox attack surface complete: ${targets.length} targets from ${result.apps.length} apps`);
+          log8.info(`Whitebox attack surface complete: ${targets.length} targets from ${result.apps.length} apps`);
           ctx.eventBus?.emit("subagent-complete", {
             subagentId,
             status: "completed",
@@ -120138,7 +120158,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
           };
         } catch (error) {
           const errorMsg = error instanceof Error ? error.message : String(error);
-          console.error(`✗ Whitebox attack surface agent failed: ${errorMsg}`);
+          log8.error(`Whitebox attack surface agent failed: ${errorMsg}`);
           ctx.eventBus?.emit("subagent-complete", {
             subagentId,
             status: "failed",
@@ -120153,7 +120173,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         }
       }
       try {
-        const { BlackboxAttackSurfaceAgent } = await import("./blackboxAgent-76tnwwg7.js");
+        const { BlackboxAttackSurfaceAgent } = await import("./blackboxAgent-sgph70e4.js");
         const localBus = new AgentEventBus;
         AgentEventBus.attachChild(localBus, ctx.eventBus, subagentId);
         const agent = new BlackboxAttackSurfaceAgent({
@@ -120168,8 +120188,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         });
         const result = await agent.consume();
         const targetCount = result.targets.length;
-        console.log(`
-✓ Blackbox attack surface complete: ${targetCount} targets identified`);
+        log8.info(`Blackbox attack surface complete: ${targetCount} targets identified`);
         ctx.eventBus?.emit("subagent-complete", {
           subagentId,
           status: "completed",
@@ -120192,7 +120211,7 @@ should be passed directly to spawn_pentest_swarm for deep testing.`,
         };
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        console.error(`✗ Blackbox attack surface agent failed: ${errorMsg}`);
+        log8.error(`Blackbox attack surface agent failed: ${errorMsg}`);
         ctx.eventBus?.emit("subagent-complete", {
           subagentId,
           status: "failed",
@@ -120232,7 +120251,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-wy4eeagc.js");
+      const { runPentestWorkflow: workflow } = await import("./pentest-2vsjf0j8.js");
       if (!ctx.model) {
         return {
           success: false,
@@ -121808,7 +121827,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-84enr6xn.js");
+  const { CodeAgent } = await import("./agent-4g69jwmq.js");
   const subagentId = `coding-agent-${agentIndex}`;
   ctx.eventBus?.emit("subagent-spawn", {
     subagentId,
@@ -121855,8 +121874,11 @@ 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"],
@@ -122035,22 +122057,22 @@ class FindingsRegistry {
     if (!existsSync16(findingsPath))
       return registry;
     const files = readdirSync3(findingsPath).filter((f) => f.endsWith(".json"));
-    console.log(`[FindingsRegistry.fromDirectory] path=${findingsPath}, jsonFiles=${files.length}`);
+    log9.debug(`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);
-          console.log(`[FindingsRegistry.fromDirectory]   indexed: "${finding.title}" endpoint="${finding.endpoint}" (file=${file})`);
+          log9.debug(`fromDirectory: indexed "${finding.title}" endpoint="${finding.endpoint}" (file=${file})`);
         } else {
-          console.log(`[FindingsRegistry.fromDirectory]   skipped (missing title/endpoint): file=${file}`);
+          log9.debug(`fromDirectory: skipped (missing title/endpoint) file=${file}`);
         }
       } catch {
-        console.log(`[FindingsRegistry.fromDirectory]   skipped (malformed): file=${file}`);
+        log9.debug(`fromDirectory: skipped (malformed) file=${file}`);
       }
     }
-    console.log(`[FindingsRegistry.fromDirectory] Registry initialized: ${registry.size} findings indexed`);
+    log9.debug(`fromDirectory: registry initialized with ${registry.size} findings indexed`);
     return registry;
   }
   static fromFindings(findings, opts) {
@@ -122081,19 +122103,19 @@ class FindingsRegistry {
     return { duplicate: false };
   }
   async register(finding) {
-    console.log(`[FindingsRegistry.register] Checking: "${finding.title}" endpoint="${finding.endpoint}"`);
+    log9.debug(`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) {
-          console.log(`[FindingsRegistry.register] DUPLICATE (${check.matchType}): "${finding.title}" matched="${check.matchedFinding?.title}"`);
+          log9.debug(`register: DUPLICATE (${check.matchType}) "${finding.title}" matched="${check.matchedFinding?.title}"`);
           resolve6(check);
         } else if (!this.model || this.findings.length === 0) {
           this.indexFinding(finding);
-          console.log(`[FindingsRegistry.register] UNIQUE (Tier 1+2, no LLM needed): "${finding.title}" — registry size=${this.size}`);
+          log9.debug(`register: UNIQUE (Tier 1+2, no LLM needed) "${finding.title}" — registry size=${this.size}`);
           resolve6({ duplicate: false });
         } else {
-          console.log(`[FindingsRegistry.register] Tier 1+2 pass — proceeding to Tier 3 LLM check for "${finding.title}"`);
+          log9.debug(`register: Tier 1+2 pass — proceeding to Tier 3 LLM check for "${finding.title}"`);
           resolve6(null);
         }
       });
@@ -122105,21 +122127,21 @@ class FindingsRegistry {
     try {
       semanticResult = await this.semanticDedup(finding, snapshot);
     } catch {
-      console.log(`[FindingsRegistry.register] Tier 3 LLM error for "${finding.title}" — falling back to Tier 1+2 only`);
+      log9.warn(`register: Tier 3 LLM error for "${finding.title}" — falling back to Tier 1+2 only`);
     }
     if (semanticResult.duplicate) {
-      console.log(`[FindingsRegistry.register] DUPLICATE (semantic/Tier 3): "${finding.title}" matched="${semanticResult.matchedFinding?.title}"`);
+      log9.debug(`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) {
-          console.log(`[FindingsRegistry.register] DUPLICATE (race re-check, ${recheck.matchType}): "${finding.title}" matched="${recheck.matchedFinding?.title}"`);
+          log9.debug(`register: DUPLICATE (race re-check, ${recheck.matchType}) "${finding.title}" matched="${recheck.matchedFinding?.title}"`);
           resolve6(recheck);
         } else {
           this.indexFinding(finding);
-          console.log(`[FindingsRegistry.register] UNIQUE (all tiers passed): "${finding.title}" — registry size=${this.size}`);
+          log9.debug(`register: UNIQUE (all tiers passed) "${finding.title}" — registry size=${this.size}`);
           resolve6({ duplicate: false });
         }
       });
@@ -122176,7 +122198,7 @@ class FindingsRegistry {
         abortSignal: this.abortSignal
       });
     } catch {
-      console.log(`[FindingsRegistry.groupByRootCause] LLM error — skipping root-cause grouping`);
+      log9.warn("groupByRootCause: LLM error — skipping root-cause grouping");
       return [];
     }
     const sanitised = [];
@@ -122288,7 +122310,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-z8043nrm.js");
+      const { TargetedPentestAgent } = await import("./agent-x7n47c84.js");
       const findingsRegistry = ctx.findingsRegistry ?? FindingsRegistry.fromDirectory(ctx.session.findingsPath, {
         model: ctx.model,
         authConfig: ctx.authConfig,
@@ -122418,6 +122440,9 @@ ${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.
@@ -122439,7 +122464,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-wy4eeagc.js");
+      const { runPentestSwarm, DEFAULT_CONCURRENCY: DEFAULT_CONCURRENCY2 } = await import("./pentest-2vsjf0j8.js");
       if (!ctx.model) {
         return {
           success: false,
@@ -122452,8 +122477,7 @@ Pass every target you want tested — the swarm handles concurrency automaticall
         abortSignal: ctx.abortSignal
       });
       const total = targets.length;
-      console.log(`
-\uD83D\uDC1D Spawning pentest swarm: ${total} agents (concurrency: ${DEFAULT_CONCURRENCY2})`);
+      log10.info(`Spawning pentest swarm: ${total} agents (concurrency: ${DEFAULT_CONCURRENCY2})`);
       const swarmResults = await runPentestSwarm({
         targets,
         model: ctx.model,
@@ -122487,6 +122511,9 @@ 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')")
 });
@@ -122503,7 +122530,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);
-      console.error(`[submit_plan] enter: path=${planPath}`);
+      log11.debug(`enter: path=${planPath}`);
       const plan = readPlan(ctx.session.rootPath, scopeId);
       if (!plan || !plan.trim()) {
         return {
@@ -122512,7 +122539,7 @@ Only call this when the plan is complete and ready for review.`,
           path: planPath
         };
       }
-      console.error(`[submit_plan] done: planLen=${plan.length}`);
+      log11.debug(`done: planLen=${plan.length}`);
       return { success: true, error: "", path: planPath };
     }
   });
@@ -123071,9 +123098,12 @@ 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')")
@@ -123098,13 +123128,15 @@ Required plan sections:
       const scopeId = ctx.planSubagentId ?? ctx.subagentId;
       const planPath = planFilePath(ctx.session.rootPath, scopeId);
       mkdirSync12(dirname4(planPath), { recursive: true });
-      console.error(`[write_plan] enter: contentLen=${content.length}, path=${planPath}`);
+      log12.debug(`enter: contentLen=${content.length}, path=${planPath}`);
       try {
         await writeFile5(planPath, content, "utf-8");
-        console.error(`[write_plan] done`);
+        log12.debug("done");
         return { success: true, error: "", path: planPath };
       } catch (err) {
-        console.error(`[write_plan] error: ${err}`);
+        log12.error("write failed", err instanceof Error ? err : undefined, {
+          error: String(err)
+        });
         return {
           success: false,
           error: err instanceof Error ? err.message : String(err),
@@ -124324,9 +124356,10 @@ class StepTraceWriter {
 // src/core/agents/offSecAgent/offensiveSecurityAgent.ts
 init_dist();
 init_ai();
-import { existsSync as existsSync19, mkdirSync as mkdirSync14 } from "fs";
+import { existsSync as existsSync18, 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
@@ -124602,510 +124635,11 @@ var OperatorSettingsObject = exports_external.object({
   initialMode: exports_external.enum(["plan", "manual", "auto"]).default("manual"),
   requireApproval: exports_external.boolean().default(true)
 });
-// 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
+init_session();
+init_lazyLogger();
+var log13 = scopedLogger(() => createLogger("approval-gate"));
+
 class OffensiveSecurityAgent {
   _streamResult = null;
   createStream;
@@ -125238,7 +124772,7 @@ class OffensiveSecurityAgent {
       const planSet = new Set(PLAN_MODE_TOOL_NAMES);
       activeTools = activeTools.filter((t) => planSet.has(t));
     }
-    if (!existsSync19(messagesDir)) {
+    if (!existsSync18(messagesDir)) {
       mkdirSync14(messagesDir, { recursive: true });
     }
     const messagesPath = join25(messagesDir, "messages.json");
@@ -125409,19 +124943,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)}`;
-        console.error(`[approval-gate] ${name} (${toolCallId}): checking`);
+        log13.debug(`${name} (${toolCallId}): checking`);
         try {
           await gate.check(name, String(toolCallId), args);
         } catch (err) {
           if (err instanceof ApprovalDeniedError) {
-            console.error(`[approval-gate] ${name} (${toolCallId}): denied`);
+            log13.debug(`${name} (${toolCallId}): denied`);
             return { blocked: true, reason: "Denied by operator" };
           }
           throw err;
         }
-        console.error(`[approval-gate] ${name} (${toolCallId}): approved, executing`);
+        log13.debug(`${name} (${toolCallId}): approved, executing`);
         const result = await originalExecute(args, options);
-        console.error(`[approval-gate] ${name} (${toolCallId}): execute finished`);
+        log13.debug(`${name} (${toolCallId}): execute finished`);
         return result;
       }
     };
@@ -125429,4 +124963,4 @@ function wrapToolsWithApprovalGate(tools, gate, exemptToolNames) {
   return wrapped;
 }
 
-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 };
+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 };