gitnexus 1.6.13-rc.36 → 1.6.13-rc.38

package/README.md

@@ -367,7 +367,7 @@ projects:
       - git@gitee.com:owner/repo.git
 ```
 
-`sync_interval_minutes` must be an integer of at least `5`. `local_path` must be an absolute path without traversal; each remote is cloned below it as `host/namespace/repo`, preventing same-basename repositories from colliding. `remote_urls` must use SSH SCP form for github.com, gitlab.com, or gitee.com. `repo_git_timeout` applies to each repo clone/pull and defaults to `10s`; a bare number such as `10` is interpreted as seconds, while `10000ms`, `10s`, and `1m` keep their explicit units. It must not exceed one hour or `sync_interval_minutes`, whichever is smaller — so a bare `600000` is rejected, because it means 600000 seconds rather than milliseconds. `analyze_timeout` applies to each isolated analysis worker and defaults to half of `sync_interval_minutes`, but it is independent of polling and may be longer, up to Node's timer limit (`2147483647ms`). A `5` minute poll with `analyze_timeout: 30m` is valid. A tick that arrives while the previous loop is active never overlaps it: ticks coalesce into one immediate follow-up run, which pulls and analyzes the newest commit. If the parent times out and leaves that worker running, the follow-up is deferred to the next interval so a leftover lock holder is not counted as a hard analyze failure. Timeout and `auto-sync stop` request safe cancellation; a worker already in native work exits after it returns to a JS-visible safe point. While waiting, auto-sync reports `cancelling` or `stopping` and keeps its ownership files so another auto-sync cannot take over. The parent waits up to 5 seconds for the worker to exit; after that it stops waiting, releases its ownership files, and leaves the worker to finish and exit on its own rather than killing it mid-write. `auto-sync stop` uses this same control path on macOS and Windows.
+`sync_interval_minutes` must be an integer of at least `5`. `local_path` must be an absolute path without traversal; each remote is cloned below it as `host/namespace/repo`, preventing same-basename repositories from colliding. `remote_urls` may use SSH SCP form (`git@host:owner/repo.git`) or HTTPS (`https://host/owner/repo.git`) for github.com, gitlab.com, or gitee.com. The published CLI image includes `openssh-client` so SSH remotes can clone; mount keys and `known_hosts` yourself. An invalid `watch_config.yml` skips auto-sync immediately with the validation error. `repo_git_timeout` applies to each repo clone/pull and defaults to `10s`; a bare number such as `10` is interpreted as seconds, while `10000ms`, `10s`, and `1m` keep their explicit units. It must not exceed one hour or `sync_interval_minutes`, whichever is smaller — so a bare `600000` is rejected, because it means 600000 seconds rather than milliseconds. `analyze_timeout` applies to each isolated analysis worker and defaults to half of `sync_interval_minutes`, but it is independent of polling and may be longer, up to Node's timer limit (`2147483647ms`). A `5` minute poll with `analyze_timeout: 30m` is valid. Auto-sync analysis honors the cloned repo's `.gitnexusrc` embeddings settings; the CLI image still needs `GITNEXUS_EMBEDDING_URL` or a bind-mounted embedding stack because npm is stripped. A tick that arrives while the previous loop is active never overlaps it: ticks coalesce into one immediate follow-up run, which pulls and analyzes the newest commit. If the parent times out and leaves that worker running, the follow-up is deferred to the next interval so a leftover lock holder is not counted as a hard analyze failure. Timeout and `auto-sync stop` request safe cancellation; a worker already in native work exits after it returns to a JS-visible safe point. While waiting, auto-sync reports `cancelling` or `stopping` and keeps its ownership files so another auto-sync cannot take over. The parent waits up to 5 seconds for the worker to exit; after that it stops waiting, releases its ownership files, and leaves the worker to finish and exit on its own rather than killing it mid-write. `auto-sync stop` uses this same control path on macOS and Windows.
 
 `pdg` is configured per project. `pdg: true` builds and maintains the full CFG, control-dependence, reaching-definition, and taint layers on both initial and incremental analyses. Auto-sync requests staged atomic incremental publication where the analyzer supports it: the old graph remains available to readers until the replacement succeeds, and analysis errors are recorded while the old graph remains intact. Unsupported paths retain the analyzer's existing in-place behavior. Untouched configs that omit `pdg` preserve the existing index mode and cannot silently strip PDG data. Do not paste `pdg: false` from this example onto an existing watch file unless you intend to drop PDG. An explicit `pdg: false` disables PDG and emits a warning before a successful rebuild removes those layers. `overwrite_local_changes` defaults to `false`; a dirty local clone is skipped with an error log, while `true` allows branch fallback to replace local changes and additionally discards untracked files and directories in the clone after checkout — ignored paths, including GitNexus's own `.gitnexus/` storage, are preserved. `max_concurrency` defaults to `1` and is capped at runtime by `floor(availableMemoryGB / 2)` with a minimum of `1`; the effective value is printed at the start of each loop. Each analysis worker's heap cap is the machine-wide cap divided by the number of repositories analyzed in parallel, so concurrent workers share one memory budget instead of each claiming the whole machine. `analyze_failure_threshold` defaults to `3`, must be at least `2`, and pauses repeated failures only for the same repo branch, commit, and requested PDG mode; a new commit, a PDG mode change, or `gitnexus auto-sync reset` clears the block and allows analysis again. Repositories are registered and added to groups by their full remote identity (`host/namespace/repo`), so repositories with the same basename remain distinct. Use `branches` to try branches in order; legacy `branch` remains supported, but the two fields cannot be set together. If all branches are unavailable or time out, watch logs an error, records the repo status, and skips that repo for the loop. Leave `group_name` empty or omit it to skip group add/sync for that project; otherwise create the group first with `gitnexus group create <name>`. `$GITNEXUS_HOME/watch/project_commit_info.txt` is for inspection only; GitNexus stores machine state separately in `$GITNEXUS_HOME/watch/auto-sync-state.json`.
 

package/dist/cli/auto-sync.js

@@ -106,6 +106,8 @@ function defaultSyncConfig(localPath) {
         '    overwrite_local_changes: false',
         '    remote_urls:',
         '      - git@github.com:owner/repo.git',
+        '      # HTTPS remotes on github.com, gitlab.com, or gitee.com are also allowed',
+        '      # - https://github.com/owner/public-repo.git',
         '',
     ].join('\n');
 }

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

