@wrongstack/tools 1.0.0 → 1.0.2

package/dist/codebase-index/worker.js

@@ -1,4 +1,5 @@
 import {
+  contextService,
   fileGraphService,
   incomingCallsService,
   indexService,
@@ -6,12 +7,13 @@ import {
   packageGraphService,
   searchService,
   statsService,
-  symbolGraphService
-} from "../chunk-N3K2SFEI.js";
-import "../chunk-NU2IZ72J.js";
-import "../chunk-VVZPQPTY.js";
+  symbolGraphService,
+  vectorSearchService
+} from "../chunk-52UXXQMP.js";
+import "../chunk-DL2ARI4S.js";
+import "../chunk-3AU6CZWL.js";
 import "../chunk-6IEBD27U.js";
-import "../chunk-UCYQTZ7F.js";
+import "../chunk-ZKC5UNGD.js";
 import "../chunk-YOHO4DVT.js";
 import "../chunk-2CTZW6JQ.js";
 import "../chunk-KE7A76VC.js";
@@ -50,6 +52,10 @@ async function dispatch(msg) {
     }
     case "search":
       return searchService(msg.args);
+    case "context":
+      return contextService(msg.args);
+    case "vectorSearch":
+      return vectorSearchService(msg.args);
     case "stats":
       return statsService(msg.args);
     case "packageGraph":

package/dist/codebase-index/writer-concepts.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Persistence for the concept layer (`file_concepts`, `subsystems`,
+ * `concept_edges`).
+ *
+ * Unlike the rank tables, these are written incrementally: a summary costs a
+ * model call, so the runner checkpoints as it goes and a cancelled or crashed
+ * pass must not throw away what it already paid for.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+type Statement = ReturnType<DatabaseSync['prepare']>;
+type PrepareStatement = (sql: string) => Statement;
+/**
+ * Whether a stored summary describes the file's current bytes.
+ *
+ * `stale` is kept rather than deleted: an outdated description of a file is
+ * still a better starting point than nothing, both for a reader and as a hint
+ * to the model on the next pass.
+ */
+export type ConceptState = 'ready' | 'stale' | 'pending';
+export interface FileConcept {
+    file: string;
+    contentHash: string;
+    summary: string;
+    /** 1-based inclusive line span of the file's load-bearing lines. */
+    cruxStart: number | null;
+    cruxEnd: number | null;
+    state: ConceptState;
+    model: string;
+    updatedAt: number;
+}
+export interface Subsystem {
+    id: string;
+    name: string;
+    summary: string;
+    memberFiles: string[];
+    model: string;
+    updatedAt: number;
+}
+/**
+ * Closed vocabulary for concept-to-concept relations.
+ *
+ * Closed on purpose. An open-ended verb list produces a graph where
+ * `configures`, `sets up` and `initialises` are three different edges between
+ * the same pair, which nothing downstream can group or filter on.
+ */
+export declare const CONCEPT_RELATIONS: readonly ['uses', 'configures', 'validates', 'extends', 'persists', 'observes'];
+export type ConceptRelation = (typeof CONCEPT_RELATIONS)[number];
+export declare function isConceptRelation(value: string): value is ConceptRelation;
+export interface ConceptEdge {
+    fromId: string;
+    toId: string;
+    relation: ConceptRelation;
+}
+/** Write (or replace) one file's concept. */
+export declare function upsertFileConceptWithStatement(stmt: PrepareStatement, concept: FileConcept): void;
+export declare function getFileConceptWithStatement(stmt: PrepareStatement, file: string): FileConcept | undefined;
+/** All concepts, for whole-index consumers (atlas, embeddings, injection). */
+export declare function getAllFileConceptsWithStatement(stmt: PrepareStatement): FileConcept[];
+/** `file → summary` for the files that currently have a usable description. */
+export declare function getReadyConceptSummariesWithStatement(stmt: PrepareStatement): Map<string, string>;
+export interface ConceptCoverage {
+    ready: number;
+    stale: number;
+    pending: number;
+    subsystems: number;
+}
+export declare function getConceptCoverageWithStatement(stmt: PrepareStatement): ConceptCoverage;
+/**
+ * Mark every concept whose recorded hash no longer matches the indexed file as
+ * `stale`, in one statement.
+ *
+ * Run before a pass rather than during indexing: the indexer's atomic write is
+ * not the place to reason about a layer it does not own, and a summary that is
+ * one generation behind harms nothing until someone asks for it.
+ */
+export declare function markStaleConceptsWithStatement(stmt: PrepareStatement): number;
+/** Drop concepts for files that are no longer indexed. */
+export declare function pruneOrphanConceptsWithStatement(stmt: PrepareStatement): number;
+/** Replace the whole subsystem layer. Subsystems are derived as a set. */
+export declare function replaceSubsystemsWithStatement(stmt: PrepareStatement, maxSqlVars: number, subsystems: readonly Subsystem[], edges: readonly ConceptEdge[]): void;
+export declare function getSubsystemsWithStatement(stmt: PrepareStatement): Subsystem[];
+export declare function getConceptEdgesWithStatement(stmt: PrepareStatement): ConceptEdge[];
+export {};
+//# sourceMappingURL=writer-concepts.d.ts.map

