@claude-flow/cli 3.72.0 → 3.72.1

package/dist/src/mcp-tools/agentdb-tools.js

@@ -1502,6 +1502,8 @@ export const agentdbGraphPathfinder = {
             }
             const edges = rawEdges;
             let paths = [];
+            let mincutInfo;
+            let approximation;
             // Check millisecond budget before heavy computation
             if (Date.now() - t0 > budget.maxMillis) {
                 return { success: true, paths: [], count: 0, message: `complexityBudget.maxMillis (${budget.maxMillis}ms) exceeded before solver dispatch`, seedNodeId, algorithm, elapsedMs: Date.now() - t0 };
@@ -1557,10 +1559,38 @@ export const agentdbGraphPathfinder = {
                     paths = witnessChain.slice(0, topK);
                     break;
                 }
+                case 'dynamic-mincut': {
+                    // Exact minimum cut of the seed's depth-hop neighbourhood: the
+                    // weakest boundary around the seed, and the nodes on its side of it.
+                    // Wasm solver via ruvector (@ruvector/mincut-wasm), JS Stoer-Wagner
+                    // fallback for small neighbourhoods.
+                    const edgeTuples = edges.map(r => [String(r[0]), String(r[1]), Number(r[2]) || 1.0]);
+                    const { seedLocalMinCut } = await import('../ruvector/mincut-bridge.js');
+                    const { fallbackMinCut } = await import('../ruvector/graph-analyzer.js');
+                    const cut = await seedLocalMinCut(seedNodeId, edgeTuples, depth, budget.maxNodesVisited, fallbackMinCut);
+                    if (!cut) {
+                        mincutInfo = { backend: 'none', message: 'seed neighbourhood too large for the JS fallback and the wasm solver is unavailable (install ruvector)' };
+                        break;
+                    }
+                    paths = cut.seedSide
+                        .map(r => ({ nodeId: r.nodeId, score: 1 / (1 + r.depth), depth: r.depth }))
+                        .filter(r => r.score >= threshold)
+                        .slice(0, topK);
+                    mincutInfo = {
+                        backend: cut.backend,
+                        cutValue: cut.cutValue,
+                        seedSideSize: cut.seedSide.length + 1,
+                        otherSideSize: cut.otherSide.length,
+                        subgraphNodes: cut.subgraphNodes,
+                        cutEdges: cut.cutEdges.slice(0, 50),
+                    };
+                    break;
+                }
                 case 'connected-component-churn':
-                case 'dynamic-mincut':
                 case 'spectral-sparsify': {
-                    // Simplified implementations: return k-hop neighbors with basic score
+                    // Not implemented natively yet: approximated by k-hop neighbours with
+                    // a rank-decay score. The response says so via `implementation`.
+                    approximation = 'k-hop';
                     const edgeTuples = edges.map(r => [r[0], r[1], Number(r[2]) || 1.0]);
                     const khopResult = await agentdbGraphQuery.handler({
                         nodeId: seedNodeId, mode: 'k-hop', depth, complexityBudget: budget,
@@ -1582,6 +1612,8 @@ export const agentdbGraphPathfinder = {
                 count: paths.length,
                 elapsedMs,
                 budgetUsed: { millis: elapsedMs, nodes: rawEdges.length },
+                ...(mincutInfo && { mincut: mincutInfo }),
+                ...(approximation && { implementation: `${approximation} approximation` }),
                 ...(depthWarning && { warning: depthWarning }),
             };
         }

package/dist/src/mcp-tools/fast-apply-tools.d.ts

@@ -0,0 +1,4 @@
+import { type MCPTool } from './types.js';
+export declare const hooksFastApply: MCPTool;
+export declare const fastApplyTools: MCPTool[];
+//# sourceMappingURL=fast-apply-tools.d.ts.map

package/dist/src/mcp-tools/fast-apply-tools.js

@@ -0,0 +1,85 @@
+/**
+ * hooks_fast-apply — merge a code snippet into a file or string with
+ * agent-booster (~ms, no LLM). The caller supplies the target code; for
+ * deterministic intents with no snippet use hooks_codemod instead.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { resolve, sep } from 'path';
+import { getProjectCwd } from './types.js';
+import { validatePath } from './validate-input.js';
+import { realpathNearest, isInsideRealRoot } from './realpath-containment.js';
+const MAX_INPUT_BYTES = 1_000_000;
+function langForPath(p) {
+    const ext = p.slice(p.lastIndexOf('.') + 1).toLowerCase();
+    const map = {
+        ts: 'typescript', tsx: 'typescript', mts: 'typescript', cts: 'typescript',
+        js: 'javascript', jsx: 'javascript', mjs: 'javascript', cjs: 'javascript',
+        py: 'python', rs: 'rust', go: 'go', java: 'java', c: 'c', cpp: 'cpp', h: 'c',
+    };
+    return map[ext];
+}
+export const hooksFastApply = {
+    name: 'hooks_fast-apply',
+    description: 'Merge an edit SNIPPET (the rewritten code, e.g. a whole new version of one function) into a file or raw code using agent-booster — a local fast-apply engine (~1-10 ms, no LLM, $0). `edit` must be code, not an instruction: "make add typed" fails, "function add(a: number, b: number): number { return a + b; }" works. Use when you already have the replacement code and the surrounding file is large, instead of re-sending the whole file. Deterministic intents (var-to-const, remove-console, add-logging) belong to hooks_codemod. Returns confidence + strategy; below minConfidence nothing is written.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            edit: { type: 'string', description: 'Target code snippet to merge (code, not an instruction)' },
+            file: { type: 'string', description: 'Existing file inside the project to patch in place' },
+            code: { type: 'string', description: 'Raw source to patch instead of a file (returns output, writes nothing)' },
+            language: { type: 'string', description: 'Language hint (inferred from the file extension when omitted)' },
+            minConfidence: { type: 'number', description: 'Minimum merge confidence 0-1 required to apply (default 0.5)' },
+            dryRun: { type: 'boolean', description: 'Report the merge result without writing the file' },
+        },
+        required: ['edit'],
+    },
+    handler: async (params) => {
+        const edit = params.edit;
+        if (typeof edit !== 'string' || edit.trim() === '')
+            return { success: false, error: 'edit (non-empty code snippet) is required' };
+        if (edit.length > MAX_INPUT_BYTES)
+            return { success: false, error: 'edit too large' };
+        const minConfidence = typeof params.minConfidence === 'number'
+            ? Math.min(Math.max(params.minConfidence, 0), 1) : 0.5;
+        const dryRun = params.dryRun === true;
+        const { fastApply } = await import('../ruvector/fast-apply.js');
+        if (typeof params.code === 'string') {
+            if (params.code.length > MAX_INPUT_BYTES)
+                return { success: false, error: 'code too large' };
+            const r = await fastApply({ code: params.code, edit, language: params.language, minConfidence });
+            return { ...r, mode: 'code', cost: 0 };
+        }
+        if (typeof params.file !== 'string')
+            return { success: false, error: 'Provide `file` or `code`.' };
+        const v = validatePath(params.file, 'file');
+        if (!v.valid)
+            return { success: false, error: v.error };
+        const cwd = getProjectCwd();
+        const abs = resolve(cwd, v.sanitized);
+        if (abs !== cwd && !abs.startsWith(cwd + sep))
+            return { success: false, error: `path escapes project root: ${params.file}` };
+        let realRoot;
+        try {
+            realRoot = realpathNearest(cwd);
+        }
+        catch (err) {
+            return { success: false, error: `cannot resolve project root: ${err.message}` };
+        }
+        if (!isInsideRealRoot(realRoot, abs))
+            return { success: false, error: `path escapes project root via symlink: ${params.file}` };
+        if (!existsSync(abs))
+            return { success: false, error: `file not found: ${params.file}` };
+        const before = readFileSync(abs, 'utf-8');
+        if (before.length > MAX_INPUT_BYTES)
+            return { success: false, error: 'file too large' };
+        const language = params.language ?? langForPath(abs);
+        const r = await fastApply({ code: before, edit, language, minConfidence });
+        const written = r.success && !dryRun;
+        if (written)
+            writeFileSync(abs, r.output, 'utf-8');
+        const { output, ...meta } = r;
+        return { ...meta, mode: dryRun ? 'dry-run' : 'file', file: params.file, written, ...(dryRun && { output }), cost: 0 };
+    },
+};
+export const fastApplyTools = [hooksFastApply];
+//# sourceMappingURL=fast-apply-tools.js.map

package/dist/src/mcp-tools/hooks-tools.js

@@ -5,9 +5,10 @@ import { feedbackPatternsSchema, validateFeedbackPatterns } from '../memory/feed
  */
 import { mkdirSync, writeFileSync, existsSync, readFileSync, statSync, unlinkSync, readdirSync } from 'fs';
 import * as nodeFs from 'fs';
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'path';
+import { dirname, join, resolve, sep } from 'path';
 import { getProjectCwd } from './types.js';
 import { validateIdentifier, validateText, validatePath } from './validate-input.js';
+import { realpathNearest, isInsideRealRoot } from './realpath-containment.js';
 import { commandRecordingDisabled, redactCommandForStorage } from '../services/command-recording.js';
 import { checkCommandLoop, recordCommandOutcome } from './tool-loop-guardrail.js';
 import { buildLearnedRoutingPatterns, } from '../services/learned-routing.js';
@@ -5126,38 +5127,6 @@ function codemodLangForExt(abs) {
         return 'javascript';
     return 'typescript';
 }
-// Canonicalize a path that may not exist yet: realpath the nearest existing
-// ancestor and re-attach the missing tail, so a symlinked parent still
-// resolves to its real location (mirrors @claude-flow/security's
-// canonicalizeSync, which is not exported).
-function realpathNearest(p) {
-    try {
-        return nodeFs.realpathSync(p);
-    }
-    catch (err) {
-        if (err?.code !== 'ENOENT')
-            throw err;
-    }
-    const parent = dirname(p);
-    if (parent === p)
-        return p;
-    return join(realpathNearest(parent), basename(p));
-}
-// CWE-59 (#4346): containment must compare real paths on BOTH sides — a
-// symlink inside the project pointing outside it must not pass, and a
-// symlinked project root (e.g. macOS /var -> /private/var) must not make
-// every path fail. Fails closed if canonicalization throws (ELOOP, EACCES).
-function isInsideRealRoot(realRoot, abs) {
-    let real;
-    try {
-        real = realpathNearest(abs);
-    }
-    catch {
-        return false;
-    }
-    const rel = relative(realRoot, real);
-    return rel === '' || (rel !== '..' && !rel.startsWith('..' + sep) && !isAbsolute(rel));
-}
 // Deterministic codemod execution — the real Tier-1 path (ADR-143)
 export const hooksCodemod = {
     name: 'hooks_codemod',

package/dist/src/mcp-tools/metaharness-tools.js

@@ -399,7 +399,7 @@ export const metaharnessTools = [
     },
     // ───────────────────────────────────────────────────────────────────────
     // ADR-153 — @metaharness/darwin integration (3 tools).
-    // Backed by the separate `@metaharness/darwin@~0.12.0` npm package, NOT
+    // Backed by the separate `@metaharness/darwin@~0.13.0` npm package, NOT
     // the umbrella `metaharness`. Plugin scripts shell out via _darwin.mjs.
     // Same {success, data, degraded, exitCode} contract.
     // ───────────────────────────────────────────────────────────────────────

package/dist/src/mcp-tools/realpath-containment.d.ts

@@ -0,0 +1,3 @@
+export declare function realpathNearest(p: string): string;
+export declare function isInsideRealRoot(realRoot: string, abs: string): boolean;
+//# sourceMappingURL=realpath-containment.d.ts.map

package/dist/src/mcp-tools/realpath-containment.js

@@ -0,0 +1,39 @@
+/**
+ * Project-root containment for MCP tools that read or write files.
+ * Shared by hooks_codemod and hooks_fast-apply (moved out of hooks-tools.ts).
+ */
+import * as nodeFs from 'fs';
+import { basename, dirname, isAbsolute, join, relative, sep } from 'path';
+// Canonicalize a path that may not exist yet: realpath the nearest existing
+// ancestor and re-attach the missing tail, so a symlinked parent still
+// resolves to its real location (mirrors @claude-flow/security's
+// canonicalizeSync, which is not exported).
+export function realpathNearest(p) {
+    try {
+        return nodeFs.realpathSync(p);
+    }
+    catch (err) {
+        if (err?.code !== 'ENOENT')
+            throw err;
+    }
+    const parent = dirname(p);
+    if (parent === p)
+        return p;
+    return join(realpathNearest(parent), basename(p));
+}
+// CWE-59 (#4346): containment must compare real paths on BOTH sides — a
+// symlink inside the project pointing outside it must not pass, and a
+// symlinked project root (e.g. macOS /var -> /private/var) must not make
+// every path fail. Fails closed if canonicalization throws (ELOOP, EACCES).
+export function isInsideRealRoot(realRoot, abs) {
+    let real;
+    try {
+        real = realpathNearest(abs);
+    }
+    catch {
+        return false;
+    }
+    const rel = relative(realRoot, real);
+    return rel === '' || (rel !== '..' && !rel.startsWith('..' + sep) && !isAbsolute(rel));
+}
+//# sourceMappingURL=realpath-containment.js.map

package/dist/src/mods/command-registry/schema.d.ts

@@ -192,8 +192,8 @@ export declare const inventorySourceSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     digest: string;
     sourcePath: string;
-    channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
     package: string;
+    channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
     observedInvocation: string;
     binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
     shippedIn: string[];
@@ -201,8 +201,8 @@ export declare const inventorySourceSchema: z.ZodObject<{
 }, {
     digest: string;
     sourcePath: string;
-    channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
     package: string;
+    channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
     observedInvocation: string;
     binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
     shippedIn: string[];
@@ -370,8 +370,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
     }, "strict", z.ZodTypeAny, {
         digest: string;
         sourcePath: string;
-        channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
         package: string;
+        channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
         observedInvocation: string;
         binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
         shippedIn: string[];
@@ -379,8 +379,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
     }, {
         digest: string;
         sourcePath: string;
-        channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
         package: string;
+        channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
         observedInvocation: string;
         binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
         shippedIn: string[];
@@ -391,8 +391,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
     sources: {
         digest: string;
         sourcePath: string;
-        channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
         package: string;
+        channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
         observedInvocation: string;
         binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
         shippedIn: string[];
@@ -432,8 +432,8 @@ export declare const catalogEntrySchema: z.ZodObject<{
     sources: {
         digest: string;
         sourcePath: string;
-        channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
         package: string;
+        channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
         observedInvocation: string;
         binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
         shippedIn: string[];
@@ -636,8 +636,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
         }, "strict", z.ZodTypeAny, {
             digest: string;
             sourcePath: string;
-            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             package: string;
+            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             observedInvocation: string;
             binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
             shippedIn: string[];
@@ -645,8 +645,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
         }, {
             digest: string;
             sourcePath: string;
-            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             package: string;
+            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             observedInvocation: string;
             binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
             shippedIn: string[];
@@ -657,8 +657,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
         sources: {
             digest: string;
             sourcePath: string;
-            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             package: string;
+            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             observedInvocation: string;
             binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
             shippedIn: string[];
@@ -698,8 +698,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
         sources: {
             digest: string;
             sourcePath: string;
-            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             package: string;
+            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             observedInvocation: string;
             binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
             shippedIn: string[];
@@ -741,8 +741,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
         sources: {
             digest: string;
             sourcePath: string;
-            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             package: string;
+            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             observedInvocation: string;
             binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
             shippedIn: string[];
@@ -787,8 +787,8 @@ export declare const commandCatalogSchema: z.ZodObject<{
         sources: {
             digest: string;
             sourcePath: string;
-            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             package: string;
+            channel: "repo-project-commands" | "cli-init-template" | "marketplace-plugin" | "source-plugin" | "mod-registration";
             observedInvocation: string;
             binding: "markdown-loader" | "mod-register" | "mod-middleware-on-markdown";
             shippedIn: string[];

package/dist/src/ruvector/ast-analyzer.d.ts

@@ -40,8 +40,7 @@ export interface ASTAnalysis {
 }
 export declare class ASTAnalyzer {
     private config;
-    private ruvectorEngine;
-    private useNative;
+    private readonly useNative;
     private analysisCache;
     constructor(config?: Partial<ASTAnalyzerConfig>);
     initialize(): Promise<void>;

package/dist/src/ruvector/ast-analyzer.js

@@ -22,24 +22,16 @@ const LANGUAGE_PATTERNS = {
 };
 export class ASTAnalyzer {
     config;
-    ruvectorEngine = null;
     useNative = false;
     analysisCache = new Map();
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
     async initialize() {
-        try {
-            // @ruvector/ast is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/ast').catch(() => null);
-            if (ruvector) {
-                this.ruvectorEngine = ruvector.createASTAnalyzer?.(this.config);
-                this.useNative = !!this.ruvectorEngine;
-            }
-        }
-        catch {
-            this.useNative = false;
-        }
+        // Pure-JS analysis. This used to try `import('@ruvector/ast')`, a package that has
+        // never been published (npm 404), so it always fell through to here. ruvector@0.3's
+        // ASTParser needs the native tree-sitter grammars and is async-only, so it cannot
+        // back this synchronous analyzer.
     }
     analyze(code, filePath = 'unknown') {
         const startTime = performance.now();

package/dist/src/ruvector/coverage-router.d.ts

@@ -63,8 +63,7 @@ export interface CoverageRouteResult {
 }
 export declare class CoverageRouter {
     private config;
-    private ruvectorEngine;
-    private useNative;
+    private readonly useNative;
     private coverageHistory;
     constructor(config?: Partial<CoverageRouterConfig>);
     initialize(): Promise<void>;

package/dist/src/ruvector/coverage-router.js

@@ -37,24 +37,16 @@ const DEFAULT_CONFIG = {
 };
 export class CoverageRouter {
     config;
-    ruvectorEngine = null;
     useNative = false;
     coverageHistory = [];
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
     async initialize() {
-        try {
-            // @ruvector/coverage is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/coverage').catch(() => null);
-            if (ruvector) {
-                this.ruvectorEngine = ruvector.createCoverageRouter?.(this.config);
-                this.useNative = !!this.ruvectorEngine;
-            }
-        }
-        catch {
-            this.useNative = false;
-        }
+        // Pure-JS analysis. This used to try `import('@ruvector/coverage')`, a package that
+        // has never been published (npm 404), so it always fell through to here.
+        // ruvector@0.3's parseIstanbulCoverage is a plain-JS parser equivalent to the parsers
+        // below.
     }
     parseCoverage(data, format = 'json') {
         switch (format) {

package/dist/src/ruvector/diff-classifier.d.ts

@@ -49,8 +49,7 @@ export interface DiffAnalysis {
 }
 export declare class DiffClassifier {
     private config;
-    private ruvectorEngine;
-    private useNative;
+    private readonly useNative;
     private classificationCache;
     constructor(config?: Partial<DiffClassifierConfig>);
     initialize(): Promise<void>;

package/dist/src/ruvector/diff-classifier.js

@@ -60,24 +60,15 @@ function isSecuritySensitivePath(path) {
 }
 export class DiffClassifier {
     config;
-    ruvectorEngine = null;
     useNative = false;
     classificationCache = new Map();
     constructor(config = {}) {
         this.config = { ...DEFAULT_CONFIG, ...config };
     }
     async initialize() {
-        try {
-            // @ruvector/diff is optional - gracefully fallback if not installed
-            const ruvector = await import('@ruvector/diff').catch(() => null);
-            if (ruvector) {
-                this.ruvectorEngine = ruvector.createDiffClassifier?.(this.config);
-                this.useNative = !!this.ruvectorEngine;
-            }
-        }
-        catch {
-            this.useNative = false;
-        }
+        // Pure-JS analysis. This used to try `import('@ruvector/diff')`, a package that has
+        // never been published (npm 404), so it always fell through to here. ruvector@0.3's
+        // parseDiff is a plain-JS parser equivalent to parseDiff() below.
     }
     parseDiff(diffContent) {
         const files = [];

package/dist/src/ruvector/fast-apply.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Fast-apply: merge an edit snippet into existing code with agent-booster.
+ *
+ * agent-booster is a Morph/Cursor-style *applier*: `apply({ code, edit })`
+ * expects `edit` to be the target code (e.g. the rewritten function), and it
+ * locates and splices it into `code` in a few milliseconds with no LLM call.
+ * It cannot turn a natural-language instruction into an edit — given one it
+ * returns `success: false, strategy: "failed"` (see ADR-143). So this is the
+ * path for callers that already hold a snippet (an agent's proposed rewrite),
+ * not a Tier-1 intent engine; deterministic intents stay in hooks_codemod.
+ */
+export interface FastApplyRequest {
+    code: string;
+    edit: string;
+    language?: string;
+    /** Results below this confidence are reported as not applied. Default 0.5. */
+    minConfidence?: number;
+}
+export interface FastApplyResult {
+    success: boolean;
+    output: string;
+    confidence: number;
+    strategy: string;
+    latencyMs: number;
+    backend: 'agent-booster' | 'unavailable';
+    reason?: string;
+}
+interface BoosterLike {
+    apply(req: {
+        code: string;
+        edit: string;
+        language?: string;
+    }): Promise<{
+        output: string;
+        success: boolean;
+        confidence: number;
+        strategy: string;
+    }>;
+}
+/** Lazily construct one AgentBooster. Resolves null when it is not installed. */
+export declare function loadAgentBooster(): Promise<BoosterLike | null>;
+/** Test hook: forget the memoised AgentBooster. */
+export declare function resetAgentBoosterLoader(): void;
+export declare function fastApply(req: FastApplyRequest): Promise<FastApplyResult>;
+export {};
+//# sourceMappingURL=fast-apply.d.ts.map

package/dist/src/ruvector/fast-apply.js

@@ -0,0 +1,73 @@
+/**
+ * Fast-apply: merge an edit snippet into existing code with agent-booster.
+ *
+ * agent-booster is a Morph/Cursor-style *applier*: `apply({ code, edit })`
+ * expects `edit` to be the target code (e.g. the rewritten function), and it
+ * locates and splices it into `code` in a few milliseconds with no LLM call.
+ * It cannot turn a natural-language instruction into an edit — given one it
+ * returns `success: false, strategy: "failed"` (see ADR-143). So this is the
+ * path for callers that already hold a snippet (an agent's proposed rewrite),
+ * not a Tier-1 intent engine; deterministic intents stay in hooks_codemod.
+ */
+let boosterPromise = null;
+/** Lazily construct one AgentBooster. Resolves null when it is not installed. */
+export function loadAgentBooster() {
+    if (!boosterPromise) {
+        boosterPromise = (async () => {
+            try {
+                const specifier = 'agent-booster';
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any -- optional dep
+                const mod = await import(specifier);
+                const Ctor = mod?.AgentBooster ?? mod?.default?.AgentBooster ?? mod?.default;
+                if (typeof Ctor !== 'function')
+                    return null;
+                // Our own threshold is applied below; let the engine report everything.
+                return new Ctor({ confidenceThreshold: 0 });
+            }
+            catch {
+                return null;
+            }
+        })();
+    }
+    return boosterPromise;
+}
+/** Test hook: forget the memoised AgentBooster. */
+export function resetAgentBoosterLoader() {
+    boosterPromise = null;
+}
+export async function fastApply(req) {
+    const start = performance.now();
+    const minConfidence = req.minConfidence ?? 0.5;
+    const booster = await loadAgentBooster();
+    if (!booster) {
+        return {
+            success: false, output: req.code, confidence: 0, strategy: 'none',
+            latencyMs: performance.now() - start, backend: 'unavailable',
+            reason: 'agent-booster is not installed (npm i agent-booster); apply the edit with the Edit tool instead',
+        };
+    }
+    try {
+        const r = await booster.apply({ code: req.code, edit: req.edit, language: req.language });
+        const applied = r.success && r.confidence >= minConfidence && r.output !== req.code;
+        return {
+            success: applied,
+            output: applied ? r.output : req.code,
+            confidence: r.confidence,
+            strategy: r.strategy,
+            latencyMs: performance.now() - start,
+            backend: 'agent-booster',
+            reason: applied ? undefined
+                : !r.success ? 'agent-booster could not place the snippet (it must be code, not an instruction)'
+                    : r.output === req.code ? 'snippet is already present; nothing to change'
+                        : `confidence ${r.confidence.toFixed(2)} below minConfidence ${minConfidence}`,
+        };
+    }
+    catch (err) {
+        return {
+            success: false, output: req.code, confidence: 0, strategy: 'error',
+            latencyMs: performance.now() - start, backend: 'agent-booster',
+            reason: `agent-booster threw: ${err.message}`,
+        };
+    }
+}
+//# sourceMappingURL=fast-apply.js.map

package/dist/src/ruvector/graph-analyzer.d.ts

@@ -121,9 +121,19 @@ interface IRuVectorGraph {
     };
 }
 /**
- * Attempt to load ruvector graph algorithms
+ * Load the accelerated graph backend.
+ *
+ * MinCut runs on ruvector's `DynamicMinCut` (the `@ruvector/mincut-wasm`
+ * solver ruvector ships as an optional dependency), see mincut-bridge.ts.
+ * Inputs the wasm solver cannot describe (isolated nodes, no edges) and
+ * Louvain go to the built-in JS implementations — ruvector's own
+ * `louvainCommunities` is plain JS too, so there is nothing to gain there.
+ * Returns null when the wasm solver is unavailable; callers then use the
+ * built-in Stoer-Wagner `fallbackMinCut`.
  */
 declare function loadRuVector(): Promise<IRuVectorGraph | null>;
+/** Which MinCut backend `analyzeMinCutBoundaries` will use. */
+export declare function getMinCutBackend(): Promise<'mincut-wasm' | 'stoer-wagner'>;
 /**
  * Build dependency graph from source directory (with caching)
  */