{
  "version": "act 2.1.1",
  "language_id": "qml",
  "language_name": "QML",
  "url": "https://act101.ai/docs/languages/qml",
  "is_premium": false,
  "operations": [
    {
      "anchor": "op-callers",
      "name": "callers",
      "category": "Query",
      "description": "Find every call site of a function or method across the codebase. Use to understand who depends on a function before changing its signature. Requires LSP. Params: symbol (string) [, file (string)]"
    },
    {
      "anchor": "op-control-flow",
      "name": "control_flow",
      "category": "Query",
      "description": "Get a function's control flow \u2014 branches, loops, early returns, and basic blocks in execution order. Use to understand complex logic without reading the full implementation. Params: target (string), file (string)"
    },
    {
      "anchor": "op-data-flow",
      "name": "data_flow",
      "category": "Query",
      "description": "Intra-procedural def-use \u2014 variable definitions, uses, def\u2192use edges, and which locals flow into the return. The dual of control_flow. Single-file. Params: target (string), file (string)"
    },
    {
      "anchor": "op-definition",
      "name": "definition",
      "category": "Query",
      "description": "Jump to definition \u2014 find where a symbol is defined given a usage location. Uses AST-based parsing by default, no LSP required. Params: symbol (string), file (string), line (u32), column (u32)"
    },
    {
      "anchor": "op-diagnostics",
      "name": "diagnostics",
      "category": "Query",
      "description": "Get compiler errors and warnings from the language server. Omit `file` for workspace-wide diagnostics. Pass a file path or directory path to scope results. Requires LSP. Params: none [, file (string)]"
    },
    {
      "anchor": "op-effect-closure",
      "name": "effect_closure",
      "category": "Query",
      "description": "Transitive effect closure of a function across the call graph \u2014 composed reads/writes/raises/allocates/blocks/awaits with provenance, recorded cycles, and the unresolved-call frontier. Params: target (string), file (string) [, max_depth (u32), max_nodes (u32)]"
    },
    {
      "anchor": "op-effect-summary",
      "name": "effect_summary",
      "category": "Query",
      "description": "Get a function's effect signature \u2014 reads, writes, raises, allocates, blocking calls, and awaits \u2014 plus the unresolved-call frontier. Single-file, intra-procedural. Params: target (string), file (string)"
    },
    {
      "anchor": "op-fix-auto",
      "name": "fix_auto",
      "category": "Query",
      "description": "Auto-fix all deterministic issues in a file, directory, or workspace \u2014 missing imports, unused imports, simple type errors. Runs multiple fix-revalidate cycles. Use after making changes to clean up automatically. Requires LSP. Params: none [, file (string), workspace_mode (bool), category (string), commit (bool), max_rounds (u32)]"
    },
    {
      "anchor": "op-get-type",
      "name": "get_type",
      "category": "Query",
      "description": "Get the compiler-inferred type of any expression at a position. Use to understand types without reading surrounding code. Requires LSP. Params: file (string), line (u32), column (u32)"
    },
    {
      "anchor": "op-graph",
      "name": "graph",
      "category": "Query",
      "description": "Build a dependency graph from a file \u2014 trace what it imports and what imports it, across multiple hops. Use to understand module relationships and change impact before refactoring. Params: file (string) [, depth (u32), direction (string), leaves (bool), order (string)]"
    },
    {
      "anchor": "op-import-organize",
      "name": "import_organize",
      "category": "Query",
      "description": "Organize, sort, and deduplicate imports in a file. Removes unused imports. Use after adding new code or moving symbols to clean up import blocks automatically. Params: file (string) [, preview (bool)]"
    },
    {
      "anchor": "op-interface",
      "name": "interface",
      "category": "Query",
      "description": "Get a symbol's public API \u2014 signatures, types, and docstrings without implementation bodies. Like skeleton but for a single symbol. Use to understand how to call something without reading its internals. Params: target (string), file (string) [, include_private (bool)]"
    },
    {
      "anchor": "op-mutations",
      "name": "mutations",
      "category": "Query",
      "description": "Identify side effects \u2014 what external state a function reads or writes (globals, file I/O, network, etc.). Use to understand if a function is pure or has hidden dependencies. Params: target (string), file (string)"
    },
    {
      "anchor": "op-references",
      "name": "references",
      "category": "Query",
      "description": "Find every usage of a symbol across the entire codebase \u2014 all files, not just the current one. Use before renaming, refactoring, or deleting to understand full impact. Requires LSP. Params: symbol (string), file (string)"
    },
    {
      "anchor": "op-repo-outline",
      "name": "repo_outline",
      "category": "Query",
      "description": "Get a compressed overview of the entire repository in one call \u2014 file tree with languages, line counts, and optionally symbol names per file. Orders of magnitude cheaper than listing directories and reading files individually. Params: none [, path (string), depth (u32), include (glob), exclude (glob), symbols (bool), max_files (u32), relative (bool)]"
    },
    {
      "anchor": "op-skeleton",
      "name": "skeleton",
      "category": "Query",
      "description": "Get a file's structure \u2014 function signatures, class declarations, type definitions \u2014 without implementation bodies. Use INSTEAD of reading the full file to understand its API. Typically 5-10x fewer tokens than reading the raw file. Params: file (string)"
    },
    {
      "anchor": "op-symbols",
      "name": "symbols",
      "category": "Query",
      "description": "List all symbols (functions, classes, variables, types, constants) defined in a file with their locations and kinds. Use INSTEAD of reading a file when you need to know what's defined in it. Much cheaper than reading the full file. IMPORTANT: file must be a path to a single source file \u2014 never a directory or empty string. Params: file (string)"
    },
    {
      "anchor": "op-symbols-batch",
      "name": "symbols_batch",
      "category": "Query",
      "description": "Retrieve symbols from multiple files in a single call. Use instead of calling symbols() in a loop \u2014 one request instead of N. Params: none [, files (string[]), ids (string[]), kinds (string[])] \u2014 provide files or ids"
    },
    {
      "anchor": "op-add-explicit-type-to-property",
      "name": "add-explicit-type-to-property",
      "category": "Refactor",
      "description": "Add type annotation to property"
    },
    {
      "anchor": "op-add-import-statement",
      "name": "add-import-statement",
      "category": "Refactor",
      "description": "Add missing import statement"
    },
    {
      "anchor": "op-add-null-check",
      "name": "add-null-check",
      "category": "Refactor",
      "description": "Wrap property access in conditional guard against undefined"
    },
    {
      "anchor": "op-add-parentheses-to-complex-expression",
      "name": "add-parentheses-to-complex-expression",
      "category": "Refactor",
      "description": "Add parentheses to complex expression for clarity"
    },
    {
      "anchor": "op-convert-arrow-to-block-body",
      "name": "convert-arrow-to-block-body",
      "category": "Refactor",
      "description": "Convert arrow function to block body"
    },
    {
      "anchor": "op-convert-binding-loop-breaker",
      "name": "convert-binding-loop-breaker",
      "category": "Refactor",
      "description": "Add explicit state variable to break property binding loops"
    },
    {
      "anchor": "op-convert-block-to-arrow-body",
      "name": "convert-block-to-arrow-body",
      "category": "Refactor",
      "description": "Convert block function body to arrow expression"
    },
    {
      "anchor": "op-convert-repeated-to-repeater",
      "name": "convert-repeated-to-repeater",
      "category": "Refactor",
      "description": "Extract list binding into Repeater component"
    },
    {
      "anchor": "op-convert-signal-parameters-to-object",
      "name": "convert-signal-parameters-to-object",
      "category": "Refactor",
      "description": "Convert multiple signal parameters to single object parameter"
    },
    {
      "anchor": "op-convert-string-concatenation-to-template",
      "name": "convert-string-concatenation-to-template",
      "category": "Refactor",
      "description": "Convert string concatenation to template literal"
    },
    {
      "anchor": "op-convert-var-to-property",
      "name": "convert-var-to-property",
      "category": "Refactor",
      "description": "Convert var variable to typed property"
    },
    {
      "anchor": "op-extract-component",
      "name": "extract-component",
      "category": "Refactor",
      "description": "Move inline component to separate .qml file"
    },
    {
      "anchor": "op-extract-lambda-to-named-function",
      "name": "extract-lambda-to-named-function",
      "category": "Refactor",
      "description": "Extract lambda to named method"
    },
    {
      "anchor": "op-extract-method",
      "name": "extract-method",
      "category": "Refactor",
      "description": "Extract code block into new method within component"
    },
    {
      "anchor": "op-extract-property",
      "name": "extract-property",
      "category": "Refactor",
      "description": "Extract computed expression into new property with binding"
    },
    {
      "anchor": "op-extract-function",
      "name": "extract_function",
      "category": "Refactor",
      "description": "Extract a code selection into a new function \u2014 automatically infers parameters, return types, and inserts the call site. Use instead of manually cutting/pasting code. Works without LSP; LSP improves type inference. Params: file (string), new_name (string), start_line (u32), start_column (u32), end_line (u32), end_column (u32) [, preview (bool), receipt (bool)]"
    },
    {
      "anchor": "op-extract-variable",
      "name": "extract_variable",
      "category": "Refactor",
      "description": "Extract an expression into a named variable \u2014 inserts the declaration and replaces the expression with the variable name. Works without LSP. Params: file (string), new_name (string), start_line (u32), start_column (u32), end_line (u32), end_column (u32) [, preview (bool)]"
    },
    {
      "anchor": "op-generate-compare-method",
      "name": "generate-compare-method",
      "category": "Refactor",
      "description": "Generate comparison method"
    },
    {
      "anchor": "op-generate-component-structure",
      "name": "generate-component-structure",
      "category": "Refactor",
      "description": "Generate basic component skeleton"
    },
    {
      "anchor": "op-generate-getter-setter-pair",
      "name": "generate-getter-setter-pair",
      "category": "Refactor",
      "description": "Generate get/set functions for property"
    },
    {
      "anchor": "op-generate-import-statement",
      "name": "generate-import-statement",
      "category": "Refactor",
      "description": "Generate and add required import statement"
    },
    {
      "anchor": "op-generate-method-signature",
      "name": "generate-method-signature",
      "category": "Refactor",
      "description": "Generate method declaration"
    },
    {
      "anchor": "op-generate-property",
      "name": "generate-property",
      "category": "Refactor",
      "description": "Generate property declaration"
    },
    {
      "anchor": "op-generate-signal",
      "name": "generate-signal",
      "category": "Refactor",
      "description": "Generate signal with parameters"
    },
    {
      "anchor": "op-generate-signal-handler",
      "name": "generate-signal-handler",
      "category": "Refactor",
      "description": "Generate signal handler method"
    },
    {
      "anchor": "op-generate-tostring-method",
      "name": "generate-tostring-method",
      "category": "Refactor",
      "description": "Generate string representation method"
    },
    {
      "anchor": "op-inline",
      "name": "inline",
      "category": "Refactor",
      "description": "Inline a variable, function, or method \u2014 replace every usage with its definition body, then remove the original. The inverse of extract. Works without LSP (single-file); LSP enables cross-file inlining. Params: file (string), symbol (string) [, line (u32), preview (bool), receipt (bool)]"
    },
    {
      "anchor": "op-inline-component",
      "name": "inline-component",
      "category": "Refactor",
      "description": "Inline component from separate file"
    },
    {
      "anchor": "op-inline-lambda-expression",
      "name": "inline-lambda-expression",
      "category": "Refactor",
      "description": "Replace named function reference with inline lambda"
    },
    {
      "anchor": "op-inline-trivial-component",
      "name": "inline-trivial-component",
      "category": "Refactor",
      "description": "Inline simple 1-2 property component"
    },
    {
      "anchor": "op-insert-body",
      "name": "insert_body",
      "category": "Refactor",
      "description": "Replace a function's implementation body with new code. AST-validated \u2014 rejects if the result has parse errors, so you can't accidentally break syntax. Use instead of manual text editing for function rewrites. Params: file (string), symbol (string), code (string) [, commit (bool)]"
    },
    {
      "anchor": "op-invert-conditional",
      "name": "invert-conditional",
      "category": "Refactor",
      "description": "Invert if-else blocks"
    },
    {
      "anchor": "op-move-property-to-parent",
      "name": "move-property-to-parent",
      "category": "Refactor",
      "description": "Move property from child to parent component"
    },
    {
      "anchor": "op-move-symbol",
      "name": "move_symbol",
      "category": "Refactor",
      "description": "Move a function, class, or type to a different file and automatically update all imports across the codebase. Use instead of manually cut/paste + fixing imports. Works without LSP (single-file); LSP enables cross-file import updates. Params: file (string), symbol (string), destination (string) [, preview (bool), receipt (bool)]"
    },
    {
      "anchor": "op-recipe-run",
      "name": "recipe_run",
      "category": "Refactor",
      "description": "Run a codemod recipe: declarative match \u2192 transform \u2192 optional verify across modeled grammars. Preview lists matches; apply writes with optional E7 receipts and all-or-nothing rollback. Returns a per-site report."
    },
    {
      "anchor": "op-remove-unnecessary-parentheses",
      "name": "remove-unnecessary-parentheses",
      "category": "Refactor",
      "description": "Remove redundant parentheses from expressions"
    },
    {
      "anchor": "op-remove-unused-import",
      "name": "remove-unused-import",
      "category": "Refactor",
      "description": "Remove unused import statement"
    },
    {
      "anchor": "op-remove-unused-property",
      "name": "remove-unused-property",
      "category": "Refactor",
      "description": "Remove unused property declaration"
    },
    {
      "anchor": "op-remove-unused-signal",
      "name": "remove-unused-signal",
      "category": "Refactor",
      "description": "Remove unused signal declaration"
    },
    {
      "anchor": "op-rename",
      "name": "rename",
      "category": "Refactor",
      "description": "Rename a symbol and automatically update ALL references across the codebase. Safer and faster than find-and-replace \u2014 AST-aware, won't rename strings or comments. Works without LSP (single-file); LSP enables cross-file renames. Params: file (string), old_name (string), new_name (string) [, line (u32), column (u32), preview (bool), receipt (bool)]"
    },
    {
      "anchor": "op-rename-identifier",
      "name": "rename-identifier",
      "category": "Refactor",
      "description": "Rename a property, signal, method, or component across all references"
    },
    {
      "anchor": "op-simplify-conditional-expression",
      "name": "simplify-conditional-expression",
      "category": "Refactor",
      "description": "Simplify if-else to ternary expression"
    },
    {
      "anchor": "op-analyze-api-diff",
      "name": "analyze_api_diff",
      "category": "Analysis",
      "description": "Diff the exported/public symbol surface between merge-base(base_ref, HEAD) and the working tree: per-symbol verdict rows (breaking / possibly-breaking / additive) with both signatures where they changed \u2014 removed public symbols, gained parameters, and visibility narrowing are breaking; new exports additive. Visibility-unmodeled grammars yield unjudgeable rows naming the grammar (never silence, never guessed-private); type-level claims only where types are modeled. Params: none [, base_ref (string \u2014 omit to diff against HEAD)]"
    },
    {
      "anchor": "op-analyze-chokepoints",
      "name": "analyze_chokepoints",
      "category": "Analysis",
      "description": "Find files that act as critical bottlenecks \u2014 high betweenness centrality in the dependency graph (R4). granularity=\"symbol\" ranks individual functions over the call graph instead of files (capped, with truncation disclosure). Params: none [, granularity (string), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-clones",
      "name": "analyze_clones",
      "category": "Analysis",
      "description": "Detect duplicated code as clone classes \u2014 type-1 (exact) and type-2 (renamed identifiers/literals) subtree clones with member ranges, token counts, and an extract_function remediation pointer when all members sit in function bodies; type-3 (gapped) clones are not detected. Params: none [, include (string[]), exclude (string[]), min_tokens (number)]. Use include/exclude to restrict the scan scope; min_tokens overrides the minimum clone size (default 50)."
    },
    {
      "anchor": "op-analyze-clusters",
      "name": "analyze_clusters",
      "category": "Analysis",
      "description": "Identify tightly coupled groups of files using community detection. Use to discover natural module boundaries and understand which files change together. Clusters where a hub file glues unrelated files together are flagged via hub_collapse=true and top_hubs (named hub files); pass dampen_top_k (u32) to exclude the top-k highest-degree files from propagation and reveal genuine neighborhoods. Params: none [, granularity (string), min_size (u32), dampen_top_k (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-cohesion",
      "name": "analyze_cohesion",
      "category": "Analysis",
      "description": "Measure intra-module cohesion for each file \u2014 ratio of internal to total symbol edges (H2); counts call edges between symbols (syntactic, LSP-enriched when available). Also reports class-level LCOM4 (connected components of each class's method graph \u2014 methods linked by a shared field access or intra-class call) with coverage-law disclosure of which grammars were modeled. Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-conformance",
      "name": "analyze_conformance",
      "category": "Analysis",
      "description": "Evaluate the [architecture] contract in .act/config.toml against the actual import graph \u2014 deny-rule, layer-rank, and public-surface violations with the offending import's file:line, plus named cycle exemptions (suppressed but counted). Returns contract_present: false when no contract section exists. Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope."
    },
    {
      "anchor": "op-analyze-coupling",
      "name": "analyze_coupling",
      "category": "Analysis",
      "description": "Measure coupling per file \u2014 how many files depend on it (afferent) vs how many it depends on (efferent), plus instability and abstractness scores; symbol granularity reflects call relationships (syntactic, LSP-enriched when available). Use to find the most critical/fragile files. Params: none [, granularity (string), sort (string: coupling|instability|distance|afferent|efferent, default coupling = most entangled first), threshold (f64), top_n (u32, default 200), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-cycle-risk",
      "name": "analyze_cycle_risk",
      "category": "Analysis",
      "description": "Score each circular dependency cycle by its external risk surface (R6 circular risk zones analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-cycles",
      "name": "analyze_cycles",
      "category": "Analysis",
      "description": "Find circular dependency chains in the codebase. Use to identify import cycles that cause build issues or indicate architecture problems. Params: none [, granularity (string), max_length (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-dead-code",
      "name": "analyze_dead_code",
      "category": "Analysis",
      "description": "Find dead code \u2014 functions, classes, and types that are never referenced from any entry point; reachability follows call edges (syntactic, LSP-enriched when available). Use before cleanup to safely identify what can be deleted. Params: none [, entry (string[]), granularity (string), include_tests (bool), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-depth",
      "name": "analyze_depth",
      "category": "Analysis",
      "description": "Compute longest transitive dependency chain per file (S4 dependency depth analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-entry-points",
      "name": "analyze_entry_points",
      "category": "Analysis",
      "description": "Detect entry points: main functions, HTTP routes, CLI commands, event listeners, test files (S5). Params: none [, include (string[]), exclude (string[])]."
    },
    {
      "anchor": "op-analyze-export",
      "name": "analyze_export",
      "category": "Analysis",
      "description": "Export the full semantic graph (files, symbols, dependencies) in JSON, DOT (Graphviz), or CSV format. Use for visualization or external analysis. Responses are size-bounded: large graphs return truncated:true plus next_cursor \u2014 pass it back as cursor to page through; stats always reports full node/edge counts. Params: none [, format (string), cursor (u32), max_bytes (u32, default 1000000, hard cap 4000000), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-extraction",
      "name": "analyze_extraction",
      "category": "Analysis",
      "description": "Score clusters for service or package extraction viability (M2 extraction candidates analysis); skips hub-collapse artifact clusters (flagged by analyze_clusters). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-fan-balance",
      "name": "analyze_fan_balance",
      "category": "Analysis",
      "description": "Compute fan-in/fan-out imbalance for migration ordering guidance (M6 fan balance analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-features",
      "name": "analyze_features",
      "category": "Analysis",
      "description": "Inventory language-specific AST features used in the codebase \u2014 async, generics, decorators, etc. (M3). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-hotspots",
      "name": "analyze_hotspots",
      "category": "Analysis",
      "description": "Rank files by composite complexity score \u2014 max cyclomatic complexity, statement count, nesting depth (H1). Test files are excluded by default (is_test_file conventions); summary.test_files_excluded discloses the count. Item-level exclusion (e.g. Rust #[cfg(test)]) is per-grammar; summary.item_level_exclusion_grammars names grammars where it was modeled. Params: none [, top_n (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-impact",
      "name": "analyze_impact",
      "category": "Analysis",
      "description": "Compute change impact \u2014 two modes. File mode (Free, default): finds all files directly and transitively depending on `target` (R1). Symbol mode (Architecture): when `symbol` is set, returns transitive callers of that function symbol \u2014 syntactic-floor analysis, LSP-enhanced when available, no LSP required. Append `::<line>` to `symbol` to disambiguate overloads (e.g. `\"process::42\"`). Params: target (string) [, symbol (string), max_depth (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"]). Errors: SYMBOL_NOT_FOUND, AMBIGUOUS_SYMBOL, UNSUPPORTED_SYMBOL_KIND."
    },
    {
      "anchor": "op-analyze-inconsistencies",
      "name": "analyze_inconsistencies",
      "category": "Analysis",
      "description": "Detect inconsistent abstractions \u2014 sibling files in the same directory that diverge from the group's structural pattern (H5). Params: none [, include (string[]), exclude (string[])]."
    },
    {
      "anchor": "op-analyze-inheritance",
      "name": "analyze_inheritance",
      "category": "Analysis",
      "description": "Detect tangled inheritance \u2014 deep hierarchies (>N levels) and diamond inheritance (H6). Params: none [, include (string[]), exclude (string[])]."
    },
    {
      "anchor": "op-analyze-interface-bloat",
      "name": "analyze_interface_bloat",
      "category": "Analysis",
      "description": "Detect interface bloat \u2014 files where the public API is disproportionately large relative to implementation (H3). Params: none [, include (string[]), exclude (string[])]."
    },
    {
      "anchor": "op-analyze-interfaces",
      "name": "analyze_interfaces",
      "category": "Analysis",
      "description": "Map cross-module interfaces \u2014 symbols that cross directory-module boundaries, ranked by interface width (M4). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-layers",
      "name": "analyze_layers",
      "category": "Analysis",
      "description": "Detect architectural layers from directory names and find dependency direction violations (S1+S2); result carries classification_coverage and is marked unreliable below 0.5 coverage (verdicts not-modeled). Params: none [, detect_only (bool), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-orphan-types",
      "name": "analyze_orphan_types",
      "category": "Analysis",
      "description": "Find type definitions used exclusively outside their defining directory (H4 orphan types analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-patterns",
      "name": "analyze_patterns",
      "category": "Analysis",
      "description": "Find code smells \u2014 god functions, deep nesting, high coupling, and other structural issues. Use to identify refactoring targets or assess code quality. Params: none [, tier (string), pattern (string), file (string), severity (string), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-platform-deps",
      "name": "analyze_platform_deps",
      "category": "Analysis",
      "description": "Detect platform-specific API usage by scanning imports (M5 platform dependencies analysis). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-readiness",
      "name": "analyze_readiness",
      "category": "Analysis",
      "description": "Compute migration readiness scores per file \u2014 composite of complexity, coupling, porting blockers (M1). Params: none [, include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-roles",
      "name": "analyze_roles",
      "category": "Analysis",
      "description": "Classify files by architectural role: entry point, routing, business logic, data access, config, test, utility, types, generated (S3). Params: none [, include (string[]), exclude (string[])]."
    },
    {
      "anchor": "op-analyze-seams",
      "name": "analyze_seams",
      "category": "Analysis",
      "description": "Find the natural boundaries between file clusters \u2014 the narrowest points where groups of files communicate. Use to identify where to split modules or add API boundaries. Params: none [, min_cluster_size (u32), max_seam_width (u32), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-stability",
      "name": "analyze_stability",
      "category": "Analysis",
      "description": "Compute stability index (R2) and detect stable dependency violations (R3) \u2014 flags edges where stable modules depend on unstable ones. Params: none [, index_only (bool), include (string[]), exclude (string[])]."
    },
    {
      "anchor": "op-analyze-surface",
      "name": "analyze_surface",
      "category": "Analysis",
      "description": "Measure API surface area \u2014 count exposed functions, types, and complexity at a module boundary. Use to assess whether an API is too large or leaky. Params: none [, boundary (string), files (string), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-test-gaps",
      "name": "analyze_test_gaps",
      "category": "Analysis",
      "description": "Detect source files with no or partial test coverage (R5). When coverage_report is supplied (lcov, JaCoCo XML, or coverage.py JSON), statuses are evidence-based (evidence: \"lcov\"); otherwise convention-based (evidence: \"convention\"). Params: none [, coverage_report (string), include (string[]), exclude (string[])]. Use include/exclude to restrict the scan scope (e.g. include=[\"crates\"], exclude=[\"corpus\"])."
    },
    {
      "anchor": "op-analyze-type-completeness",
      "name": "analyze_type_completeness",
      "category": "Analysis",
      "description": "Analyze type boundary completeness \u2014 detect 'any' types, untyped parameters, missing return types at exported function boundaries (M7). Params: none [, include (string[]), exclude (string[])]."
    },
    {
      "anchor": "op-churn-hotspots",
      "name": "churn_hotspots",
      "category": "Analysis",
      "description": "Rank code by git churn \u2014 change frequency weighted by recency. Workspace mode (no `file`, Architecture) ranks symbols by score = \u03a3 recency-decayed changes; single-file mode (`file`, Free teaser) returns that file's bare commit count. Honest degradation: grammars without symbol extraction yield file-level facts only. Params: none [, file (string), top_n (u32)=50, max_files (u32)=500]"
    },
    {
      "anchor": "op-co-change-clusters",
      "name": "co_change_clusters",
      "category": "Analysis",
      "description": "Cluster symbols that change together across git history (co-change coupling). Returns clusters with support (shared commits) and confidence. Useful for finding hidden coupling and shotgun-surgery risk. Params: none [, min_support (u32)=3, min_confidence (f64)=0.7, max_files (u32)=500]"
    },
    {
      "anchor": "op-coverage-overlay",
      "name": "coverage_overlay",
      "category": "Analysis",
      "description": "Join line coverage onto symbols \u2014 per-symbol covered/hits, plus the count of coverage records that mapped to no symbol. Joins against the current working tree; a disclosure field flags tree-relative unmapped counts and stale-report line drift. Makes test-gap analysis concrete. Auto-detects the report format: lcov, JaCoCo XML, or coverage.py native JSON. Params: report (string, path to a coverage report) [, top_n (u32)]"
    },
    {
      "anchor": "op-ownership-map",
      "name": "ownership_map",
      "category": "Analysis",
      "description": "Map code ownership from git blame \u2014 per-symbol author line shares and a bus factor (smallest author set owning >50% of lines). Low bus factor = knowledge concentration risk. Identities consolidate via .mailmap when present; otherwise fragmentation_hints disclose suspect identity pairs. Workspace-wide results are ranked lowest-bus-factor-first and capped at top_n. Params: none [, file (string), max_files (u32)=500, top_n (u32)=50]"
    },
    {
      "anchor": "op-profile-overlay",
      "name": "profile_overlay",
      "category": "Analysis",
      "description": "Join a CPU/sample profile onto symbols \u2014 per-symbol self% / total% / inclusive samples, ranked hottest first, plus an unmapped-frames count. Auto-detects the report format: speedscope JSON, or pprof (gzipped protobuf). Params: report (string, path to a profile report) [, top_n (u32)]"
    },
    {
      "anchor": "op-simulate",
      "name": "simulate",
      "category": "Analysis",
      "description": "Simulate structural refactors in-memory and report before/after deltas \u2014 never touches disk (simulated: true). ops is an ordered change script: move_file{from,to}, remove_edge{from,to}, split_file{file,groups:[[symbol]]}, merge_files{files,to}, delete_module{file} (the deletion test \u2014 drops the module and re-wires transitive bridges A\u2192M\u2192B\u21d2A\u2192B). Returns cycles (resolved/introduced), coupling deltas per affected unit, chokepoint centrality changes, deletion deltas for delete_module ops (surface_consumers + surface_modeled \u2014 the load-bearing signal of external symbols calling/extending the module's own surface, plus rewired vs severed file-routing edges), and \u2014 when an [architecture] contract exists in .act/config.toml \u2014 conformance violation deltas (cleared/introduced). Params: ops (required, non-empty) [, include (string[]), exclude (string[])]."
    },
    {
      "anchor": "op-split-module",
      "name": "split_module",
      "category": "Analysis",
      "description": "Propose how to split a file into cohesive modules \u2014 detects symbol clusters (label propagation), scores per-cluster cohesion (compute_cohesion), runs compute_extraction on the real workspace graph to produce a file-level extraction_score, and counts boundary edges (seams). Returns a ModuleSplit with confidence_floor=Syntactic, modeled_kinds=[clusters,cohesion,extraction,seams], and proposed_modules sorted by cohesion descending. Params: file (string)"
    },
    {
      "anchor": "op-trace-overlay",
      "name": "trace_overlay",
      "category": "Analysis",
      "description": "Join OpenTelemetry spans onto symbols \u2014 per-symbol span count and whether the symbol lies on a trace's critical (longest-duration) path. Shows which code actually runs in production. Auto-detects the report format: OTLP/JSON or OTLP-protobuf. Params: report (string, path to an OTLP trace file) [, top_n (u32)]"
    },
    {
      "anchor": "op-bisect-regression",
      "name": "bisect_regression",
      "category": "Verify",
      "description": "Semantic git-bisect: walk good_ref..bad_ref oldest-to-newest, apply verify_diff_semantics to each adjacent commit pair for the target symbol, and return the first commit that introduced a Behavior hunk. Returns BisectResult { target, file, culprit: { commit, author } | null, scanned, modeled_kinds }. Pairs where the file is absent at either revision are skipped. Params: file (string), target (string), good_ref (string), bad_ref (string)"
    },
    {
      "anchor": "op-gate",
      "name": "gate",
      "category": "Verify",
      "description": "Deterministic merge gate: discover changed functions from the git diff (working tree vs HEAD, or vs merge-base of base_ref), run verify_diff_semantics + verify_test_impact + verify_side_effects per function, and synthesize MERGE | REVIEW | BLOCK | UNKNOWN per function and overall \u2014 UNKNOWN is never presented as MERGE; unmodeled dimensions and tier-blocked files degrade to UNKNOWN with the evidence quoted. receipts: write verification receipts to .act/receipts/ (consumption of valid receipts is always on). Params: none [, base_ref (string), root (string), receipts (boolean)]"
    },
    {
      "anchor": "op-generate-test-harness",
      "name": "generate_test_harness",
      "category": "Verify",
      "description": "Generate a test scaffold for a target function \u2014 extracts the Contract (signature, guards, raises) and synthesises a test file with one happy-path case + one case per guard + one case per error path. Supported across tier-1+ programming languages (TypeScript/TSX, JavaScript, Python, Rust, Go, Java, Kotlin, C#, Swift, Ruby, C, C++, PHP, Scala); grammars with no unit-test idiom return supported:false (documented opt-out). Params: file (string), target (string)"
    },
    {
      "anchor": "op-scan",
      "name": "scan",
      "category": "Verify",
      "description": "Scan a repository for AI-code security issues (hardcoded credentials, .cursorrules backdoors, MCP-config RCE) and return an AI-Code Health Score + remediation bundle (JSON). Private repos require an act101 scan entitlement; public repos are free. Coverage auto-discovery: conventional lcov reports (coverage/lcov.info, lcov.info, target/coverage/lcov.info) are probed and, when found, test-gap statuses are coverage-evidence-based with the report named (and stale-flagged) in the coverage record. Params: none [, root (string), visibility (\"public\"|\"private\"), files (string[] \u2014 path-scoped scan; report gains scope section, scores cover the selected files only; conflicts with baseline_write), baseline (string \u2014 compare against a committed baseline; report gains new/baselined partition), baseline_write (string \u2014 record current findings as the baseline; full scans only), base_ref (string \u2014 diff-scoped scan vs merge-base(ref, HEAD); report gains scope section; conflicts with baseline_write)]"
    },
    {
      "anchor": "op-secret-surface",
      "name": "secret_surface",
      "category": "Verify",
      "description": "Surface secret-touching code in a file \u2014 credential params, token vars, signing keys, env-secret reads, and hardcoded secret literals \u2014 with per-item confidence. Heuristic; LSP upgrades confidence. Params: file (string)"
    },
    {
      "anchor": "op-summarize-pr",
      "name": "summarize_pr",
      "category": "Verify",
      "description": "Summarize a changed file by composing verify_diff_semantics across changed symbols and tallying signature, behavior, and format-only changes. Params: file (string) [, base_ref (string)='HEAD', before (string), after (string), targets (string[])]"
    },
    {
      "anchor": "op-taint-flow",
      "name": "taint_flow",
      "category": "Verify",
      "description": "Trace tainted (untrusted) data from sources (request params, env/file reads, argv) to dangerous sinks (raw SQL, eval, command exec, fs path, deserialization) across the call graph, with per-flow steps and the unresolved-call frontier. Params: target (string), file (string) [, max_depth (u32), max_nodes (u32)]"
    },
    {
      "anchor": "op-unsafe-surface",
      "name": "unsafe_surface",
      "category": "Verify",
      "description": "Surface dangerous constructs in a file \u2014 unsafe blocks, dynamic eval, raw SQL sinks, FFI calls, reflective invocation, unsafe deserialization \u2014 with per-item confidence. Params: file (string)"
    },
    {
      "anchor": "op-verify-behavioral-equivalence",
      "name": "verify_behavioral_equivalence",
      "category": "Verify",
      "description": "Verify two versions of a function have equivalent behavior by structural CFG diff (same branch/loop/exception/return shape). Verdict: equivalent | changed{dimensions} | unknown{reason}. scope='refactor' (default, Engineering) or 'port' (Enterprise, cross-language). Params: target (string), file (string) [, base_ref (string)='HEAD', before (string), after (string), scope (string)='refactor']"
    },
    {
      "anchor": "op-verify-contract-preserved",
      "name": "verify_contract_preserved",
      "category": "Verify",
      "description": "Verify a function's public + behavioral contract (signature, effects, control-flow shape, return shape, guards, raises) is preserved across two versions. Verdict: preserved | broken{dimensions} | unknown{dimensions} \u2014 never claims preserved on a dimension the grammar does not model. Params: target (string), file (string) [, base_ref (string)='HEAD', before (string), after (string)]"
    },
    {
      "anchor": "op-verify-diff-semantics",
      "name": "verify_diff_semantics",
      "category": "Verify",
      "description": "Classify how a function changed across two versions: each hunk as format | signature | behavior (rename/move when symbol-identity is available). Uses model diffs (signature via interface, behavior via CFG/effect diff, format via AST-equal-but-text-different). Params: target (string), file (string) [, base_ref (string)='HEAD', before (string), after (string)]"
    },
    {
      "anchor": "op-verify-port-parity",
      "name": "verify_port_parity",
      "category": "Verify",
      "description": "Cross-language contract equivalence check (v1): compare the source and ported symbol's signature arity, return presence, effect-kind set, CFG shape, and raise count. A dimension that either grammar doesn't model contributes no evidence \u2014 never a false Preserved. Verdict: 'diverged' if any compared dimension differs (dominates); 'preserved' only if all compared dimensions match AND at least two dimensions were jointly modeled (matching signature arity alone is not parity evidence); 'unknown' when too few dimensions are jointly modeled to claim parity (e.g. only signature was comparable). Tier-1 contract analysis runs by default \u2014 no code execution. OPT-IN Tier-2: pass execute=true to ALSO run subprocess differential execution for interpreter languages whose runtime is present (node, python3) and a JSON-able source signature \u2014 it generates inputs, runs both functions under a ulimit resource cap (CPU/address-space/file-size) in a throwaway temp CWD, and diffs their JSON outputs; verified_by becomes 'execution' and an executed output divergence forces 'diverged'. This is a RESOURCE boundary, NOT a security sandbox (no network isolation). When execution is not eligible (compiled language, absent runtime, non-JSON-able signature) it falls back to Tier-1 cleanly with no false parity claim. Returns ParityReport { verdict: preserved|diverged|unknown, dimensions_checked, mismatches, verified_by: 'contract'|'execution', modeled_kinds, execution?: { cases_run, mismatches, note } }. Params: source_file (string), source_target (string), ported_file (string), ported_target (string), execute (bool, optional, default false)"
    },
    {
      "anchor": "op-verify-side-effects",
      "name": "verify_side_effects",
      "category": "Verify",
      "description": "Diff a function's side effects between two versions (git working-tree vs HEAD by default, or an explicit before/after pair) \u2014 added/removed effects plus the dropped-cleanup class (a removed write/blocking call while an allocation is kept). Params: target (string), file (string) [, base_ref (string)='HEAD', before (string), after (string)]"
    },
    {
      "anchor": "op-verify-test-impact",
      "name": "verify_test_impact",
      "category": "Verify",
      "description": "The minimal set of tests whose call graph reaches a change \u2014 pass `target` for one changed symbol, or omit it to derive the changed set from the file's before/after symbol diff (git working-tree vs base_ref, or explicit before/after). Composes the call-graph engine + test-file detection. Params: file (string) [, target (string), base_ref (string)='HEAD', before (string), after (string), max_depth (u32)=32]"
    }
  ]
}