@@ -170,7 +170,7 @@ export declare const en: {
     readonly 'help.command.setup.description': 'One-time setup: configure MCP for Cursor, Claude Code, Antigravity, OpenCode, CodeBuddy, Qoder, Codex, Factory Droid';
     readonly 'help.command.uninstall.description': 'Reverse `setup`: remove GitNexus MCP entries, skills, and hooks from all detected editors';
     readonly 'help.command.autoSync.description': 'Control scheduled repository clone/pull and analysis from GITNEXUS_HOME/watch_config.yml';
-    readonly 'help.autoSync.details': '\nActions: init, start (default), restart, stop, status, reset\nConfiguration: GITNEXUS_HOME/watch_config.yml\nRuntime files: GITNEXUS_HOME/watch/watch.pid, watch.mutex, watch.owner.json, watch.status.json, auto-sync-state.json\nRecovery: mutexes with verified dead owners are reclaimed automatically; invalid or legacy mutexes fail closed and require manual removal after confirming no watch process is running.\nWrites: GITNEXUS_HOME/watch/project_commit_info.txt\nRemote URLs: only SSH URLs on github.com, gitlab.com, and gitee.com are allowed.\nRuns once immediately, then repeats on sync_interval_minutes.';
+    readonly 'help.autoSync.details': '\nActions: init, start (default), restart, stop, status, reset\nConfiguration: GITNEXUS_HOME/watch_config.yml\nRuntime files: GITNEXUS_HOME/watch/watch.pid, watch.mutex, watch.owner.json, watch.status.json, auto-sync-state.json\nRecovery: mutexes with verified dead owners are reclaimed automatically; invalid or legacy mutexes fail closed and require manual removal after confirming no watch process is running.\nWrites: GITNEXUS_HOME/watch/project_commit_info.txt\nRemote URLs: SSH or HTTPS URLs on github.com, gitlab.com, and gitee.com are allowed. Invalid watch_config.yml skips auto-sync immediately.\nRuns once immediately, then repeats on sync_interval_minutes.';
     readonly 'help.command.watch.description': 'Ambiguous: use `analyze --watch` for local files, or `auto-sync` for scheduled remotes';
     readonly 'help.watch.details': '\n`gitnexus watch` does not start a watcher.\n  Local working-tree incremental index:  gitnexus analyze --watch\n  Scheduled remote clone/pull + analyze: gitnexus auto-sync start\n';
     readonly 'error.watch.ambiguous': '`gitnexus watch` is ambiguous.\n  Local working-tree incremental index:  gitnexus analyze --watch\n  Scheduled remote clone/pull + analyze: gitnexus auto-sync start\n';

package/dist/cli/i18n/en.js

@@ -172,7 +172,7 @@ export const en = {
     'help.command.setup.description': 'One-time setup: configure MCP for Cursor, Claude Code, Antigravity, OpenCode, CodeBuddy, Qoder, Codex, Factory Droid',
     'help.command.uninstall.description': 'Reverse `setup`: remove GitNexus MCP entries, skills, and hooks from all detected editors',
     'help.command.autoSync.description': 'Control scheduled repository clone/pull and analysis from GITNEXUS_HOME/watch_config.yml',
-    'help.autoSync.details': '\nActions: init, start (default), restart, stop, status, reset\nConfiguration: GITNEXUS_HOME/watch_config.yml\nRuntime files: GITNEXUS_HOME/watch/watch.pid, watch.mutex, watch.owner.json, watch.status.json, auto-sync-state.json\nRecovery: mutexes with verified dead owners are reclaimed automatically; invalid or legacy mutexes fail closed and require manual removal after confirming no watch process is running.\nWrites: GITNEXUS_HOME/watch/project_commit_info.txt\nRemote URLs: only SSH URLs on github.com, gitlab.com, and gitee.com are allowed.\nRuns once immediately, then repeats on sync_interval_minutes.',
+    'help.autoSync.details': '\nActions: init, start (default), restart, stop, status, reset\nConfiguration: GITNEXUS_HOME/watch_config.yml\nRuntime files: GITNEXUS_HOME/watch/watch.pid, watch.mutex, watch.owner.json, watch.status.json, auto-sync-state.json\nRecovery: mutexes with verified dead owners are reclaimed automatically; invalid or legacy mutexes fail closed and require manual removal after confirming no watch process is running.\nWrites: GITNEXUS_HOME/watch/project_commit_info.txt\nRemote URLs: SSH or HTTPS URLs on github.com, gitlab.com, and gitee.com are allowed. Invalid watch_config.yml skips auto-sync immediately.\nRuns once immediately, then repeats on sync_interval_minutes.',
     'help.command.watch.description': 'Ambiguous: use `analyze --watch` for local files, or `auto-sync` for scheduled remotes',
     'help.watch.details': '\n`gitnexus watch` does not start a watcher.\n  Local working-tree incremental index:  gitnexus analyze --watch\n  Scheduled remote clone/pull + analyze: gitnexus auto-sync start\n',
     'error.watch.ambiguous': '`gitnexus watch` is ambiguous.\n  Local working-tree incremental index:  gitnexus analyze --watch\n  Scheduled remote clone/pull + analyze: gitnexus auto-sync start\n',

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

@@ -171,7 +171,7 @@ export declare const cliResources: {
         readonly 'help.command.setup.description': 'One-time setup: configure MCP for Cursor, Claude Code, Antigravity, OpenCode, CodeBuddy, Qoder, Codex, Factory Droid';
         readonly 'help.command.uninstall.description': 'Reverse `setup`: remove GitNexus MCP entries, skills, and hooks from all detected editors';
         readonly 'help.command.autoSync.description': 'Control scheduled repository clone/pull and analysis from GITNEXUS_HOME/watch_config.yml';
-        readonly 'help.autoSync.details': '\nActions: init, start (default), restart, stop, status, reset\nConfiguration: GITNEXUS_HOME/watch_config.yml\nRuntime files: GITNEXUS_HOME/watch/watch.pid, watch.mutex, watch.owner.json, watch.status.json, auto-sync-state.json\nRecovery: mutexes with verified dead owners are reclaimed automatically; invalid or legacy mutexes fail closed and require manual removal after confirming no watch process is running.\nWrites: GITNEXUS_HOME/watch/project_commit_info.txt\nRemote URLs: only SSH URLs on github.com, gitlab.com, and gitee.com are allowed.\nRuns once immediately, then repeats on sync_interval_minutes.';
+        readonly 'help.autoSync.details': '\nActions: init, start (default), restart, stop, status, reset\nConfiguration: GITNEXUS_HOME/watch_config.yml\nRuntime files: GITNEXUS_HOME/watch/watch.pid, watch.mutex, watch.owner.json, watch.status.json, auto-sync-state.json\nRecovery: mutexes with verified dead owners are reclaimed automatically; invalid or legacy mutexes fail closed and require manual removal after confirming no watch process is running.\nWrites: GITNEXUS_HOME/watch/project_commit_info.txt\nRemote URLs: SSH or HTTPS URLs on github.com, gitlab.com, and gitee.com are allowed. Invalid watch_config.yml skips auto-sync immediately.\nRuns once immediately, then repeats on sync_interval_minutes.';
         readonly 'help.command.watch.description': 'Ambiguous: use `analyze --watch` for local files, or `auto-sync` for scheduled remotes';
         readonly 'help.watch.details': '\n`gitnexus watch` does not start a watcher.\n  Local working-tree incremental index:  gitnexus analyze --watch\n  Scheduled remote clone/pull + analyze: gitnexus auto-sync start\n';
         readonly 'error.watch.ambiguous': '`gitnexus watch` is ambiguous.\n  Local working-tree incremental index:  gitnexus analyze --watch\n  Scheduled remote clone/pull + analyze: gitnexus auto-sync start\n';

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

@@ -170,7 +170,7 @@ export const zhCN = {
     'help.command.setup.description': '一次性设置：为 Cursor、Claude Code、Antigravity、OpenCode、CodeBuddy、Qoder、Codex、Factory Droid 配置 MCP',
     'help.command.uninstall.description': '撤销 `setup`：从所有检测到的编辑器中移除 GitNexus 的 MCP 配置、技能和钩子',
     'help.command.autoSync.description': '控制基于 GITNEXUS_HOME/watch_config.yml 的定时 clone/pull 和分析',
-    'help.autoSync.details': '\n操作：init、start（默认）、restart、stop、status、reset\n配置：GITNEXUS_HOME/watch_config.yml\n运行时文件：GITNEXUS_HOME/watch/watch.pid、watch.mutex、watch.owner.json、watch.status.json、auto-sync-state.json\n恢复：已验证 owner 退出的 mutex 会自动回收；无效或旧版 mutex 会安全拒绝，确认没有 watch 进程运行后再手动删除。\n写入：GITNEXUS_HOME/watch/project_commit_info.txt\n远程地址：仅允许 github.com、gitlab.com 和 gitee.com 上的 SSH 地址。\n启动后立即运行一次，之后按 sync_interval_minutes 重复。',
+    'help.autoSync.details': '\n操作：init、start（默认）、restart、stop、status、reset\n配置：GITNEXUS_HOME/watch_config.yml\n运行时文件：GITNEXUS_HOME/watch/watch.pid、watch.mutex、watch.owner.json、watch.status.json、auto-sync-state.json\n恢复：已验证 owner 退出的 mutex 会自动回收；无效或旧版 mutex 会安全拒绝，确认没有 watch 进程运行后再手动删除。\n写入：GITNEXUS_HOME/watch/project_commit_info.txt\n远程地址：允许 github.com、gitlab.com 和 gitee.com 上的 SSH 或 HTTPS 地址。无效的 watch_config.yml 会立即跳过 auto-sync。\n启动后立即运行一次，之后按 sync_interval_minutes 重复。',
     'help.command.watch.description': '含义不明确：本地文件请用 `analyze --watch`，定时远程同步请用 `auto-sync`',
     'help.watch.details': '\n`gitnexus watch` 不会启动监视器。\n  本地工作区增量索引：gitnexus analyze --watch\n  定时远程 clone/pull 并分析：gitnexus auto-sync start\n',
     'error.watch.ambiguous': '`gitnexus watch` 含义不明确。\n  本地工作区增量索引：gitnexus analyze --watch\n  定时远程 clone/pull 并分析：gitnexus auto-sync start\n',

package/dist/core/auto-sync/config.d.ts

@@ -30,6 +30,12 @@ export declare function getAutoSyncConfigPath(gitnexusDir?: string): string;
 export declare function parseBranchCandidates(branchValue: unknown): string[];
 export declare function loadAutoSyncConfig(configPath?: string): Promise<AutoSyncConfigLoadResult>;
 export declare function parseAutoSyncConfig(content: string, configPath: string): AutoSyncConfig;
+export declare function parseAutoSyncRemoteIdentity(remoteUrl: string): {
+    host: string;
+    repoPath: string;
+};
+/** Canonical `host/owner/repo` key. Strips one trailing `.git`. Throws on an invalid remote. */
+export declare function getAutoSyncRepoIdentity(remoteUrl: string): string;
 export declare function validateAutoSyncRemoteUrl(remoteUrl: string): void;
 export declare function validateAutoSyncBranchName(branch: string): void;
 export declare function parseDurationMs(value: unknown): number;

package/dist/core/auto-sync/config.js

@@ -237,17 +237,42 @@ export function parseAutoSyncConfig(content, configPath) {
         projects,
     };
 }
-export function validateAutoSyncRemoteUrl(remoteUrl) {
+export function parseAutoSyncRemoteIdentity(remoteUrl) {
     const trimmed = remoteUrl.trim();
     if (trimmed.includes('?') || trimmed.includes('#')) {
         throw new Error('must not include query strings or fragments');
     }
-    const match = /^git@([^:\s/]+):([^\s]+)$/.exec(trimmed);
-    if (!match) {
-        throw new Error('must use an SSH URL on github.com, gitlab.com, or gitee.com');
+    const sshMatch = /^git@([^:\s/]+):([^\s]+)$/.exec(trimmed);
+    const httpsMatch = /^https:\/\/([^/\s]+)\/([^\s]+)$/.exec(trimmed);
+    let host;
+    let repoPath;
+    if (sshMatch) {
+        host = sshMatch[1];
+        repoPath = sshMatch[2];
+    }
+    else if (httpsMatch) {
+        host = httpsMatch[1];
+        repoPath = httpsMatch[2];
+        if (host.includes('@') || host.includes(':')) {
+            throw new Error('must not include userinfo or a port');
+        }
+    }
+    else {
+        throw new Error('must use an SSH or HTTPS URL on github.com, gitlab.com, or gitee.com');
     }
-    const host = match[1].toLowerCase();
-    const repoPath = match[2];
+    host = host.toLowerCase();
+    assertAutoSyncRemotePath(host, repoPath);
+    return { host, repoPath };
+}
+/** Canonical `host/owner/repo` key. Strips one trailing `.git`. Throws on an invalid remote. */
+export function getAutoSyncRepoIdentity(remoteUrl) {
+    const { host, repoPath } = parseAutoSyncRemoteIdentity(remoteUrl);
+    return `${host}/${repoPath.replace(/\.git$/i, '')}`;
+}
+export function validateAutoSyncRemoteUrl(remoteUrl) {
+    parseAutoSyncRemoteIdentity(remoteUrl);
+}
+function assertAutoSyncRemotePath(host, repoPath) {
     if (!ALLOWED_REMOTE_HOSTS.has(host)) {
         throw new Error('host must be one of github.com, gitlab.com, or gitee.com');
     }

package/dist/core/auto-sync/index.d.ts

@@ -1,4 +1,4 @@
-export { AUTO_SYNC_CONFIG_FILE, getAutoSyncConfigPath, loadAutoSyncConfig, parseAutoSyncConfig, parseBranchCandidates, parseDurationMs, validateAutoSyncBranchName, validateAutoSyncRemoteUrl, type AutoSyncConfig, type AutoSyncConfigLoadResult, type AutoSyncProjectConfig, } from './config.js';
+export { AUTO_SYNC_CONFIG_FILE, getAutoSyncConfigPath, loadAutoSyncConfig, parseAutoSyncConfig, parseBranchCandidates, parseDurationMs, validateAutoSyncBranchName, validateAutoSyncRemoteUrl, parseAutoSyncRemoteIdentity, type AutoSyncConfig, type AutoSyncConfigLoadResult, type AutoSyncProjectConfig, } from './config.js';
 export { buildStateKey, getAutoSyncMutexPath, getAutoSyncWatchDir, getAutoSyncStatePath, getProjectCommitInfoPath, loadAutoSyncState, resetAutoSyncState, saveAutoSyncState, shouldAnalyzeCommit, writeProjectCommitInfo, type AutoSyncAnalyzeStatus, type AutoSyncCommitState, type AutoSyncCommitStateEntry, type ProjectCommitInfoEntry, } from './state.js';
 export { extractRepoNameFromRemoteUrl } from './repo.js';
 export { normalizeConfiguredCloneRoot, quarantineAutoSyncPartial, resolveConfiguredCloneRoot, type AutoSyncCloneRoot, } from './path-security.js';

package/dist/core/auto-sync/index.js

@@ -1,4 +1,4 @@
-export { AUTO_SYNC_CONFIG_FILE, getAutoSyncConfigPath, loadAutoSyncConfig, parseAutoSyncConfig, parseBranchCandidates, parseDurationMs, validateAutoSyncBranchName, validateAutoSyncRemoteUrl, } from './config.js';
+export { AUTO_SYNC_CONFIG_FILE, getAutoSyncConfigPath, loadAutoSyncConfig, parseAutoSyncConfig, parseBranchCandidates, parseDurationMs, validateAutoSyncBranchName, validateAutoSyncRemoteUrl, parseAutoSyncRemoteIdentity, } from './config.js';
 export { buildStateKey, getAutoSyncMutexPath, getAutoSyncWatchDir, getAutoSyncStatePath, getProjectCommitInfoPath, loadAutoSyncState, resetAutoSyncState, saveAutoSyncState, shouldAnalyzeCommit, writeProjectCommitInfo, } from './state.js';
 export { extractRepoNameFromRemoteUrl } from './repo.js';
 export { normalizeConfiguredCloneRoot, quarantineAutoSyncPartial, resolveConfiguredCloneRoot, } from './path-security.js';

package/dist/core/auto-sync/runner.d.ts

@@ -42,6 +42,6 @@ export declare function runAutoSyncOnce(config: AutoSyncConfig, options?: {
 }): Promise<AutoSyncRunResult>;
 export declare function getConfiguredRepoPath(project: Pick<AutoSyncProjectConfig, 'localPath'>, repoName: string, remoteUrl?: string): string;
 export declare function addRepoToGroup(project: Pick<AutoSyncProjectConfig, 'groupName'>, groupPath: string, registryName?: string): Promise<boolean>;
-export declare function getAutoSyncRepoIdentity(remoteUrl: string): string;
+export { getAutoSyncRepoIdentity } from './config.js';
 export declare function syncGroupByName(groupName: string): Promise<void>;
 export declare function resolveActualConcurrency(configured: number, availableMemoryGB: number): number;

package/dist/core/auto-sync/runner.js

@@ -5,11 +5,12 @@ import { loadGroupConfig } from '../group/config-parser.js';
 import { getDefaultGitnexusDir, getGroupDir } from '../group/storage.js';
 import { syncGroup } from '../group/sync.js';
 import { getStoragePaths, loadMeta, registerRepo, resolveBranchPlacement, } from '../../storage/repo-manager.js';
+import { embeddingsFromGitnexusRc } from '../gitnexus-rc-embeddings.js';
+import { getAutoSyncRepoIdentity } from './config.js';
 import { extractRepoNameFromRemoteUrl } from './repo.js';
 import { cloneOrPull, runGit } from '../../server/git-clone.js';
 import { resolveConfiguredCloneRoot } from './path-security.js';
 import { buildStateKey, loadAutoSyncState, saveAutoSyncState, shouldAnalyzeCommit, writeProjectCommitInfo, } from './state.js';
-import { validateAutoSyncRemoteUrl } from './config.js';
 import { AutoSyncAnalysisError, runAutoSyncAnalysis, } from './analysis-worker-launch.js';
 const _require = createRequire(import.meta.url);
 const yaml = _require('js-yaml');
@@ -149,6 +150,7 @@ export async function runAutoSyncOnce(config, options = {}) {
                     previousStatus: previous?.lastAnalyzeStatus,
                 })) {
                 try {
+                    const rcEmbeddings = await embeddingsFromGitnexusRc(targetDir);
                     const analysis = await deps.runAnalysis(targetDir, {
                         branch: currentBranch,
                         skipAgentsMd: true,
@@ -157,6 +159,7 @@ export async function runAutoSyncOnce(config, options = {}) {
                             ? { preserveExistingPdg: true }
                             : { pdg: requestedPdg }),
                         atomicIncremental: true,
+                        ...rcEmbeddings,
                     }, config.analyzeTimeoutMs, options.signal, options.onAnalysisCancellationRequested, analysisParallelism);
                     throwIfAborted(options.signal);
                     stats = analysis.stats;
@@ -386,11 +389,7 @@ export async function addRepoToGroup(project, groupPath, registryName = groupPat
     await writeGroupConfigAtomic(path.join(groupDir, 'group.yaml'), config);
     return true;
 }
-export function getAutoSyncRepoIdentity(remoteUrl) {
-    validateAutoSyncRemoteUrl(remoteUrl);
-    const [, host, remotePath] = /^git@([^:\s/]+):([^\s]+)$/.exec(remoteUrl.trim());
-    return `${host.toLowerCase()}/${remotePath.replace(/\.git$/i, '')}`;
-}
+export { getAutoSyncRepoIdentity } from './config.js';
 export async function syncGroupByName(groupName) {
     const groupDir = getGroupDir(getDefaultGitnexusDir(), groupName);
     const config = await loadGroupConfig(groupDir);

package/dist/core/gitnexus-rc-embeddings.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Auto-sync reads embeddings settings from a cloned repo's `.gitnexusrc`
+ * without importing CLI modules (`src/core` must not import `src/cli`).
+ * Invalid JSON fails the analyze for that repo the same way CLI analyze fails closed.
+ */
+import type { AnalyzeOptions } from './run-analyze.js';
+export declare const GITNEXUS_RC_FILENAME = ".gitnexusrc";
+export declare class AutoSyncGitnexusRcError extends Error {
+    constructor(message: string);
+}
+export declare function embeddingsFromGitnexusRc(repoRoot: string): Promise<Pick<AnalyzeOptions, 'embeddings' | 'embeddingsNodeLimit'>>;

package/dist/core/gitnexus-rc-embeddings.js

@@ -0,0 +1,51 @@
+import { readRepoControlFile } from '../config/repo-control-file.js';
+export const GITNEXUS_RC_FILENAME = '.gitnexusrc';
+export class AutoSyncGitnexusRcError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AutoSyncGitnexusRcError';
+    }
+}
+export async function embeddingsFromGitnexusRc(repoRoot) {
+    let raw;
+    try {
+        raw = await readRepoControlFile(repoRoot, GITNEXUS_RC_FILENAME);
+    }
+    catch (err) {
+        throw new AutoSyncGitnexusRcError(`Could not read ${GITNEXUS_RC_FILENAME}: ${err.message}`);
+    }
+    if (raw === null)
+        return {};
+    if (raw.charCodeAt(0) === 0xfeff)
+        raw = raw.slice(1);
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new AutoSyncGitnexusRcError(`${GITNEXUS_RC_FILENAME} is not valid JSON`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new AutoSyncGitnexusRcError(`${GITNEXUS_RC_FILENAME} must contain a JSON object.`);
+    }
+    const obj = parsed;
+    let embeddingsVal = obj.embeddings;
+    if (obj.analyze && typeof obj.analyze === 'object' && !Array.isArray(obj.analyze)) {
+        const nested = obj.analyze;
+        if (Object.prototype.hasOwnProperty.call(nested, 'embeddings')) {
+            embeddingsVal = nested.embeddings;
+        }
+    }
+    if (embeddingsVal === undefined)
+        return {};
+    if (typeof embeddingsVal === 'boolean') {
+        return { embeddings: embeddingsVal };
+    }
+    if (typeof embeddingsVal === 'number') {
+        if (!Number.isInteger(embeddingsVal) || embeddingsVal < 0) {
+            throw new AutoSyncGitnexusRcError(`${GITNEXUS_RC_FILENAME} embeddings must be true/false or a non-negative integer`);
+        }
+        return { embeddings: true, embeddingsNodeLimit: embeddingsVal };
+    }
+    throw new AutoSyncGitnexusRcError(`${GITNEXUS_RC_FILENAME} embeddings must be a boolean or a non-negative integer`);
+}

package/dist/core/ingestion/cfg/visitors/kotlin.d.ts

@@ -3,9 +3,10 @@
  *
  * Kotlin's tree-sitter grammar (vendored, NOT an npm package — loaded via
  * `requireVendoredGrammar('tree-sitter-kotlin')`, exactly like tree-sitter-swift)
- * is field-less for control flow: NONE of the control-flow nodes expose
- * `childForFieldName` fields (verified by a real parse — every `fieldNameForChild`
- * came back null), so this visitor navigates purely by child TYPE and position.
+ * is mostly field-less for control flow (`when` / loops / `try` / `elvis_expression`
+ * expose no fields), so this visitor navigates purely by child TYPE and position.
+ * `if_expression` is the exception: it DOES field `condition` / `consequence` /
+ * `alternative` (#3354 — callable-flow capture reads them); position still works.
  * Every node-type literal below was grammar-validated against the vendored
  * tree-sitter-kotlin via the introspection probe before use (mandatory pre-step —
  * the grammar-literal CI gate maps `kotlin.ts → Kotlin` and fails on a wrong

package/dist/core/ingestion/cfg/visitors/python-harvest.d.ts

@@ -46,8 +46,8 @@
  *  - reads: `attribute` (fields `object`/`attribute`), `subscript` (fields
  *    `value`/`subscript`), `call` (fields `function`/`arguments`),
  *    `boolean_operator` (fields `left`/`operator`/`right`),
- *    `conditional_expression` (ternary: consequent / condition / alternative in
- *    source order), `parenthesized_expression`.
+ *    `conditional_expression` (ternary, FIELDLESS: consequent, condition,
+ *    alternative as positional children), `parenthesized_expression`.
  *
  * TWO-PHASE, ORDER-INDEPENDENT (load-bearing — mirrors the TS / Go harvesters):
  * the CFG walk is NOT source-order, so resolving names against a scope stack

package/dist/core/ingestion/languages/dart/captures.js

@@ -109,6 +109,23 @@ const DART_CALLABLE_CAPTURE_OPTIONS = {
     extractCallCallee: (node) => dartCallableCallee(node) ?? undefined,
     callSiteNode: (node) => dartCallableCallee(node) ?? undefined,
     callableProtocolMethods: new Set(['call']),
+    // tree-sitter-dart spells `a ?? b` as `if_null_expression(first:, second:)`
+    // and `c ? a : b` as a `conditional_expression` with `consequence` /
+    // `alternative` but NO `condition` field, so neither matches the shared
+    // field-based branch rule and only the last operand flowed (#3354).
+    valueAlternatives: (node) => {
+        if (node.type === 'if_null_expression') {
+            const first = node.childForFieldName('first');
+            const second = node.childForFieldName('second');
+            return first !== null && second !== null ? [first, second] : undefined;
+        }
+        if (node.type === 'conditional_expression') {
+            const consequence = node.childForFieldName('consequence');
+            const alternative = node.childForFieldName('alternative');
+            return consequence !== null && alternative !== null ? [consequence, alternative] : undefined;
+        }
+        return undefined;
+    },
 };
 function dartLexicalFunctionOwner(input) {
     let node = input;

package/dist/core/ingestion/languages/kotlin/captures.js

@@ -57,7 +57,44 @@ const KOTLIN_CALLABLE_CAPTURE_OPTIONS = {
         return destination === undefined || source === undefined ? undefined : { destination, source };
     },
     normalizeQualifiedName: (raw) => raw.replaceAll('::', '.'),
+    valueAlternatives: (node) => kotlinValueAlternatives(node),
 };
+const isKotlinComment = (node) => node.type === 'line_comment' || node.type === 'multiline_comment';
+const namedNonComments = (node) => node.namedChildren.filter((child) => child !== null && !isKotlinComment(child));
+/**
+ * Branches of a Kotlin value-selecting expression (#3354). `a ?: b` is a
+ * FIELDLESS `elvis_expression` (positional operands), so the shared
+ * field-based rule never saw it and only the last operand flowed. An
+ * `if_expression` fields its branches as `control_structure_body` wrappers:
+ * a bare branch (`if (c) ::f`) holds the expression directly, a braced one
+ * (`if (c) { ::f }`) nests it one level deeper in a `statements` node. A
+ * branch holding exactly one expression is that expression's value; an
+ * empty or multi-statement block, or an `if` without `else`, keeps the
+ * whole `if` one opaque source.
+ */
+function kotlinValueAlternatives(node) {
+    if (node.type === 'elvis_expression') {
+        const operands = namedNonComments(node);
+        return operands.length === 2 ? operands : undefined;
+    }
+    if (node.type !== 'if_expression')
+        return undefined;
+    const branches = [];
+    for (const field of ['consequence', 'alternative']) {
+        const body = node.childForFieldName(field);
+        if (body === null)
+            return [node];
+        let values = namedNonComments(body);
+        const [block] = values;
+        if (values.length === 1 && block?.type === 'statements')
+            values = namedNonComments(block);
+        const [value] = values;
+        if (values.length !== 1 || value === undefined)
+            return [node];
+        branches.push(value);
+    }
+    return branches;
+}
 export function emitKotlinScopeCaptures(sourceText, filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {

package/dist/core/ingestion/languages/python/captures.js

@@ -42,6 +42,19 @@ const PYTHON_CALLABLE_CAPTURE_OPTIONS = {
     assignmentNodeTypes: new Set(['assignment', 'named_expression']),
     identifierNodeTypes: new Set(['identifier']),
     functionScopedValueBindings: true,
+    // `a if c else b` is a FIELDLESS `conditional_expression` (positional
+    // value, condition, value), so the shared condition/consequence/alternative
+    // rule never sees its branches and only the last operand flowed (#3354).
+    // `a or b` is a fielded `boolean_operator` the shared rule already handles.
+    valueAlternatives: (node) => {
+        if (node.type !== 'conditional_expression')
+            return undefined;
+        const named = node.namedChildren.filter((child) => child !== null && child.type !== 'comment');
+        const [value, , alternative] = named;
+        return named.length === 3 && value !== undefined && alternative !== undefined
+            ? [value, alternative]
+            : undefined;
+    },
 };
 export function emitPythonScopeCaptures(sourceText, _filePath, cachedTree) {
     // Skip the parse when the caller (the scope-resolution orchestrator's

package/dist/core/ingestion/languages/ruby/captures.js

@@ -41,6 +41,7 @@ const RUBY_CALLABLE_CAPTURE_OPTIONS = {
     // Ruby (`action = process` stores process's RETURN value) — only explicit
     // reference forms (method(:x), &:x, lambda/proc) reference the callable.
     bareNamesAreCalls: true,
+    valueAlternatives: (node) => rubyValueAlternatives(node),
     extractCallableReference: (node) => {
         if (node.type !== 'call')
             return undefined;
@@ -55,6 +56,40 @@ const RUBY_CALLABLE_CAPTURE_OPTIONS = {
         return name.length === 0 ? undefined : { name, anchor: symbol };
     },
 };
+/**
+ * Branches of a statement-bodied `if` / `unless` / `elsif` (#3354). They field
+ * `condition` / `consequence` / `alternative` like a ternary, but their
+ * branches are `then` / `else` STATEMENT LISTS, so the shared ternary rule
+ * would dig an identifier out of whichever statement it found (`g = h; 0`
+ * flowed `h`, although the branch evaluates to `0`). A branch holding one
+ * statement is that statement's value. A longer branch is skipped: it adds
+ * no alternative, while the other branches still flow. Every alternative
+ * emitted is a value the conditional really evaluates to, so skipping cannot
+ * add an edge. It only drops the skipped branch's own value. The `elsif`
+ * chain is walked here, so one multi-statement `elsif` no longer hides the
+ * branches after it. When no branch is a single statement, the whole
+ * conditional stays one opaque source. The `c ? a : b` ternary
+ * (`conditional`) is left to the shared rule.
+ */
+function rubyValueAlternatives(node) {
+    if (node.type !== 'if' && node.type !== 'unless' && node.type !== 'elsif')
+        return undefined;
+    const branches = [];
+    for (let link = node; link !== null;) {
+        const consequence = link.childForFieldName('consequence');
+        const alternative = link.childForFieldName('alternative');
+        link = alternative?.type === 'elsif' ? alternative : null;
+        for (const branch of [consequence, link === null ? alternative : null]) {
+            if (branch === null)
+                continue;
+            const statements = branch.namedChildren.filter((child) => child !== null && child.type !== 'comment');
+            const [statement] = statements;
+            if (statements.length === 1 && statement !== undefined)
+                branches.push(statement);
+        }
+    }
+    return branches.length > 0 ? branches : [node];
+}
 /**
  * Build the full `.`-joined qualified owner name for a heritage/attr call by
  * walking ALL enclosing class/module ancestors (not just the immediate one),

package/dist/core/ingestion/languages/swift/captures.js

@@ -94,6 +94,17 @@ const SWIFT_CALLABLE_CAPTURE_OPTIONS = {
     assignmentNodeTypes: new Set(['assignment']),
     identifierNodeTypes: new Set(['simple_identifier', 'type_identifier']),
     extractFunctionParameters: (node) => node.namedChildren.filter((child) => child !== null && child.type === 'parameter'),
+    // tree-sitter-swift fields `a ?? b` as `value` / `if_nil` and `c ? a : b` as
+    // `if_true` / `if_false`, neither of which the shared field-based branch
+    // rule knows, so only the last operand flowed (#3354).
+    valueAlternatives: (node) => {
+        const [first, second] = node.type === 'nil_coalescing_expression'
+            ? [node.childForFieldName('value'), node.childForFieldName('if_nil')]
+            : node.type === 'ternary_expression'
+                ? [node.childForFieldName('if_true'), node.childForFieldName('if_false')]
+                : [null, null];
+        return first !== null && second !== null ? [first, second] : undefined;
+    },
 };
 /** tree-sitter-swift node types that carry arity. */
 const FUNCTION_NODE_TYPES = [

package/dist/core/ingestion/utils/callable-flow-captures.d.ts

@@ -47,6 +47,12 @@
  *   `extractAssignment` (Kotlin's `assignment`, Dart's
  *   `initialized_identifier`). Returning `undefined` falls back to the shared
  *   path, so one callback can handle the odd node and leave the rest alone.
+ * - A **fieldless or oddly-fielded** `??`/`?:`/elvis/ternary node is invisible
+ *   to the shared branch expansion, so only one operand (if any) flows.
+ *   Supply `valueAlternatives` (Kotlin's `elvis_expression`, Swift's
+ *   `nil_coalescing_expression`, Dart's `if_null_expression`, Python's
+ *   `conditional_expression`); return `[node]` to keep a statement-bodied
+ *   `if` opaque (Ruby).
  * - A binding needs a `SymbolDefinition` for the pass to attach to. Captures
  *   alone are not enough: without a `@declaration.*` for the bound name, the
  *   seed has no cell to key on.
@@ -139,6 +145,20 @@ export interface CallableFlowCaptureOptions {
         readonly anchor: SyntaxNode;
         readonly qualifiedName?: string;
     } | undefined;
+    /**
+     * Provider-owned branches of a value-selecting expression (#3354). The
+     * shared rule only knows the field shapes `left`/`operator`/`right` (with a
+     * `??`/`||`/`or` operator) and `condition`/`consequence`/`alternative`; a
+     * grammar that spells the same construct differently (fieldless children,
+     * `value`/`if_nil`, `first`/`second`, a ternary without a `condition`
+     * field) supplies the branches here. Each returned branch is expanded again,
+     * so chains work. Returning `[node]` means "recognized, but opaque": the
+     * whole expression stays one source, which is how a provider keeps the
+     * shared ternary rule off a statement-bodied `if` whose branches are
+     * statement lists, not values. `undefined` falls back to the shared rule
+     * (mirrors `extractAssignment`).
+     */
+    readonly valueAlternatives?: (node: SyntaxNode) => readonly SyntaxNode[] | undefined;
 }
 /**
  * Emit normalized flow captures in deterministic source order.
@@ -146,6 +166,10 @@ export interface CallableFlowCaptureOptions {
  * One explicit DFS supplies all phases below. Query-backed emitters may still
  * perform their existing query walk; this helper never reparses and remains
  * linear in AST size (the scope-capture benchmark guards the scaling ratio).
+ * That includes a value-selecting source: `valueAlternatives` expands a
+ * chain iteratively into disjoint leaves, and each leaf's visibility walk
+ * reuses the memoized anchor spine instead of re-walking to the root (the
+ * `typescript-deep-chain` benchmark case guards that one).
  */
 export declare function synthesizeCallableFlowCaptures(root: SyntaxNode, options: CallableFlowCaptureOptions): readonly CaptureMatch[];
 /**

package/dist/core/ingestion/utils/callable-flow-captures.js

@@ -47,6 +47,12 @@
  *   `extractAssignment` (Kotlin's `assignment`, Dart's
  *   `initialized_identifier`). Returning `undefined` falls back to the shared
  *   path, so one callback can handle the odd node and leave the rest alone.
+ * - A **fieldless or oddly-fielded** `??`/`?:`/elvis/ternary node is invisible
+ *   to the shared branch expansion, so only one operand (if any) flows.
+ *   Supply `valueAlternatives` (Kotlin's `elvis_expression`, Swift's
+ *   `nil_coalescing_expression`, Dart's `if_null_expression`, Python's
+ *   `conditional_expression`); return `[node]` to keep a statement-bodied
+ *   `if` opaque (Ruby).
  * - A binding needs a `SymbolDefinition` for the pass to attach to. Captures
  *   alone are not enough: without a `@declaration.*` for the bound name, the
  *   seed has no cell to key on.
@@ -61,16 +67,23 @@ import { nodeToCapture, syntheticCapture } from './ast-helpers.js';
  * One explicit DFS supplies all phases below. Query-backed emitters may still
  * perform their existing query walk; this helper never reparses and remains
  * linear in AST size (the scope-capture benchmark guards the scaling ratio).
+ * That includes a value-selecting source: `valueAlternatives` expands a
+ * chain iteratively into disjoint leaves, and each leaf's visibility walk
+ * reuses the memoized anchor spine instead of re-walking to the root (the
+ * `typescript-deep-chain` benchmark case guards that one).
  */
 export function synthesizeCallableFlowCaptures(root, options) {
-    const nodes = collectNodes(root);
+    const parentById = new Map();
+    const nodes = collectNodes(root, parentById);
     const functions = collectFunctions(nodes, options);
     const knownCallableNames = new Set(functions.map((fn) => fn.name));
     const assignments = collectAssignments(nodes, options);
-    const valueBindings = buildValueBindingIndex(nodes, assignments, functions, options);
+    const valueBindings = buildValueBindingIndex(nodes, parentById, assignments, functions, options);
     const out = [];
     for (const assignment of assignments) {
-        emitAssignmentFact(assignment, knownCallableNames, valueBindings, options, out);
+        for (const source of valueAlternatives(assignment.source, options)) {
+            emitAssignmentFact({ ...assignment, source }, knownCallableNames, valueBindings, options, out);
+        }
     }
     for (const fn of functions)
         emitFormalFacts(fn, options, out);
@@ -83,7 +96,9 @@ export function synthesizeCallableFlowCaptures(root, options) {
     out.sort((a, b) => compareCaptures(firstCapture(a), firstCapture(b)));
     return out;
 }
-function collectNodes(root) {
+/** Every named node in document order; also records each one's parent into
+ *  `parentById` (see `ValueBindingIndex.parentById`). */
+function collectNodes(root, parentById) {
     const out = [];
     const stack = [root];
     while (stack.length > 0) {
@@ -92,8 +107,10 @@ function collectNodes(root) {
         const children = node.namedChildren;
         for (let i = children.length - 1; i >= 0; i--) {
             const child = children[i];
-            if (child !== null)
-                stack.push(child);
+            if (child === null)
+                continue;
+            parentById.set(child.id, node);
+            stack.push(child);
         }
     }
     return out;
@@ -163,7 +180,7 @@ function collectAssignments(nodes, options) {
     }
     return out;
 }
-function buildValueBindingIndex(nodes, assignments, functions, options) {
+function buildValueBindingIndex(nodes, parentById, assignments, functions, options) {
     const assignmentRegionIdsByName = new Map();
     const memberStoreRegionIdsByName = new Map();
     const formalByOwner = new Map();
@@ -250,13 +267,59 @@ function buildValueBindingIndex(nodes, assignments, functions, options) {
                 byRegion.set(functionOwner.id, signature);
         }
     }
+    const anchorIds = new Set();
+    for (const index of [assignmentRegionIdsByName, memberStoreRegionIdsByName]) {
+        for (const regionIds of index.values())
+            for (const id of regionIds)
+                anchorIds.add(id);
+    }
+    for (const byRegion of signatureByNameAndRegion.values()) {
+        for (const id of byRegion.keys())
+            anchorIds.add(id);
+    }
+    for (const owner of formalByOwner.keys())
+        if (owner !== undefined)
+            anchorIds.add(owner);
     return {
         assignmentRegionIdsByName,
         memberStoreRegionIdsByName,
         formalByOwner,
         signatureByNameAndRegion,
+        anchorIds,
+        parentById,
+        nearestAnchorById: new Map(),
     };
 }
+/** A node the DFS did not reach (none in practice) falls back to tree-sitter. */
+function parentOf(node, bindings) {
+    return bindings.parentById.get(node.id) ?? node.parent;
+}
+/**
+ * The nearest anchor at-or-above `start` (see `ValueBindingIndex.anchorIds`),
+ * or null when none is. Every node visited on the way is memoized, so across
+ * one file each node's `parent` is taken at most once by these walks.
+ */
+function nearestAnchor(start, bindings) {
+    const visited = [];
+    let node = start;
+    let found = null;
+    while (node !== null) {
+        const cached = bindings.nearestAnchorById.get(node.id);
+        if (cached !== undefined) {
+            found = cached;
+            break;
+        }
+        visited.push(node.id);
+        if (bindings.anchorIds.has(node.id)) {
+            found = node;
+            break;
+        }
+        node = parentOf(node, bindings);
+    }
+    for (const id of visited)
+        bindings.nearestAnchorById.set(id, found);
+    return found;
+}
 /** True when a pointer/parenthesized declarator sits between the declaration
  *  and its binding identifier — the shape of a callable-typed variable, never
  *  of a plain prototype. Only C/C++ supply signature-declaration node types,
@@ -307,15 +370,13 @@ function isVisibleValueBinding(input, name, bindings, options) {
             bindings.formalByOwner.get(providerOwner.id)?.has(name) === true)) {
         return true;
     }
-    let node = input;
-    while (node !== null) {
+    for (let node = nearestAnchor(input, bindings); node !== null; node = nearestAnchor(parentOf(node, bindings), bindings)) {
         if (assignmentRegionIds?.has(node.id) === true)
             return true;
         if (options.functionNodeTypes.has(node.type) &&
             bindings.formalByOwner.get(node.id)?.has(name) === true) {
             return true;
         }
-        node = node.parent;
     }
     if (bindings.formalByOwner.get(undefined)?.has(name) === true)
         return true;
@@ -341,11 +402,9 @@ function isVisibleMemberStore(input, name, bindings, options) {
         const providerOwner = options.lexicalFunctionOwner?.(input);
         if (providerOwner !== undefined && regionIds.has(providerOwner.id))
             return true;
-        let node = input;
-        while (node !== null) {
+        for (let node = nearestAnchor(input, bindings); node !== null; node = nearestAnchor(parentOf(node, bindings), bindings)) {
             if (regionIds.has(node.id))
                 return true;
-            node = node.parent;
         }
     }
     return visibleCallableSignature(input, name, bindings, options) !== undefined;
@@ -360,12 +419,10 @@ function visibleCallableSignature(input, name, bindings, options) {
         if (signature !== undefined)
             return signature;
     }
-    let node = input;
-    while (node !== null) {
+    for (let node = nearestAnchor(input, bindings); node !== null; node = nearestAnchor(parentOf(node, bindings), bindings)) {
         const signature = byRegion.get(node.id);
         if (signature !== undefined)
             return signature;
-        node = node.parent;
     }
     return undefined;
 }
@@ -402,6 +459,108 @@ function assignmentParts(node, options) {
         return [];
     return [{ container: node, destination, source }];
 }
+/** Operators whose result is one of their operands, not a computed value. */
+const VALUE_SELECTING_OPERATORS = new Set(['??', '||', 'or']);
+/**
+ * Operators that yield their left operand when it is falsy and their right
+ * operand otherwise. A falsy value is never a callable, so only the RIGHT
+ * operand can be the callable that is later invoked. Where `&&` / `and`
+ * yields a boolean instead (Java, C#, Go, Rust, C, C++, PHP, Zig), the
+ * destination is not callable, so the flow never meets an invoke.
+ */
+const RIGHT_SELECTING_OPERATORS = new Set(['&&', 'and']);
+/**
+ * The operands a value-selecting expression can evaluate to (#3354):
+ * `a ?? b`, `a || b`, `a or b`, and `c ? a : b` each yield one of their
+ * branches, so each branch flows into the destination. `a && b` / `a and b`
+ * can only yield a callable through `b`, so `x and f or g` reaches `f` and `g`.
+ * Anything else is its own single alternative, which leaves every other
+ * source shape untouched. A branch that is itself an operator expression
+ * (`x.kind === f || g`) yields a computed value, so it contributes nothing.
+ * `options.valueAlternatives` is consulted first for grammars whose shape the
+ * field-based rule below cannot see.
+ */
+function valueAlternatives(node, options) {
+    // Explicit stack, not recursion: `a || b || …` nests one level per operand,
+    // so a generated keyword table thousands of operands long overflowed the
+    // call stack (and re-copied every partial result at each level).
+    const out = [];
+    const pending = [node];
+    for (let current = pending.pop(); current !== undefined; current = pending.pop()) {
+        const branches = valueBranches(current, options);
+        if (branches === undefined) {
+            // An operator branch is opaque, as the whole compound source was before
+            // the fan-out: emitted alone, `x.kind === Handlers.run` becomes a seed
+            // whose qualified text slices to receiver `Handlers`, member `run`.
+            if (current === node || !isBinaryOperatorExpression(unwrapParentheses(current))) {
+                out.push(current);
+            }
+            continue;
+        }
+        // Reverse push keeps the left-to-right branch order on output.
+        for (let i = branches.length - 1; i >= 0; i--) {
+            const branch = branches[i];
+            if (branch !== undefined)
+                pending.push(branch);
+        }
+    }
+    return out;
+}
+/** One level of `valueAlternatives`: the branches `node` selects between, or
+ *  undefined when it is opaque (its own single alternative). */
+function valueBranches(node, options) {
+    const inner = unwrapParentheses(node);
+    const provided = options.valueAlternatives?.(inner);
+    if (provided !== undefined) {
+        return provided.length === 1 && provided[0]?.id === inner.id ? undefined : provided;
+    }
+    const consequence = inner.childForFieldName('consequence');
+    const alternative = inner.childForFieldName('alternative');
+    if (consequence !== null && alternative !== null && inner.childForFieldName('condition')) {
+        return [consequence, alternative];
+    }
+    const left = inner.childForFieldName('left');
+    const right = inner.childForFieldName('right');
+    const operator = inner.childForFieldName('operator')?.type;
+    if (left === null || right === null || !operator)
+        return undefined;
+    if (VALUE_SELECTING_OPERATORS.has(operator))
+        return [left, right];
+    if (RIGHT_SELECTING_OPERATORS.has(operator))
+        return [right];
+    return undefined;
+}
+function unwrapParentheses(node) {
+    let inner = node;
+    while (inner.type.includes('parenthesized') && inner.namedChildCount === 1) {
+        const child = inner.namedChild(0);
+        if (child === null)
+            break;
+        inner = child;
+    }
+    return inner;
+}
+/**
+ * True for an expression that computes a value from two operands (`a === b`,
+ * `a + b`, `a is b`), which designates neither operand. Read from the same
+ * field vocabulary as `valueBranches` rather than grammar type names: a
+ * `left`/`right` pair, or an operator token (`operator`, Python's
+ * `operators`, Swift's `op`) that follows the expression's start. A member
+ * access that fields its `.` / `->` as `operator` (Ruby `call`, C/C++
+ * `field_expression`) also fields its member name, so it stays a designator;
+ * a unary `&f` / `*fp` leads with its operator and stays one too.
+ */
+function isBinaryOperatorExpression(node) {
+    if (node.childForFieldName('left') !== null && node.childForFieldName('right') !== null) {
+        return true;
+    }
+    if (memberNameNode(node) !== null)
+        return false;
+    const operator = node.childForFieldName('operator') ??
+        node.childForFieldName('operators') ??
+        node.childForFieldName('op');
+    return operator !== null && operator.startIndex > node.startIndex;
+}
 function emitAssignmentFact(assignment, knownCallableNames, valueBindings, options, out) {
     const destination = operandSyntax(assignment.destination, options, options.bindingNodeTypes.has(assignment.container.type));
     const source = operandSyntax(assignment.source, options);
@@ -699,10 +858,7 @@ function memberParts(input, options) {
     // stay unaffected. Without it every `x.f(arg)` in such a grammar collapsed
     // to a DIRECT call named `f` and the flow solver fanned the argument out to
     // every same-named callable.
-    const memberNode = node.childForFieldName('property') ??
-        node.childForFieldName('field') ??
-        node.childForFieldName('method') ??
-        node.childForFieldName('member');
+    const memberNode = memberNameNode(node);
     if (receiverNode === null || memberNode === null)
         return undefined;
     const receiver = operandSyntax(receiverNode, options);
@@ -713,6 +869,14 @@ function memberParts(input, options) {
         options.memberPointerOperators?.has(child.text) === true);
     return { receiver, member, ...(operator !== undefined ? { operator: operator.text } : {}) };
 }
+/** The member-name child of a member access, under the field names the
+ *  grammars use for it. */
+function memberNameNode(node) {
+    return (node.childForFieldName('property') ??
+        node.childForFieldName('field') ??
+        node.childForFieldName('method') ??
+        node.childForFieldName('member'));
+}
 function operandSyntax(input, options, declarationBinding = false) {
     if (declarationBinding) {
         const binding = bindingIdentifier(input, options);

package/dist/mcp/local/local-backend.d.ts

@@ -317,6 +317,7 @@ export declare class LocalBackend {
      * degradation is visible once instead of silent.
      */
     private warnedMissingEmbeddingStack;
+    private warnedNoEmbeddingVectors;
     /**
      * Width the semantic lane last produced a QUERY vector at for an index, keyed
      * by `lbugPath` (like `lastObservedPoolState`, and for the same reason: branch
@@ -622,6 +623,11 @@ export declare class LocalBackend {
      * BM25 keyword search helper - uses LadybugDB FTS for always-fresh results
      */
     private bm25Search;
+    /**
+     * Keyword-only indexes are the default. Do not put this on `query.warning`
+     * (that field is reserved for FTS/stack degradation). Log once per backend.
+     */
+    private logKeywordOnlyEmbeddings;
     /**
      * Semantic vector search helper
      */

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

@@ -178,6 +178,14 @@ function resolveAliasString(canonical, legacy) {
     }
     return undefined;
 }
+/**
+ * A `*_uid` param as a lookup key: trimmed, or `undefined` when it is blank or
+ * not a string (#3354). Strict adapters send `" "`/`""` for an omitted optional
+ * string, and the MCP envelope is not type-validated.
+ */
+function nonBlankUid(value) {
+    return typeof value === 'string' ? value.trim() || undefined : undefined;
+}
 const TOOL_STRING_ALIASES = {
     impact: [{ canonical: 'target', aliases: ['name', 'symbol'] }],
     context: [{ canonical: 'file_path', aliases: ['file'] }],
@@ -1060,6 +1068,7 @@ export class LocalBackend {
      * degradation is visible once instead of silent.
      */
     warnedMissingEmbeddingStack = false;
+    warnedNoEmbeddingVectors = false;
     /**
      * Width the semantic lane last produced a QUERY vector at for an index, keyed
      * by `lbugPath` (like `lastObservedPoolState`, and for the same reason: branch
@@ -3043,6 +3052,16 @@ export class LocalBackend {
         }
         return { results, ftsUsed, ...(nonBenignErrors && { nonBenignErrors }) };
     }
+    /**
+     * Keyword-only indexes are the default. Do not put this on `query.warning`
+     * (that field is reserved for FTS/stack degradation). Log once per backend.
+     */
+    logKeywordOnlyEmbeddings() {
+        if (this.warnedNoEmbeddingVectors)
+            return;
+        this.warnedNoEmbeddingVectors = true;
+        logger.warn('GitNexus [query:vector]: This index has no embedding vectors — results are keyword-only. Enable embeddings in `.gitnexusrc` (auto-sync honors that file) or run `gitnexus analyze --embeddings`.');
+    }
     /**
      * Semantic vector search helper
      */
@@ -3057,10 +3076,8 @@ export class LocalBackend {
             // the count is read, to decide whether to load the embedding model at all.
             const tableCheck = await executeQuery(repo.lbugPath, `MATCH (e:${EMBEDDING_TABLE_NAME}) RETURN COUNT(*) AS cnt LIMIT 1`);
             if (!tableCheck.length || (tableCheck[0].cnt ?? tableCheck[0][0]) === 0) {
-                // No vectors to search: nothing is embedded below, so drop any width a
-                // previous call recorded rather than let query() warn about a lane that
-                // did not run this time (#2798).
                 this.lastQueryEmbeddingDims.delete(repo.lbugPath);
+                this.logKeywordOnlyEmbeddings();
                 return [];
             }
             const { embedQuery, getEmbeddingDims } = await import('../core/embedder.js');
@@ -3204,6 +3221,9 @@ export class LocalBackend {
                 if (degraded)
                     degraded.reason = message;
             }
+            else if (isBenignMissingTableError(err)) {
+                this.logKeywordOnlyEmbeddings();
+            }
             if (!this.warnedMissingEmbeddingStack && isDegradedVectorError) {
                 this.warnedMissingEmbeddingStack = true;
                 logger.warn(`GitNexus [query:vector]: ${message}`);
@@ -3498,7 +3518,11 @@ export class LocalBackend {
      * same filePath), the Class wins silently.
      */
     async resolveSymbolCandidates(repo, query, hints) {
-        const { uid, name, include_content } = query;
+        const { name, include_content } = query;
+        // A blank or non-string uid is omitted, not a lookup key — fall through to
+        // the name instead of `not_found`, matching normalizeToolParams' impact
+        // target_uid check.
+        const uid = nonBlankUid(query.uid);
         const selectClause = `n.id AS id, n.name AS name, labels(n)[0] AS type, n.filePath AS filePath, n.startLine AS startLine, n.endLine AS endLine${include_content ? ', n.content AS content' : ''}`;
         // Direct UID — zero-ambiguity path.
         if (uid) {
@@ -5498,7 +5522,7 @@ export class LocalBackend {
         if (fromOutcome.kind === 'not_found') {
             return {
                 status: 'not_found',
-                error: `Source symbol '${params.from_uid ?? params.from}' not found.`,
+                error: `Source symbol '${nonBlankUid(params.from_uid) ?? params.from}' not found.`,
                 suggestion: 'Check the symbol name or use --from-uid for zero-ambiguity.',
             };
         }
@@ -5516,7 +5540,7 @@ export class LocalBackend {
         if (toOutcome.kind === 'not_found') {
             return {
                 status: 'not_found',
-                error: `Target symbol '${params.to_uid ?? params.to}' not found.`,
+                error: `Target symbol '${nonBlankUid(params.to_uid) ?? params.to}' not found.`,
                 suggestion: 'Check the symbol name or use --to-uid for zero-ambiguity.',
             };
         }
@@ -5840,7 +5864,7 @@ export class LocalBackend {
         // selected silently.
         const outcome = await this.resolveSymbolCandidates(repo, { uid: params.target_uid, name: target }, { file_path: params.file_path, kind: params.kind });
         if (outcome.kind === 'not_found') {
-            const missing = params.target_uid ?? target;
+            const missing = nonBlankUid(params.target_uid) ?? target;
             // not_found = no resolved symbol, so the envelope keeps the partial-but-
             // typed target (typed PdgImpactTarget — there is no id/type/filePath yet).
             const notFoundTarget = { name: target };
@@ -6537,6 +6561,12 @@ export class LocalBackend {
         const safeMinConfidence = Number.isFinite(minConfidence) ? minConfidence : 0;
         const confidenceFilter = safeMinConfidence > 0 ? ' AND r.confidence >= $minConfidence' : '';
         const symId = sym.id || sym[0];
+        // #3354: a walk with no anchor id cannot say anything about THIS symbol,
+        // yet it still ships a normal-looking `exact` result with the target's
+        // name echoed back. Throw so every caller's catch reports UNKNOWN instead.
+        if (!symId) {
+            throw new Error(`Impact target '${sym.name || sym[1] || '?'}' resolved without a node id; refusing to report a blast radius`);
+        }
         // #1858 — kick off the epistemic boundary probe concurrently with the BFS.
         // It depends only on symId/symType/symName (all known now) and touches no
         // shared state, so its extra round-trip overlaps the traversal instead of

package/dist/server/git-clone.d.ts

@@ -109,10 +109,9 @@ export declare function normalizeGitUrlForCompare(url: string): string;
 /**
  * Read `remote.origin.url` from an existing clone using `git config --get`.
  *
- * Returns `null` if the config key is absent, the spawn fails, or the
- * directory isn't a git repository. The caller decides what a missing
- * remote means for its threat model — for cloneOrPull, a missing remote
- * on an existing clone is treated as a refuse-to-pull condition.
+ * Returns `null` only when the key is absent (exit 1) or empty. Timeouts and
+ * every other git failure throw, so a lock or spawn error is not treated as
+ * a missing origin.
  */
 export declare function getRemoteOriginUrl(cwd: string, timeoutMs?: number): Promise<string | null>;
 /**
@@ -129,7 +128,7 @@ export declare function getRemoteOriginUrl(cwd: string, timeoutMs?: number): Pro
  * Exported so the comparison logic is testable in isolation against any
  * tmpdir-based fixture, without needing to populate CLONE_ROOT.
  */
-export declare function assertRemoteMatchesRequestedUrl(targetDir: string, requestedUrl: string, timeoutMs?: number): Promise<void>;
+export declare function assertRemoteMatchesRequestedUrl(targetDir: string, requestedUrl: string, timeoutMs?: number, knownOriginUrl?: string): Promise<void>;
 /**
  * Clone or pull a git repository.
  *

package/dist/server/git-clone.js

@@ -14,7 +14,7 @@ import { branchSlug } from '../storage/branch-index.js';
 import { sanitizeRepoName, stripUrlCredentials } from '../storage/git.js';
 import { validateGitUrl } from '../core/net/url-guard.js';
 import { assertDirectoryOwnerAndPermissions, quarantineAutoSyncPartial, } from '../core/auto-sync/path-security.js';
-import { validateAutoSyncRemoteUrl } from '../core/auto-sync/config.js';
+import { getAutoSyncRepoIdentity, validateAutoSyncRemoteUrl } from '../core/auto-sync/config.js';
 export { validateGitUrl };
 /**
  * Root directory for all cloned repositories. Targets must resolve inside this.
@@ -272,13 +272,21 @@ export function normalizeGitUrlForCompare(url) {
         return trimmed.toLowerCase();
     }
 }
+/** Same allowlisted repo across SSH and HTTPS, ignoring a trailing `.git`. */
+function sameAllowlistedAutoSyncRepo(left, right) {
+    try {
+        return getAutoSyncRepoIdentity(left) === getAutoSyncRepoIdentity(right);
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Read `remote.origin.url` from an existing clone using `git config --get`.
  *
- * Returns `null` if the config key is absent, the spawn fails, or the
- * directory isn't a git repository. The caller decides what a missing
- * remote means for its threat model — for cloneOrPull, a missing remote
- * on an existing clone is treated as a refuse-to-pull condition.
+ * Returns `null` only when the key is absent (exit 1) or empty. Timeouts and
+ * every other git failure throw, so a lock or spawn error is not treated as
+ * a missing origin.
  */
 export async function getRemoteOriginUrl(cwd, timeoutMs) {
     try {
@@ -286,9 +294,12 @@ export async function getRemoteOriginUrl(cwd, timeoutMs) {
         return stdout.trim() || null;
     }
     catch (error) {
-        if (error.message.includes('timed out'))
+        const message = error.message ?? '';
+        if (message.includes('timed out'))
             throw error;
-        return null;
+        if (message.includes('failed (exit code 1)'))
+            return null;
+        throw error;
     }
 }
 /**
@@ -305,8 +316,8 @@ export async function getRemoteOriginUrl(cwd, timeoutMs) {
  * Exported so the comparison logic is testable in isolation against any
  * tmpdir-based fixture, without needing to populate CLONE_ROOT.
  */
-export async function assertRemoteMatchesRequestedUrl(targetDir, requestedUrl, timeoutMs) {
-    const remoteUrl = await getRemoteOriginUrl(targetDir, timeoutMs);
+export async function assertRemoteMatchesRequestedUrl(targetDir, requestedUrl, timeoutMs, knownOriginUrl) {
+    const remoteUrl = knownOriginUrl ?? (await getRemoteOriginUrl(targetDir, timeoutMs));
     if (remoteUrl === null) {
         throw new Error(`Existing clone at ${targetDir} has no remote.origin — refusing to pull`);
     }
@@ -477,17 +488,39 @@ export async function cloneOrPull(url, targetDir, onProgress, options) {
     await fs.mkdir(path.dirname(safeTarget), { recursive: true });
     await assertNoSymlinkPath(cloneRoot, safeTarget, Boolean(options?.allowedCloneRoot));
     await assertPreRealpathContainment(cloneRoot, safeTarget);
-    const exists = await fs.access(path.join(safeTarget, '.git')).then(() => true, () => false);
+    let exists = await fs.access(path.join(safeTarget, '.git')).then(() => true, () => false);
+    let originUrl = null;
+    if (exists && options?.allowAutoSyncSsh) {
+        originUrl = await getRemoteOriginUrl(safeTarget, options?.timeoutMs);
+        if (!originUrl) {
+            if (options.quarantineRoot) {
+                await quarantineAutoSyncPartial(safeTarget, options.quarantineRoot);
+                exists = false;
+            }
+            else {
+                throw new Error(`Existing clone at ${safeTarget} has no remote.origin — remove ${safeTarget} and retry`);
+            }
+        }
+    }
     const targetExists = await fs.access(safeTarget).then(() => true, () => false);
     if (exists) {
         if (options?.allowedCloneRoot) {
             await assertNoSymlinkPath(cloneRoot, path.join(safeTarget, '.git'), true);
         }
         await assertPostRealpathContainment(cloneRoot, safeTarget);
+        let originForCompare = originUrl;
+        if (originUrl &&
+            normalizeGitUrlForCompare(originUrl) !== normalizeGitUrlForCompare(url) &&
+            sameAllowlistedAutoSyncRepo(originUrl, url)) {
+            await runGit(['remote', 'set-url', 'origin', url], safeTarget, {
+                timeoutMs: options?.timeoutMs,
+            });
+            originForCompare = url;
+        }
         // Confirm the existing clone is actually the same repository the caller
         // requested. Without this check, a pull would silently succeed against
         // whatever remote the dir was originally cloned from.
-        await assertRemoteMatchesRequestedUrl(safeTarget, url, options?.timeoutMs);
+        await assertRemoteMatchesRequestedUrl(safeTarget, url, options?.timeoutMs, originForCompare ?? undefined);
         onProgress?.({ phase: 'pulling', message: 'Pulling latest changes...' });
         const runGitImpl = options?.runGitForTest ?? runGit;
         const gitOpts = {

package/dist/storage/parse-cache.js

@@ -773,7 +773,14 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // v104 (#3339 review): TS/JS pair-HOC queries now name object-pair
 // `mutation(withAuth(arrow))` handlers. Warm caches replay the pre-fix
 // capture set (anonymous arrows, no Function name), so both stores re-extract.
-const SCHEMA_BUMP = 104;
+// v112 (#3354): callable-value flow now follows each branch of `a ?? f`,
+// `a || f`, and `c ? f : g`. Warm caches replay the pre-fix flow facts, which
+// have no flow for those assignments, so both stores re-extract. 105-111 are
+// claimed by open PR #3326 (Elixir).
+// Same v112: the `valueAlternatives` provider hook extends it to Kotlin
+// `?:`/`if`, Swift/Dart `??`/`?:`, and Python `x if c else y`, and keeps a
+// Ruby multi-statement `if` one opaque source.
+const SCHEMA_BUMP = 112;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.36",
+  "version": "1.6.13-rc.38",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",

package/scripts/cross-platform-tests.ts

@@ -341,6 +341,12 @@ const FILESYSTEM = [
   // 4893-file pass — 2.3 s on a slow virtualised filesystem, 0.34 s on a local
   // disk — against a 30 s testTimeout.
   'test/unit/source-control-bytes.test.ts',
+  // Auto-sync reads a cloned `.gitnexusrc` through the symlink/hard-link guard,
+  // and clone recovery uses real `git` plus temp dirs. Ubuntu coverage alone
+  // would never create the Windows file symlink (`type: 'file'`) or run the
+  // git-config failure path on windows-latest / macos-latest.
+  'test/unit/gitnexus-rc-embeddings.test.ts',
+  'test/unit/git-clone.test.ts',
 ];
 
 const ALL_CROSS_PLATFORM = [