gitnexus 1.6.13-rc.29 → 1.6.13-rc.30

package/dist/cli/clean.js

@@ -14,136 +14,127 @@ import { listLocalHeads } from '../storage/git.js';
 import { isContainedBranchDir, isDeleteCandidate, listStaleBranchSlots, removeBranchSlot, staleListingBlock, } from '../storage/stale-branch-slots.js';
 import { cleanParkedLbugSidecars, inspectLbugSidecars, listParkedLbugSidecars, } from '../core/lbug/sidecar-recovery.js';
 import { t } from './i18n/index.js';
-export const cleanCommand = async (options) => {
-    // --stale: reclaim leftover per-branch slots whose recorded branch is not
-    // a live local head (#3331). Exclusive arm before --branch.
-    if (options?.stale) {
-        const cwd = process.cwd();
-        const repo = await findRepo(cwd);
-        if (!repo) {
-            console.log(t('clean.notFoundHere'));
-            return;
-        }
-        const entries = await listRegisteredRepos();
-        const entry = findRegistryEntryByRepoPath(entries, repo.repoPath);
-        let storagePath;
-        try {
-            storagePath = await requireDeletableStoragePath({
+const resolveOwnedCwdStorage = async (refusePrefix) => {
+    const repo = await findRepo(process.cwd());
+    if (!repo) {
+        console.log(t('clean.notFoundHere'));
+        return null;
+    }
+    try {
+        const [entries, storagePath] = await Promise.all([
+            listRegisteredRepos(),
+            requireDeletableStoragePath({
                 path: repo.repoPath,
                 storagePath: repo.storagePath,
-            });
-        }
-        catch (err) {
-            if (err instanceof StorageDeletionError) {
-                logger.error(`Refusing to clean leftover branch indexes: ${err.message}`);
-                return;
-            }
-            throw err;
-        }
-        const slots = await listStaleBranchSlots({
-            repoPath: repo.repoPath,
+            }),
+        ]);
+        return {
+            repo,
+            entry: findRegistryEntryByRepoPath(entries, repo.repoPath),
             storagePath,
-            branches: entry?.branches,
-            includeSize: !options.force,
-        });
-        const listingBlock = staleListingBlock(slots);
-        if (listingBlock === 'heads-unavailable') {
-            console.log(t('clean.stale.headsUnavailable'));
-            for (const slot of slots.filter((row) => row.reason === 'heads-unavailable')) {
-                console.log(`  - ${formatStaleSlotLine(slot)}`);
-            }
-            return;
+        };
+    }
+    catch (err) {
+        if (err instanceof StorageDeletionError) {
+            logger.error(`${refusePrefix}${err.message}`);
+            return null;
         }
-        if (listingBlock === 'listing-failed') {
-            console.log(t('clean.stale.listingFailed'));
+        throw err;
+    }
+};
+const printStaleSlotLines = (message, slots) => {
+    console.log(message);
+    for (const slot of slots) {
+        console.log(`  - ${formatStaleSlotLine(slot)}`);
+    }
+};
+const cleanStaleBranchSlots = async (force) => {
+    const owned = await resolveOwnedCwdStorage('Refusing to clean leftover branch indexes: ');
+    if (!owned)
+        return;
+    const { repo, entry, storagePath } = owned;
+    const slots = await listStaleBranchSlots({
+        repoPath: repo.repoPath,
+        storagePath,
+        branches: entry?.branches,
+        includeSize: !force,
+    });
+    const listingBlock = staleListingBlock(slots);
+    if (listingBlock === 'heads-unavailable') {
+        printStaleSlotLines(t('clean.stale.headsUnavailable'), slots.filter((row) => row.reason === 'heads-unavailable'));
+        return;
+    }
+    if (listingBlock === 'listing-failed') {
+        console.log(t('clean.stale.listingFailed'));
+        return;
+    }
+    const candidates = slots.filter(isDeleteCandidate);
+    const probeFailed = slots.filter((slot) => slot.reason === 'probe-failed');
+    if (candidates.length === 0) {
+        if (probeFailed.length > 0) {
+            printStaleSlotLines(t('clean.stale.probeFailed'), probeFailed);
             return;
         }
-        const candidates = slots.filter(isDeleteCandidate);
-        const probeFailed = slots.filter((slot) => slot.reason === 'probe-failed');
-        const printProbeFailed = () => {
-            console.log(t('clean.stale.probeFailed'));
-            for (const slot of probeFailed) {
-                console.log(`  - ${formatStaleSlotLine(slot)}`);
-            }
-        };
-        if (candidates.length === 0) {
-            if (probeFailed.length > 0) {
-                printProbeFailed();
-                return;
-            }
-            console.log(t('clean.stale.none'));
-            return;
+        console.log(t('clean.stale.none'));
+        return;
+    }
+    if (!force) {
+        printStaleSlotLines(t('clean.stale.preview', { count: candidates.length }), candidates);
+        if (probeFailed.length > 0) {
+            printStaleSlotLines(t('clean.stale.probeFailed'), probeFailed);
         }
-        if (!options.force) {
-            console.log(t('clean.stale.preview', { count: candidates.length }));
-            for (const slot of candidates) {
-                console.log(`  - ${formatStaleSlotLine(slot)}`);
-            }
-            if (probeFailed.length > 0) {
-                printProbeFailed();
-            }
-            console.log(`\n${t('common.runForceConfirm')}`);
+        console.log(`\n${t('common.runForceConfirm')}`);
+        return;
+    }
+    let deletedAny = false;
+    for (const slot of candidates) {
+        const heads = listLocalHeads(repo.repoPath);
+        if (heads === null) {
+            console.log(deletedAny ? t('clean.stale.remainingSkipped') : t('clean.stale.headsUnavailable'));
             return;
         }
-        for (const slot of candidates) {
-            const heads = listLocalHeads(repo.repoPath);
-            if (heads === null) {
-                console.log(t('clean.stale.headsUnavailable'));
-                return;
-            }
-            if (heads.includes(slot.branch)) {
-                console.log(t('clean.stale.skippedLive', { branch: slot.branch }));
-                continue;
-            }
-            const result = await removeBranchSlot({
-                repoPath: repo.repoPath,
-                storagePath,
-                branch: slot.branch,
-                dir: slot.dir,
-            });
-            if (!result.ok) {
-                console.log(t('clean.stale.failed', { branch: slot.branch }));
-                logger.error({ err: result.error }, 'Failed to delete leftover branch index:');
-                continue;
-            }
-            console.log(t('clean.stale.deleted', { branch: slot.branch }));
+        if (heads.includes(slot.branch)) {
+            console.log(t('clean.stale.skippedLive', { branch: slot.branch }));
+            continue;
         }
-        if (probeFailed.length > 0) {
-            printProbeFailed();
+        const result = await removeBranchSlot({
+            repoPath: repo.repoPath,
+            storagePath,
+            branch: slot.branch,
+            dir: slot.dir,
+        });
+        if (!result.ok) {
+            console.log(t('clean.stale.failed', { branch: slot.branch }));
+            logger.error({ err: result.error }, 'Failed to delete leftover branch index:');
+            continue;
         }
+        deletedAny = true;
+        console.log(t('clean.stale.deleted', { branch: slot.branch }));
+    }
+    if (probeFailed.length > 0) {
+        printStaleSlotLines(t('clean.stale.probeFailed'), probeFailed);
+    }
+};
+export const cleanCommand = async (options) => {
+    // --stale: reclaim leftover per-branch slots whose recorded branch is not
+    // a live local head (#3331). Exclusive arm before --branch.
+    if (options?.stale) {
+        await cleanStaleBranchSlots(options.force === true);
         return;
     }
     // --branch <name>: remove a single non-primary branch's index (#2106 R7).
     // Resolve against the RECORDED branches[] summary (never by slugging the
     // user's raw input, which can disagree with the index-time-sanitized label).
     if (options?.branch) {
-        const cwd = process.cwd();
-        const repo = await findRepo(cwd);
-        if (!repo) {
-            console.log(t('clean.notFoundHere'));
+        const owned = await resolveOwnedCwdStorage('Refusing to clean branch index: ');
+        if (!owned)
             return;
-        }
-        const entries = await listRegisteredRepos();
-        const entry = findRegistryEntryByRepoPath(entries, repo.repoPath);
+        const { repo, entry, storagePath } = owned;
         const summary = entry?.branches?.find((b) => b.branch === options.branch);
         if (!summary) {
             console.log(t('clean.branchNotIndexed', { branch: options.branch }));
             return;
         }
-        let storagePath;
-        try {
-            storagePath = await requireDeletableStoragePath({
-                path: repo.repoPath,
-                storagePath: repo.storagePath,
-            });
-        }
-        catch (err) {
-            if (err instanceof StorageDeletionError) {
-                logger.error(`Refusing to clean branch index: ${err.message}`);
-                return;
-            }
-            throw err;
-        }
         const { lbugPath } = getStoragePaths(repo.repoPath, summary.branch, storagePath);
         const branchDir = path.dirname(lbugPath);
         if (!isContainedBranchDir(storagePath, branchDir)) {

package/dist/cli/doctor.d.ts

@@ -66,7 +66,7 @@ export declare function nativeStatusLine(check: NativeCheckResult): string;
  * When heads cannot be listed, do not title rows as orphaned or name
  * `clean --stale` (#3337): that command refuses to delete in the same state.
  */
-export declare function orphanedBranchSlotDoctorLines(slots: StaleBranchSlot[]): string[];
+export declare function leftoverBranchSlotDoctorLines(slots: StaleBranchSlot[]): string[];
 export declare function cachedUpdateDoctorLine(options: {
     installedVersion: string;
     eligible: boolean;

package/dist/cli/doctor.js

@@ -153,7 +153,7 @@ export function nativeStatusLine(check) {
  * When heads cannot be listed, do not title rows as orphaned or name
  * `clean --stale` (#3337): that command refuses to delete in the same state.
  */
-export function orphanedBranchSlotDoctorLines(slots) {
+export function leftoverBranchSlotDoctorLines(slots) {
     if (slots.length === 0)
         return [];
     const listingBlock = staleListingBlock(slots);
@@ -315,24 +315,22 @@ export const doctorCommand = async () => {
             console.log(`  ${padDisplayEnd('', 12)}${cudaRedirect.detail}`);
         }
     }
-    // Doctor stays runtime-global. Add only a cwd leftover-slot section when
-    // this process is inside an indexed repo. Look up that repo's registry row
-    // for recorded branch slugs; do not report leftovers for every registered
-    // repo, and never delete.
-    const [cwdRepo, entries] = await Promise.all([findRepo(process.cwd()), listRegisteredRepos()]);
+    // Cwd leftover-slot report only; never delete.
+    const cwdRepo = await findRepo(process.cwd());
     if (!cwdRepo)
         return;
+    const entries = await listRegisteredRepos();
     const entry = findRegistryEntryByRepoPath(entries, cwdRepo.repoPath);
     const slots = await listStaleBranchSlots({
         repoPath: cwdRepo.repoPath,
         storagePath: cwdRepo.storagePath,
         branches: entry?.branches,
     });
-    const orphanLines = orphanedBranchSlotDoctorLines(slots);
-    if (orphanLines.length === 0)
+    const leftoverLines = leftoverBranchSlotDoctorLines(slots);
+    if (leftoverLines.length === 0)
         return;
     console.log('');
-    for (const line of orphanLines) {
+    for (const line of leftoverLines) {
         console.log(line);
     }
 };

package/dist/cli/i18n/en.d.ts

@@ -59,6 +59,7 @@ export declare const en: {
     readonly 'clean.stale.item': '{{branch}}  {{reason}}  {{path}}  {{size}}';
     readonly 'clean.stale.registryOnlyPath': '(registry only)';
     readonly 'clean.stale.headsUnavailable': 'Could not list local heads; leftover branch indexes were not deleted. Re-run `gitnexus clean --stale` when git is available.';
+    readonly 'clean.stale.remainingSkipped': 'Could not list local heads; remaining leftover branch indexes were skipped. Re-run `gitnexus clean --stale` when git is available.';
     readonly 'clean.stale.listingFailed': 'Could not read leftover branch index directories; leftover indexes were not deleted. Check permissions on the branches/ directory and re-run `gitnexus clean --stale`.';
     readonly 'clean.stale.probeFailed': 'Could not inspect leftover branch index path(s); those slots were not deleted.';
     readonly 'clean.stale.deleted': 'Deleted leftover branch index: {{branch}}';

package/dist/cli/i18n/en.js

@@ -59,6 +59,7 @@ export const en = {
     'clean.stale.item': '{{branch}}  {{reason}}  {{path}}  {{size}}',
     'clean.stale.registryOnlyPath': '(registry only)',
     'clean.stale.headsUnavailable': 'Could not list local heads; leftover branch indexes were not deleted. Re-run `gitnexus clean --stale` when git is available.',
+    'clean.stale.remainingSkipped': 'Could not list local heads; remaining leftover branch indexes were skipped. Re-run `gitnexus clean --stale` when git is available.',
     'clean.stale.listingFailed': 'Could not read leftover branch index directories; leftover indexes were not deleted. Check permissions on the branches/ directory and re-run `gitnexus clean --stale`.',
     'clean.stale.probeFailed': 'Could not inspect leftover branch index path(s); those slots were not deleted.',
     'clean.stale.deleted': 'Deleted leftover branch index: {{branch}}',

package/dist/cli/i18n/resources.d.ts

@@ -60,6 +60,7 @@ export declare const cliResources: {
         readonly 'clean.stale.item': '{{branch}}  {{reason}}  {{path}}  {{size}}';
         readonly 'clean.stale.registryOnlyPath': '(registry only)';
         readonly 'clean.stale.headsUnavailable': 'Could not list local heads; leftover branch indexes were not deleted. Re-run `gitnexus clean --stale` when git is available.';
+        readonly 'clean.stale.remainingSkipped': 'Could not list local heads; remaining leftover branch indexes were skipped. Re-run `gitnexus clean --stale` when git is available.';
         readonly 'clean.stale.listingFailed': 'Could not read leftover branch index directories; leftover indexes were not deleted. Check permissions on the branches/ directory and re-run `gitnexus clean --stale`.';
         readonly 'clean.stale.probeFailed': 'Could not inspect leftover branch index path(s); those slots were not deleted.';
         readonly 'clean.stale.deleted': 'Deleted leftover branch index: {{branch}}';
@@ -366,6 +367,7 @@ export declare const cliResources: {
         'clean.stale.item': string;
         'clean.stale.registryOnlyPath': string;
         'clean.stale.headsUnavailable': string;
+        'clean.stale.remainingSkipped': string;
         'clean.stale.listingFailed': string;
         'clean.stale.probeFailed': string;
         'clean.stale.deleted': string;

package/dist/cli/i18n/zh-CN.d.ts

@@ -59,6 +59,7 @@ export declare const zhCN: {
     'clean.stale.item': string;
     'clean.stale.registryOnlyPath': string;
     'clean.stale.headsUnavailable': string;
+    'clean.stale.remainingSkipped': string;
     'clean.stale.listingFailed': string;
     'clean.stale.probeFailed': string;
     'clean.stale.deleted': string;

package/dist/cli/i18n/zh-CN.js

@@ -59,6 +59,7 @@ export const zhCN = {
     'clean.stale.item': '{{branch}}  {{reason}}  {{path}}  {{size}}',
     'clean.stale.registryOnlyPath': '（仅注册表）',
     'clean.stale.headsUnavailable': '无法列出本地分支，因此未删除残留分支索引。请在 git 可用后重新运行 `gitnexus clean --stale`。',
+    'clean.stale.remainingSkipped': '无法列出本地分支，因此已跳过其余残留分支索引。请在 git 可用后重新运行 `gitnexus clean --stale`。',
     'clean.stale.listingFailed': '无法读取残留分支索引目录，因此未删除残留索引。请检查 branches/ 目录权限后重新运行 `gitnexus clean --stale`。',
     'clean.stale.probeFailed': '无法检查残留分支索引路径，因此未删除这些槽位。',
     'clean.stale.deleted': '已删除残留分支索引：{{branch}}',

package/dist/core/group/service.js

@@ -41,8 +41,19 @@ function isStoredContract(raw) {
 }
 function filterQueryByServicePrefix(queryResult, servicePrefix) {
     const symbols = (queryResult.process_symbols || []).filter((s) => fileMatchesServicePrefix(typeof s.filePath === 'string' ? s.filePath : undefined, servicePrefix));
-    const allowed = new Set(symbols.map((s) => String(s.process_id ?? '')).filter(Boolean));
-    const processes = (queryResult.processes || []).filter((p) => allowed.has(String(p.id)));
+    const countByProcess = new Map();
+    for (const symbol of symbols) {
+        const pid = String(symbol.process_id ?? '');
+        if (!pid)
+            continue;
+        countByProcess.set(pid, (countByProcess.get(pid) ?? 0) + 1);
+    }
+    const processes = (queryResult.processes || []).filter((p) => countByProcess.has(String(p.id)));
+    for (const process of processes) {
+        const id = String(process.id ?? '');
+        if (id)
+            process.symbol_count = countByProcess.get(id) ?? 0;
+    }
     return { processes, process_symbols: symbols };
 }
 function isCrossLink(raw) {

package/dist/mcp/local/local-backend.js

@@ -15,6 +15,7 @@ import { querySpringAopMetadata } from './aop-metadata.js';
 import { queryConvexDispatchMetadata } from './convex-metadata.js';
 import { isValidQueryParams } from '../../core/lbug/query-params.js';
 import { toDisplayLine } from './line-display.js';
+import { shapeQueryProcessAttaches } from './query-process-attaches.js';
 import { LBUG_ID_PROBE_BATCH_SIZE, LBUG_QUERY_BATCH_SIZE } from '../../core/lbug/query-batch.js';
 import { chunk, mapConcurrent } from '../../lib/utils.js';
 import { pathSuffixOf } from './path-predicate.js';
@@ -2750,35 +2751,9 @@ export class LocalBackend {
         }
         // Step 4: Build response
         timer.start('formatting');
-        const processes = rankedProcesses.map((p) => ({
-            id: p.id,
-            summary: p.heuristicLabel || p.label,
-            priority: Math.round(p.priority * 1000) / 1000,
-            symbol_count: p.symbols.length,
-            process_type: p.processType,
-            step_count: p.stepCount,
-            ...(p.routes && p.routes.length > 0
-                ? {
-                    route: p.routes[0].url,
-                    method: p.routes[0].method || undefined,
-                    routes: p.routes,
-                }
-                : {}),
-            ...(chainByProcessId.has(p.id) ? { chain: chainByProcessId.get(p.id) } : {}),
-        }));
-        const processSymbols = rankedProcesses.flatMap((p) => p.symbols.slice(0, maxSymbolsPerProcess).map((s) => ({
-            ...s,
-            // mark the entry-point symbol so an agent reading the
-            // process can tell procedure vs. workflow vs. helper at a glance.
-            ...(p.entryPointId && s.id === p.entryPointId ? { is_entry_point: true } : {}),
-        })));
-        // Deduplicate process_symbols by id
-        const seen = new Set();
-        const dedupedSymbols = processSymbols.filter((s) => {
-            if (seen.has(s.id))
-                return false;
-            seen.add(s.id);
-            return true;
+        const { processes, process_symbols } = shapeQueryProcessAttaches(rankedProcesses, {
+            maxSymbolsPerProcess,
+            chainByProcessId,
         });
         timer.stop(); // formatting
         // End-to-end wall time — deliberately a separate mark so callers can
@@ -2941,7 +2916,7 @@ export class LocalBackend {
         const ftsPartial = ftsUsed && !!ftsQueryErrors;
         return {
             processes,
-            process_symbols: dedupedSymbols,
+            process_symbols,
             definitions: definitions.slice(0, 20), // cap standalone definitions
             timing,
             ...(contentAvailability ? { contentAvailability } : {}),

package/dist/mcp/local/query-process-attaches.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Shape ranked query processes into the MCP `process_symbols` attach list
+ * and honest per-process `symbol_count` (#3351).
+ *
+ * Aggregation already pushes a hub onto every owning process. This helper
+ * is the last shaping step: slice each process to `max_symbols`, keep one
+ * row per `(id, process_id)`, then set `symbol_count` from those rows.
+ */
+export type QueryProcessAttach = {
+    id: string;
+    process_id: string;
+    is_entry_point?: boolean;
+} & Record<string, unknown>;
+export type RankedQueryProcess<S extends QueryProcessAttach = QueryProcessAttach> = {
+    id: string;
+    label?: string;
+    heuristicLabel?: string;
+    processType?: string;
+    stepCount?: number;
+    entryPointId?: string;
+    priority: number;
+    symbols: S[];
+    routes?: Array<{
+        url: string;
+        method?: string;
+    }>;
+};
+export type QueryProcessCard = {
+    id: string;
+    summary: string;
+    priority: number;
+    symbol_count: number;
+    process_type?: string;
+    step_count?: number;
+    route?: string;
+    method?: string;
+    routes?: Array<{
+        url: string;
+        method?: string;
+    }>;
+    chain?: unknown;
+};
+export declare function shapeQueryProcessAttaches<S extends QueryProcessAttach>(rankedProcesses: Array<RankedQueryProcess<S>>, options: {
+    maxSymbolsPerProcess: number;
+    chainByProcessId?: ReadonlyMap<string, unknown>;
+}): {
+    processes: QueryProcessCard[];
+    process_symbols: S[];
+};

package/dist/mcp/local/query-process-attaches.js

@@ -0,0 +1,52 @@
+/**
+ * Shape ranked query processes into the MCP `process_symbols` attach list
+ * and honest per-process `symbol_count` (#3351).
+ *
+ * Aggregation already pushes a hub onto every owning process. This helper
+ * is the last shaping step: slice each process to `max_symbols`, keep one
+ * row per `(id, process_id)`, then set `symbol_count` from those rows.
+ */
+/**
+ * Pair key for attach rows. Both `id` and `process_id` routinely contain
+ * colons (`func:validate`, `proc:login-flow`), so a `:` join would collide.
+ */
+function attachPairKey(id, processId) {
+    return `${id}\0${processId}`;
+}
+export function shapeQueryProcessAttaches(rankedProcesses, options) {
+    const { maxSymbolsPerProcess, chainByProcessId } = options;
+    const seen = new Set();
+    const process_symbols = [];
+    const countByProcess = new Map();
+    for (const p of rankedProcesses) {
+        for (const s of p.symbols.slice(0, maxSymbolsPerProcess)) {
+            const key = attachPairKey(s.id, s.process_id);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const row = p.entryPointId && s.id === p.entryPointId ? { ...s, is_entry_point: true } : s;
+            process_symbols.push(row);
+            countByProcess.set(s.process_id, (countByProcess.get(s.process_id) ?? 0) + 1);
+        }
+    }
+    const processes = rankedProcesses.map((p) => {
+        const card = {
+            id: p.id,
+            summary: p.heuristicLabel || p.label || '',
+            priority: Math.round(p.priority * 1000) / 1000,
+            symbol_count: countByProcess.get(p.id) ?? 0,
+            process_type: p.processType,
+            step_count: p.stepCount,
+        };
+        if (p.routes && p.routes.length > 0) {
+            card.route = p.routes[0].url;
+            card.method = p.routes[0].method || undefined;
+            card.routes = p.routes;
+        }
+        const chain = chainByProcessId?.get(p.id);
+        if (chain !== undefined)
+            card.chain = chain;
+        return card;
+    });
+    return { processes, process_symbols };
+}

package/dist/mcp/tools.js

@@ -100,14 +100,14 @@ specify the "repo" parameter explicitly.`,
     {
         name: 'query',
         description: `Query the code knowledge graph for execution flows related to a concept.
-Returns processes (call chains) ranked by relevance, each with its symbols and file locations.
+Returns ranked processes plus a flat process_symbols list. Join processes[].id to process_symbols[].process_id.
 
 WHEN TO USE: Understanding how code works together. Use this when you need execution flows and relationships, not just file matches. Complements grep/IDE search.
 AFTER THIS: Use context() on a specific symbol for 360-degree view (callers, callees, categorized refs).
 
 Returns results grouped by process (execution flow):
 - processes: ranked execution flows with relevance priority. When a process has an HTTP endpoint, each item includes route and method string aliases plus routes: [{ url, method? }] (same shape as context). When chain_depth > 0, each item also includes chain — layered upstream callers + downstream callees from the process entry symbol (same BFS as context({chain_depth})).
-- process_symbols: search-hit symbols in those flows with file locations and module (functional area). When the process entry is among those hits, it is marked is_entry_point: true.
+- process_symbols: search-hit symbols in those flows with file locations and module (functional area). On the single-repo envelope { processes, process_symbols, definitions }: One row per (id, process_id) — the same symbol id may appear under more than one process. Join a process to its rows by process_id; symbol_count is the number of those rows. When the process entry is among those hits, it is marked is_entry_point: true. A repo of "@<group>" returns { group, query, results, per_repo } and does not include process_symbols. results[].symbol_count is the member's post-slice attach count; when service is set, it counts only attaches under that prefix. To get process_symbols for one member, query again with repo "@<group>/<memberPath>" (member path from group.yaml, or results[]._repo).
 - definitions: standalone types/interfaces not in any process. Keyword hits on Route URLs (route_fts) are bridged to their handler via HANDLES_ROUTE (handlerSymbolId, routes) when the edge exists; use route_map({route}) for the full HTTP surface.
 
 Hybrid ranking: BM25 keyword + semantic vector search, ranked by Reciprocal Rank Fusion.

package/dist/server/analyze-job.d.ts

@@ -74,6 +74,9 @@ export declare class JobManager {
     private children;
     private abortControllers;
     private timeouts;
+    private cancelGraceTimers;
+    /** Cancel reason to apply when a still-running worker exits. */
+    private pendingCancelReasons;
     private emitter;
     private cleanupTimer;
     constructor();
@@ -99,13 +102,44 @@ export declare class JobManager {
     updateJob(id: string, update: Partial<Pick<AnalyzeJob, 'status' | 'progress' | 'error' | 'partial' | 'repoPath' | 'repoName' | 'completedAt'>>): void;
     /** Register a child process for a job — enables cancellation and timeout. */
     registerChild(jobId: string, child: ChildProcess): void;
+    /** True while cancel was requested and the worker has not exited yet. */
+    hasPendingCancel(jobId: string): boolean;
+    /**
+     * Drop a registered child without waiting for `exit`. Spawn failures emit
+     * `error` and never `exit`, which would otherwise leave `isSlotOccupied`
+     * true forever after the job is already failed.
+     */
+    releaseChild(jobId: string): void;
+    /**
+     * Apply a stored cancel reason if one is pending. Returns true when a reason
+     * was consumed. Used by the worker-exit handler and by analyze-launch when
+     * the child reports a generic cancel IPC — that message must not overwrite
+     * the caller's reason (timeout vs user cancel).
+     */
+    applyPendingCancel(jobId: string): boolean;
     /** Register cancellable in-process work for a job. */
     registerAbortController(jobId: string, controller: AbortController): void;
-    /** Cancel a running job — sends SIGTERM to child process. */
+    /**
+     * Cancel a running job.
+     *
+     * The worker is asked to stop over IPC first (`{ type: 'cancel' }`), which
+     * lets it reach a JS-visible safe point and checkpoint before exiting —
+     * the same cross-platform control path `core/auto-sync` uses. A signal is
+     * sent only as a bounded fallback: on Windows `child.kill('SIGTERM')` is a
+     * forceful termination (Node ignores the signal name there), so leading
+     * with it could kill the worker mid LadybugDB write.
+     */
     cancelJob(jobId: string, reason?: string): boolean;
     /** Subscribe to progress events for a job. Returns unsubscribe function. */
     onProgress(jobId: string, listener: (progress: AnalyzeJobProgress) => void): () => void;
+    /**
+     * Ask a worker to shut down: IPC cancel now, signal after a grace period if
+     * it has not exited on its own. The grace timer is cleared by the child's
+     * `exit` handler registered in `registerChild`.
+     */
+    private requestChildShutdown;
     dispose(): void;
     private isTerminal;
+    private isSlotOccupied;
     private cleanup;
 }