@colbymchenry/codegraph 1.1.6 → 1.3.0

package/dist/resolution/index.d.ts

@@ -27,6 +27,9 @@ export declare class ReferenceResolver {
     private nameCache;
     private lowerNameCache;
     private qualifiedNameCache;
+    private fileLinesCache;
+    private methodMatchCache;
+    private nodesByKindCache;
     private knownNames;
     private knownFiles;
     private cachesWarmed;
@@ -58,6 +61,8 @@ export declare class ReferenceResolver {
      * Clear internal caches
      */
     clearCaches(): void;
+    /** `readFile` through the LRU content cache (null = read failed, also cached). */
+    private readFileCached;
     /**
      * Create the resolution context
      */
@@ -103,7 +108,21 @@ export declare class ReferenceResolver {
      * (re-resolving an already-resolved ref is a no-op since it's been deleted).
      * Returns the number of newly-created edges.
      */
-    resolveChainedCallsViaConformance(): number;
+    resolveChainedCallsViaConformance(): Promise<number>;
+    /**
+     * Resolve one batch with a yield checkpoint between EVERY ref so the #850
+     * liveness heartbeat can fire on a slow/dense batch (#1091). The checkpoint
+     * granularity is per-ref — not per-N-refs — because per-ref cost is unbounded
+     * in the worst case (a collision-heavy method name whose candidate set misses
+     * the LRU re-fetches tens of thousands of rows): any fixed N multiplies that
+     * worst case into the watchdog window, which is how v1.2.0 still got killed
+     * at "Resolving refs" on large Java monorepos (#1122). `maybeYield()` is a
+     * ~ns time check when under budget, so per-ref checkpoints cost nothing.
+     * Behaviourally identical to `resolveAll(batch)`: `warmCaches()` is
+     * idempotent (guarded) and `resolveOne` is independent per ref, so yielding
+     * between refs changes only timing, never which edges get created.
+     */
+    private resolveBatchYielding;
     /**
      * Resolve and persist in batches to keep memory bounded.
      * Processes unresolved references in chunks, persisting edges and cleaning
@@ -152,6 +171,29 @@ export declare class ReferenceResolver {
      * through to name-matching).
      */
     private resolveRazorUsing;
+    /**
+     * Resolve a CFML inheritance reference written as a component path (#1152).
+     * Two forms exist in real code:
+     *
+     * - Dotted: `extends="coldbox.system.web.Controller"` — dots are directory
+     *   separators from the webroot or a CFML mapping. Mappings live in server
+     *   config / Application.cfc, so the leading segments may not exist in the
+     *   repo at all (in the coldbox repo itself the path is `system/web/
+     *   Controller.cfc` — the `coldbox.` root IS the repo). Matched by final
+     *   segment (the class), corroborated right-to-left against the candidate's
+     *   parent directories.
+     * - Relative: `extends="../base"` / `extends="./base"` (the FW/1 style) —
+     *   resolved against the referencing file's own directory.
+     *
+     * Conservative by design: a candidate needs at least one corroborating
+     * directory segment (a dotted path whose only same-named class sits in an
+     * unrelated directory is almost always an out-of-repo library supertype —
+     * mxunit/testbox/coldbox-as-dependency), and a corroboration tie yields no
+     * edge. Directory comparison is case-insensitive (CFML path resolution is);
+     * the class segment itself is matched exactly, which real code satisfies —
+     * dotted paths are written to match the on-disk file name.
+     */
+    private resolveCfmlComponentPath;
     /**
      * Resolve a `this.<member>` function-as-value reference (#756/#808) to the
      * ENCLOSING CLASS's own member — never a same-named symbol elsewhere. The
@@ -172,7 +214,7 @@ export declare class ReferenceResolver {
      * Mirrors resolveChainedCallsViaConformance's lifecycle. Returns the number
      * of newly-created edges.
      */
-    resolveDeferredThisMemberRefs(): number;
+    resolveDeferredThisMemberRefs(): Promise<number>;
     private gateLanguage;
     /**
      * Drop a FRAMEWORK-strategy resolution that crosses two *known* language

package/dist/resolution/name-matcher.d.ts

@@ -3,6 +3,7 @@
  *
  * Handles symbol name matching for reference resolution.
  */
+import { Node } from '../types';
 import { UnresolvedRef, ResolvedRef, ResolutionContext } from './types';
 /**
  * Try to resolve a path-like reference (e.g., "snippets/drawer-menu.liquid")
@@ -47,6 +48,27 @@ export declare function matchByExactName(ref: UnresolvedRef, context: Resolution
  * Try to resolve by qualified name
  */
 export declare function matchByQualifiedName(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * When a symbol name is ambiguous across files, prefer the candidate(s) declared
+ * in the call site's own file, keeping the rest in their original order (#1079).
+ * A same-file definition is the strongest language-agnostic signal for which of
+ * several same-named symbols a call means; without it, resolution collapses onto
+ * whichever was indexed first, so a call in `b/svc` wrongly targets `a/svc`.
+ * No-op when there are <2 candidates or none share the call site's file.
+ */
+export declare function preferCallSiteFile(nodes: Node[], callSiteFile: string): Node[];
+export declare function resolveMethodOnType(typeName: string, methodName: string, ref: UnresolvedRef, context: ResolutionContext, confidence: number, resolvedBy: ResolvedRef['resolvedBy'], 
+/**
+ * Optional FQN that identifies WHICH class declaration `typeName`
+ * refers to in the caller's file. When multiple candidates share
+ * the same qualifiedName (`FooConverter::convert` in both
+ * `dao/converter/` and `service/converter/`), the FQN's
+ * file-path-suffix picks the right one — the disambiguation
+ * signal Java imports carry but the call site doesn't (#314).
+ */
+preferredFqn?: string, 
+/** Recursion guard for the supertype/conformance walk. */
+depth?: number): ResolvedRef | null;
 /**
  * Resolve a C++ chained call whose receiver is itself a call — encoded by the
  * extractor as `<innerCallee>().<method>` (#645). The receiver's type is what
@@ -86,8 +108,5 @@ export declare function matchMethodCall(ref: UnresolvedRef, context: ResolutionC
  * Fuzzy match - last resort with lower confidence
  */
 export declare function matchFuzzy(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
-/**
- * Match all strategies in order of confidence
- */
 export declare function matchReference(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
 //# sourceMappingURL=name-matcher.d.ts.map

package/dist/resolution/strip-comments.d.ts

@@ -22,6 +22,6 @@
  * `path(...)`, `Route::get(...)`, `app.get(...)` style patterns that
  * framework extractors scan for.
  */
-export type CommentLang = 'python' | 'javascript' | 'typescript' | 'php' | 'ruby' | 'java' | 'csharp' | 'swift' | 'go' | 'rust' | 'c' | 'cpp';
+export type CommentLang = 'python' | 'javascript' | 'typescript' | 'php' | 'ruby' | 'java' | 'csharp' | 'swift' | 'go' | 'rust' | 'c' | 'cpp' | 'erlang';
 export declare function stripCommentsForRegex(content: string, lang: CommentLang): string;
 //# sourceMappingURL=strip-comments.d.ts.map

package/dist/resolution/types.d.ts

@@ -70,6 +70,26 @@ export interface ResolutionContext {
     fileExists(filePath: string): boolean;
     /** Read file content */
     readFile(filePath: string): string | null;
+    /**
+     * `readFile(filePath)` split into lines, LRU-cached per file. Receiver-type
+     * inference scans source lines for EVERY `receiver.method()` ref; splitting
+     * the whole file per ref made that O(refs-in-file × file-size) — ~20% of
+     * total index CPU on a Java-heavy repo and a driver of the #1122 watchdog
+     * kill on large ones. Optional so external/test contexts compile without it;
+     * callers fall back to splitting `readFile` themselves.
+     */
+    getFileLines?(filePath: string): string[] | null;
+    /**
+     * The method-definition nodes matching `typeName::methodName` in `language` —
+     * exactly `resolveMethodOnType`'s kind/language/qualifiedName-suffix filter,
+     * LRU-cached per (language, type, method). The uncached path re-fetches every
+     * node sharing the METHOD name (unbounded — tens of thousands on a collision-
+     * heavy Java repo) and re-scans it per ref, the dominant term in the #1122
+     * watchdog kill. Cached entries hold only the small filtered result; per-ref
+     * disambiguation (import FQN, call-site file) stays in the caller so a cached
+     * entry is valid from any call site. Optional for external/test contexts.
+     */
+    getMethodMatches?(typeName: string, methodName: string, language: Language): Node[];
     /** Get project root */
     getProjectRoot(): string;
     /** Get all files */

package/dist/resolution/workspace-packages.d.ts

@@ -26,6 +26,16 @@
 export interface WorkspacePackages {
     /** Member package `name` → directory relative to projectRoot (posix). */
     byName: Map<string, string>;
+    /**
+     * Member package `name` → its declared ENTRY FILE relative to projectRoot
+     * (posix), when the member's manifest names one (ohpm's oh-package.json5
+     * `"main": "Index.ets"`). Lets a bare `import { X } from "data"` resolve to
+     * the member's real barrel even when it doesn't follow an index-file
+     * convention — and independent of the CONSUMER's language (a `.ts` file
+     * importing an `.ets` barrel resolves without `.ets` in the TS candidate
+     * list). Absent for npm/pnpm members (their index conventions cover it).
+     */
+    entryByName?: Map<string, string>;
 }
 /**
  * Load workspace member packages for `projectRoot`. Returns `null` when

package/dist/search/identifier-segments.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Identifier-segment utilities for the prompt hook's graph-derived gate
+ * (name_segment_vocab): symbol names split into the words a human would use
+ * for them in prose, and prompt prose normalized into candidate words to look
+ * those segments up with.
+ *
+ * "OrderStateMachine" → order / state / machine — so the French prompt
+ * "comment marche la state machine des commandes ?" (or any language's prose
+ * naming the concept in Latin script) can be verified against the graph
+ * without a keyword list ever knowing the words. The FTS index can't serve
+ * this — its tokenizer keeps camelCase names as single tokens — which is why
+ * segments are materialized at index time instead (see schema.sql,
+ * name_segment_vocab).
+ */
+/**
+ * Split a symbol or file name into lowercase word segments.
+ *
+ * Handles camelCase / PascalCase (inner lower→Upper), acronym runs
+ * ("HTMLParser" → html/parser), snake_case / kebab-case / dotted file names
+ * (non-alphanumerics separate), and keeps digits glued to their word
+ * ("base64Encode" → base64/encode). Digit-only fragments are dropped.
+ */
+export declare function splitIdentifierSegments(name: string): string[];
+/**
+ * Normalize a prose word for segment lookup: lowercase + strip diacritics
+ * (NFD, drop combining marks), so "références" matches the segment
+ * "references" and "résolution" matches "resolution". Identifier segments are
+ * overwhelmingly ASCII, so this is what buys Latin-script languages their
+ * cross-lingual reach on loanwords.
+ */
+export declare function normalizeProseWord(word: string): string;
+/**
+ * Candidate words from a prompt for segment-vocabulary lookup, in order of
+ * appearance: Unicode letter/digit runs, normalized via
+ * {@link normalizeProseWord}, length-bounded, digit-only dropped,
+ * {@link ENGLISH_PROSE_STOPWORDS} dropped, deduped, capped. Everything that
+ * survives is judged per-repo by the rarity and co-occurrence rules in
+ * CodeGraph.getSegmentMatches — there is no domain-word list.
+ */
+export declare function extractProseCandidates(prompt: string): string[];
+/**
+ * Lookup variants for a prose word: the word itself plus light plural folding
+ * ("services" → service, "dependencies" → dependencie/dependency is NOT
+ * attempted — only a trailing s/es strip), so common plurals still hit their
+ * singular segment. Returned variants map back to the same original word.
+ *
+ * The strips are keyed on English plural spelling (#1145), in three classes:
+ * - UNAMBIGUOUS `-es` (after x/sh/ss/zz: boxes, hashes, classes, quizzes) —
+ *   strip 2 only. Stripping 1 minted a bogus sibling ("classes" → classe).
+ * - AMBIGUOUS endings (`-ches`/`-ses`/`-zes`/`-oes`): spelling alone can't
+ *   split patches(+es) from caches(+s), lenses from databases, heroes from
+ *   shoes — emit BOTH candidate keys and let the vocab lookup decide; a miss
+ *   is an ignored key, a wrong exclusive guess would LOSE the real match.
+ * - Everything else ending in `-s` — a bare `-s` plural (services, machines,
+ *   cookies): strip 1 only. Stripping 2 minted "services" → servic.
+ * A trailing `-ss` is a singular (class, process), not a plural: no strip —
+ * that used to mint "class" → clas.
+ */
+export declare function segmentLookupVariants(word: string): string[];
+//# sourceMappingURL=identifier-segments.d.ts.map

package/dist/sync/watcher.d.ts

@@ -63,8 +63,9 @@ export interface WatchOptions {
     onSyncError?: (error: Error) => void;
     /**
      * Callback fired ONCE when live watching degrades permanently and auto-sync
-     * is disabled — OS watch-resource exhaustion (EMFILE/ENFILE), or a write lock
-     * held past the retry budget. The string is an actionable, human-readable
+     * is disabled — OS watch-resource exhaustion (EMFILE/ENFILE), a write lock
+     * held past the retry budget, or a generic sync failure that persists past
+     * the retry budget (#1127). The string is an actionable, human-readable
      * reason. Lets a host (MCP server, daemon, CLI) tell the user that the index
      * will no longer auto-update instead of silently serving stale results.
      */
@@ -139,12 +140,15 @@ export declare class FileWatcher {
     private inotifyLimitWarned;
     /**
      * One-way latch: the reason live watching was permanently disabled at runtime
-     * (watch-resource exhaustion, or lock contention past the retry budget), or
-     * null while healthy. Set by {@link degrade}; cleared only by a fresh start().
+     * (watch-resource exhaustion, lock contention past the retry budget, or a
+     * persistent generic sync failure past the retry budget), or null while
+     * healthy. Set by {@link degrade}; cleared only by a fresh start().
      */
     private degradedReason;
     /** Consecutive lock-contention retries for watcher-triggered syncs. */
     private lockRetryCount;
+    /** Consecutive generic (non-lock) sync failures; reset only by a clean sync. */
+    private syncFailureRetryCount;
     /** Test-only inert mode: started, but with no OS watcher installed. */
     private inert;
     private debounceTimer;
@@ -248,7 +252,8 @@ export declare class FileWatcher {
     private shouldIgnoreDir;
     /**
      * Permanently disable live watching after a terminal runtime failure
-     * (watch-resource exhaustion, or lock contention past the retry budget).
+     * (watch-resource exhaustion, lock contention past the retry budget, or a
+     * persistent generic sync failure past the retry budget).
      * Idempotent: logs one actionable warning, fires {@link WatchOptions.onDegraded}
      * once, and stops the watcher. A subsequent start() clears the latch.
      */

package/dist/types.d.ts

@@ -20,7 +20,7 @@ export type EdgeKind = 'contains' | 'calls' | 'imports' | 'exports' | 'extends'
  * Supported programming languages. See NODE_KINDS for why this is a
  * runtime-iterable const array.
  */
-export declare const LANGUAGES: readonly ["typescript", "javascript", "tsx", "jsx", "python", "go", "rust", "java", "c", "cpp", "csharp", "razor", "php", "ruby", "swift", "kotlin", "dart", "svelte", "vue", "astro", "liquid", "pascal", "scala", "lua", "luau", "objc", "r", "yaml", "twig", "xml", "properties", "unknown"];
+export declare const LANGUAGES: readonly ["typescript", "javascript", "tsx", "jsx", "arkts", "python", "go", "rust", "java", "c", "cpp", "csharp", "razor", "php", "ruby", "swift", "kotlin", "dart", "svelte", "vue", "astro", "liquid", "pascal", "scala", "lua", "luau", "objc", "r", "solidity", "nix", "yaml", "twig", "xml", "properties", "cfml", "cfscript", "cfquery", "cobol", "vbnet", "erlang", "terraform", "unknown"];
 export type Language = (typeof LANGUAGES)[number];
 /**
  * A node in the knowledge graph representing a code symbol
@@ -245,6 +245,24 @@ export interface SearchResult {
     /** Matched text snippets for highlighting */
     highlights?: string[];
 }
+/**
+ * A symbol whose name-segments match prose words from a prompt — the
+ * graph-derived signal behind the front-load hook's medium tier
+ * (CodeGraph.getSegmentMatches). Always verified to exist in `nodes` at the
+ * time it is returned.
+ */
+export interface SegmentMatch {
+    /** Symbol name as indexed (e.g. `OrderStateMachine`). */
+    name: string;
+    /** Kind of the representative definition. */
+    kind: NodeKind;
+    /** File of the representative definition. */
+    filePath: string;
+    /** 1-based start line of the representative definition. */
+    startLine: number;
+    /** The prompt words (normalized) that matched this name's segments. */
+    matchedWords: string[];
+}
 /**
  * Context information for code understanding
  */

package/npm-shim.js

@@ -45,7 +45,14 @@ async function main() {
   // Happy path: the npm-installed optional dependency. Fall back to a download
   // when the registry didn't deliver it.
   var resolved = resolveInstalledBundle() || (await selfHealBundle());
-  var res = childProcess.spawnSync(resolved.command, resolved.args, { stdio: 'inherit' });
+  // Thread the MCP host's pid (our parent) down to the bundled server so its
+  // orphan watchdog can poll the host directly. Without this, the server can
+  // only watch THIS shim — and a shim killed during the server's first ~100ms
+  // of startup used to leave the server orphaned forever (issue #1185). An
+  // already-set value (an outer launcher) wins.
+  var env = Object.assign({}, process.env);
+  if (!env.CODEGRAPH_HOST_PPID) env.CODEGRAPH_HOST_PPID = String(process.ppid);
+  var res = childProcess.spawnSync(resolved.command, resolved.args, { stdio: 'inherit', windowsHide: true, env: env });
   if (res.error) {
     process.stderr.write('codegraph: ' + res.error.message + '\n');
     process.exit(1);
@@ -222,7 +229,7 @@ function extract(archive, destDir) {
   var args = isWindows
     ? ['-xf', archive, '-C', destDir, '--strip-components=1']
     : ['-xzf', archive, '-C', destDir, '--strip-components=1'];
-  var res = childProcess.spawnSync('tar', args, { stdio: 'ignore' });
+  var res = childProcess.spawnSync('tar', args, { stdio: 'ignore', windowsHide: true });
   if (res.error) throw new Error('tar unavailable: ' + res.error.message);
   if (res.status !== 0) throw new Error('tar exited ' + res.status);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@colbymchenry/codegraph",
-  "version": "1.1.6",
+  "version": "1.3.0",
   "description": "Local-first code intelligence for AI agents (MCP). Self-contained — bundles its own runtime.",
   "bin": {
     "codegraph": "npm-shim.js"
@@ -15,12 +15,12 @@
     "./package.json": "./package.json"
   },
   "optionalDependencies": {
-    "@colbymchenry/codegraph-darwin-arm64": "1.1.6",
-    "@colbymchenry/codegraph-darwin-x64": "1.1.6",
-    "@colbymchenry/codegraph-linux-arm64": "1.1.6",
-    "@colbymchenry/codegraph-linux-x64": "1.1.6",
-    "@colbymchenry/codegraph-win32-arm64": "1.1.6",
-    "@colbymchenry/codegraph-win32-x64": "1.1.6"
+    "@colbymchenry/codegraph-darwin-arm64": "1.3.0",
+    "@colbymchenry/codegraph-darwin-x64": "1.3.0",
+    "@colbymchenry/codegraph-linux-arm64": "1.3.0",
+    "@colbymchenry/codegraph-linux-x64": "1.3.0",
+    "@colbymchenry/codegraph-win32-arm64": "1.3.0",
+    "@colbymchenry/codegraph-win32-x64": "1.3.0"
   },
   "files": [
     "npm-shim.js",

package/dist/reasoning/config.d.ts

@@ -1,45 +0,0 @@
-/** Managed tier ("CodeGraph AI") — the metered gateway used when logged in. */
-export declare const MANAGED_DEFAULT_URL = "https://ai.getcodegraph.com/v1";
-/** The gateway's public model id (it translates this to the upstream provider id). */
-export declare const MANAGED_DEFAULT_MODEL = "openai/gpt-oss-120b";
-export interface OffloadConfig {
-    /** Managed tier: route through CodeGraph AI (metered) with the logged-in org token. */
-    managed?: boolean;
-    /** OpenAI-compatible base URL ending in `/v1` (e.g. https://api.cerebras.ai/v1). */
-    url?: string;
-    /** Model id to request (default `gpt-oss-120b` BYO, `openai/gpt-oss-120b` managed). */
-    model?: string;
-    /** Name of the env var holding the provider API key (never persisted). BYO only. */
-    keyEnv?: string;
-    /** reasoning_effort: low | medium | high (default `low`). */
-    effort?: string;
-    /** Output style: plain | report (default `plain`). */
-    style?: string;
-}
-export interface ResolvedOffload {
-    /** True when the offload is usable (endpoint present; for managed, a token too). */
-    enabled: boolean;
-    /** Managed tier (CodeGraph AI, metered) vs BYO endpoint. */
-    managed: boolean;
-    url?: string;
-    model: string;
-    /** Resolved API key / org token (from env, the configured `keyEnv`, or login), if any. */
-    apiKey?: string;
-    /** Where the key/token came from (for `status` display) — never the secret itself. */
-    keySource?: string;
-    effort: string;
-    style: string;
-    timeoutMs: number;
-    maxTokens: number;
-    strip: boolean;
-    debug: boolean;
-    /** Where the endpoint came from — drives `codegraph offload status`. */
-    origin: 'env' | 'config' | 'none';
-}
-/** The persisted offload block (empty object if none). */
-export declare function readOffloadConfig(): OffloadConfig;
-/** Persist (or, with `null`, clear) the offload block, leaving other config keys intact. */
-export declare function writeOffloadConfig(offload: OffloadConfig | null): void;
-/** Merge the persisted config with `CODEGRAPH_OFFLOAD_*` env overrides (env wins). */
-export declare function resolveOffload(env?: NodeJS.ProcessEnv): ResolvedOffload;
-//# sourceMappingURL=config.d.ts.map

package/dist/reasoning/credentials.d.ts

@@ -1,5 +0,0 @@
-/** The stored managed-offload org token, if the machine is logged in. */
-export declare function readOffloadToken(): string | undefined;
-/** Persist (or, with `null`, clear) the managed-offload org token at `0600`. */
-export declare function writeOffloadToken(token: string | null): void;
-//# sourceMappingURL=credentials.d.ts.map

package/dist/reasoning/login.d.ts

@@ -1,21 +0,0 @@
-/** Dashboard base for the device-login endpoints; override for testing via CODEGRAPH_LOGIN_URL. */
-export declare function loginBaseUrl(): string;
-/** The dashboard's response to a device-authorization start request. */
-export interface DeviceStart {
-    device_code: string;
-    user_code: string;
-    verification_uri: string;
-    /** Same URL with the code prefilled, for one-click open. */
-    verification_uri_complete?: string;
-    /** Seconds the CLI should wait between polls. */
-    interval?: number;
-    /** Seconds until the request expires. */
-    expires_in?: number;
-}
-/** Begin a device-authorization request. */
-export declare function startDeviceLogin(): Promise<DeviceStart>;
-/** Poll until the user approves in the browser; resolves with the org token. */
-export declare function pollForToken(deviceCode: string, intervalSec: number, expiresInSec: number): Promise<string>;
-/** Best-effort: open a URL in the default browser. Never throws — the URL is also printed. */
-export declare function openBrowser(url: string): Promise<void>;
-//# sourceMappingURL=login.d.ts.map

package/dist/reasoning/reasoner.d.ts

@@ -1,43 +0,0 @@
-interface SynthArgs {
-    query: string;
-    context: string;
-}
-/** True when a reasoning offload endpoint is configured (env or `~/.codegraph/config.json`). */
-export declare function isOffloadEnabled(): boolean;
-export interface OffloadUsage {
-    plan?: string;
-    allowance?: number;
-    used?: number;
-    overage?: number;
-    remaining?: number;
-    periodEnd?: number;
-    unlimited?: boolean;
-    banned?: boolean;
-    tokensLast30?: number;
-    callsLast30?: number;
-    creditsLast30?: number;
-    models?: string[];
-}
-/**
- * GET `/v1/usage` from the configured (managed) endpoint → the org's credit
- * balance/usage, or null on any failure. Drives `codegraph offload status`.
- */
-export declare function fetchUsage(): Promise<OffloadUsage | null>;
-/**
- * Strip sections of the explore output addressed to the AGENT (not useful to a
- * reasoning model): the "Not shown above" pointer list, the completeness signal,
- * the explore-budget note, the trimmed/truncation notices, and the redundant
- * "## Exploration:/Found N symbols" header (the query is sent separately). Left
- * in, some models regurgitate them ("We have 2 explore calls. Let's explore…")
- * and they add noise. Source code, blast radius, relationships, and flow stay.
- * Opt-in (`CODEGRAPH_OFFLOAD_STRIP=1`) — default off (it also removes the "Not
- * shown above" pointers, which can be useful navigation).
- */
-export declare function stripAgentDirectives(context: string): string;
-/**
- * Offload reasoning over the retrieved `context` to the configured model and
- * return its synthesized answer, or null to signal "fall back to local source".
- */
-export declare function synthesizeOffload({ query, context }: SynthArgs): Promise<string | null>;
-export {};
-//# sourceMappingURL=reasoner.d.ts.map