truecourse 0.6.6 → 0.6.7-next.1

package/cli.mjs

@@ -4882,7 +4882,7 @@ function configureLogger(config2) {
 async function closeLogger() {
   while (stack.length > 0) {
     const sink = stack.pop();
-    await new Promise((resolve9) => sink.stream.end(resolve9));
+    await new Promise((resolve10) => sink.stream.end(resolve10));
   }
 }
 function currentSink() {
@@ -11147,6 +11147,14 @@ function parseFile(filePath, code, language) {
     throw new Error(`Failed to parse file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
+function withParsedTree(filePath, code, language, use) {
+  const tree = parseFile(filePath, code, language);
+  try {
+    return use(tree);
+  } finally {
+    tree.delete();
+  }
+}
 var _require, BUNDLED_WASM_DIR, GRAMMAR_WASM, languageCache, parserCache, initPromise, initialized;
 var init_parser = __esm({
   "packages/analyzer/dist/parser.js"() {
@@ -14006,53 +14014,15 @@ async function analyzeFile(filePath) {
   }
   try {
     const content = await readFile(filePath, "utf-8");
-    const tree = parseFile(filePath, content, language);
-    let functions, classes, imports, exports;
-    switch (language) {
-      case "typescript":
-      case "tsx":
-        functions = extractTypeScriptFunctions(tree, filePath, language);
-        classes = extractTypeScriptClasses(tree, filePath, language);
-        imports = extractTypeScriptImports(tree, filePath, language);
-        exports = extractTypeScriptExports(tree, filePath, language);
-        break;
-      case "javascript":
-        functions = extractJavaScriptFunctions(tree, filePath);
-        classes = extractJavaScriptClasses(tree, filePath);
-        imports = extractJavaScriptImports(tree, filePath);
-        exports = extractJavaScriptExports(tree, filePath);
-        break;
-      case "python":
-        functions = extractPythonFunctions(tree, filePath);
-        classes = extractPythonClasses(tree, filePath);
-        imports = extractPythonImports(tree, filePath);
-        exports = extractPythonExports(tree, filePath);
-        break;
-      default:
-        throw new Error(`Unsupported language: ${language}`);
-    }
-    const functionContext = buildFunctionContext(functions, classes);
-    const calls = extractCalls(tree, filePath, language, functionContext);
-    const httpCalls = extractHttpCalls(tree, filePath, language, functions, classes);
-    const { routes: routeRegistrations, mounts: routerMounts } = extractRouteRegistrations(tree, filePath, language);
-    return {
-      filePath,
-      language,
-      functions,
-      classes,
-      imports,
-      exports,
-      calls,
-      httpCalls,
-      ...routeRegistrations.length > 0 ? { routeRegistrations } : {},
-      ...routerMounts.length > 0 ? { routerMounts } : {}
-    };
+    return withParsedTree(filePath, content, language, (tree) => buildFileAnalysis(tree, filePath, language));
   } catch (error) {
     throw new Error(`Failed to analyze file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
 function analyzeFileContent(filePath, content, language) {
-  const tree = parseFile(filePath, content, language);
+  return withParsedTree(filePath, content, language, (tree) => buildFileAnalysis(tree, filePath, language));
+}
+function buildFileAnalysis(tree, filePath, language) {
   let functions, classes, imports, exports;
   switch (language) {
     case "typescript":
@@ -14068,6 +14038,12 @@ function analyzeFileContent(filePath, content, language) {
       imports = extractJavaScriptImports(tree, filePath);
       exports = extractJavaScriptExports(tree, filePath);
       break;
+    case "python":
+      functions = extractPythonFunctions(tree, filePath);
+      classes = extractPythonClasses(tree, filePath);
+      imports = extractPythonImports(tree, filePath);
+      exports = extractPythonExports(tree, filePath);
+      break;
     default:
       throw new Error(`Unsupported language: ${language}`);
   }
@@ -18783,11 +18759,6 @@ var init_entities = __esm({
     init_patterns();
     init_parser();
     TypeScriptEntityDetector = class {
-      // Lazy: do not call getParser() at construction time — callers may
-      // instantiate this before initParsers() has completed.
-      get parser() {
-        return getParser("typescript");
-      }
       shouldScanFile(filePath) {
         if (!/\.(ts|tsx|js|jsx)$/.test(filePath)) {
           return false;
@@ -18802,25 +18773,24 @@ var init_entities = __esm({
         return hasEntityDir || hasEntityPattern;
       }
       detectEntities(sourceCode, filePath, service) {
-        const tree = this.parser.parse(sourceCode);
-        const entities = [];
-        if (!tree)
-          return entities;
-        const classNodes = this.findClassDeclarations(tree.rootNode);
-        for (const classNode of classNodes) {
-          const entity = this.detectEntityFromClass(classNode, sourceCode, filePath, service);
-          if (entity) {
-            entities.push(entity);
+        return withParsedTree(filePath, sourceCode, "typescript", (tree) => {
+          const entities = [];
+          const classNodes = this.findClassDeclarations(tree.rootNode);
+          for (const classNode of classNodes) {
+            const entity = this.detectEntityFromClass(classNode, sourceCode, filePath, service);
+            if (entity) {
+              entities.push(entity);
+            }
           }
-        }
-        const interfaceNodes = this.findInterfaceDeclarations(tree.rootNode);
-        for (const interfaceNode of interfaceNodes) {
-          const entity = this.detectEntityFromInterface(interfaceNode, sourceCode, filePath, service);
-          if (entity) {
-            entities.push(entity);
+          const interfaceNodes = this.findInterfaceDeclarations(tree.rootNode);
+          for (const interfaceNode of interfaceNodes) {
+            const entity = this.detectEntityFromInterface(interfaceNode, sourceCode, filePath, service);
+            if (entity) {
+              entities.push(entity);
+            }
           }
-        }
-        return entities;
+          return entities;
+        });
       }
       findClassDeclarations(node2) {
         const classes = [];
@@ -19188,14 +19158,14 @@ var init_lsp_client = __esm({
           this.sendNotification("exit", null);
         } catch {
         }
-        await new Promise((resolve9) => {
+        await new Promise((resolve10) => {
           const timeout = setTimeout(() => {
             this.process?.kill("SIGKILL");
-            resolve9();
+            resolve10();
           }, 2e3);
           this.process.on("exit", () => {
             clearTimeout(timeout);
-            resolve9();
+            resolve10();
           });
         });
         this.process = null;
@@ -19338,9 +19308,9 @@ var init_lsp_client = __esm({
       // Internal: JSON-RPC transport
       // -------------------------------------------------------------------------
       sendRequest(method, params) {
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           const id = ++this.requestId;
-          this.pendingRequests.set(id, { resolve: resolve9, reject });
+          this.pendingRequests.set(id, { resolve: resolve10, reject });
           const msg = { jsonrpc: "2.0", id, method, params };
           this.process.stdin.write(encodeMessage(msg));
         });
@@ -19397,7 +19367,7 @@ var init_lsp_client = __esm({
        */
       waitForDiagnostics(fileCount) {
         const waitMs = Math.min(Math.max(fileCount * 100, 1e3), 1e4);
-        return new Promise((resolve9) => setTimeout(resolve9, waitMs));
+        return new Promise((resolve10) => setTimeout(resolve10, waitMs));
       }
     };
   }
@@ -47403,6 +47373,9 @@ var init_no_self_compare = __esm({
 });
 
 // packages/analyzer/dist/rules/bugs/visitors/javascript/duplicate-class-members.js
+function reportDuplicate(ruleKey, child, filePath, sourceCode, name) {
+  return makeViolation(ruleKey, child, filePath, "high", "Duplicate class member", `Member \`${name}\` is defined more than once \u2014 the later definition silently overwrites the earlier one.`, sourceCode, "Remove the duplicate member or rename one of them.");
+}
 var duplicateClassMembersVisitor;
 var init_duplicate_class_members = __esm({
   "packages/analyzer/dist/rules/bugs/visitors/javascript/duplicate-class-members.js"() {
@@ -47416,18 +47389,37 @@ var init_duplicate_class_members = __esm({
       visit(node2, filePath, sourceCode) {
         const seen = /* @__PURE__ */ new Map();
         for (const child of node2.namedChildren) {
-          let name = null;
-          if (child.type === "method_definition" || child.type === "public_field_definition" || child.type === "field_definition") {
-            const nameNode = child.childForFieldName("name");
-            if (nameNode)
-              name = nameNode.text;
+          if (child.type !== "method_definition" && child.type !== "public_field_definition" && child.type !== "field_definition")
+            continue;
+          const nameNode = child.childForFieldName("name");
+          if (!nameNode)
+            continue;
+          const name = nameNode.text;
+          let isStatic = false;
+          let accessor = null;
+          for (let i = 0; i < child.childCount; i++) {
+            const c2 = child.child(i);
+            if (!c2)
+              continue;
+            if (c2.type === "static")
+              isStatic = true;
+            else if (c2.type === "get")
+              accessor = "get";
+            else if (c2.type === "set")
+              accessor = "set";
+          }
+          const kind = accessor ?? (child.type === "method_definition" ? "method" : "field");
+          const key2 = `${isStatic ? "static" : "instance"}:${name}`;
+          const existing = seen.get(key2);
+          if (!existing) {
+            seen.set(key2, { kinds: /* @__PURE__ */ new Set([kind]) });
+            continue;
           }
-          if (name) {
-            if (seen.has(name)) {
-              return makeViolation(this.ruleKey, child, filePath, "high", "Duplicate class member", `Member \`${name}\` is defined more than once \u2014 the later definition silently overwrites the earlier one.`, sourceCode, "Remove the duplicate member or rename one of them.");
-            }
-            seen.set(name, child);
+          const isGetSetPair = existing.kinds.size === 1 && existing.kinds.has("get") && kind === "set" || existing.kinds.size === 1 && existing.kinds.has("set") && kind === "get";
+          if (!isGetSetPair) {
+            return reportDuplicate(this.ruleKey, child, filePath, sourceCode, name);
           }
+          existing.kinds.add(kind);
         }
         return null;
       }
@@ -49774,7 +49766,9 @@ var init_element_overwrite = __esm({
                 hasAwait2 = true;
             }
             const isRefCurrent = left.type === "member_expression" && indexOrProp.text === "current";
-            if (!wasRead && !(isRefCurrent && hasAwait2)) {
+            const right = expr.childForFieldName("right");
+            const readsSelfInRhs = right ? right.text.includes(left.text) : false;
+            if (!wasRead && !readsSelfInRhs && !(isRefCurrent && hasAwait2)) {
               return makeViolation(this.ruleKey, expr, filePath, "high", "Element overwritten before read", `\`${key2}\` is assigned again before being read \u2014 the first assignment has no effect.`, sourceCode, "Remove the first assignment or use the value before overwriting it.");
             }
           }
@@ -51138,6 +51132,17 @@ var init_promise_executor_return = __esm({
 });
 
 // packages/analyzer/dist/rules/bugs/visitors/javascript/empty-pattern.js
+function isFunctionParameter(node2) {
+  const parent = node2.parent;
+  if (!parent)
+    return false;
+  if (parent.type === "formal_parameters")
+    return true;
+  if (parent.type === "required_parameter" || parent.type === "optional_parameter") {
+    return parent.parent?.type === "formal_parameters";
+  }
+  return false;
+}
 var emptyPatternVisitor;
 var init_empty_pattern = __esm({
   "packages/analyzer/dist/rules/bugs/visitors/javascript/empty-pattern.js"() {
@@ -51151,6 +51156,8 @@ var init_empty_pattern = __esm({
       visit(node2, filePath, sourceCode) {
         const bindings = node2.namedChildren.filter((c2) => c2.type !== "comment");
         if (bindings.length === 0) {
+          if (node2.type === "object_pattern" && isFunctionParameter(node2))
+            return null;
           const kind = node2.type === "object_pattern" ? "{}" : "[]";
           return makeViolation(this.ruleKey, node2, filePath, "medium", "Empty destructuring pattern", `Empty destructuring pattern \`${kind}\` does not bind any variables.`, sourceCode, "Add variable bindings to the destructuring pattern or remove it entirely.");
         }
@@ -52702,6 +52709,15 @@ var init_contradictory_non_null_coalescing = __esm({
 });
 
 // packages/analyzer/dist/rules/bugs/visitors/javascript/empty-object-type.js
+function isReactPropsParameter(typeAnnotation, filePath) {
+  if (!/\.(tsx|jsx)$/i.test(filePath))
+    return false;
+  const param = typeAnnotation.parent;
+  if (param?.type !== "required_parameter" && param?.type !== "optional_parameter")
+    return false;
+  const pattern = param.childForFieldName("pattern");
+  return pattern?.text === "props";
+}
 var emptyObjectTypeVisitor;
 var init_empty_object_type = __esm({
   "packages/analyzer/dist/rules/bugs/visitors/javascript/empty-object-type.js"() {
@@ -52726,7 +52742,7 @@ var init_empty_object_type = __esm({
         };
         if (node2.type === "type_annotation") {
           const emptyObj = checkForEmptyObject(node2);
-          if (emptyObj) {
+          if (emptyObj && !isReactPropsParameter(node2, filePath)) {
             return makeViolation(this.ruleKey, emptyObj, filePath, "high", "Empty object type {}", "`{}` type matches everything except `null` and `undefined` \u2014 this is rarely intentional. Use `object` for non-primitive objects or `Record<string, unknown>` for generic objects.", sourceCode, "Replace `{}` with `object`, `Record<string, unknown>`, or a specific type.");
           }
         }
@@ -69319,6 +69335,12 @@ var init_prefer_immediate_return = __esm({
         const nameNode = decl.childForFieldName("name");
         if (nameNode?.text !== retName)
           return null;
+        const valueNode = decl.childForFieldName("value");
+        if (valueNode) {
+          const lineSpan = valueNode.endPosition.row - valueNode.startPosition.row + 1;
+          if (lineSpan > 10)
+            return null;
+        }
         let usageCount = 0;
         function countUsages2(n) {
           if (n.type === "identifier" && n.text === retName) {
@@ -71464,6 +71486,14 @@ function isDirectCallbackArg(fn) {
     p2 = p2.parent;
   return p2?.type === "arguments" ? p2 : null;
 }
+function isTrivialCallback(fn) {
+  const body = fn.childForFieldName("body");
+  if (!body)
+    return false;
+  if (body.type !== "statement_block")
+    return true;
+  return body.namedChildren.length === 0;
+}
 function findEnclosingFn(start) {
   let n = start;
   while (n) {
@@ -71485,6 +71515,8 @@ var init_deep_callback_nesting = __esm({
       languages: ["typescript", "tsx", "javascript"],
       nodeTypes: ["function_expression", "arrow_function"],
       visit(node2, filePath, sourceCode) {
+        if (isTrivialCallback(node2))
+          return null;
         let depth = 0;
         let current = node2;
         while (true) {
@@ -71603,6 +71635,10 @@ var init_default_parameter_position = __esm({
             const isOptional = param.type === "optional_parameter" || param.text.includes("?");
             if (isOptional)
               continue;
+            const patternNode = param.childForFieldName("pattern") ?? param.namedChildren[0];
+            const isDestructured = param.type === "object_pattern" || param.type === "array_pattern" || patternNode?.type === "object_pattern" || patternNode?.type === "array_pattern";
+            if (isDestructured)
+              continue;
             const nameNode = param.childForFieldName("pattern") ?? param.childForFieldName("name") ?? param.namedChildren[0];
             const name = nameNode?.text ?? "parameter";
             return makeViolation(this.ruleKey, param, filePath, "low", "Default parameter not last", `Required parameter \`${name}\` appears after a default parameter. Default parameters should come last.`, sourceCode, "Move default parameters to the end of the parameter list.");
@@ -72348,7 +72384,8 @@ var init_public_static_readonly = __esm({
           const isStatic = member.children.some((c2) => c2.type === "static");
           const isPublic = !member.children.some((c2) => c2.type === "accessibility_modifier" && (c2.text === "private" || c2.text === "protected"));
           const isReadonly = member.children.some((c2) => c2.type === "readonly");
-          if (isStatic && isPublic && !isReadonly) {
+          const hasInitializer = member.childForFieldName("value") != null;
+          if (isStatic && isPublic && !isReadonly && hasInitializer) {
             const nameNode = member.childForFieldName("name");
             const name = nameNode?.text ?? "field";
             return makeViolation(this.ruleKey, member, filePath, "medium", "Mutable public static field", `Public static field \`${name}\` is not \`readonly\`. Static public fields that are constants should be readonly.`, sourceCode, `Add the \`readonly\` modifier: \`public static readonly ${name}\`.`);
@@ -77799,11 +77836,18 @@ var init_confusing_void_expression = __esm({
           }
           parent = parent.parent;
         }
-        if (containingFn?.type === "arrow_function") {
+        const isContainingFnVoid = () => {
+          if (!containingFn)
+            return false;
           const fnReturnType = typeQuery.getReturnType(filePath, containingFn.startPosition.row, containingFn.startPosition.column, containingFn.endPosition.row, containingFn.endPosition.column);
-          if (fnReturnType && /^(void|undefined|Promise<\s*(void|undefined)\s*>)$/.test(fnReturnType)) {
+          return !!fnReturnType && /^(void|undefined|Promise<\s*(void|undefined)\s*>)$/.test(fnReturnType);
+        };
+        if (containingFn?.type === "arrow_function") {
+          if (isContainingFnVoid())
+            return null;
+        } else if (value.type === "await_expression" && (containingFn?.type === "function_declaration" || containingFn?.type === "function_expression" || containingFn?.type === "method_definition" || containingFn?.type === "function")) {
+          if (isContainingFnVoid())
             return null;
-          }
         }
         return makeViolation(this.ruleKey, node2, filePath, "low", "Returning void expression", `Returning a void expression \u2014 \`${value.text.slice(0, 40)}\` returns \`undefined\`. This is confusing because it looks like the return value matters.`, sourceCode, "Put the expression on its own line and use a bare `return` statement.");
       }
@@ -77989,6 +78033,32 @@ var init_unnecessary_type_parameter = __esm({
 });
 
 // packages/analyzer/dist/rules/code-quality/visitors/javascript/prefer-this-return-type.js
+function collectMethodReturns(body) {
+  const returns = [];
+  const NESTED_SCOPES = /* @__PURE__ */ new Set([
+    "function_declaration",
+    "function_expression",
+    "function",
+    "arrow_function",
+    "generator_function",
+    "generator_function_declaration",
+    "method_definition",
+    "class_declaration",
+    "class"
+  ]);
+  const walk11 = (n) => {
+    for (const child of n.namedChildren) {
+      if (child.type === "return_statement") {
+        returns.push(child);
+      }
+      if (!NESTED_SCOPES.has(child.type)) {
+        walk11(child);
+      }
+    }
+  };
+  walk11(body);
+  return returns;
+}
 function findEnclosingClass(node2) {
   let current = node2.parent;
   while (current) {
@@ -78041,6 +78111,23 @@ var init_prefer_this_return_type = __esm({
         if (!typeText)
           return null;
         if (typeText === className) {
+          const body = node2.childForFieldName("body");
+          if (!body)
+            return null;
+          const returns = collectMethodReturns(body);
+          if (returns.length === 0)
+            return null;
+          let returnsThis = false;
+          for (const ret of returns) {
+            const arg = ret.namedChildren[0];
+            if (arg && arg.type === "this") {
+              returnsThis = true;
+            } else {
+              return null;
+            }
+          }
+          if (!returnsThis)
+            return null;
           return makeViolation(this.ruleKey, returnTypeNode, filePath, "low", "Method should return `this` instead of class name", `Method \`${methodName}\` returns \`${className}\` but should return \`this\` to support subclass chaining.`, sourceCode, `Change the return type from \`${className}\` to \`this\`.`);
         }
         return null;
@@ -91788,12 +91875,32 @@ var init_regex_in_loop = __esm({
 });
 
 // packages/analyzer/dist/rules/performance/visitors/javascript/spread-in-reduce.js
-function containsSpread(node2) {
-  if (node2.type === "spread_element")
-    return true;
+function getAccumulatorName(callback) {
+  if (callback.type !== "arrow_function" && callback.type !== "function_expression" && callback.type !== "function") {
+    return null;
+  }
+  const params = callback.childForFieldName("parameters");
+  if (!params)
+    return null;
+  const first2 = params.namedChildren.find((c2) => c2.type !== "comment");
+  if (!first2)
+    return null;
+  if (first2.type === "identifier")
+    return first2.text;
+  const pattern = first2.childForFieldName("pattern");
+  if (pattern && pattern.type === "identifier")
+    return pattern.text;
+  return null;
+}
+function spreadsIdentifier(node2, name) {
+  if (node2.type === "spread_element") {
+    const arg = node2.namedChildren[0];
+    if (arg && arg.type === "identifier" && arg.text === name)
+      return true;
+  }
   for (let i = 0; i < node2.childCount; i++) {
     const child = node2.child(i);
-    if (child && containsSpread(child))
+    if (child && spreadsIdentifier(child, name))
       return true;
   }
   return false;
@@ -91820,7 +91927,10 @@ var init_spread_in_reduce = __esm({
         const callback = args.namedChildren[0];
         if (!callback)
           return null;
-        if (containsSpread(callback)) {
+        const accName = getAccumulatorName(callback);
+        if (!accName)
+          return null;
+        if (spreadsIdentifier(callback, accName)) {
           return makeViolation(this.ruleKey, node2, filePath, "medium", "Spread operator in reduce callback", "Using spread in a reduce callback creates a new copy on every iteration, resulting in O(n^2) time complexity.", sourceCode, "Use Object.assign() or direct mutation of the accumulator instead of spread.");
         }
         return null;
@@ -91890,6 +92000,8 @@ var init_sync_fs_in_request_handler = __esm({
           return null;
         if (SEED_FILE_PATH_PATTERN2.test(filePath))
           return null;
+        if (sourceCode.startsWith("#!"))
+          return null;
         if (!isInsideAsyncFunctionOrHandler(node2))
           return null;
         const enclosingName = findEnclosingFunctionName(node2);
@@ -92070,6 +92182,100 @@ var init_large_bundle_import = __esm({
 });
 
 // packages/analyzer/dist/rules/performance/visitors/javascript/json-parse-in-loop.js
+function isDynamicPerIteration(arg, callNode) {
+  switch (arg.type) {
+    case "parenthesized_expression": {
+      const inner = arg.namedChildren[0];
+      return inner ? isDynamicPerIteration(inner, callNode) : false;
+    }
+    case "call_expression":
+    case "subscript_expression":
+    case "template_string":
+      return true;
+    case "ternary_expression": {
+      const cons = arg.childForFieldName("consequence");
+      const alt = arg.childForFieldName("alternative");
+      return !!cons && isDynamicPerIteration(cons, callNode) || !!alt && isDynamicPerIteration(alt, callNode);
+    }
+    case "binary_expression": {
+      const left = arg.childForFieldName("left");
+      const right = arg.childForFieldName("right");
+      return !!left && isDynamicPerIteration(left, callNode) || !!right && isDynamicPerIteration(right, callNode);
+    }
+    case "identifier":
+      return isLoopBoundIdentifier(arg.text, callNode);
+    case "member_expression": {
+      const inner = arg.childForFieldName("object");
+      if (!inner)
+        return false;
+      if (inner.type === "identifier")
+        return isLoopBoundIdentifier(inner.text, callNode);
+      return isDynamicPerIteration(inner, callNode);
+    }
+    default:
+      return false;
+  }
+}
+function isLoopBoundIdentifier(varName, callNode) {
+  let current = callNode.parent;
+  let innermostLoop = null;
+  while (current) {
+    if (current.type === "for_in_statement" || current.type === "for_of_statement") {
+      const left = current.childForFieldName("left");
+      if (left && containsIdentifierExact(left, varName))
+        return true;
+      if (!innermostLoop)
+        innermostLoop = current;
+    }
+    if (current.type === "for_statement") {
+      const init = current.childForFieldName("initializer");
+      if (init && containsIdentifierExact(init, varName))
+        return true;
+      if (!innermostLoop)
+        innermostLoop = current;
+    }
+    if (current.type === "while_statement" || current.type === "do_statement") {
+      if (!innermostLoop)
+        innermostLoop = current;
+    }
+    if (current.type === "arrow_function" || current.type === "function_expression" || current.type === "function") {
+      const params = current.childForFieldName("parameters");
+      if (params && containsIdentifierExact(params, varName)) {
+        const callParent = current.parent?.parent;
+        if (callParent?.type === "call_expression")
+          return true;
+      }
+    }
+    current = current.parent;
+  }
+  if (innermostLoop) {
+    const body = innermostLoop.childForFieldName("body");
+    if (body && containsBindingInBlock(body, varName))
+      return true;
+  }
+  return false;
+}
+function containsBindingInBlock(node2, varName) {
+  if (node2.type === "lexical_declaration" || node2.type === "variable_declaration") {
+    for (const decl of node2.namedChildren) {
+      if (decl.type === "variable_declarator") {
+        const name = decl.childForFieldName("name");
+        if (name && containsIdentifierExact(name, varName))
+          return true;
+      }
+    }
+    return false;
+  }
+  if (node2.type === "function_declaration" || node2.type === "arrow_function" || node2.type === "function" || node2.type === "function_expression" || node2.type === "method_definition" || node2.type === "class_declaration") {
+    return false;
+  }
+  for (let i = 0; i < node2.childCount; i++) {
+    const child = node2.child(i);
+    if (child && containsBindingInBlock(child, varName))
+      return true;
+  }
+  return false;
+}
 var jsonParseInLoopVisitor;
 var init_json_parse_in_loop = __esm({
   "packages/analyzer/dist/rules/performance/visitors/javascript/json-parse-in-loop.js"() {
@@ -92094,64 +92300,9 @@ var init_json_parse_in_loop = __esm({
         if (!isInsideLoop(node2))
           return null;
         const args = node2.childForFieldName("arguments");
-        if (args) {
-          const firstArg = args.namedChildren[0];
-          if (firstArg) {
-            if (firstArg.type === "call_expression")
-              return null;
-            if (firstArg.type === "subscript_expression")
-              return null;
-            if (firstArg.type === "template_string")
-              return null;
-            if (firstArg.type === "identifier") {
-              const varName = firstArg.text;
-              let current = node2.parent;
-              while (current) {
-                if (current.type === "for_in_statement" || current.type === "for_of_statement") {
-                  const left = current.childForFieldName("left");
-                  if (left && containsIdentifierExact(left, varName))
-                    return null;
-                }
-                if (current.type === "for_statement") {
-                  const init = current.childForFieldName("initializer");
-                  if (init && containsIdentifierExact(init, varName))
-                    return null;
-                }
-                if (current.type === "arrow_function" || current.type === "function_expression" || current.type === "function") {
-                  const params = current.childForFieldName("parameters");
-                  if (params && containsIdentifierExact(params, varName)) {
-                    const callParent = current.parent?.parent;
-                    if (callParent?.type === "call_expression")
-                      return null;
-                  }
-                }
-                current = current.parent;
-              }
-            }
-            if (firstArg.type === "member_expression") {
-              const innerObj = firstArg.childForFieldName("object");
-              if (innerObj?.type === "identifier") {
-                let current = node2.parent;
-                while (current) {
-                  if (current.type === "for_in_statement" || current.type === "for_of_statement") {
-                    const left = current.childForFieldName("left");
-                    if (left && containsIdentifierExact(left, innerObj.text))
-                      return null;
-                  }
-                  if (current.type === "arrow_function" || current.type === "function_expression" || current.type === "function") {
-                    const params = current.childForFieldName("parameters");
-                    if (params && containsIdentifierExact(params, innerObj.text)) {
-                      const callParent = current.parent?.parent;
-                      if (callParent?.type === "call_expression")
-                        return null;
-                    }
-                  }
-                  current = current.parent;
-                }
-              }
-            }
-          }
-        }
+        const firstArg = args?.namedChildren[0];
+        if (firstArg && isDynamicPerIteration(firstArg, node2))
+          return null;
         return makeViolation(this.ruleKey, node2, filePath, "medium", `JSON.${prop.text}() inside loop`, `JSON.${prop.text}() is expensive and calling it inside a loop degrades performance. Move it outside the loop if possible.`, sourceCode, `Cache the result of JSON.${prop.text}() outside the loop.`);
       }
     };
@@ -92484,6 +92635,19 @@ var init_missing_usememo_expensive = __esm({
               return null;
           }
         }
+        if (prop.text === "reduce") {
+          const args = node2.childForFieldName("arguments");
+          const callback = args?.namedChild(0);
+          if (callback?.type === "arrow_function" || callback?.type === "function_expression" || callback?.type === "function") {
+            const body = callback.childForFieldName("body");
+            let inspect = body;
+            if (inspect?.type === "parenthesized_expression") {
+              inspect = inspect.namedChildren[0] ?? inspect;
+            }
+            if (inspect?.type === "binary_expression")
+              return null;
+          }
+        }
         const enclosingFn = findEnclosingFunctionNode(node2);
         if (!enclosingFn)
           return null;
@@ -93479,6 +93643,37 @@ var init_python9 = __esm({
 });
 
 // packages/analyzer/dist/rules/reliability/visitors/javascript/catch-without-error-type.js
+function narrowsViaTypeGuard(node2, paramName2) {
+  if (node2.type === "call_expression") {
+    const fn = node2.childForFieldName("function");
+    let calleeName = null;
+    if (fn?.type === "identifier")
+      calleeName = fn.text;
+    else if (fn?.type === "member_expression")
+      calleeName = fn.childForFieldName("property")?.text ?? null;
+    if (calleeName && TYPE_GUARD_NAME.test(calleeName)) {
+      const args = node2.childForFieldName("arguments");
+      if (args && referencesBinding(args, paramName2))
+        return true;
+    }
+  }
+  for (let i = 0; i < node2.childCount; i++) {
+    const ch = node2.child(i);
+    if (ch && narrowsViaTypeGuard(ch, paramName2))
+      return true;
+  }
+  return false;
+}
+function referencesBinding(node2, name) {
+  if (node2.type === "identifier" && node2.text === name)
+    return true;
+  for (let i = 0; i < node2.childCount; i++) {
+    const ch = node2.child(i);
+    if (ch && referencesBinding(ch, name))
+      return true;
+  }
+  return false;
+}
 function hasBranchingConstruct(node2) {
   if (node2.type === "if_statement" || node2.type === "switch_statement" || node2.type === "ternary_expression")
     return true;
@@ -93491,7 +93686,7 @@ function hasBranchingConstruct(node2) {
   }
   return false;
 }
-var catchWithoutErrorTypeVisitor;
+var catchWithoutErrorTypeVisitor, TYPE_GUARD_NAME;
 var init_catch_without_error_type = __esm({
   "packages/analyzer/dist/rules/reliability/visitors/javascript/catch-without-error-type.js"() {
     "use strict";
@@ -93519,9 +93714,13 @@ var init_catch_without_error_type = __esm({
           return null;
         if (!hasBranchingConstruct(body))
           return null;
+        const paramName2 = param.type === "identifier" ? param.text : null;
+        if (paramName2 && narrowsViaTypeGuard(body, paramName2))
+          return null;
         return makeViolation(this.ruleKey, node2, filePath, "medium", "Catch without error type discrimination", "Catch block does not check or narrow the error type. Different error types may need different handling.", sourceCode, "Use instanceof checks or type guards in the catch block to handle specific error types.");
       }
     };
+    TYPE_GUARD_NAME = /^(is|has|assert)[A-Z]/;
   }
 });
 
@@ -98763,7 +98962,8 @@ __export(dist_exports2, {
   shouldExtractEntities: () => shouldExtractEntities,
   toLayerDetectionResults: () => toLayerDetectionResults,
   traceFlows: () => traceFlows,
-  walkAstWithVisitors: () => walkAstWithVisitors
+  walkAstWithVisitors: () => walkAstWithVisitors,
+  withParsedTree: () => withParsedTree
 });
 async function analyzeRepository(rootPath) {
   await initParsers();
@@ -104140,6 +104340,12 @@ function loadTcIgnore(startDir) {
       if (rel === "" || rel.startsWith(".."))
         return false;
       return ig.ignores(rel);
+    },
+    reincludes(absPath) {
+      const rel = path12.relative(root, path12.resolve(absPath)).split(path12.sep).join("/");
+      if (rel === "" || rel.startsWith(".."))
+        return false;
+      return ig.test(rel).unignored;
     }
   };
 }
@@ -104377,12 +104583,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve9, reject) {
+        return new Promise(function(resolve10, reject) {
           isexe(path61, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve9(is);
+              resolve10(is);
             }
           });
         });
@@ -104448,27 +104654,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i) => new Promise((resolve9, reject) => {
+      const step = (i) => new Promise((resolve10, reject) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve9(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve10(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path61.join(pathPart, cmd);
         const p2 = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve9(subStep(p2, i, 0));
+        resolve10(subStep(p2, i, 0));
       });
-      const subStep = (p2, i, ii) => new Promise((resolve9, reject) => {
+      const subStep = (p2, i, ii) => new Promise((resolve10, reject) => {
         if (ii === pathExt.length)
-          return resolve9(step(i + 1));
+          return resolve10(step(i + 1));
         const ext2 = pathExt[ii];
         isexe(p2 + ext2, { pathExt: pathExtExe }, (er, is) => {
           if (!er && is) {
             if (opt.all)
               found.push(p2 + ext2);
             else
-              return resolve9(p2 + ext2);
+              return resolve10(p2 + ext2);
           }
-          return resolve9(subStep(p2, i, ii + 1));
+          return resolve10(subStep(p2, i, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -104873,27 +105079,27 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run = async (function_, resolve9, arguments_) => {
+  const run = async (function_, resolve10, arguments_) => {
     const result = (async () => function_(...arguments_))();
-    resolve9(result);
+    resolve10(result);
     try {
       await result;
     } catch {
     }
     next();
   };
-  const enqueue = (function_, resolve9, reject, arguments_) => {
+  const enqueue = (function_, resolve10, reject, arguments_) => {
     const queueItem = { reject };
     new Promise((internalResolve) => {
       queueItem.run = internalResolve;
       queue.enqueue(queueItem);
-    }).then(run.bind(void 0, function_, resolve9, arguments_));
+    }).then(run.bind(void 0, function_, resolve10, arguments_));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_) => new Promise((resolve9, reject) => {
-    enqueue(function_, resolve9, reject, arguments_);
+  const generator = (function_, ...arguments_) => new Promise((resolve10, reject) => {
+    enqueue(function_, resolve10, reject, arguments_);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -107746,7 +107952,7 @@ var init_cli_provider = __esm({
           jsonSchemaStr,
           ...opts?.extraArgs ?? []
         ];
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           const child = (0, import_cross_spawn.default)(this.binaryName, args, {
             env: this.getCleanEnv(),
             stdio: ["pipe", "pipe", "pipe"],
@@ -107794,7 +108000,7 @@ var init_cli_provider = __esm({
               reject(new Error(`[CLI] ${this.binaryName} exited with code ${code}: ${detail}`));
               return;
             }
-            resolve9(stdout);
+            resolve10(stdout);
           });
           child.on("error", (err) => {
             clearTimeout(timer);
@@ -109303,12 +109509,12 @@ async function runViolationPipeline(input) {
   const fileContents = /* @__PURE__ */ new Map();
   const totalToScan = filesToScan.length;
   let scanned = 0;
-  for (const { filePath, resolve: resolve9 } of filesToScan) {
+  for (const { filePath, resolve: resolve10 } of filesToScan) {
     try {
       const lang = detectLanguage(filePath);
       if (!lang)
         continue;
-      const absPath = resolve9 ? path14.resolve(repoPath, filePath) : path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
+      const absPath = resolve10 ? path14.resolve(repoPath, filePath) : path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
       if (!fs12.existsSync(absPath))
         continue;
       const content = fs12.readFileSync(absPath, "utf-8");
@@ -109413,18 +109619,17 @@ async function runViolationPipeline(input) {
     const DETAIL_UPDATE_MS = 100;
     let lastYieldMs = Date.now();
     let lastDetailMs = lastYieldMs;
-    for (const { filePath, resolve: resolve9 } of filesToScan) {
+    for (const { filePath, resolve: resolve10 } of filesToScan) {
       try {
         const lang = detectLanguage(filePath);
         if (!lang)
           continue;
-        const absPath = resolve9 ? path14.resolve(repoPath, filePath) : path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
+        const absPath = resolve10 ? path14.resolve(repoPath, filePath) : path14.isAbsolute(filePath) ? filePath : path14.join(repoPath, filePath);
         const key2 = changedFileSet ? absPath : filePath;
         const fc = fileContents.get(key2);
         if (!fc)
           continue;
-        const tree = parseFile(changedFileSet ? filePath : filePath, fc.content, lang);
-        const codeRuleViolations = checkCodeRules(tree, changedFileSet ? absPath : filePath, fc.content, enabledCodeRules, lang, typeQuery, schemaIndex);
+        const codeRuleViolations = withParsedTree(filePath, fc.content, lang, (tree) => checkCodeRules(tree, changedFileSet ? absPath : filePath, fc.content, enabledCodeRules, lang, typeQuery, schemaIndex));
         allCodeViolations.push(...codeRuleViolations);
       } catch {
       }
@@ -123260,10 +123465,10 @@ var require_axios = __commonJS({
         this.__CANCEL__ = true;
       }
     };
-    function settle(resolve9, reject, response) {
+    function settle(resolve10, reject, response) {
       const validateStatus = response.config.validateStatus;
       if (!response.status || !validateStatus || validateStatus(response.status)) {
-        resolve9(response);
+        resolve10(response);
       } else {
         reject(new AxiosError("Request failed with status code " + response.status, [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4], response.config, response.request, response));
       }
@@ -123906,7 +124111,7 @@ var require_axios = __commonJS({
     }
     var isHttpAdapterSupported = typeof process !== "undefined" && utils$1.kindOf(process) === "process";
     var wrapAsync = (asyncExecutor) => {
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         let onDone;
         let isDone;
         const done = (value, isRejected) => {
@@ -123916,7 +124121,7 @@ var require_axios = __commonJS({
         };
         const _resolve = (value) => {
           done(value);
-          resolve9(value);
+          resolve10(value);
         };
         const _reject = (reason) => {
           done(reason, true);
@@ -123977,7 +124182,7 @@ var require_axios = __commonJS({
       }
     };
     var httpAdapter = isHttpAdapterSupported && function httpAdapter2(config2) {
-      return wrapAsync(async function dispatchHttpRequest(resolve9, reject, onDone) {
+      return wrapAsync(async function dispatchHttpRequest(resolve10, reject, onDone) {
         let {
           data,
           lookup,
@@ -124069,7 +124274,7 @@ var require_axios = __commonJS({
           }
           let convertedData;
           if (method !== "GET") {
-            return settle(resolve9, reject, {
+            return settle(resolve10, reject, {
               status: 405,
               statusText: "method not allowed",
               headers: {},
@@ -124091,7 +124296,7 @@ var require_axios = __commonJS({
           } else if (responseType === "stream") {
             convertedData = stream.Readable.from(convertedData);
           }
-          return settle(resolve9, reject, {
+          return settle(resolve10, reject, {
             data: convertedData,
             status: 200,
             statusText: "OK",
@@ -124286,7 +124491,7 @@ var require_axios = __commonJS({
           };
           if (responseType === "stream") {
             response.data = responseStream;
-            settle(resolve9, reject, response);
+            settle(resolve10, reject, response);
           } else {
             const responseBuffer = [];
             let totalResponseBytes = 0;
@@ -124324,7 +124529,7 @@ var require_axios = __commonJS({
               } catch (err) {
                 return reject(AxiosError.from(err, null, config2, response.request, response));
               }
-              settle(resolve9, reject, response);
+              settle(resolve10, reject, response);
             });
           }
           abortEmitter.once("abort", (err) => {
@@ -124562,7 +124767,7 @@ var require_axios = __commonJS({
     };
     var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
     var xhrAdapter = isXHRAdapterSupported && function(config2) {
-      return new Promise(function dispatchXhrRequest(resolve9, reject) {
+      return new Promise(function dispatchXhrRequest(resolve10, reject) {
         const _config = resolveConfig(config2);
         let requestData = _config.data;
         const requestHeaders = AxiosHeaders.from(_config.headers).normalize();
@@ -124598,7 +124803,7 @@ var require_axios = __commonJS({
             request
           };
           settle(function _resolve(value) {
-            resolve9(value);
+            resolve10(value);
             done();
           }, function _reject(err) {
             reject(err);
@@ -124969,8 +125174,8 @@ var require_axios = __commonJS({
           responseType = responseType || "text";
           let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || "text"](response, config2);
           !isStreamResponse && unsubscribe && unsubscribe();
-          return await new Promise((resolve9, reject) => {
-            settle(resolve9, reject, {
+          return await new Promise((resolve10, reject) => {
+            settle(resolve10, reject, {
               data: responseData,
               headers: AxiosHeaders.from(response.headers),
               status: response.status,
@@ -125339,8 +125544,8 @@ var require_axios = __commonJS({
           throw new TypeError("executor must be a function.");
         }
         let resolvePromise;
-        this.promise = new Promise(function promiseExecutor(resolve9) {
-          resolvePromise = resolve9;
+        this.promise = new Promise(function promiseExecutor(resolve10) {
+          resolvePromise = resolve10;
         });
         const token = this;
         this.promise.then((cancel) => {
@@ -125353,9 +125558,9 @@ var require_axios = __commonJS({
         });
         this.promise.then = (onfulfilled) => {
           let _resolve;
-          const promise = new Promise((resolve9) => {
-            token.subscribe(resolve9);
-            _resolve = resolve9;
+          const promise = new Promise((resolve10) => {
+            token.subscribe(resolve10);
+            _resolve = resolve10;
           }).then(onfulfilled);
           promise.cancel = function reject() {
             token.unsubscribe(_resolve);
@@ -125969,14 +126174,14 @@ async function addSourceContext(frames) {
   return frames;
 }
 function getContextLinesFromFile(path61, ranges, output) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const stream = createReadStream(path61);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve9();
+      resolve10();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -129082,15 +129287,15 @@ var init_node = __esm({
         if (this.featureFlagsPoller === void 0) {
           return false;
         }
-        return new Promise((resolve9) => {
+        return new Promise((resolve10) => {
           const timeout = setTimeout(() => {
             cleanup();
-            resolve9(false);
+            resolve10(false);
           }, timeoutMs);
           const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
             clearTimeout(timeout);
             cleanup();
-            resolve9(count > 0);
+            resolve10(count > 0);
           });
         });
       }
@@ -129415,7 +129620,7 @@ function readToolVersion() {
   if (cachedVersion)
     return cachedVersion;
   if (true) {
-    cachedVersion = "0.6.6";
+    cachedVersion = "0.6.7-next.1";
     return cachedVersion;
   }
   try {
@@ -132744,6 +132949,77 @@ var init_operation2 = __esm({
 });
 
 // packages/contract-verifier/dist/extractor/operation-fastapi.js
+function extractStarletteRoutesFromFile(filePath, source, tree) {
+  const out = [];
+  walk(tree.rootNode, (node2) => {
+    if (node2.type !== "call")
+      return;
+    const fn = node2.childForFieldName("function");
+    if (fn?.type !== "identifier" || source.slice(fn.startIndex, fn.endIndex) !== "Route")
+      return;
+    const args = node2.childForFieldName("arguments");
+    if (!args)
+      return;
+    const first2 = args.namedChild(0);
+    if (first2?.type !== "string")
+      return;
+    const rawPath = pyStr(first2, source);
+    if (!rawPath.startsWith("/"))
+      return;
+    const second = args.namedChild(1);
+    if (!second || second.type === "keyword_argument")
+      return;
+    const methods = readStarletteMethods(args, source);
+    const identities = starletteIdentitiesForPath(rawPath);
+    const line = node2.startPosition.row + 1;
+    for (const method of methods) {
+      for (const path61 of identities) {
+        out.push({
+          identity: `${method} ${path61}`,
+          contract: {
+            protocol: "http",
+            method,
+            path: path61,
+            responses: [],
+            tags: []
+          },
+          filePath,
+          declarationLine: line,
+          observed: { queryParams: [], numericClamps: [], hasClampCall: false }
+        });
+      }
+    }
+  });
+  return out;
+}
+function readStarletteMethods(args, source) {
+  for (let i = 0; i < args.namedChildCount; i++) {
+    const a = args.namedChild(i);
+    if (a?.type !== "keyword_argument")
+      continue;
+    const name = a.childForFieldName("name");
+    if (!name || source.slice(name.startIndex, name.endIndex) !== "methods")
+      continue;
+    const value = a.childForFieldName("value");
+    if (value?.type !== "list")
+      return ["GET"];
+    const methods = [];
+    for (let j2 = 0; j2 < value.namedChildCount; j2++) {
+      const el = value.namedChild(j2);
+      if (el?.type === "string")
+        methods.push(pyStr(el, source).toUpperCase());
+    }
+    return methods.length > 0 ? methods : ["GET"];
+  }
+  return ["GET"];
+}
+function starletteIdentitiesForPath(rawPath) {
+  const catchAll = rawPath.match(/^(\/.*\/)\{\w+:path\}$/);
+  if (catchAll) {
+    return [catchAll[1].replace(/\{(\w+):[^}]+\}/g, "{$1}")];
+  }
+  return [rawPath.replace(/\{(\w+):[^}]+\}/g, "{$1}")];
+}
 function extractFastApiOperationsFromFile(filePath, source, tree) {
   const routers = collectRouters(tree.rootNode, source);
   const stringVars = collectStringVars(tree.rootNode, source);
@@ -136348,9 +136624,85 @@ var init_ts_enums = __esm({
   }
 });
 
+// packages/contract-verifier/dist/extractor/py-string-resolver.js
+function collectStringConstantTable(rootNode, source) {
+  const table = /* @__PURE__ */ new Map();
+  for (let i = 0; i < rootNode.namedChildCount; i++) {
+    const stmt = rootNode.namedChild(i);
+    if (stmt?.type !== "expression_statement")
+      continue;
+    const assign = stmt.namedChild(0);
+    if (assign?.type !== "assignment")
+      continue;
+    const left = assign.childForFieldName("left");
+    if (left?.type !== "identifier")
+      continue;
+    const right = assign.childForFieldName("right");
+    if (right?.type !== "string")
+      continue;
+    const name = source.slice(left.startIndex, left.endIndex);
+    if (table.has(name))
+      continue;
+    table.set(name, right);
+  }
+  return table;
+}
+function stringValue(node2, source, table) {
+  return resolve9(node2, source, table, 0);
+}
+function resolve9(node2, source, table, depth) {
+  if (node2.type !== "string")
+    return null;
+  if (depth > MAX_DEPTH3)
+    return null;
+  let content = "";
+  let sawContent = false;
+  for (let i = 0; i < node2.namedChildCount; i++) {
+    const c2 = node2.namedChild(i);
+    if (!c2)
+      continue;
+    if (c2.type === "string_content") {
+      content += source.slice(c2.startIndex, c2.endIndex);
+      sawContent = true;
+      continue;
+    }
+    if (c2.type === "interpolation") {
+      if (c2.namedChildren.some((g) => g?.type === "format_specifier"))
+        return null;
+      const expr = c2.namedChild(0);
+      if (expr?.type !== "identifier" || !table)
+        return null;
+      const referent = table.get(source.slice(expr.startIndex, expr.endIndex));
+      if (!referent)
+        return null;
+      const resolved = resolve9(referent, source, table, depth + 1);
+      if (resolved === null)
+        return null;
+      content += resolved;
+      sawContent = true;
+      continue;
+    }
+    if (c2.type === "format_specifier")
+      return null;
+  }
+  if (sawContent)
+    return content;
+  const raw = source.slice(node2.startIndex, node2.endIndex);
+  const m = raw.match(/^[a-zA-Z]*('''|"""|'|")([\s\S]*)\1$/);
+  return m ? m[2] : null;
+}
+var MAX_DEPTH3;
+var init_py_string_resolver = __esm({
+  "packages/contract-verifier/dist/extractor/py-string-resolver.js"() {
+    "use strict";
+    MAX_DEPTH3 = 4;
+  }
+});
+
 // packages/contract-verifier/dist/extractor/enum/py-enums.js
 function extractPyEnumsFromFile(filePath, source, tree) {
   const out = [];
+  const stringTable = collectStringConstantTable(tree.rootNode, source);
   walk7(tree.rootNode, (node2) => {
     if (node2.type === "class_definition") {
       const decl = extractEnumClass(node2, filePath, source);
@@ -136366,6 +136718,302 @@ function extractPyEnumsFromFile(filePath, source, tree) {
     }
     return true;
   });
+  out.push(...synthesizeInstanceRegistryEnum(tree.rootNode, filePath, source));
+  out.push(...synthesizeDiscriminatedUnionEnum(tree.rootNode, filePath, source));
+  out.push(...synthesizeConstantClusterEnums(tree.rootNode, filePath, source, stringTable));
+  return out;
+}
+function synthesizeDiscriminatedUnionEnum(root, filePath, source) {
+  const discriminatorOf = /* @__PURE__ */ new Map();
+  walk7(root, (node2) => {
+    if (node2.type !== "class_definition")
+      return true;
+    const className = textOfField(node2, "name", source);
+    const body = node2.childForFieldName("body");
+    if (!className || !body)
+      return true;
+    for (let i = 0; i < body.namedChildCount; i++) {
+      const stmt = body.namedChild(i);
+      if (stmt?.type !== "expression_statement")
+        continue;
+      const assign = stmt.namedChild(0);
+      if (assign?.type !== "assignment")
+        continue;
+      const left = assign.childForFieldName("left");
+      const typeAnn = assign.childForFieldName("type");
+      if (left?.type !== "identifier" || !typeAnn)
+        continue;
+      if (source.slice(left.startIndex, left.endIndex) !== "type")
+        continue;
+      const lit = literalStringOfAnnotation(typeAnn, source);
+      if (lit !== null)
+        discriminatorOf.set(className, lit);
+    }
+    return true;
+  });
+  if (discriminatorOf.size === 0)
+    return [];
+  const out = [];
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const stmt = root.namedChild(i);
+    if (stmt?.type !== "expression_statement")
+      continue;
+    const assign = stmt.namedChild(0);
+    if (assign?.type !== "assignment")
+      continue;
+    const left = assign.childForFieldName("left");
+    if (left?.type !== "identifier")
+      continue;
+    const aliasName = source.slice(left.startIndex, left.endIndex);
+    const right = assign.childForFieldName("right");
+    if (!right)
+      continue;
+    const memberClasses = unionMemberIdentifiers(right, source);
+    if (memberClasses.length === 0)
+      continue;
+    const values = memberClasses.map((m) => discriminatorOf.get(m)).filter((v) => v !== void 0);
+    if (values.length < 3)
+      continue;
+    out.push(mkEnum2(aliasName, values, "py-discriminated-union", root, filePath));
+  }
+  return out;
+}
+function literalStringOfAnnotation(ann, source) {
+  let node2 = ann;
+  if (node2.type === "type")
+    node2 = node2.namedChild(0);
+  if (!node2 || node2.type !== "generic_type" && node2.type !== "subscript")
+    return null;
+  const base = node2.namedChild(0);
+  if (!base || !source.slice(base.startIndex, base.endIndex).endsWith("Literal"))
+    return null;
+  const strings = collectStringsDeep(node2, source);
+  return strings.length === 1 ? strings[0] : null;
+}
+function collectStringsDeep(node2, source) {
+  const out = [];
+  const visit = (n) => {
+    if (n.type === "string") {
+      const v = stringValue(n, source);
+      if (v !== null)
+        out.push(v);
+      return;
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c2 = n.namedChild(i);
+      if (c2)
+        visit(c2);
+    }
+  };
+  visit(node2);
+  return out;
+}
+function unionMemberIdentifiers(node2, source) {
+  if (node2.type === "subscript") {
+    const value = node2.childForFieldName("value");
+    if (value && source.slice(value.startIndex, value.endIndex).endsWith("Union")) {
+      const out = [];
+      for (let i = 0; i < node2.namedChildCount; i++) {
+        const c2 = node2.namedChild(i);
+        if (c2 && c2 !== value)
+          collectTypeIdentifiers(c2, out, source);
+      }
+      return out;
+    }
+    return [];
+  }
+  if (node2.type === "binary_operator") {
+    const text = source.slice(node2.startIndex, node2.endIndex);
+    if (text.includes("|")) {
+      const out = [];
+      collectTypeIdentifiers(node2, out, source);
+      return out;
+    }
+  }
+  return [];
+}
+function collectTypeIdentifiers(node2, out, source) {
+  if (node2.type === "identifier") {
+    out.push(source.slice(node2.startIndex, node2.endIndex));
+    return;
+  }
+  for (let i = 0; i < node2.namedChildCount; i++) {
+    const c2 = node2.namedChild(i);
+    if (c2)
+      collectTypeIdentifiers(c2, out, source);
+  }
+}
+function synthesizeConstantClusterEnums(root, filePath, source, stringTable) {
+  const named = [];
+  for (const [name, node2] of stringTable) {
+    const v = stringValue(node2, source, stringTable);
+    if (v === null)
+      continue;
+    named.push({ name, value: v });
+  }
+  if (named.length < MIN_CLUSTER_MEMBERS)
+    return [];
+  named.sort((a, b) => a.value < b.value ? -1 : a.value > b.value ? 1 : 0);
+  const clusters = [];
+  let i = 0;
+  while (i < named.length) {
+    let j2 = i + 1;
+    let prefix = named[i].value;
+    while (j2 < named.length) {
+      const next = commonPrefix(prefix, named[j2].value);
+      if (next.length < MIN_PREFIX)
+        break;
+      prefix = next;
+      j2++;
+    }
+    if (j2 - i >= MIN_CLUSTER_MEMBERS && j2 - i <= MAX_CLUSTER_MEMBERS && prefix.length >= MIN_PREFIX) {
+      clusters.push({ prefix, members: named.slice(i, j2) });
+    }
+    i = j2 === i + 1 ? i + 1 : j2;
+  }
+  const out = [];
+  for (const cluster of clusters) {
+    const realMembers = cluster.members.filter((m) => m.value.length > cluster.prefix.length);
+    if (realMembers.length < MIN_CLUSTER_MEMBERS)
+      continue;
+    let prefix = realMembers[0].value;
+    for (let k = 1; k < realMembers.length; k++) {
+      prefix = commonPrefix(prefix, realMembers[k].value);
+      if (prefix.length < MIN_PREFIX)
+        break;
+    }
+    if (prefix.length < MIN_PREFIX)
+      continue;
+    const trailingDelim = /[/\-_.:]$/.test(prefix);
+    const allCleanTails = trailingDelim || realMembers.every((m) => /^[A-Za-z0-9_\-./:]+$/.test(m.value.slice(prefix.length)));
+    if (!allCleanTails)
+      continue;
+    const trimmedName = prefix.replace(/[^A-Za-z0-9]+$/, "") || prefix;
+    const firstNode = stringTable.get(realMembers[0].name);
+    const lastNode = stringTable.get(realMembers[realMembers.length - 1].name);
+    out.push({
+      name: trimmedName,
+      values: [...new Set(realMembers.map((m) => m.value))].sort(),
+      shape: "py-constant-cluster",
+      source: {
+        filePath,
+        lineStart: firstNode ? firstNode.startPosition.row + 1 : 1,
+        lineEnd: lastNode ? lastNode.endPosition.row + 1 : 1
+      }
+    });
+  }
+  return out;
+}
+function commonPrefix(a, b) {
+  const len = Math.min(a.length, b.length);
+  let i = 0;
+  while (i < len && a.charCodeAt(i) === b.charCodeAt(i))
+    i++;
+  return a.slice(0, i);
+}
+function synthesizeInstanceRegistryEnum(root, filePath, source) {
+  const baseOf = /* @__PURE__ */ new Map();
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const child = root.namedChild(i);
+    const node2 = child?.type === "class_definition" ? child : child?.type === "decorated_definition" ? child.childForFieldName("definition") : null;
+    if (node2?.type !== "class_definition")
+      continue;
+    const name = textOfField(node2, "name", source);
+    const supers = node2.childForFieldName("superclasses");
+    if (!name || !supers)
+      continue;
+    const first2 = supers.namedChild(0);
+    if (first2?.type === "identifier")
+      baseOf.set(name, source.slice(first2.startIndex, first2.endIndex));
+  }
+  const subclassCount = /* @__PURE__ */ new Map();
+  for (const base of baseOf.values())
+    subclassCount.set(base, (subclassCount.get(base) ?? 0) + 1);
+  const categoricalBases = new Set([...subclassCount].filter(([, n]) => n >= 2).map(([b]) => b));
+  if (categoricalBases.size === 0)
+    return [];
+  const resolveBase = (cls) => {
+    let cur = cls;
+    for (let hops = 0; hops < 8; hops++) {
+      if (categoricalBases.has(cur))
+        return cur;
+      const next = baseOf.get(cur);
+      if (!next)
+        return null;
+      cur = next;
+    }
+    return null;
+  };
+  const group = /* @__PURE__ */ new Map();
+  const memberBase = /* @__PURE__ */ new Map();
+  const deferred2 = [];
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const stmt = root.namedChild(i);
+    if (stmt?.type !== "expression_statement")
+      continue;
+    const assign = stmt.namedChild(0);
+    if (assign?.type !== "assignment")
+      continue;
+    if (assign.childForFieldName("type"))
+      continue;
+    const left = assign.childForFieldName("left");
+    if (left?.type !== "identifier")
+      continue;
+    const name = source.slice(left.startIndex, left.endIndex);
+    if (!/^[A-Z][A-Z0-9_]*$/.test(name))
+      continue;
+    const right = assign.childForFieldName("right");
+    if (!right)
+      continue;
+    if (right.type === "call") {
+      const fn = right.childForFieldName("function");
+      if (fn?.type !== "identifier")
+        continue;
+      const ctor = source.slice(fn.startIndex, fn.endIndex);
+      const base = resolveBase(ctor);
+      if (base) {
+        if (!group.has(base))
+          group.set(base, []);
+        group.get(base).push(name);
+        memberBase.set(name, base);
+      }
+    } else {
+      deferred2.push({ name, rhs: right });
+    }
+  }
+  for (const { name, rhs } of deferred2) {
+    const ids = collectIdentifiers3(rhs, source);
+    if (ids.length === 0)
+      continue;
+    const bases = new Set(ids.map((id) => memberBase.get(id)).filter((b) => !!b));
+    if (bases.size === 1) {
+      const base = [...bases][0];
+      group.get(base).push(name);
+      memberBase.set(name, base);
+    }
+  }
+  const out = [];
+  for (const [base, members] of group) {
+    if (members.length < 3)
+      continue;
+    out.push(mkEnum2(base, members, "py-instance-registry", root, filePath));
+  }
+  return out;
+}
+function collectIdentifiers3(node2, source) {
+  const out = [];
+  const visit = (n) => {
+    if (n.type === "identifier") {
+      out.push(source.slice(n.startIndex, n.endIndex));
+      return;
+    }
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c2 = n.namedChild(i);
+      if (c2)
+        visit(c2);
+    }
+  };
+  visit(node2);
   return out;
 }
 function extractEnumClass(node2, filePath, source) {
@@ -136442,6 +137090,22 @@ function extractAssignmentEnum(node2, filePath, source) {
     }
     return null;
   }
+  if (right.type === "set" || right.type === "list") {
+    const attrs = attributeSetValues(right, source);
+    if (attrs) {
+      return mkEnum2(name, attrs, right.type === "set" ? "py-set" : "py-list", node2, filePath);
+    }
+  }
+  const diff = parseSetDifference(right, source);
+  if (diff) {
+    return {
+      name,
+      values: [],
+      shape: "py-set-difference",
+      source: { filePath, lineStart: node2.startPosition.row + 1, lineEnd: node2.endPosition.row + 1 },
+      unresolved: diff
+    };
+  }
   if (!nameLooksLikeEnumConst2(name))
     return null;
   if (right.type === "set" || right.type === "list") {
@@ -136468,6 +137132,60 @@ function extractAssignmentEnum(node2, filePath, source) {
 function nameLooksLikeEnumConst2(name) {
   return ENUM_CONVENTION_NAME2.test(name) || ENUM_CONVENTION_SUFFIX2.test(name);
 }
+function attributeSetValues(node2, source) {
+  const out = [];
+  for (let i = 0; i < node2.namedChildCount; i++) {
+    const c2 = node2.namedChild(i);
+    if (!c2)
+      continue;
+    if (c2.type !== "attribute")
+      return null;
+    const attr = c2.childForFieldName("attribute");
+    if (!attr)
+      return null;
+    out.push(source.slice(attr.startIndex, attr.endIndex));
+  }
+  return out.length >= 2 ? out : null;
+}
+function parseSetDifference(node2, source) {
+  let n = node2;
+  if (n.type === "call") {
+    const fn = n.childForFieldName("function");
+    const fnName = fn ? source.slice(fn.startIndex, fn.endIndex) : "";
+    if (/^(list|set|frozenset|tuple)$/.test(fnName)) {
+      const inner = n.childForFieldName("arguments")?.namedChild(0);
+      if (inner)
+        n = inner;
+    }
+  }
+  if (n.type !== "binary_operator")
+    return null;
+  if (!source.slice(n.startIndex, n.endIndex).includes("-"))
+    return null;
+  const left = n.childForFieldName("left");
+  const right = n.childForFieldName("right");
+  if (!left || !right)
+    return null;
+  const base = enumOperandName(left, source);
+  const minus = enumOperandName(right, source);
+  return base && minus ? { base, minus } : null;
+}
+function enumOperandName(node2, source) {
+  let n = node2;
+  if (n.type === "call") {
+    const inner = n.childForFieldName("arguments")?.namedChild(0);
+    if (inner)
+      n = inner;
+  }
+  if (n.type === "identifier")
+    return source.slice(n.startIndex, n.endIndex);
+  if (n.type === "attribute") {
+    const a = n.childForFieldName("attribute");
+    if (a)
+      return source.slice(a.startIndex, a.endIndex);
+  }
+  return null;
+}
 function collectStringChildren(node2, source) {
   const out = [];
   for (let i = 0; i < node2.namedChildCount; i++) {
@@ -136480,24 +137198,6 @@ function collectStringChildren(node2, source) {
   }
   return out;
 }
-function stringValue(node2, source) {
-  let content = "";
-  let sawContent = false;
-  for (let i = 0; i < node2.namedChildCount; i++) {
-    const c2 = node2.namedChild(i);
-    if (c2?.type === "string_content") {
-      content += source.slice(c2.startIndex, c2.endIndex);
-      sawContent = true;
-    } else if (c2?.type === "interpolation" || c2?.type === "format_specifier") {
-      return null;
-    }
-  }
-  if (sawContent)
-    return content;
-  const raw = source.slice(node2.startIndex, node2.endIndex);
-  const m = raw.match(/^[a-zA-Z]*('''|"""|'|")([\s\S]*)\1$/);
-  return m ? m[2] : null;
-}
 function textOfField(node2, field, source) {
   const c2 = node2.childForFieldName(field);
   return c2 ? source.slice(c2.startIndex, c2.endIndex) : "";
@@ -136520,12 +137220,16 @@ function walk7(node2, visit) {
       walk7(c2, visit);
   }
 }
-var ENUM_CONVENTION_NAME2, ENUM_CONVENTION_SUFFIX2;
+var ENUM_CONVENTION_NAME2, ENUM_CONVENTION_SUFFIX2, MIN_PREFIX, MIN_CLUSTER_MEMBERS, MAX_CLUSTER_MEMBERS;
 var init_py_enums = __esm({
   "packages/contract-verifier/dist/extractor/enum/py-enums.js"() {
     "use strict";
+    init_py_string_resolver();
     ENUM_CONVENTION_NAME2 = /^(?:VALID|ALLOWED|KNOWN|ENUM)_/i;
     ENUM_CONVENTION_SUFFIX2 = /_(?:VALUES|SET|CLASSIFICATIONS|STATUSES|KINDS|TYPES|OPTIONS|CHOICES)$/i;
+    MIN_PREFIX = 6;
+    MIN_CLUSTER_MEMBERS = 3;
+    MAX_CLUSTER_MEMBERS = 200;
   }
 });
 
@@ -136559,8 +137263,27 @@ async function extractEnumsFromDir(rootDir) {
       source: { filePath: entries[0].filePath, lineStart: 1, lineEnd: 1 }
     });
   }
-  const seen = /* @__PURE__ */ new Map();
+  const norm = (s) => s.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
+  const valuesByName = /* @__PURE__ */ new Map();
+  for (const e of raw) {
+    if (e.shape !== "py-set-difference")
+      valuesByName.set(norm(e.name), e.values);
+  }
   for (const e of raw) {
+    if (e.shape !== "py-set-difference" || !e.unresolved)
+      continue;
+    const baseVals = valuesByName.get(norm(e.unresolved.base));
+    const minusVals = valuesByName.get(norm(e.unresolved.minus));
+    if (baseVals && minusVals) {
+      const minusSet = new Set(minusVals.map((v) => v.replace(/[^A-Za-z0-9]/g, "").toLowerCase()));
+      e.values = [...new Set(baseVals.filter((v) => !minusSet.has(v.replace(/[^A-Za-z0-9]/g, "").toLowerCase())))].sort();
+      e.shape = "py-set";
+      delete e.unresolved;
+    }
+  }
+  const resolved = raw.filter((e) => e.shape !== "py-set-difference");
+  const seen = /* @__PURE__ */ new Map();
+  for (const e of resolved) {
     const key2 = `${e.name}|${e.values.join(",")}`;
     if (!seen.has(key2))
       seen.set(key2, e);
@@ -137254,6 +137977,13 @@ var init_ts_constants = __esm({
 // packages/contract-verifier/dist/extractor/constant/py-constants.js
 function extractPyConstantsFromFile(filePath, source, tree) {
   const out = [];
+  const stringTable = collectStringConstantTable(tree.rootNode, source);
+  walk10(tree.rootNode, (node2) => {
+    if (node2.type === "class_definition") {
+      out.push(...extractSettingsFields(node2, source, filePath, stringTable));
+    }
+    return true;
+  });
   walk10(tree.rootNode, (node2) => {
     if (node2.type !== "assignment")
       return true;
@@ -137263,23 +137993,169 @@ function extractPyConstantsFromFile(filePath, source, tree) {
     const right = node2.childForFieldName("right");
     if (!right)
       return true;
-    const value = parseLiteral(right, source);
-    if (value === UNPARSEABLE2)
+    const name = source.slice(left.startIndex, left.endIndex);
+    const pos = { filePath, lineStart: node2.startPosition.row + 1, lineEnd: node2.endPosition.row + 1 };
+    const value = parseLiteral(right, source, stringTable);
+    if (value !== UNPARSEABLE2) {
+      out.push({ name, value, shape: "const-literal", source: pos });
+      return true;
+    }
+    if (!node2.childForFieldName("type"))
+      return true;
+    if (right.type !== "call")
+      return true;
+    const fn = right.childForFieldName("function");
+    if (!fn)
+      return true;
+    if (!source.slice(fn.startIndex, fn.endIndex).endsWith("Field"))
+      return true;
+    const callArgs = right.childForFieldName("arguments");
+    if (!callArgs)
+      return true;
+    let defaultVal = UNPARSEABLE2;
+    const aliasStrings = [];
+    for (let i = 0; i < callArgs.namedChildCount; i++) {
+      const arg = callArgs.namedChild(i);
+      if (arg?.type !== "keyword_argument")
+        continue;
+      const kwName = arg.childForFieldName("name");
+      const kwVal = arg.childForFieldName("value");
+      if (!kwName || !kwVal)
+        continue;
+      const kw = source.slice(kwName.startIndex, kwName.endIndex);
+      if (kw === "default" && defaultVal === UNPARSEABLE2) {
+        defaultVal = parseLiteral(kwVal, source, stringTable);
+      } else if (kw === "validation_alias") {
+        aliasStrings.push(...extractAliasChoiceStrings(kwVal, source, stringTable));
+      }
+    }
+    if (defaultVal === UNPARSEABLE2)
       return true;
+    out.push({ name, value: defaultVal, shape: "const-literal", source: pos });
+    for (const alias of aliasStrings) {
+      out.push({ name: alias, value: defaultVal, shape: "const-literal", source: pos });
+    }
+    return true;
+  });
+  return out;
+}
+function extractSettingsFields(classNode, source, filePath, stringTable) {
+  const body = classNode.childForFieldName("body");
+  if (!body)
+    return [];
+  const scope = deriveSettingsScope(body, source, stringTable);
+  if (scope === null)
+    return [];
+  const out = [];
+  for (let i = 0; i < body.namedChildCount; i++) {
+    const stmt = body.namedChild(i);
+    if (stmt?.type !== "expression_statement")
+      continue;
+    const assign = stmt.namedChild(0);
+    if (assign?.type !== "assignment")
+      continue;
+    if (!assign.childForFieldName("type"))
+      continue;
+    const left = assign.childForFieldName("left");
+    if (left?.type !== "identifier")
+      continue;
+    const fieldName = source.slice(left.startIndex, left.endIndex);
+    if (fieldName === "model_config")
+      continue;
+    const right = assign.childForFieldName("right");
+    if (!right)
+      continue;
+    const value = fieldDefaultValue(right, source, stringTable);
+    if (value === UNPARSEABLE2)
+      continue;
+    const name = `${scope}_${fieldName}`.toUpperCase();
     out.push({
-      name: source.slice(left.startIndex, left.endIndex),
+      name,
       value,
-      shape: "const-literal",
-      source: { filePath, lineStart: node2.startPosition.row + 1, lineEnd: node2.endPosition.row + 1 }
+      shape: "settings-field",
+      source: { filePath, lineStart: assign.startPosition.row + 1, lineEnd: assign.endPosition.row + 1 }
     });
-    return true;
-  });
+  }
   return out;
 }
-function parseLiteral(node2, source) {
+function deriveSettingsScope(body, source, stringTable) {
+  for (let i = 0; i < body.namedChildCount; i++) {
+    const stmt = body.namedChild(i);
+    if (stmt?.type !== "expression_statement")
+      continue;
+    const assign = stmt.namedChild(0);
+    if (assign?.type !== "assignment")
+      continue;
+    const left = assign.childForFieldName("left");
+    if (left?.type !== "identifier")
+      continue;
+    if (source.slice(left.startIndex, left.endIndex) !== "model_config")
+      continue;
+    const right = assign.childForFieldName("right");
+    if (right?.type !== "call")
+      continue;
+    const args = right.childForFieldName("arguments");
+    if (!args)
+      continue;
+    for (let j2 = 0; j2 < args.namedChildCount; j2++) {
+      const arg = args.namedChild(j2);
+      if (arg?.type !== "keyword_argument")
+        continue;
+      const kw = arg.childForFieldName("name");
+      const val = arg.childForFieldName("value");
+      if (kw && val && source.slice(kw.startIndex, kw.endIndex) === "env_prefix" && val.type === "string") {
+        const prefix = stringValue(val, source, stringTable);
+        if (prefix)
+          return prefix.replace(/_+$/, "").toLowerCase();
+      }
+    }
+    for (let j2 = 0; j2 < args.namedChildCount; j2++) {
+      const arg = args.namedChild(j2);
+      if (arg?.type !== "tuple")
+        continue;
+      const parts = [];
+      for (let k = 0; k < arg.namedChildCount; k++) {
+        const el = arg.namedChild(k);
+        if (el?.type === "string") {
+          const v = stringValue(el, source, stringTable);
+          if (v)
+            parts.push(v);
+        }
+      }
+      if (parts.length > 0)
+        return parts.join("_").toLowerCase();
+    }
+  }
+  return null;
+}
+function fieldDefaultValue(right, source, stringTable) {
+  const direct = parseLiteral(right, source, stringTable);
+  if (direct !== UNPARSEABLE2)
+    return direct;
+  if (right.type !== "call")
+    return UNPARSEABLE2;
+  const fn = right.childForFieldName("function");
+  if (!fn || !source.slice(fn.startIndex, fn.endIndex).endsWith("Field"))
+    return UNPARSEABLE2;
+  const args = right.childForFieldName("arguments");
+  if (!args)
+    return UNPARSEABLE2;
+  for (let i = 0; i < args.namedChildCount; i++) {
+    const arg = args.namedChild(i);
+    if (arg?.type !== "keyword_argument")
+      continue;
+    const kw = arg.childForFieldName("name");
+    const val = arg.childForFieldName("value");
+    if (kw && val && source.slice(kw.startIndex, kw.endIndex) === "default") {
+      return parseLiteral(val, source, stringTable);
+    }
+  }
+  return UNPARSEABLE2;
+}
+function parseLiteral(node2, source, stringTable) {
   switch (node2.type) {
     case "string": {
-      const v = stringValue2(node2, source);
+      const v = stringValue(node2, source, stringTable);
       return v === null ? UNPARSEABLE2 : v;
     }
     case "integer":
@@ -137303,7 +138179,7 @@ function parseLiteral(node2, source) {
         const c2 = node2.namedChild(i);
         if (!c2)
           continue;
-        const v = parseLiteral(c2, source);
+        const v = parseLiteral(c2, source, stringTable);
         if (v === UNPARSEABLE2)
           return UNPARSEABLE2;
         items.push(v);
@@ -137322,12 +138198,12 @@ function parseLiteral(node2, source) {
           continue;
         let key2 = null;
         if (keyNode.type === "string")
-          key2 = stringValue2(keyNode, source);
+          key2 = stringValue(keyNode, source, stringTable);
         else if (keyNode.type === "identifier")
           key2 = source.slice(keyNode.startIndex, keyNode.endIndex);
         if (key2 === null)
           return UNPARSEABLE2;
-        const v = parseLiteral(valNode, source);
+        const v = parseLiteral(valNode, source, stringTable);
         if (v === UNPARSEABLE2)
           return UNPARSEABLE2;
         obj[key2] = v;
@@ -137338,23 +138214,28 @@ function parseLiteral(node2, source) {
       return UNPARSEABLE2;
   }
 }
-function stringValue2(node2, source) {
-  let content = "";
-  let sawContent = false;
-  for (let i = 0; i < node2.namedChildCount; i++) {
-    const c2 = node2.namedChild(i);
-    if (c2?.type === "string_content") {
-      content += source.slice(c2.startIndex, c2.endIndex);
-      sawContent = true;
-    } else if (c2?.type === "interpolation") {
-      return null;
+function extractAliasChoiceStrings(node2, source, stringTable) {
+  if (node2.type !== "call")
+    return [];
+  const fn = node2.childForFieldName("function");
+  if (!fn)
+    return [];
+  const fnText = source.slice(fn.startIndex, fn.endIndex);
+  if (!fnText.endsWith("AliasChoices"))
+    return [];
+  const args = node2.childForFieldName("arguments");
+  if (!args)
+    return [];
+  const result = [];
+  for (let i = 0; i < args.namedChildCount; i++) {
+    const c2 = args.namedChild(i);
+    if (c2?.type === "string") {
+      const v = stringValue(c2, source, stringTable);
+      if (v !== null)
+        result.push(v);
     }
   }
-  if (sawContent)
-    return content;
-  const raw = source.slice(node2.startIndex, node2.endIndex);
-  const m = raw.match(/^[a-zA-Z]*('''|"""|'|")([\s\S]*)\1$/);
-  return m ? m[2] : null;
+  return result;
 }
 function walk10(node2, visit) {
   const recurse = visit(node2);
@@ -137370,6 +138251,7 @@ var UNPARSEABLE2;
 var init_py_constants = __esm({
   "packages/contract-verifier/dist/extractor/constant/py-constants.js"() {
     "use strict";
+    init_py_string_resolver();
     UNPARSEABLE2 = Symbol("unparseable");
   }
 });
@@ -137855,7 +138737,7 @@ function readTransitionMap(node2, s) {
     for (const elem of v.namedChildren) {
       if (elem.type !== "string")
         return null;
-      const text = stringValue3(elem, s);
+      const text = stringValue2(elem, s);
       if (text === null)
         return null;
       tos.push(text);
@@ -137894,7 +138776,7 @@ function readFieldAssignment(node2, s) {
     return null;
   if (rhs.type !== "string")
     return null;
-  const value = stringValue3(rhs, s);
+  const value = stringValue2(rhs, s);
   if (value === null)
     return null;
   return {
@@ -138001,13 +138883,13 @@ function matchPair(member, literal, s) {
   return [{
     receiver: s.source.slice(obj.startIndex, obj.endIndex),
     field: s.source.slice(prop.startIndex, prop.endIndex),
-    value: stringValue3(literal, s) ?? ""
+    value: stringValue2(literal, s) ?? ""
   }];
 }
 function stripQuotes(str2) {
   return str2.replace(/^['"]|['"]$/g, "");
 }
-function stringValue3(node2, s) {
+function stringValue2(node2, s) {
   if (node2.type !== "string")
     return null;
   const childType = s.lang === "python" ? "string_content" : "string_fragment";
@@ -139170,7 +140052,11 @@ async function extractOperationsFromDir(rootDir) {
   await eachParsedSource(rootDir, (s) => {
     if (s.lang !== "python")
       return;
-    for (const op of extractFastApiOperationsFromFile(s.filePath, s.source, s.tree)) {
+    const pythonOps = [
+      ...extractFastApiOperationsFromFile(s.filePath, s.source, s.tree),
+      ...extractStarletteRoutesFromFile(s.filePath, s.source, s.tree)
+    ];
+    for (const op of pythonOps) {
       if (!seen.has(op.identity)) {
         expressOps.push(op);
         seen.add(op.identity);
@@ -140402,7 +141288,9 @@ import { randomUUID as randomUUID19 } from "node:crypto";
 function compareEnum(input) {
   const { ref, contract, codeEnums } = input;
   const drifts = [];
-  const nameMatches = matchByName(contract, codeEnums, ref.identity);
+  const matched = matchByName(contract, codeEnums, ref.identity);
+  const valueOnlyMatch = matched.byName.length === 0;
+  const nameMatches = matched.byName.length > 0 ? matched.byName : bestValueMatch(contract, matched.byValue);
   if (nameMatches.length === 0) {
     drifts.push({
       id: randomUUID19(),
@@ -140418,21 +141306,37 @@ function compareEnum(input) {
       codeSide: "<no match>"
     });
   } else {
+    const specNorm = new Map(contract.values.map((v) => [normalizeValue(v), v]));
+    const cloudOnlyValues = new Set((contract.triggerSubsets ?? []).filter((s) => isEnvironmentGatedSubset(s.name)).flatMap((s) => s.values.map(normalizeValue)));
+    const byName = /* @__PURE__ */ new Map();
     for (const m of nameMatches) {
-      const specNorm = new Map(contract.values.map((v) => [normalizeValue(v), v]));
-      const codeNorm = new Map(m.values.map((v) => [normalizeValue(v), v]));
-      const missing = contract.values.filter((v) => !codeNorm.has(normalizeValue(v)));
-      const extra = m.values.filter((v) => !specNorm.has(normalizeValue(v)));
+      const key2 = normalizeName(m.name);
+      if (!byName.has(key2))
+        byName.set(key2, { values: /* @__PURE__ */ new Set(), repr: m });
+      const g = byName.get(key2);
+      for (const v of m.values)
+        g.values.add(normalizeValue(v));
+    }
+    const specNormSet = new Set(contract.values.map(normalizeValue));
+    for (const g of byName.values()) {
+      if (valueOnlyMatch && isStrictSubset(g.values, specNormSet))
+        continue;
+      const missing = contract.values.filter((v) => !g.values.has(normalizeValue(v)) && !cloudOnlyValues.has(normalizeValue(v)));
       for (const v of missing) {
-        drifts.push(mkValueDrift(ref, "missing-value", v, m, contract.values));
+        drifts.push(mkValueDrift(ref, "missing-value", v, g.repr, contract.values));
       }
+    }
+    for (const m of nameMatches) {
+      if (isSynthesizedEnumShape(m.shape))
+        continue;
+      const extra = m.values.filter((v) => !specNorm.has(normalizeValue(v)));
       for (const v of extra) {
         drifts.push(mkValueDrift(ref, "extra-value", v, m, contract.values));
       }
     }
   }
   for (const subset of contract.triggerSubsets ?? []) {
-    const subsetMatches = matchSubsetByName(subset.name, codeEnums);
+    const subsetMatches = matchSubsetByName(subset.name, subset.values, codeEnums);
     if (subsetMatches.length === 0) {
       drifts.push({
         id: randomUUID19(),
@@ -140473,13 +141377,17 @@ function normalizeName(s) {
   }
   return n;
 }
+function isEnvironmentGatedSubset(name) {
+  return normalizeName(name) === "cloudonly";
+}
 function matchByName(contract, codeEnums, specName) {
   const target = normalizeName(specName);
-  const out = [];
+  const byName = [];
+  const byValue = [];
   for (const e of codeEnums) {
     const codeName = normalizeName(e.name);
     if (codeName === target) {
-      out.push(e);
+      byName.push(e);
       continue;
     }
     if (codeName.includes(target) || target.includes(codeName)) {
@@ -140490,7 +141398,7 @@ function matchByName(contract, codeEnums, specName) {
         }
       }
       if (valueSetOverlap(contract.values, e.values) >= 0.5) {
-        out.push(e);
+        byName.push(e);
         continue;
       }
     }
@@ -140499,21 +141407,40 @@ function matchByName(contract, codeEnums, specName) {
       const overlap = valueSetOverlap(contract.values, e.values);
       const sizeDiff = Math.abs(contract.values.length - e.values.length);
       if (overlap >= 0.6 && sizeDiff <= 2) {
-        out.push(e);
+        byValue.push(e);
       }
     } else if (minLen >= 2) {
       const overlap = valueSetOverlap(contract.values, e.values);
       const sizeDiff = Math.abs(contract.values.length - e.values.length);
       if (overlap === 1 && sizeDiff === 0) {
-        out.push(e);
+        byValue.push(e);
       }
     }
   }
-  return out;
+  return { byName, byValue };
+}
+function bestValueMatch(contract, byValue) {
+  if (byValue.length <= 1)
+    return byValue;
+  let best = -1;
+  for (const e of byValue)
+    best = Math.max(best, valueSetOverlap(contract.values, e.values));
+  return byValue.filter((e) => valueSetOverlap(contract.values, e.values) === best);
+}
+function isSynthesizedEnumShape(shape) {
+  return shape === "sibling-id-literal" || shape === "py-instance-registry" || shape === "py-discriminated-union" || shape === "py-constant-cluster";
 }
 function normalizeValue(v) {
   return v.replace(/[^A-Za-z0-9]/g, "").toLowerCase();
 }
+function isStrictSubset(codeValues, specNorm) {
+  if (codeValues.size === 0 || codeValues.size >= specNorm.size)
+    return false;
+  for (const v of codeValues)
+    if (!specNorm.has(v))
+      return false;
+  return true;
+}
 function valueSetOverlap(a, b) {
   const aSet = new Set(a.map(normalizeValue));
   const bSet = new Set(b.map(normalizeValue));
@@ -140521,9 +141448,21 @@ function valueSetOverlap(a, b) {
   const union = (/* @__PURE__ */ new Set([...aSet, ...bSet])).size;
   return union === 0 ? 0 : intersection / union;
 }
-function matchSubsetByName(subsetName, codeEnums) {
+function matchSubsetByName(subsetName, subsetValues, codeEnums) {
   const target = normalizeName(subsetName);
-  return codeEnums.filter((e) => normalizeName(e.name) === target);
+  const out = [];
+  for (const e of codeEnums) {
+    const codeName = normalizeName(e.name);
+    if (codeName === target) {
+      out.push(e);
+      continue;
+    }
+    if (codeName.includes(target) || target.includes(codeName)) {
+      if (valueSetOverlap(subsetValues, e.values) >= 0.5)
+        out.push(e);
+    }
+  }
+  return out;
 }
 function mkValueDrift(ref, kind, value, codeEnum, specValues) {
   const severity = kind === "missing-value" ? "high" : "medium";
@@ -140648,6 +141587,21 @@ function compareNamedConstant(input) {
       return false;
     });
   }
+  if (matches.length === 0) {
+    matches = codeConstants.filter((c2) => {
+      if (c2.shape !== "settings-field")
+        return false;
+      const codeName = normalizeName2(c2.name);
+      if (codeName.length < 8 || !target.endsWith(codeName))
+        return false;
+      return contract.expectedValue === void 0 || deepEqual(
+        contract.expectedValue,
+        c2.value,
+        /*allowExtraCodeKeys*/
+        true
+      );
+    });
+  }
   if (matches.length === 0) {
     return [{
       id: randomUUID21(),
@@ -140891,6 +141845,8 @@ async function verify(opts) {
     if (!code2) {
       if (st2 === "planned" || st2 === "deferred" || st2 === "out-of-scope")
         continue;
+      if (/^[A-Z]+ https?:\/\//.test(artifact.ref.identity))
+        continue;
       drifts.push({
         id: cryptoRandomId(),
         type: "contract-drift",
@@ -142199,7 +143155,7 @@ function stripCodeFences(text) {
 }
 function cliTransport(opts = {}) {
   const bin = opts.bin ?? resolveClaudeBinary();
-  return (req) => new Promise((resolve9, reject) => {
+  return (req) => new Promise((resolve10, reject) => {
     const modelArgs = [];
     if (req.model)
       modelArgs.push("--model", req.model);
@@ -142244,7 +143200,7 @@ function cliTransport(opts = {}) {
           reject(new Error("claude returned no text"));
           return;
         }
-        resolve9(text);
+        resolve10(text);
       } catch (e) {
         reject(e instanceof Error ? e : new Error(String(e)));
       }
@@ -142378,7 +143334,7 @@ function checkClaudeAuth(binary2 = resolveClaudeBinary(), options = {}) {
     return Promise.resolve({ ok: false, reason: "not-found" });
   }
   const timeoutMs = options.timeoutMs ?? 6e4;
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const proc = (0, import_cross_spawn2.spawn)(binary2, ["-p", "Reply with the single word: ok"], {
       stdio: ["ignore", "pipe", "pipe"],
       env: cleanClaudeEnv()
@@ -142390,7 +143346,7 @@ function checkClaudeAuth(binary2 = resolveClaudeBinary(), options = {}) {
         return;
       settled = true;
       clearTimeout(timer);
-      resolve9(r);
+      resolve10(r);
     };
     const timer = setTimeout(() => {
       proc.kill("SIGKILL");
@@ -143088,7 +144044,7 @@ var WindowsService = class {
     const { Service } = nw;
     const logDir = path22.dirname(logPath);
     const truecourseHome = path22.join(os7.homedir(), ".truecourse");
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const svc = new Service({
         name: SERVICE_DISPLAY_NAME,
         description: "TrueCourse Server",
@@ -143104,7 +144060,7 @@ var WindowsService = class {
       });
       svc.on("install", () => {
         svc.start();
-        resolve9();
+        resolve10();
       });
       svc.on("error", (err) => reject(err));
       svc.install();
@@ -143113,13 +144069,13 @@ var WindowsService = class {
   async uninstall() {
     const nw = await this.getNodeWindows();
     const { Service } = nw;
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       const svc = new Service({
         name: SERVICE_DISPLAY_NAME,
         script: ""
         // Not needed for uninstall
       });
-      svc.on("uninstall", () => resolve9());
+      svc.on("uninstall", () => resolve10());
       svc.on("error", (err) => reject(err));
       svc.uninstall();
     });
@@ -144583,6 +145539,27 @@ not narrow the set.
 substitute for \`immutable\`. If a derived/server-computed field is also frozen
 after creation, emit BOTH \`computed-at\` AND \`immutable\`.
 
+**NEVER infer \`immutable\` from what a field IS \u2014 only from what the spec SAYS
+about changing it.** The following do NOT imply immutability, alone or combined:
+
+- The field is required (\`Required? yes\` in a field table).
+- The field is an identifier (\`id\`, \`uuid\`, "identifier of this X").
+- The field is a timestamp ("when the event happened", \`occurred\`, \`createdAt\`).
+- The field is client-provided or server-assigned (provenance is not mutability).
+
+Counter-example \u2014 a field table like:
+
+| Name     | Type   | Required? | Description                              |
+| -------- | ------ | --------- | ---------------------------------------- |
+| occurred | String | yes       | When the event happened                  |
+| id       | String | yes       | Client-provided identifier of this event |
+
+asserts NOTHING about mutability. Both fields get plain \`field occurred: string {}\`
+/ \`field id: string {}\` \u2014 no \`immutable\`, even though an id "sounds" immutable.
+Emitting un-stated \`immutable\` creates a false drift against every codebase whose
+model simply doesn't freeze the field. If the spec is silent on mutability, the
+contract is silent on mutability.
+
 # Enum extraction \u2014 required whenever spec defines an enum
 
 Whenever the spec text contains any of:
@@ -144605,6 +145582,27 @@ data document. If \`Entity:Customer\` references \`Enum:LoyaltyTier\` and the sa
 slice contains "LoyaltyTier values: standard, silver, gold", emit BOTH the entity
 fragment AND the enum fragment.
 
+**An enum is a closed set of DATA VALUES the code compares against** (the
+string/number literals a field is set to or checked against) \u2014 NOT a catalog of
+code symbols a caller picks between. Before emitting, check what the listed items
+ARE. Emit nothing when the list is:
+
+- **Implementation / plugin classes** \u2014 e.g. "run launchers: \`DefaultRunLauncher\`,
+  \`DockerRunLauncher\`, \`K8sRunLauncher\`", storage backends, compute-log managers.
+  These are swappable extension points (a user can add their own); the items are
+  class names, not a closed value set.
+- **API functions, decorators, or methods** \u2014 e.g. "asset decorators: \`asset\`,
+  \`multi_asset\`, \`graph_asset\`". These are symbols a user calls, not values.
+- **An incidental excerpt** \u2014 a few items quoted inside a troubleshooting,
+  example, or how-to passage ("relevant event types: \u2026") rather than a
+  definitional "the valid values of X are \u2026". A subset mentioned in passing is
+  not an enum definition.
+
+Discriminator: if the items are **names of code symbols** (classes / functions a
+caller selects), do NOT emit an enum. Only emit when the items are **literal data
+values** the code stores or compares against (config keys, status strings, tag
+keys, numeric codes).
+
 **Never reference an enum without defining it.** Every \`Enum:X\` identifier you
 emit (in \`field: Enum:X\` or \`states Enum:X\`) MUST have a matching \`enum X { \u2026 }\`
 artifact somewhere in the same slice (or you must assume another slice provides
@@ -144934,6 +145932,42 @@ Don't emit constants whose value is a function call, expression, or
 external reference \u2014 only literal values (strings, numbers, booleans,
 arrays of literals, flat object literals of literals).
 
+**Don't extract constants from customization examples.** A constant asserts
+"the code MUST hold this value". A doc that shows users how to CUSTOMIZE or
+OVERRIDE something is asserting the opposite \u2014 "you can put whatever value
+you want here" \u2014 and its example values are illustrations, not obligations.
+Skip a candidate value when EITHER signal is present:
+
+1. **Context signal**: the page title or enclosing section heading describes
+   a customization/override mechanism \u2014 "Customize \u2026", "Override \u2026",
+   "\u2026 template", "\u2026 variables", "Configure your own \u2026", "Example
+   configuration".
+2. **Shape signal**: the value sits inside a JSON-schema-style variables
+   block, i.e. an object of the form
+   \`"<name>": { "title": \u2026, "description": \u2026, "default": <value>, "type": \u2026 }\`.
+   That quadruple is a schema DECLARING an overridable variable; the
+   \`"default"\` there is a starting point the user is expected to change.
+
+Counter-example \u2014 a page titled "Customize Base Job Templates" containing:
+
+\`\`\`json
+"cpu_request": {
+  "title": "CPU Request",
+  "description": "CPU allocation to request for this pod",
+  "default": "100m",
+  "type": "string"
+}
+\`\`\`
+
+emits NO constant. Both signals fire: the page is a customization guide, and
+the value is a variables-schema \`default\`. Extracting
+\`constant cpu_request { expected-value "100m" }\` would demand every codebase
+hard-code the example \u2014 a guaranteed false drift.
+
+By contrast, prose like "the scheduler polls every 15 seconds" or "the API
+version is \`v2\`" in a behavioral spec section IS an assertion about the
+system \u2014 extract those normally.
+
 # ArchitectureDecision \u2014 extract when the spec/ADR fixes a platform choice
 
 A spec or ADR that records a system-wide technology choice \u2014 "we use
@@ -145431,6 +146465,7 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   ".cache",
   "coverage"
 ]);
+var SKIP_DIR_PROBE = "__tc_skipdir_probe__.md";
 var PREVIEW_LINE_LIMIT = 200;
 function discoverDocs(rootDir, opts = {}) {
   const previewLines = opts.previewLines ?? PREVIEW_LINE_LIMIT;
@@ -145445,11 +146480,12 @@ function discoverDocs(rootDir, opts = {}) {
     }
     entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
     for (const entry of entries) {
-      if (SKIP_DIRS.has(entry.name))
+      const full = path26.join(dir, entry.name);
+      if (SKIP_DIRS.has(entry.name) && !(entry.isDirectory() && tcIgnore.reincludes(path26.join(full, SKIP_DIR_PROBE)))) {
         continue;
+      }
       if (entry.name.startsWith(".") && entry.name !== ".")
         continue;
-      const full = path26.join(dir, entry.name);
       if (tcIgnore.ignores(full))
         continue;
       if (entry.isDirectory()) {
@@ -147308,14 +148344,14 @@ async function explainConflicts(repoRoot6, conflicts2, opts = {}) {
   opts.onStart?.(conflicts2.length);
   let active = 0;
   let cursor = 0;
-  await new Promise((resolve9) => {
+  await new Promise((resolve10) => {
     const launch = () => {
       while (active < concurrency && cursor < conflicts2.length) {
         const conflict = conflicts2[cursor++];
         if (conflict.explanation) {
           opts.onDone?.();
           if (cursor >= conflicts2.length && active === 0)
-            resolve9();
+            resolve10();
           continue;
         }
         active++;
@@ -147323,13 +148359,13 @@ async function explainConflicts(repoRoot6, conflicts2, opts = {}) {
           opts.onDone?.();
           active--;
           if (cursor >= conflicts2.length && active === 0)
-            resolve9();
+            resolve10();
           else
             launch();
         });
       }
       if (cursor >= conflicts2.length && active === 0)
-        resolve9();
+        resolve10();
     };
     launch();
   });
@@ -147562,7 +148598,7 @@ async function resolveConflicts(repoRoot6, conflicts2, opts = {}) {
   const out = [];
   let cursor = 0;
   let active = 0;
-  await new Promise((resolve9) => {
+  await new Promise((resolve10) => {
     const launch = () => {
       while (active < concurrency && cursor < conflicts2.length) {
         const conflict = conflicts2[cursor++];
@@ -147581,13 +148617,13 @@ async function resolveConflicts(repoRoot6, conflicts2, opts = {}) {
         }).finally(() => {
           active--;
           if (cursor >= conflicts2.length && active === 0)
-            resolve9();
+            resolve10();
           else
             launch();
         });
       }
       if (cursor >= conflicts2.length && active === 0)
-        resolve9();
+        resolve10();
     };
     launch();
   });
@@ -147807,7 +148843,7 @@ async function filterByRelevance(repoRoot6, docs, opts = {}) {
   const verdicts = /* @__PURE__ */ new Map();
   let cursor = 0;
   let active = 0;
-  await new Promise((resolve9) => {
+  await new Promise((resolve10) => {
     const launch = () => {
       while (active < concurrency && cursor < docs.length) {
         const doc = docs[cursor++];
@@ -147815,7 +148851,7 @@ async function filterByRelevance(repoRoot6, docs, opts = {}) {
           verdicts.set(doc.path, { path: doc.path, include: true, reason: "manual include" });
           markDone();
           if (cursor >= docs.length && active === 0)
-            resolve9();
+            resolve10();
           continue;
         }
         active++;
@@ -147831,13 +148867,13 @@ async function filterByRelevance(repoRoot6, docs, opts = {}) {
           markDone();
           active--;
           if (cursor >= docs.length && active === 0)
-            resolve9();
+            resolve10();
           else
             launch();
         });
       }
       if (cursor >= docs.length && active === 0)
-        resolve9();
+        resolve10();
     };
     launch();
   });
@@ -154574,7 +155610,7 @@ async function runHooksRun() {
 
 // tools/cli/src/index.ts
 var program2 = new Command();
-program2.name("truecourse").version("0.6.6").description("TrueCourse CLI \u2014 analyze your repository and open the dashboard");
+program2.name("truecourse").version("0.6.7-next.1").description("TrueCourse CLI \u2014 analyze your repository and open the dashboard");
 var dashboardCmd = program2.command("dashboard").description("Start the TrueCourse dashboard and open it in your browser").option("--reconfigure", "Re-prompt for console vs background service mode").option("--service", "Run as a background service (skips mode prompt)").option("--console", "Run in this terminal (skips mode prompt)").action(async (options) => {
   if (options.service && options.console) {
     console.error("error: --service and --console are mutually exclusive");