package/dist/codebase-index/writer-graph-decorate.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Atlas enrichment for the CodeMap graph.
+ *
+ * The three graph getters build their nodes from `symbols` and `files`. Rank,
+ * concept summaries and subsystem membership live in tables those queries know
+ * nothing about, and each getter reaches its nodes by a different route — one
+ * groups by package, one by file, one by symbol id.
+ *
+ * Rather than thread four more joins through three query shapes and their node
+ * builders, this decorates the finished nodes in one pass. That keeps the
+ * enrichment strictly additive: an index where no rank or concept pass has run
+ * produces exactly the graph it produced before, because every lookup misses
+ * and every field stays absent.
+ *
+ * It also sidesteps `chunkedIdQuery`'s documented rule that `buildSql` may not
+ * contain a `LIMIT` — there is no limit to express here.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { GraphNode } from './schema.js';
+type Statement = ReturnType<DatabaseSync['prepare']>;
+type PrepareStatement = (sql: string) => Statement;
+/**
+ * Stamp rank, concept, crux, subsystem and mtime onto graph nodes.
+ *
+ * `packageOf` is supplied by the caller because the package labeller already
+ * exists at every call site, and rebuilding it here would read `files` twice.
+ */
+export declare function decorateGraphNodes(stmt: PrepareStatement, nodes: GraphNode[], packageOf: (file: string) => string): void;
+export {};
+//# sourceMappingURL=writer-graph-decorate.d.ts.map

package/dist/codebase-index/writer-graph-reader.d.ts

@@ -1,7 +1,29 @@
 import type { DatabaseSync } from 'node:sqlite';
 import type { CallSite, CodeMapGraph, Ref } from './schema.js';
+import { type WriterSymbolGraphRow } from './writer-graph-helpers.js';
 type Statement = ReturnType<DatabaseSync['prepare']>;
 type PrepareStatement = (sql: string) => Statement;
