@fro.bot/systematic 3.15.1 → 3.16.1

package/dist/index.js

@@ -8,9 +8,10 @@ import {
   _enum,
   AgentOverlaySchema,
   CategoryOverlaySchema,
+  isRecord,
+  resolveRouting,
   loadConfig,
   loadConfigWithSources,
-  isRecord,
   isDiscoverableMarkdown,
   findAgentsInDir,
   extractAgentFrontmatter,
@@ -18,7 +19,7 @@ import {
   extractCommandFrontmatter,
   findSkillsInDir,
   discoverSkills
-} from "./index-7cyxcwf5.js";
+} from "./index-ae6mhwth.js";
 
 // src/index.ts
 import { createHash as createHash4 } from "crypto";
@@ -482,7 +483,7 @@ function loadSkillAsCommand(loaded) {
     config.subtask = loaded.subtask;
   return config;
 }
-function collectAgents(dir, disabledAgents, nativeAgents, overlays) {
+function collectAgents(dir, disabledAgents, nativeAgents, overlays, rawOverlays) {
   const agents = {};
   const agentList = findAgentsInDir(dir);
   const disabledSet = new Set(disabledAgents);
@@ -497,12 +498,16 @@ function collectAgents(dir, disabledAgents, nativeAgents, overlays) {
       continue;
     const config = loadAgentAsConfig(agentInfo);
     if (config) {
-      agents[agentInfo.name] = applyAgentOverlays(config, agentInfo, overlays);
+      agents[agentInfo.name] = applyAgentOverlays(config, agentInfo, overlays, rawOverlays);
     }
   }
   return agents;
 }
-function applyAgentOverlays(config, agentInfo, overlays) {
+var EMPTY_PI_SUBAGENTS_OVERLAYS = {
+  agents: {},
+  categories: {}
+};
+function applyAgentOverlays(config, agentInfo, overlays, rawOverlays) {
   const id = agentInfo.category ? `${agentInfo.category}/${agentInfo.name}` : agentInfo.name;
   const categoryOverlay = agentInfo.category ? overlays.categoriesByKey.get(agentInfo.category) : undefined;
   const exactOverlay = overlays.agentsByTargetId.get(id);
@@ -512,15 +517,40 @@ function applyAgentOverlays(config, agentInfo, overlays) {
   if (hasPermissionOverlay && isRecord(config.permission)) {
     addPermissionRules(permissionRules, config.permission);
   }
-  applyAgentOverlay(result, categoryOverlay?.value, permissionRules);
-  applyAgentOverlay(result, exactOverlay?.value, permissionRules);
+  const routing = resolveRouting({
+    overlays: rawOverlays,
+    piSubagentsOverlays: EMPTY_PI_SUBAGENTS_OVERLAYS,
+    target: { agentKey: agentInfo.name, category: agentInfo.category ?? "" },
+    harness: "opencode"
+  });
+  applyAgentOverlayPass(result, categoryOverlay?.value, permissionRules, routing, "category");
+  applyAgentOverlayPass(result, exactOverlay?.value, permissionRules, routing, "agent");
   applyPermissionOverlay(result, permissionRules, hasPermissionOverlay);
   return result;
 }
-function applyAgentOverlay(target, overlay, permissionRules) {
+function applyAgentOverlayPass(target, overlay, permissionRules, routing, level) {
+  if (routing.source.model?.level === level) {
+    applyRoutingModel(target, routing.model);
+  }
+  if (routing.source.qualifier?.level === level) {
+    target.variant = routing.qualifier;
+  }
   if (overlay === undefined)
     return;
-  applyOverlayObjectWithVariantClearing(target, overlay, permissionRules);
+  applyOverlayObjectFields(target, overlay);
+  if (isRecord(overlay.permission)) {
+    addPermissionRules(permissionRules, overlay.permission);
+  }
+  if (Array.isArray(overlay.skills)) {
+    addManagedSkillRules(permissionRules, overlay.skills);
+  }
+}
+function applyRoutingModel(target, model) {
+  if (model === null) {
+    delete target.model;
+  } else if (model !== undefined) {
+    target.model = model;
+  }
 }
 function applyPermissionOverlay(target, permissionRules, hasPermissionOverlay) {
   if (!hasPermissionOverlay)
@@ -536,8 +566,6 @@ function overlayControlsPermission(overlay) {
   return overlay !== undefined && (Object.hasOwn(overlay, "permission") || Object.hasOwn(overlay, "skills"));
 }
 var OVERLAY_ASSIGN_FIELDS = [
-  "model",
-  "variant",
   "temperature",
   "top_p",
   "mode",
@@ -545,27 +573,12 @@ var OVERLAY_ASSIGN_FIELDS = [
   "steps",
   "hidden"
 ];
-function applyOverlayObjectWithVariantClearing(target, overlay, permissionRules) {
-  const overlayHasModel = Object.hasOwn(overlay, "model");
-  const overlayHasVariant = Object.hasOwn(overlay, "variant");
-  if (overlayHasModel && !overlayHasVariant) {
-    delete target.variant;
-  }
+function applyOverlayObjectFields(target, overlay) {
   for (const field of OVERLAY_ASSIGN_FIELDS) {
     if (Object.hasOwn(overlay, field)) {
-      if (field === "model" && overlay[field] === null) {
-        delete target[field];
-      } else {
-        target[field] = overlay[field];
-      }
+      target[field] = overlay[field];
     }
   }
-  if (isRecord(overlay.permission)) {
-    addPermissionRules(permissionRules, overlay.permission);
-  }
-  if (Array.isArray(overlay.skills)) {
-    addManagedSkillRules(permissionRules, overlay.skills);
-  }
 }
 function createPermissionRuleAccumulator() {
   return new Map;
@@ -708,7 +721,7 @@ function createConfigHandler(deps) {
       enabledSkills: enabledSkillNames
     });
     const resolvedOverlays = resolveAgentOverlaySet(validatedOverlays);
-    const bundledAgents = collectAgents(bundledAgentsDir, systematicConfig.disabled_agents, nativeAgents, resolvedOverlays);
+    const bundledAgents = collectAgents(bundledAgentsDir, systematicConfig.disabled_agents, nativeAgents, resolvedOverlays, overlays);
     const bundledCommands = collectCommands(bundledCommandsDir, systematicConfig.disabled_commands);
     const discoveredSkillCommands = systematicConfig.skills_as_commands !== false ? collectDiscoveredSkillsAsCommands(directory, homeDir, opencodeConfigDir, opencodeConfigDirOverride, systematicConfig.disabled_commands) : {};
     const bundledAgentKeys = new Set(Object.keys(bundledAgents));
@@ -3992,7 +4005,7 @@ import { randomBytes as randomBytes3 } from "crypto";
 import fs7 from "fs";
 import { fileURLToPath } from "url";
 
-// node_modules/.bun/web-tree-sitter@0.26.12/node_modules/web-tree-sitter/web-tree-sitter.js
+// node_modules/.bun/web-tree-sitter@0.27.0/node_modules/web-tree-sitter/web-tree-sitter.js
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var Edit = class {
@@ -4097,44 +4110,65 @@ function setModule(module2) {
 }
 __name(setModule, "setModule");
 var C;
+function newFinalizer(handler) {
+  try {
+    return new FinalizationRegistry(handler);
+  } catch (e) {
+    console.error("Unsupported FinalizationRegistry:", e);
+    return;
+  }
+}
+__name(newFinalizer, "newFinalizer");
+var finalizer = newFinalizer((address) => {
+  C._ts_lookahead_iterator_delete(address);
+});
 var LookaheadIterator = class {
   static {
     __name(this, "LookaheadIterator");
   }
   [0] = 0;
   language;
+  positioned = false;
   constructor(internal, address, language) {
     assertInternal(internal);
     this[0] = address;
     this.language = language;
+    finalizer?.register(this, address, this);
   }
   get currentTypeId() {
-    return C._ts_lookahead_iterator_current_symbol(this[0]);
+    return this.positioned ? C._ts_lookahead_iterator_current_symbol(this[0]) : null;
   }
   get currentType() {
-    return this.language.types[this.currentTypeId] || "ERROR";
+    const id = this.currentTypeId;
+    if (id === null)
+      return null;
+    return this.language.types[id] ?? C.UTF8ToString(C._ts_language_symbol_name(this.language[0], id));
   }
   delete() {
+    finalizer?.unregister(this);
     C._ts_lookahead_iterator_delete(this[0]);
     this[0] = 0;
   }
   reset(language, stateId) {
     if (C._ts_lookahead_iterator_reset(this[0], language[0], stateId)) {
       this.language = language;
+      this.positioned = false;
       return true;
     }
     return false;
   }
   resetState(stateId) {
-    return Boolean(C._ts_lookahead_iterator_reset_state(this[0], stateId));
+    if (!C._ts_lookahead_iterator_reset_state(this[0], stateId))
+      return false;
+    this.positioned = false;
+    return true;
   }
   [Symbol.iterator]() {
     return {
       next: /* @__PURE__ */ __name(() => {
-        if (C._ts_lookahead_iterator_next(this[0])) {
-          return { done: false, value: this.currentType };
-        }
-        return { done: true, value: "" };
+        this.positioned = Boolean(C._ts_lookahead_iterator_next(this[0]));
+        const value = this.currentType;
+        return value === null ? { done: true, value: "" } : { done: false, value };
       }, "next")
     };
   }
@@ -4160,6 +4194,9 @@ function getText(tree, startIndex, endIndex, startPosition) {
   return result ?? "";
 }
 __name(getText, "getText");
+var finalizer2 = newFinalizer((address) => {
+  C._ts_tree_delete(address);
+});
 var Tree = class _Tree {
   static {
     __name(this, "Tree");
@@ -4172,12 +4209,14 @@ var Tree = class _Tree {
     this[0] = address;
     this.language = language;
     this.textCallback = textCallback;
+    finalizer2?.register(this, address, this);
   }
   copy() {
     const address = C._ts_tree_copy(this[0]);
     return new _Tree(INTERNAL, address, this.language, this.textCallback);
   }
   delete() {
+    finalizer2?.unregister(this);
     C._ts_tree_delete(this[0]);
     this[0] = 0;
   }
@@ -4233,6 +4272,9 @@ var Tree = class _Tree {
     return result;
   }
 };
+var finalizer3 = newFinalizer((address) => {
+  C._ts_tree_cursor_delete_wasm(address);
+});
 var TreeCursor = class _TreeCursor {
   static {
     __name(this, "TreeCursor");
@@ -4246,6 +4288,7 @@ var TreeCursor = class _TreeCursor {
     assertInternal(internal);
     this.tree = tree;
     unmarshalTreeCursor(this);
+    finalizer3?.register(this, this.tree[0], this);
   }
   copy() {
     const copy = new _TreeCursor(INTERNAL, this.tree);
@@ -4254,6 +4297,7 @@ var TreeCursor = class _TreeCursor {
     return copy;
   }
   delete() {
+    finalizer3?.unregister(this);
     marshalTreeCursor(this);
     C._ts_tree_cursor_delete_wasm(this.tree[0]);
     this[0] = this[1] = this[2] = 0;
@@ -5013,16 +5057,23 @@ ${body2}`);
       }
     }
     const mod = await C.loadWebAssemblyModule(binary2, { loadAsync: true });
+    return _Language.loadFromWasmExports(mod, { sync: false });
+  }
+  static loadFromWasmExports(mod, { sync }) {
     const symbolNames = Object.keys(mod);
     const functionName = symbolNames.find((key) => LANGUAGE_FUNCTION_REGEX.test(key) && !key.includes("external_scanner_"));
     if (!functionName) {
       console.log(`Couldn't find language function in Wasm file. Symbols:
 ${JSON.stringify(symbolNames, null, 2)}`);
-      throw new Error("Language.load failed: no language function found in Wasm file");
+      throw new Error(`Language.${sync ? "loadSync" : "load"} failed: no language function found in Wasm file`);
     }
     const languageAddress = mod[functionName]();
     return new _Language(INTERNAL, languageAddress);
   }
+  static loadSync(wasmModule) {
+    const mod = C.loadWebAssemblyModule(wasmModule, { loadAsync: false });
+    return _Language.loadFromWasmExports(mod, { sync: true });
+  }
 };
 async function Module2(moduleArg = {}) {
   var moduleRtn;
@@ -5542,7 +5593,7 @@ async function Module2(moduleArg = {}) {
       newDSO("__main__", 0, wasmImports);
     }
   };
-  var ___heap_base = 78240;
+  var ___heap_base = 82240;
   var alignMemory = /* @__PURE__ */ __name((size, alignment) => Math.ceil(size / alignment) * alignment, "alignMemory");
   var getMemory = /* @__PURE__ */ __name((size) => {
     if (runtimeInitialized) {
@@ -6068,12 +6119,12 @@ async function Module2(moduleArg = {}) {
     value: "i32",
     mutable: false
   }, 1024);
-  var ___stack_high = 78240;
-  var ___stack_low = 12704;
+  var ___stack_high = 82240;
+  var ___stack_low = 16704;
   var ___stack_pointer = new WebAssembly.Global({
     value: "i32",
     mutable: true
-  }, 78240);
+  }, 82240);
   var ___table_base = new WebAssembly.Global({
     value: "i32",
     mutable: false
@@ -6340,7 +6391,7 @@ async function Module2(moduleArg = {}) {
   Module["loadWebAssemblyModule"] = loadWebAssemblyModule;
   Module["LE_HEAP_STORE_I64"] = LE_HEAP_STORE_I64;
   var ASM_CONSTS = {};
-  var _malloc, _calloc, _realloc, _free, _ts_range_edit, _memcmp, _ts_language_symbol_count, _ts_language_state_count, _ts_language_abi_version, _ts_language_name, _ts_language_field_count, _ts_language_next_state, _ts_language_symbol_name, _ts_language_symbol_for_name, _strncmp, _ts_language_symbol_type, _ts_language_field_name_for_id, _ts_lookahead_iterator_new, _ts_lookahead_iterator_delete, _ts_lookahead_iterator_reset_state, _ts_lookahead_iterator_reset, _ts_lookahead_iterator_next, _ts_lookahead_iterator_current_symbol, _ts_point_edit, _ts_parser_delete, _ts_parser_reset, _ts_parser_set_language, _ts_parser_set_included_ranges, _ts_query_new, _ts_query_delete, _iswspace, _iswalnum, _ts_query_pattern_count, _ts_query_capture_count, _ts_query_string_count, _ts_query_capture_name_for_id, _ts_query_capture_quantifier_for_id, _ts_query_string_value_for_id, _ts_query_predicates_for_pattern, _ts_query_start_byte_for_pattern, _ts_query_end_byte_for_pattern, _ts_query_is_pattern_rooted, _ts_query_is_pattern_non_local, _ts_query_is_pattern_guaranteed_at_step, _ts_query_disable_capture, _ts_query_disable_pattern, _ts_tree_copy, _ts_tree_delete, _ts_init, _ts_parser_new_wasm, _ts_parser_enable_logger_wasm, _ts_parser_parse_wasm, _ts_parser_included_ranges_wasm, _ts_language_type_is_named_wasm, _ts_language_type_is_visible_wasm, _ts_language_metadata_wasm, _ts_language_supertypes_wasm, _ts_language_subtypes_wasm, _ts_tree_root_node_wasm, _ts_tree_root_node_with_offset_wasm, _ts_tree_edit_wasm, _ts_tree_included_ranges_wasm, _ts_tree_get_changed_ranges_wasm, _ts_tree_cursor_new_wasm, _ts_tree_cursor_copy_wasm, _ts_tree_cursor_delete_wasm, _ts_tree_cursor_reset_wasm, _ts_tree_cursor_reset_to_wasm, _ts_tree_cursor_goto_first_child_wasm, _ts_tree_cursor_goto_last_child_wasm, _ts_tree_cursor_goto_first_child_for_index_wasm, _ts_tree_cursor_goto_first_child_for_position_wasm, _ts_tree_cursor_goto_next_sibling_wasm, _ts_tree_cursor_goto_previous_sibling_wasm, _ts_tree_cursor_goto_descendant_wasm, _ts_tree_cursor_goto_parent_wasm, _ts_tree_cursor_current_node_type_id_wasm, _ts_tree_cursor_current_node_state_id_wasm, _ts_tree_cursor_current_node_is_named_wasm, _ts_tree_cursor_current_node_is_missing_wasm, _ts_tree_cursor_current_node_id_wasm, _ts_tree_cursor_start_position_wasm, _ts_tree_cursor_end_position_wasm, _ts_tree_cursor_start_index_wasm, _ts_tree_cursor_end_index_wasm, _ts_tree_cursor_current_field_id_wasm, _ts_tree_cursor_current_depth_wasm, _ts_tree_cursor_current_descendant_index_wasm, _ts_tree_cursor_current_node_wasm, _ts_node_symbol_wasm, _ts_node_field_name_for_child_wasm, _ts_node_field_name_for_named_child_wasm, _ts_node_children_by_field_id_wasm, _ts_node_first_child_for_byte_wasm, _ts_node_first_named_child_for_byte_wasm, _ts_node_grammar_symbol_wasm, _ts_node_child_count_wasm, _ts_node_named_child_count_wasm, _ts_node_child_wasm, _ts_node_named_child_wasm, _ts_node_child_by_field_id_wasm, _ts_node_next_sibling_wasm, _ts_node_prev_sibling_wasm, _ts_node_next_named_sibling_wasm, _ts_node_prev_named_sibling_wasm, _ts_node_descendant_count_wasm, _ts_node_parent_wasm, _ts_node_child_with_descendant_wasm, _ts_node_descendant_for_index_wasm, _ts_node_named_descendant_for_index_wasm, _ts_node_descendant_for_position_wasm, _ts_node_named_descendant_for_position_wasm, _ts_node_start_point_wasm, _ts_node_end_point_wasm, _ts_node_start_index_wasm, _ts_node_end_index_wasm, _ts_node_to_string_wasm, _ts_node_children_wasm, _ts_node_named_children_wasm, _ts_node_descendants_of_type_wasm, _ts_node_is_named_wasm, _ts_node_has_changes_wasm, _ts_node_has_error_wasm, _ts_node_is_error_wasm, _ts_node_is_missing_wasm, _ts_node_is_extra_wasm, _ts_node_parse_state_wasm, _ts_node_next_parse_state_wasm, _ts_query_matches_wasm, _ts_query_captures_wasm, _memset, _memcpy, _memmove, _iswalpha, _iswblank, _iswdigit, _iswlower, _iswupper, _iswxdigit, _memchr, _strlen, _strcmp, _strncat, _strncpy, _towlower, _towupper, _setThrew, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, ___wasm_apply_data_relocs;
+  var _malloc, _calloc, _realloc, _free, _ts_range_edit, _memcmp, _ts_language_symbol_count, _ts_language_state_count, _ts_language_abi_version, _ts_language_name, _ts_language_field_count, _ts_language_next_state, _ts_language_symbol_name, _ts_language_symbol_for_name, _strncmp, _ts_language_symbol_type, _ts_language_field_name_for_id, _ts_lookahead_iterator_new, _ts_lookahead_iterator_delete, _ts_lookahead_iterator_reset_state, _ts_lookahead_iterator_reset, _ts_lookahead_iterator_next, _ts_lookahead_iterator_current_symbol, _ts_point_edit, _ts_parser_delete, _ts_parser_reset, _ts_parser_set_language, _ts_parser_set_included_ranges, _ts_query_new, _ts_query_delete, _iswspace, _iswalnum, _ts_query_copy, _ts_query_pattern_count, _ts_query_capture_count, _ts_query_string_count, _ts_query_capture_name_for_id, _ts_query_capture_quantifier_for_id, _ts_query_string_value_for_id, _ts_query_predicates_for_pattern, _ts_query_start_byte_for_pattern, _ts_query_end_byte_for_pattern, _ts_query_is_pattern_rooted, _ts_query_is_pattern_non_local, _ts_query_is_pattern_guaranteed_at_step, _ts_query_disable_capture, _ts_query_disable_pattern, _ts_tree_copy, _ts_tree_delete, _ts_init, _ts_parser_new_wasm, _ts_parser_enable_logger_wasm, _ts_parser_parse_wasm, _ts_parser_included_ranges_wasm, _ts_language_type_is_named_wasm, _ts_language_type_is_visible_wasm, _ts_language_metadata_wasm, _ts_language_supertypes_wasm, _ts_language_subtypes_wasm, _ts_tree_root_node_wasm, _ts_tree_root_node_with_offset_wasm, _ts_tree_edit_wasm, _ts_tree_included_ranges_wasm, _ts_tree_get_changed_ranges_wasm, _ts_tree_cursor_new_wasm, _ts_tree_cursor_copy_wasm, _ts_tree_cursor_delete_wasm, _ts_tree_cursor_reset_wasm, _ts_tree_cursor_reset_to_wasm, _ts_tree_cursor_goto_first_child_wasm, _ts_tree_cursor_goto_last_child_wasm, _ts_tree_cursor_goto_first_child_for_index_wasm, _ts_tree_cursor_goto_first_child_for_position_wasm, _ts_tree_cursor_goto_next_sibling_wasm, _ts_tree_cursor_goto_previous_sibling_wasm, _ts_tree_cursor_goto_descendant_wasm, _ts_tree_cursor_goto_parent_wasm, _ts_tree_cursor_current_node_type_id_wasm, _ts_tree_cursor_current_node_state_id_wasm, _ts_tree_cursor_current_node_is_named_wasm, _ts_tree_cursor_current_node_is_missing_wasm, _ts_tree_cursor_current_node_id_wasm, _ts_tree_cursor_start_position_wasm, _ts_tree_cursor_end_position_wasm, _ts_tree_cursor_start_index_wasm, _ts_tree_cursor_end_index_wasm, _ts_tree_cursor_current_field_id_wasm, _ts_tree_cursor_current_depth_wasm, _ts_tree_cursor_current_descendant_index_wasm, _ts_tree_cursor_current_node_wasm, _ts_node_symbol_wasm, _ts_node_field_name_for_child_wasm, _ts_node_field_name_for_named_child_wasm, _ts_node_children_by_field_id_wasm, _ts_node_first_child_for_byte_wasm, _ts_node_first_named_child_for_byte_wasm, _ts_node_grammar_symbol_wasm, _ts_node_child_count_wasm, _ts_node_named_child_count_wasm, _ts_node_child_wasm, _ts_node_named_child_wasm, _ts_node_child_by_field_id_wasm, _ts_node_next_sibling_wasm, _ts_node_prev_sibling_wasm, _ts_node_next_named_sibling_wasm, _ts_node_prev_named_sibling_wasm, _ts_node_descendant_count_wasm, _ts_node_parent_wasm, _ts_node_child_with_descendant_wasm, _ts_node_descendant_for_index_wasm, _ts_node_named_descendant_for_index_wasm, _ts_node_descendant_for_position_wasm, _ts_node_named_descendant_for_position_wasm, _ts_node_start_point_wasm, _ts_node_end_point_wasm, _ts_node_start_index_wasm, _ts_node_end_index_wasm, _ts_node_to_string_wasm, _ts_node_children_wasm, _ts_node_named_children_wasm, _ts_node_descendants_of_type_wasm, _ts_node_is_named_wasm, _ts_node_has_changes_wasm, _ts_node_has_error_wasm, _ts_node_is_error_wasm, _ts_node_is_missing_wasm, _ts_node_is_extra_wasm, _ts_node_parse_state_wasm, _ts_node_next_parse_state_wasm, _ts_query_matches_wasm, _ts_query_captures_wasm, _memset, _memcpy, _memmove, _iswalpha, _iswblank, _iswdigit, _iswlower, _iswpunct, _iswupper, _iswxdigit, _memchr, _strlen, _strcmp, _strncat, _strncpy, _towlower, _towupper, _setThrew, __emscripten_stack_restore, __emscripten_stack_alloc, _emscripten_stack_get_current, ___wasm_apply_data_relocs;
   function assignWasmExports(wasmExports2) {
     Module["_malloc"] = _malloc = wasmExports2["malloc"];
     Module["_calloc"] = _calloc = wasmExports2["calloc"];
@@ -6374,6 +6425,7 @@ async function Module2(moduleArg = {}) {
     Module["_ts_query_delete"] = _ts_query_delete = wasmExports2["ts_query_delete"];
     Module["_iswspace"] = _iswspace = wasmExports2["iswspace"];
     Module["_iswalnum"] = _iswalnum = wasmExports2["iswalnum"];
+    Module["_ts_query_copy"] = _ts_query_copy = wasmExports2["ts_query_copy"];
     Module["_ts_query_pattern_count"] = _ts_query_pattern_count = wasmExports2["ts_query_pattern_count"];
     Module["_ts_query_capture_count"] = _ts_query_capture_count = wasmExports2["ts_query_capture_count"];
     Module["_ts_query_string_count"] = _ts_query_string_count = wasmExports2["ts_query_string_count"];
@@ -6479,6 +6531,7 @@ async function Module2(moduleArg = {}) {
     Module["_iswblank"] = _iswblank = wasmExports2["iswblank"];
     Module["_iswdigit"] = _iswdigit = wasmExports2["iswdigit"];
     Module["_iswlower"] = _iswlower = wasmExports2["iswlower"];
+    Module["_iswpunct"] = _iswpunct = wasmExports2["iswpunct"];
     Module["_iswupper"] = _iswupper = wasmExports2["iswupper"];
     Module["_iswxdigit"] = _iswxdigit = wasmExports2["iswxdigit"];
     Module["_memchr"] = _memchr = wasmExports2["memchr"];
@@ -6598,6 +6651,10 @@ __name(checkModule, "checkModule");
 var TRANSFER_BUFFER;
 var LANGUAGE_VERSION;
 var MIN_COMPATIBLE_VERSION;
+var finalizer4 = newFinalizer((addresses) => {
+  C._ts_parser_delete(addresses[0]);
+  C._free(addresses[1]);
+});
 var Parser = class {
   static {
     __name(this, "Parser");
@@ -6614,6 +6671,7 @@ var Parser = class {
   }
   constructor() {
     this.initialize();
+    finalizer4?.register(this, [this[0], this[1]], this);
   }
   initialize() {
     if (!checkModule()) {
@@ -6624,6 +6682,7 @@ var Parser = class {
     this[1] = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
   }
   delete() {
+    finalizer4?.unregister(this);
     C._ts_parser_delete(this[0]);
     C._free(this[1]);
     this[0] = 0;
@@ -6754,6 +6813,10 @@ var QueryError = class _QueryError extends Error {
     this.length = length;
     this.name = "QueryError";
   }
+  kind;
+  info;
+  index;
+  length;
   static {
     __name(this, "QueryError");
   }
@@ -6937,6 +7000,9 @@ function parsePattern(index, stepType, stepValueId, captureNames, stringValues,
   }
 }
 __name(parsePattern, "parsePattern");
+var finalizer5 = newFinalizer((address) => {
+  C._ts_query_delete(address);
+});
 var Query = class {
   static {
     __name(this, "Query");
@@ -7036,8 +7102,10 @@ var Query = class {
     this.assertedProperties = assertedProperties;
     this.refutedProperties = refutedProperties;
     this.exceededMatchLimit = false;
+    finalizer5?.register(this, address, this);
   }
   delete() {
+    finalizer5?.unregister(this);
     C._ts_query_delete(this[0]);
     this[0] = 0;
   }

package/dist/lib/agent-resolver.d.ts

@@ -1,7 +1,7 @@
 /** Runtime persona catalog for `systematic_delegate`. Pi has no agent-discovery of its own, so category is dropped when flattening `agents/<category>/<name>.md` into this catalog. */
 /** A single resolved persona entry in the flattened catalog. */
 export interface AgentCatalogEntry {
-    /** Flat persona name (category dropped). */
+    /** Flat persona name (category dropped). Used for dispatch matching (`resolveAgent`); may differ from `key` if frontmatter `name` and the file stem diverge. */
     name: string;
     /** Human-readable description, used in tool description/parameter hints. */
     description: string;
@@ -9,6 +9,12 @@ export interface AgentCatalogEntry {
     body: string;
     /** Raw comma-separated `tools:` frontmatter value, if declared. Undefined = not declared. */
     toolsSource: string | undefined;
+    /** The agent's source file stem (filename without `.md`), used to key into `agents.<key>` overlays for routing (distinct from the display `name`). */
+    key: string;
+    /** The agent's category (source subdirectory name), used to key into `categories.<category>` overlays. `''` when the file has no category subdirectory -- the same no-category sentinel `config-handler.ts` and `pi-subagents-export.ts` use. */
+    category: string;
+    /** Qualified `category/key` id, mirroring `agent-overlays.ts`'s target-id convention, for callers that want a single stable identity. */
+    id: string;
 }
 /** Fails closed if the same persona name appears under more than one category. */
 export declare function buildAgentCatalog(agentsDir: string): AgentCatalogEntry[];

package/dist/lib/capability-snapshot.d.ts

@@ -3,7 +3,7 @@ declare const CAPABILITY_SNAPSHOT_COMMAND: 'systematic capabilities';
 declare const CAPABILITY_SOURCE_IDS: readonly ['config:custom', 'config:global', 'config:project', 'config:user', 'discovery:agents', 'discovery:skills', 'host:runtime', 'package'];
 declare const CONFIG_SOURCE_KINDS: readonly ['custom', 'project', 'user'];
 declare const CONFIG_AUTHORITY_FIELD_PATHS: readonly ['bootstrap.enabled', 'bootstrap.file', 'skills_as_commands', 'workflow_guard.debug', 'workflow_guard.mode'];
-declare const CONFIG_PROTECTED_FIELD_PATHS: readonly ['workflow_guard', 'agents.*.model', 'agents.*.permission', 'agents.*.skills', 'agents.*.variant', 'categories.*.model', 'categories.*.permission', 'categories.*.skills', 'categories.*.variant'];
+declare const CONFIG_PROTECTED_FIELD_PATHS: readonly ['workflow_guard', 'profiles', 'agents.*.model', 'agents.*.permission', 'agents.*.skills', 'agents.*.variant', 'agents.*.opencode', 'agents.*.pi', 'categories.*.model', 'categories.*.permission', 'categories.*.skills', 'categories.*.variant', 'categories.*.opencode', 'categories.*.pi'];
 declare const CONFIG_SOURCE_ERROR_CODES: readonly ['parse-failed', 'read-failed', 'schema-invalid', 'source-invalid'];
 declare const CAPABILITY_SOURCE_PRESENCE: readonly ['absent', 'invalid', 'present'];
 declare const CAPABILITY_STATUSES: readonly ['available', 'unknown', 'unavailable'];

package/dist/lib/config-schema.d.ts

@@ -54,6 +54,22 @@ export declare const AgentOverlaySchema: z.ZodObject<{
         ask: "ask";
         deny: "deny";
     }>>]>>>;
+    opencode: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pi: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        thinking: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            off: "off";
+            xhigh: "xhigh";
+        }>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const CategoryOverlaySchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -86,6 +102,52 @@ export declare const CategoryOverlaySchema: z.ZodObject<{
         ask: "ask";
         deny: "deny";
     }>>]>>>;
+    opencode: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pi: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        thinking: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            off: "off";
+            xhigh: "xhigh";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * Routing-only projection of the agent/category overlay fields, permitted
+ * inside a named `profiles` bundle. Deliberately excludes every non-routing
+ * field (`mode`, `color`, `steps`, `hidden`, `disable`, `skills`,
+ * `permission`) so a profile cannot smuggle in UI/execution/permission
+ * changes through the profile-selection mechanism — only the fields a
+ * profile exists to carry: model, variant/thinking, and sampling knobs.
+ */
+export declare const ProfileOverlaySchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    variant: z.ZodOptional<z.ZodString>;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    top_p: z.ZodOptional<z.ZodNumber>;
+    opencode: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pi: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        thinking: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            max: "max";
+            medium: "medium";
+            minimal: "minimal";
+            off: "off";
+            xhigh: "xhigh";
+        }>>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export declare const PiSubagentsAgentOverlaySchema: z.ZodObject<{
     thinking: z.ZodOptional<z.ZodEnum<{
@@ -201,4 +263,4 @@ export declare function validateConfig(input: unknown): ValidationResult;
  *
  * Matches the hand-coded `SECURITY_OVERLAY_FIELDS` set in `src/lib/config.ts`.
  */
-export declare const SECURITY_OVERLAY_FIELDS: readonly ['model', 'variant', 'skills', 'permission'];
+export declare const SECURITY_OVERLAY_FIELDS: readonly ['model', 'variant', 'skills', 'permission', 'opencode', 'pi'];

package/dist/lib/config.d.ts

@@ -1,3 +1,4 @@
+import { type RoutingTarget } from './routing-resolver.js';
 export interface BootstrapConfig {
     enabled: boolean;
     file?: string;
@@ -19,7 +20,7 @@ export interface SourcedOverlayConfigMap {
     categories: Record<string, SourcedOverlayConfig>;
 }
 export declare const CONFIG_AUTHORITY_FIELD_PATHS: readonly ['bootstrap.enabled', 'bootstrap.file', 'skills_as_commands', 'workflow_guard.debug', 'workflow_guard.mode'];
-export declare const CONFIG_PROTECTED_FIELD_PATHS: readonly ['workflow_guard', 'agents.*.model', 'agents.*.permission', 'agents.*.skills', 'agents.*.variant', 'categories.*.model', 'categories.*.permission', 'categories.*.skills', 'categories.*.variant'];
+export declare const CONFIG_PROTECTED_FIELD_PATHS: readonly ['workflow_guard', 'profiles', 'agents.*.model', 'agents.*.permission', 'agents.*.skills', 'agents.*.variant', 'agents.*.opencode', 'agents.*.pi', 'categories.*.model', 'categories.*.permission', 'categories.*.skills', 'categories.*.variant', 'categories.*.opencode', 'categories.*.pi'];
 export type ConfigSourceKind = 'custom' | 'project' | 'user';
 export type ConfigSourcePresence = 'absent' | 'invalid' | 'present';
 export type ConfigSourceErrorCode = 'parse-failed' | 'read-failed' | 'schema-invalid' | 'source-invalid';
@@ -39,15 +40,48 @@ export interface ConfigProtectedFieldMetadata {
     readonly outcome: 'blocked';
     readonly sourceKind: ConfigSourceKind;
 }
+/**
+ * The source kind that supplied the winning `profile` selector value, or
+ * `null` when no source set `profile` at all (case 1 of the selection table
+ * in plan 2026-09-04-002-feat-model-config-profiles, Unit 2). This names
+ * whichever source's value won the `custom ?? project ?? user` selector
+ * lookup -- including when that value turned out to name a missing bundle
+ * and the loader fell back to the user's own default (see
+ * {@link ConfigObservationMetadata.profileFallback}).
+ */
+export type ProfileSelectorSource = ConfigSourceKind | null;
+/**
+ * Present when the winning `profile` selector named a bundle absent from
+ * the user source's `profiles` map. `usedDefault` names the user's own
+ * default profile if it resolved instead, or `null` if the loader fell back
+ * to base configuration (no profile).
+ */
+export interface ProfileFallbackMetadata {
+    readonly requested: string;
+    readonly usedDefault: string | null;
+}
 export interface ConfigObservationMetadata {
     readonly authorities: readonly ConfigAuthorityMetadata[];
     readonly protectedFields: readonly ConfigProtectedFieldMetadata[];
     readonly sources: readonly ConfigSourceMetadata[];
+    /** The active profile's name, or `null` when base configuration is active. */
+    readonly activeProfile: string | null;
+    readonly profileSelectorSource: ProfileSelectorSource;
+    readonly profileFallback: ProfileFallbackMetadata | null;
 }
 export interface SourceAwareConfigResult {
     config: SystematicConfig;
     metadata: ConfigObservationMetadata;
     overlays: SourcedOverlayConfigMap;
+    /**
+     * Merged `pi_subagents.{agents,categories}` overlays (three-entry chain --
+     * user, project, custom; no profile pseudo-entry, see the merge-order
+     * comment in `loadConfigWithSources`). Exposed so a caller building a
+     * routing table (e.g. `systematic config show`) can pass the exact same
+     * legacy-`thinking`-fallback input `resolveRouting` uses internally for
+     * the post-merge qualifier check, without recomputing it.
+     */
+    piSubagentsOverlays: SourcedOverlayConfigMap;
 }
 export interface PiSubagentsOverlayMap {
     categories?: OverlayConfigMap;
@@ -95,6 +129,30 @@ export interface LoadConfigOptions {
 }
 export declare function loadConfig(projectDir: string, options?: LoadConfigOptions): SystematicConfig;
 export declare function loadConfigWithSources(projectDir: string, options?: LoadConfigOptions): SourceAwareConfigResult;
+/**
+ * Enumerate every routing-resolver target implied by the merged overlays:
+ * every raw agent-overlay key that resolves to a real bundled agent (bare or
+ * qualified `category/key`), plus every bundled agent whose category has a
+ * category overlay (R3b's "categories are not checked in isolation" --
+ * `categories.review.variant` with no category model is fine as long as
+ * every agent in `review` resolves its own model, so every agent in an
+ * overlaid category must be walked, not just the category itself).
+ *
+ * A raw overlay key that does not resolve to any known bundled agent (e.g.
+ * an unrestricted `profiles.<name>.agents.<key>` entry naming something that
+ * isn't a real bundled agent) is silently skipped here -- it is not a valid
+ * routing target and this check has no stronger claim to make about it than
+ * schema validation already does elsewhere.
+ *
+ * A disabled agent is excluded from the result: matched by bare key or
+ * qualified `category/key` id in `disabledAgents` (the merged
+ * `disabled_agents` list), or by its own effective overlay's
+ * `disable: true` (bare key checked before the qualified id, mirroring
+ * `config-handler.ts`'s `collectAgents`/`applyAgentOverlays` precedence).
+ * A disabled agent is never emitted to OpenCode at all, so it must never
+ * block config load over a routing invariant it can't violate in practice.
+ */
+export declare function collectRoutingTargets(overlays: SourcedOverlayConfigMap, disabledAgents?: ReadonlySet<string>): RoutingTarget[];
 interface ConfigPathOptions {
     readonly homeDir?: string;
     readonly userConfigDir?: string;

package/dist/lib/pi-delegate-session.d.ts

@@ -22,6 +22,8 @@ export declare function buildDelegateAgentSessionOptions(options: {
     cwd: string;
     agentDir: string;
     model: CreateAgentSessionOptions['model'];
+    /** Omitted (not `undefined`-valued) when unset, so the child inherits Pi's default thinking level instead of an explicit `undefined` overriding it. */
+    thinkingLevel?: CreateAgentSessionOptions['thinkingLevel'];
     allowedToolNames: string[];
     resourceLoader: ResourceLoader;
     sessionManager: ReturnType<typeof SessionManager.inMemory>;