+/**
+ * Hydrate symbol rows for an arbitrary id list.
+ *
+ * The personalised retrieval walk scores dense graph indices and then needs
+ * the declarations behind the winners; this is that lookup. Chunked because
+ * the id list is unbounded — the caller decides how many nodes to hydrate.
+ */
+export declare function getSymbolsByIdsWithStatement(stmt: PrepareStatement, ids: readonly number[]): WriterSymbolGraphRow[];
+/**
+ * Declarations in one file, in source order.
+ *
+ * Ordered by line rather than by any score so the list reads the way the file
+ * does — the atlas uses it to describe a file, not to rank within it.
+ */
+export declare function getFileSymbolsWithStatement(stmt: PrepareStatement, file: string, limit: number): Array<{
+    id: number;
+    name: string;
+    kind: string;
+    line: number;
+    signature: string;
+}>;
 /**
  * Find all symbols that CALL/USE the named target symbol (incoming callers).
  *

package/dist/codebase-index/writer-rank.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Persistence for the graph centrality layer (`symbol_rank`, `file_rank`).
+ *
+ * Ranks are always written as a whole: the score is a property of the entire
+ * graph, so a partial update would leave the table describing a graph that no
+ * longer exists. Both writers therefore delete and re-insert rather than
+ * upserting row by row — at ~66k symbols that is a single fast statement plus
+ * a ladder-chunked bulk insert, well inside the index run's existing budget.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+import type { FileRankRow, SymbolRankRow } from './graph-rank.js';
+type Statement = ReturnType<DatabaseSync['prepare']>;
+type PrepareStatement = (sql: string) => Statement;
+/** Replace the whole `symbol_rank` table with `rows`. */
+export declare function replaceSymbolRanksWithStatement(stmt: PrepareStatement, maxSqlVars: number, rows: readonly SymbolRankRow[]): void;
+/** Replace the whole `file_rank` table with `rows`. */
+export declare function replaceFileRanksWithStatement(stmt: PrepareStatement, maxSqlVars: number, rows: readonly FileRankRow[]): void;
+/**
+ * Highest-ranked files, most central first.
+ *
+ * `limit` is applied in SQL — this is a plain single-table read, so none of
+ * the chunked-query constraints that forbid `LIMIT` elsewhere apply here.
+ */
+export declare function getTopFileRanksWithStatement(stmt: PrepareStatement, limit: number): FileRankRow[];
+/** A ranked file joined with the metadata the repo map needs to group it. */
+export interface RankedFileRow extends FileRankRow {
+    /** Code Atlas grouping label from `files.package` — '' when unlabelled. */
+    package: string;
+    lang: string;
+    symbolCount: number;
+}
+/**
+ * Highest-ranked files with their package label, for repo-map clustering.
+ *
+ * Joined here rather than in two round trips because the repo map always
+ * needs both, and `file_rank` is keyed by the same absolute path as `files`.
+ */
+export declare function getRankedFilesWithStatement(stmt: PrepareStatement, limit: number): RankedFileRow[];
+/**
+ * True indexed-file count per package label.
+ *
+ * The repo map only fetches its top few hundred ranked files, so counting
+ * cluster membership from that slice would report "core has 154 files" for a
+ * package with thousands. The count has to come from `files` itself.
+ */
+export declare function getPackageFileCountsWithStatement(stmt: PrepareStatement): Map<string, number>;
+/** Highest-ranked symbols, most central first. */
+export declare function getTopSymbolRanksWithStatement(stmt: PrepareStatement, limit: number): SymbolRankRow[];
+/**
+ * How many symbols declare each ambiguous symbol's name, keyed by symbol id.
+ *
+ * Counted per `(name, language family)` because that is exactly the scope ref
+ * resolution matches within (`FAMILY_MATCH_SQL`) — a Go `Read` and a
+ * TypeScript `Read` never compete for the same ref, so counting them together
+ * would understate the confidence of both.
+ *
+ * Only names with more than one declaration are returned: on this repo that
+ * is roughly a seventh of all names, so the map stays small and every absent
+ * id means "unambiguous, full weight".
+ */
+export declare function getSymbolNameCandidatesWithStatement(stmt: PrepareStatement): Map<number, number>;
+/**
+ * File-to-file import edges, as `source file → set of imported files`.
+ *
+ * Built from the import refs the module resolver managed to resolve to a real
+ * path (`refs.to_file`). Used by the rank pass to tell a cross-file reference
+ * that is genuinely visible from one the resolver merely guessed at.
+ */
+export declare function getImportVisibilityWithStatement(stmt: PrepareStatement): Map<string, Set<string>>;
+/** Whole-table `file → rank` lookup, for joining ranks onto graph reads. */
+export declare function getFileRankMapWithStatement(stmt: PrepareStatement): Map<string, number>;
+/** Row counts, for index stats and for deciding whether the layer is populated. */
+export declare function getRankCountsWithStatement(stmt: PrepareStatement): {
+    symbols: number;
+    files: number;
+};
+export {};
+//# sourceMappingURL=writer-rank.d.ts.map

package/dist/codebase-index/writer-schema.d.ts

@@ -16,6 +16,57 @@ export declare const LANG_FAMILY_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS lan
 /** Family value that matches every symbol family, used by language-less refs. */
 export declare const LANG_FAMILY_WILDCARD = "*";
 export declare const SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'trigram')";
+/**
+ * Graph centrality, computed at index time by `graph-rank.ts` once every ref
+ * has its final `to_id` / `to_file`. Two tables rather than columns on
+ * `symbols` / `files` so the whole layer is additive: an index written by an
+ * older build simply has empty rank tables, and `SCHEMA_VERSION` stays put
+ * (a bump drops and rebuilds the entire index — see `initIndexSchema`).
+ *
+ * `rank` is max-normalised to 1.0 across the run, so scores are comparable
+ * within one index but never across two.
+ */
+export declare const RANK_TABLES_SQL = "\n  CREATE TABLE IF NOT EXISTS symbol_rank (\n    symbol_id INTEGER PRIMARY KEY,\n    rank REAL NOT NULL,\n    in_deg INTEGER NOT NULL DEFAULT 0,\n    out_deg INTEGER NOT NULL DEFAULT 0\n  );\n  CREATE TABLE IF NOT EXISTS file_rank (\n    file TEXT PRIMARY KEY,\n    rank REAL NOT NULL,\n    in_deg INTEGER NOT NULL DEFAULT 0,\n    out_deg INTEGER NOT NULL DEFAULT 0\n  );\n";
+export declare const RANK_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_sr_rank ON symbol_rank(rank DESC)', 'CREATE INDEX IF NOT EXISTS idx_fr_rank ON file_rank(rank DESC)'];
+/**
+ * Concept layer — plain-English descriptions of what code is *for*, which the
+ * structural index cannot express. Symbol names and signatures answer "what is
+ * declared"; they cannot answer "where do we back off after a 429".
+ *
+ * Populated by an optional, explicitly enabled LLM pass. Additive like the rank
+ * tables: an index without the pass simply has empty concept tables, and every
+ * consumer treats a missing summary as "not described yet" rather than an error.
+ *
+ * `content_hash` mirrors `files.content_hash`, and is the cache key that keeps
+ * the pass affordable — a file whose bytes have not changed is never re-sent to
+ * a model. `state` distinguishes a summary that matches the current bytes
+ * (`ready`) from one describing an older version (`stale`, still useful as a
+ * hint) and one not yet produced (`pending`).
+ *
+ * `crux_start`/`crux_end` point at the few lines that actually carry the file's
+ * meaning. A summary can drift from the truth; a pointer into the source cannot.
+ */
+export declare const CONCEPT_TABLES_SQL = "\n  CREATE TABLE IF NOT EXISTS file_concepts (\n    file TEXT PRIMARY KEY,\n    content_hash TEXT NOT NULL DEFAULT '',\n    summary TEXT NOT NULL DEFAULT '',\n    crux_start INTEGER,\n    crux_end INTEGER,\n    state TEXT NOT NULL DEFAULT 'pending',\n    model TEXT NOT NULL DEFAULT '',\n    updated_at INTEGER NOT NULL DEFAULT 0\n  );\n  CREATE TABLE IF NOT EXISTS subsystems (\n    id TEXT PRIMARY KEY,\n    name TEXT NOT NULL,\n    summary TEXT NOT NULL DEFAULT '',\n    member_files TEXT NOT NULL DEFAULT '[]',\n    model TEXT NOT NULL DEFAULT '',\n    updated_at INTEGER NOT NULL DEFAULT 0\n  );\n  CREATE TABLE IF NOT EXISTS concept_edges (\n    from_id TEXT NOT NULL,\n    to_id TEXT NOT NULL,\n    relation TEXT NOT NULL,\n    PRIMARY KEY (from_id, to_id, relation)\n  );\n";
+/**
+ * Semantic embeddings, one per file.
+ *
+ * **Per file, not per symbol.** Embedding a bare signature — `function
+ * resolve(id: string): Widget` — captures almost nothing a lexical index does
+ * not already have. What carries meaning is the concept layer's description of
+ * what the file is *for*, so that is what gets embedded. It is also eight
+ * times cheaper on this repository: 8k files against 66k symbols.
+ *
+ * `source_hash` is a hash of the exact text that was embedded, so a changed
+ * summary re-embeds and an unchanged one never does. `provider` records which
+ * model produced the vector; vectors from a different model are not comparable,
+ * so a provider change invalidates the whole table rather than silently mixing
+ * two vector spaces.
+ *
+ * Separate from `symbol_vectors`, which stores the older synchronous
+ * char-trigram vectors and stays behind its own gate.
+ */
+export declare const FILE_VECTORS_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS file_vectors (\n    file TEXT PRIMARY KEY,\n    vector BLOB NOT NULL,\n    source_hash TEXT NOT NULL DEFAULT '',\n    provider TEXT NOT NULL DEFAULT ''\n  );\n";
+export declare const CONCEPT_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_fc_state ON file_concepts(state)', 'CREATE INDEX IF NOT EXISTS idx_ce_from ON concept_edges(from_id)'];
 /**
  * Phase 3: stores 384-dimensional float32 embedding vectors for each symbol.
  * Vectors are computed from the symbol's indexable text (name + signature +

package/dist/codebase-index/writer-vectors.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Persistence for file-level semantic embeddings (`file_vectors`).
+ *
+ * Vectors from two different models are not comparable — the spaces have
+ * nothing to do with each other — so the provider id is stored alongside every
+ * row and a provider change wipes the table rather than silently mixing them.
+ */
+import type { DatabaseSync } from 'node:sqlite';
+type Statement = ReturnType<DatabaseSync['prepare']>;
+type PrepareStatement = (sql: string) => Statement;
+/** Metadata key recording which provider produced the stored vectors. */
+export declare const FILE_VECTOR_PROVIDER_KEY = "file_vector_provider";
+export interface FileVectorRow {
+    file: string;
+    vector: Float32Array;
+    /** Hash of the exact text that was embedded. */
+    sourceHash: string;
+    provider: string;
+}
+/** What is already embedded, so a pass can skip unchanged text. */
+export interface FileVectorState {
+    file: string;
+    sourceHash: string;
+}
+export declare function getFileVectorStatesWithStatement(stmt: PrepareStatement, provider: string): Map<string, string>;
+export declare function upsertFileVectorsWithStatement(stmt: PrepareStatement, maxSqlVars: number, rows: readonly FileVectorRow[]): void;
+/**
+ * Drop every stored vector when the provider changes.
+ *
+ * Returns true when a wipe happened, so the caller can report that the next
+ * pass is a full re-embed rather than an incremental one.
+ */
+export declare function reconcileVectorProviderWithStatement(stmt: PrepareStatement, getMetadata: (key: string) => string | undefined, setMetadata: (key: string, value: string) => void, provider: string): boolean;
+/** Vectors dropped for files no longer indexed. */
+export declare function pruneOrphanFileVectorsWithStatement(stmt: PrepareStatement): number;
+export declare function countFileVectorsWithStatement(stmt: PrepareStatement): number;
+export interface VectorHit {
+    file: string;
+    /** Cosine similarity in [-1, 1]. */
+    score: number;
+}
+/**
+ * Rank every stored vector against `query` and return the closest files.
+ *
+ * A brute-force scan, deliberately: at file granularity this repository has
+ * roughly eight thousand vectors of 384 floats, which is about twelve
+ * megabytes and a few milliseconds to sweep. An approximate-nearest-neighbour
+ * index would add a dependency and an accuracy cliff to save time nobody is
+ * waiting on.
+ */
+export declare function searchFileVectorsWithStatement(stmt: PrepareStatement, query: Float32Array, limit: number, minScore: number): VectorHit[];
+export {};
+//# sourceMappingURL=writer-vectors.d.ts.map

package/dist/codebase-index/writer.d.ts

@@ -1,7 +1,11 @@
+import type { FileRankRow, SymbolRankRow } from './graph-rank.js';
 import type { CallSite, CodeMapGraph, FileMeta, IndexStats, Symbol as IndexSymbol, Ref, SearchResult, SymbolKind, SymbolLang } from './schema.js';
 import { type IndexSummary } from './writer-admin.js';
+import type { ConceptCoverage, ConceptEdge, FileConcept, Subsystem } from './writer-concepts.js';
+import type { RankedFileRow } from './writer-rank.js';
 import type { WriterSearchFilter } from './writer-search-helpers.js';
 import { StorePool } from './writer-store-pool.js';
+import type { FileVectorRow, VectorHit } from './writer-vectors.js';
 export { codebaseIndexDirOverride, resolveIndexDir } from './writer-helpers.js';
 export { StorePool } from './writer-store-pool.js';
 export declare class IndexStore {
@@ -171,11 +175,66 @@ export declare class IndexStore {
         kind: SymbolKind;
         line: number;
     }>;
+    /** Declarations in one file, in source order. */
+    getFileSymbols(file: string, limit: number): Array<{
+        id: number;
+        name: string;
+        kind: string;
+        line: number;
+        signature: string;
+    }>;
+    /** Declarations behind an arbitrary id list, for the retrieval walk. */
+    getSymbolsByIds(ids: readonly number[]): Array<{
+        id: number;
+        name: string;
+        kind: string;
+        lang: string;
+        file: string;
+        line: number;
+        signature: string;
+        scope: string;
+    }>;
     getAllResolvedRefs(): Array<{
         fromId: number;
         toId: number;
         callType: string;
     }>;
+    /**
+     * Replace both rank tables in one write. Called once per index run, after
+     * ref resolution has settled — a rank computed against half-resolved refs
+     * would describe a graph that never existed.
+     */
+    replaceRanks(symbols: readonly SymbolRankRow[], files: readonly FileRankRow[]): void;
+    /** Wipe stored vectors when the embedding model changed. */
+    reconcileVectorProvider(provider: string): boolean;
+    getFileVectorStates(provider: string): Map<string, string>;
+    upsertFileVectors(rows: readonly FileVectorRow[]): void;
+    pruneOrphanFileVectors(): number;
+    countFileVectors(): number;
+    searchFileVectors(query: Float32Array, limit: number, minScore: number): VectorHit[];
+    upsertFileConcept(concept: FileConcept): void;
+    getFileConcept(file: string): FileConcept | undefined;
+    getAllFileConcepts(): FileConcept[];
+    getReadyConceptSummaries(): Map<string, string>;
+    getConceptCoverage(): ConceptCoverage;
+    /** Flag summaries whose file has changed since they were written. */
+    markStaleConcepts(): number;
+    /** Drop summaries for files that are no longer indexed. */
+    pruneOrphanConcepts(): number;
+    replaceSubsystems(subsystems: readonly Subsystem[], edges: readonly ConceptEdge[]): void;
+    getSubsystems(): Subsystem[];
+    getConceptEdges(): ConceptEdge[];
+    getPackageFileCounts(): Map<string, number>;
+    getRankedFiles(limit: number): RankedFileRow[];
+    getTopFileRanks(limit: number): FileRankRow[];
+    getTopSymbolRanks(limit: number): SymbolRankRow[];
+    getFileRankMap(): Map<string, number>;
+    getRankCounts(): {
+        symbols: number;
+        files: number;
+    };
+    getSymbolNameCandidates(): Map<number, number>;
+    getImportVisibility(): Map<string, Set<string>>;
     getAllImportRefs(): Array<{
         sourceFile: string | null;
         toName: string;

package/dist/edit.js

@@ -1,14 +1,14 @@
 import {
   editTool
-} from "./chunk-DK4J2WMH.js";
+} from "./chunk-7XUEPBNT.js";
 import "./chunk-MSOAX3GC.js";
-import "./chunk-ZTCJCYLN.js";
-import "./chunk-GDDXX27P.js";
-import "./chunk-N3K2SFEI.js";
-import "./chunk-NU2IZ72J.js";
-import "./chunk-VVZPQPTY.js";
+import "./chunk-TI5COGLY.js";
+import "./chunk-MBR5VAB5.js";
+import "./chunk-52UXXQMP.js";
+import "./chunk-DL2ARI4S.js";
+import "./chunk-3AU6CZWL.js";
 import "./chunk-6IEBD27U.js";
-import "./chunk-UCYQTZ7F.js";
+import "./chunk-ZKC5UNGD.js";
 import "./chunk-YOHO4DVT.js";
 import "./chunk-2CTZW6JQ.js";
 import "./chunk-KE7A76VC.js";

package/dist/exec.js

@@ -7,7 +7,7 @@ import {
   isExecCommandAllowed,
   resetDangerBypass,
   resetExecPolicy
-} from "./chunk-KDEXUQY7.js";
+} from "./chunk-MGPR7VG3.js";
 import "./chunk-BTSFTGIL.js";
 import "./chunk-PVCB7RUZ.js";
 import "./chunk-SCMRM6NL.js";

package/dist/{go-parser-D7ELWQ7F.js → go-parser-QIEXU3P2.js}

@@ -1,7 +1,8 @@
 import {
   parseParserOutput,
+  recordParserSubprocess,
   withSpawnGate
-} from "./chunk-UCYQTZ7F.js";
+} from "./chunk-ZKC5UNGD.js";
 import {
   detectLang
 } from "./chunk-YOHO4DVT.js";
@@ -408,6 +409,7 @@ async function syncGoParse(filePath, content, lang) {
     const goResult = await new Promise(
       (resolve, reject) => {
         let settled = false;
+        recordParserSubprocess();
         const proc = spawn(goBinary, ["run", scriptPath], {
           stdio: ["pipe", "pipe", "pipe"],
           windowsHide: true
@@ -466,4 +468,4 @@ export {
   detectLang,
   parseSymbols
 };
-//# sourceMappingURL=go-parser-D7ELWQ7F.js.map
+//# sourceMappingURL=go-parser-QIEXU3P2.js.map