Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
feat(config): add ignore_worktrees to skip linked git worktrees
Nohj16698e8193fa
diff --git a/README.md b/README.mdindex 9c82c18ae..fb4ce7326 100644--- a/README.md+++ b/README.md@@ -155,6 +155,8 @@ Watcher registration is controlled separately by `auto_watch` (default `true`).To turn the watcher off entirely, set `config set watcher_enabled false` (default `true`): the background poll thread never starts and no project is registered, while `auto_index` and manual `index_repository` keep working. Unlike `auto_watch` — which is consulted per session — `watcher_enabled` is read once when the background daemon starts, so run `codebase-memory-mcp daemon stop` after changing it; reconnecting your MCP client alone will not restart the daemon. See [docs/CONFIGURATION.md](docs/CONFIGURATION.md#2-cli-managed-runtime-settings).+Linked git worktrees are indexed as their own projects by default. Set `config set ignore_worktrees true` to skip them on the automatic paths — useful when short-lived `git worktree add` checkouts would otherwise each leave behind a permanent index of the same repository. An explicit `index_repository` call on a worktree is then refused unless you pass `index_worktree=true`. See [docs/CONFIGURATION.md](docs/CONFIGURATION.md#ignore_worktrees).+### Keeping Up to Date**Updates run from the install script on every platform, not from inside the running binary.** `codebase-memory-mcp update` validates your flags and then prints the exact command to run:@@ -735,6 +737,7 @@ codebase-memory-mcp config list # show all settingscodebase-memory-mcp config set auto_index true # auto-index on session startcodebase-memory-mcp config set auto_index_limit 50000 # max files for auto-indexcodebase-memory-mcp config set auto_watch false # don't register background git watcher (default: true)+codebase-memory-mcp config set ignore_worktrees true # skip linked git worktrees when auto-indexing (default: false)codebase-memory-mcp config set watcher_enabled false # stop the watcher thread entirely (default: true)codebase-memory-mcp config set index_max_files 250000 # optional per-index source-file limitcodebase-memory-mcp config set index_max_source_mb 16384 # optional per-index source-size limitdiff --git a/docs/CONFIGURATION.md b/docs/CONFIGURATION.mdindex 038256976..4c27e7f57 100644--- a/docs/CONFIGURATION.md+++ b/docs/CONFIGURATION.md@@ -87,6 +87,7 @@ Current keys:|---|---|---|| `auto_index` | `false` | Automatically index new projects when an MCP session starts. || `auto_index_limit` | `50000` | Maximum file count allowed for automatic indexing of a new project. |+| `ignore_worktrees` | `false` | Skip linked git worktrees (`git worktree add`) when indexing automatically. || `auto_watch` | `true` | Register the session's project with the background git watcher on connect. Set `false` to keep a session from registering its project (the watcher still runs for other projects). || `watcher_enabled` | `true` | Master switch for the background watcher subsystem. Set `false` to stop the watcher from starting at all — no poll thread and no project registration. Reindex manually with `index_repository` when disabled. || `index_max_files` | `off` | Optional maximum number of accepted source files in one discovery run. |@@ -126,6 +127,35 @@ and preserves any previously serving database. See[Index resource limits](INDEX_RESOURCE_LIMITS.md) for counting, validation, anderror-response details.+### `ignore_worktrees`++Every indexed project is registered under its own absolute root path, so each+linked worktree becomes a separate permanent index. On machines that create many+short-lived worktrees, the automatic paths (`auto_index`, and the session hook's+"index this project first" guidance) turn every throwaway checkout into another+stored index of what is largely the same repository.++Enable the key to keep those checkouts out of the index:++```bash+codebase-memory-mcp config set ignore_worktrees true+```++With it enabled:++- automatic indexing skips a session whose root is a linked worktree;+- the `hook-augment` context says the worktree is unindexed on purpose instead+ of telling the agent to run `index_repository`;+- an explicit `index_repository` call on a linked worktree is refused, and names+ both ways forward — pass `index_worktree=true` for that one call, or turn the+ key back off.++The main checkout of the same repository is unaffected, as are ordinary clones+and submodules. Detection is git plumbing only: a linked worktree's `.git` is a+file pointing at a gitdir that contains a `commondir` entry.++The default is `false`, so indexing behavior is unchanged unless you opt in.+## 3. UI SettingsThe optional built-in graph UI stores its settings in:diff --git a/src/cli/cli.c b/src/cli/cli.cindex 6e33759e4..08aded621 100644--- a/src/cli/cli.c+++ b/src/cli/cli.c@@ -7442,6 +7442,7 @@ static const config_key_def_t CONFIG_KEYS[] = {{CBM_CONFIG_AUTO_INDEX, "false", "Enable auto-indexing on MCP session start"},{CBM_CONFIG_AUTO_INDEX_LIMIT, "50000", "Max files for auto-indexing new projects"},{CBM_CONFIG_AUTO_WATCH, "true", "Register background git watcher on session connect"},+ {CBM_CONFIG_IGNORE_WORKTREES, "false", "Skip linked git worktrees when indexing automatically"},{CBM_CONFIG_WATCHER_ENABLED, "true","Run the background watcher thread (auto-reindex); false to disable"},{CBM_CONFIG_UI_LANG, "auto", "Pin graph UI language: en, zh, or auto"},diff --git a/src/cli/cli.h b/src/cli/cli.hindex 5522edef0..a6ef66618 100644--- a/src/cli/cli.h+++ b/src/cli/cli.h@@ -262,7 +262,8 @@ bool cbm_hook_augment_invocation_supported_for_testing(const char *dialect,const char *forced_event);bool cbm_hook_path_contains_for_testing(const char *root, const char *candidate,bool case_insensitive);-const char *cbm_hook_no_project_index_guidance_for_testing(const char *event);+const char *cbm_hook_no_project_index_guidance_for_testing(const char *event,+ bool worktree_ignored);bool cbm_hook_augment_parse_bash_pattern_for_testing(const char *cmd, char *out, size_t out_sz);bool cbm_mcp_command_path_probe_safe_for_testing(const char *command, bool windows);void cbm_set_mcp_command_path_probe_counter_for_testing(int *counter);@@ -443,6 +444,7 @@ bool cbm_config_load_index_policy(cbm_config_t *cfg, cbm_index_resource_policy_t#define CBM_CONFIG_AUTO_INDEX "auto_index"#define CBM_CONFIG_AUTO_INDEX_LIMIT "auto_index_limit"#define CBM_CONFIG_AUTO_WATCH "auto_watch"+#define CBM_CONFIG_IGNORE_WORKTREES "ignore_worktrees"#define CBM_CONFIG_UI_LANG "ui-lang"#define CBM_CONFIG_WATCHER_ENABLED "watcher_enabled"/* #1558: the graph UI's loopback listener. Stored in the UI config file ratherdiff --git a/src/cli/hook_augment.c b/src/cli/hook_augment.cindex f8909c365..1043b48cd 100644--- a/src/cli/hook_augment.c+++ b/src/cli/hook_augment.c@@ -21,7 +21,9 @@#include "foundation/constants.h"#include "foundation/mem.h"#include "foundation/platform.h"+#include "git/git_context.h"#include "mcp/mcp.h"+#include "mcp/mcp_internal.h"#include "pipeline/pipeline.h"#include "yyjson/yyjson.h"@@ -1440,7 +1442,14 @@ static const char *ha_active_tier(yyjson_val *root, const char *event) {return "Tier 2 verification";}-static const char *ha_no_project_index_guidance(const char *event) {+static const char *ha_no_project_index_guidance(const char *event, bool worktree_ignored) {+ /* ignore_worktrees is on and this cwd is a linked worktree: indexing it is+ * deliberately disabled, so telling the agent to run index_repository would+ * only produce a refusal. Point at the setting instead. */+ if (worktree_ignored) {+ return "This is a linked git worktree and ignore_worktrees is enabled, so it is not "+ "indexed on purpose; do not run index_repository here.";+ }return event && strcmp(event, "SubagentStart") == 0? "Ask the parent agent to run index_repository before structural exploration; ""do not attempt graph mutation."@@ -1472,6 +1481,8 @@ static char *ha_lifecycle_json_from_root(cbm_mcp_server_t *srv, yyjson_val *root}const char *cwd = ha_normalized_cwd_with_server(root, srv, cwd_buffer, sizeof(cwd_buffer));char *project = srv && cwd ? ha_resolve_indexed_project(srv, cwd) : NULL;+ bool worktree_ignored = !project && srv && cwd && cbm_mcp_ignore_worktrees_enabled(srv) &&+ cbm_git_is_linked_worktree(cwd);cbm_mcp_server_free(owned_server);char context[2048];@@ -1505,7 +1516,7 @@ static char *ha_lifecycle_json_from_root(cbm_mcp_server_t *srv, yyjson_val *root"and file reads for literals, configs, non-code files, and verification.",scope, safe_project, tier);} else {- const char *index_guidance = ha_no_project_index_guidance(event);+ const char *index_guidance = ha_no_project_index_guidance(event, worktree_ignored);snprintf(context, sizeof(context),"[codebase-memory] %s context: no indexed graph project matched this working ""directory. %s Once indexed, "@@ -1624,8 +1635,9 @@ bool cbm_hook_path_contains_for_testing(const char *root, const char *candidate,return ha_path_contains_mode(root, candidate, case_insensitive);}-const char *cbm_hook_no_project_index_guidance_for_testing(const char *event) {- return ha_no_project_index_guidance(event);+const char *cbm_hook_no_project_index_guidance_for_testing(const char *event,+ bool worktree_ignored) {+ return ha_no_project_index_guidance(event, worktree_ignored);}bool cbm_hook_augment_parse_bash_pattern_for_testing(const char *cmd, char *out, size_t out_sz) {diff --git a/src/daemon/application.c b/src/daemon/application.cindex 748b8bb75..8a79ecd5d 100644--- a/src/daemon/application.c+++ b/src/daemon/application.c@@ -15,6 +15,7 @@#include "foundation/sha256.h"#include "foundation/subprocess.h"#include "foundation/workspace.h"+#include "git/git_context.h"#include "mcp/index_supervisor.h"#include "mcp/mcp.h"#include "mcp/mcp_internal.h"@@ -2071,6 +2072,11 @@ static void application_background_initialize_impl(cbm_daemon_application_sessio!application_session_workspace_allowed(session, "auto_index_discovery")) {auto_index_candidate = false;}+ if (auto_index_candidate && cbm_mcp_ignore_worktrees_enabled(session->mcp) &&+ cbm_git_is_linked_worktree(root_path)) {+ cbm_log_info("daemon.autoindex.skipped", "project", project, "reason", "linked_worktree");+ auto_index_candidate = false;+ }bool within_auto_index_limit =!auto_index_candidate ||cbm_mcp_auto_index_within_file_limit(root_path, auto_index_limit, &tracked_files);diff --git a/src/git/git_context.c b/src/git/git_context.cindex 47956562f..cb27c17cf 100644--- a/src/git/git_context.c+++ b/src/git/git_context.c@@ -100,6 +100,66 @@ static bool path_is_absolute(const char *path) {#endif}+/* Read the "gitdir: <path>" pointer out of a gitlink FILE at <path>/.git.+ * Returns false when .git is missing, a directory (ordinary repo), or holds no+ * pointer. A relative pointer is resolved against path. */+static bool read_gitlink_target(const char *path, char *out, size_t out_size) {+ char dot_git[GIT_OUTPUT_MAX];+ int n = snprintf(dot_git, sizeof(dot_git), "%s/.git", path);+ if (n < 0 || n >= (int)sizeof(dot_git)) {+ return false;+ }+ struct stat st;+ if (stat(dot_git, &st) != 0 || !S_ISREG(st.st_mode)) {+ return false;+ }++ FILE *f = cbm_fopen(dot_git, "r");+ if (!f) {+ return false;+ }+ char line[GIT_OUTPUT_MAX];+ bool got = false;+ while (fgets(line, sizeof(line), f)) {+ trim_newlines(line);+ if (strncmp(line, "gitdir:", 7) != 0) {+ continue;+ }+ const char *value = line + 7;+ while (*value == ' ' || *value == '\t') {+ value++;+ }+ if (!value[0]) {+ break;+ }+ int written = path_is_absolute(value) ? snprintf(out, out_size, "%s", value)+ : snprintf(out, out_size, "%s/%s", path, value);+ got = written > 0 && written < (int)out_size;+ break;+ }+ fclose(f);+ return got;+}++bool cbm_git_is_linked_worktree(const char *path) {+ if (!path || !path[0]) {+ return false;+ }+ char git_dir[GIT_OUTPUT_MAX];+ if (!read_gitlink_target(path, git_dir, sizeof(git_dir))) {+ return false;+ }+ /* Only linked worktrees carry <gitdir>/commondir; a submodule gitlink+ * points at <super>/.git/modules/<name>, which does not. */+ char commondir[GIT_OUTPUT_MAX];+ int n = snprintf(commondir, sizeof(commondir), "%s/commondir", git_dir);+ if (n < 0 || n >= (int)sizeof(commondir)) {+ return false;+ }+ struct stat st;+ return stat(commondir, &st) == 0 && S_ISREG(st.st_mode);+}+static char *join_root_relative(const char *root, const char *rel) {if (!root || !root[0]) {return git_strdup(rel);diff --git a/src/git/git_context.h b/src/git/git_context.hindex 876309eb6..633e28018 100644--- a/src/git/git_context.h+++ b/src/git/git_context.h@@ -19,6 +19,18 @@ typedef struct {char *base_sha;} cbm_git_context_t;+/* True when path is the root of a LINKED git worktree (`git worktree add`).+ *+ * Plumbing-only, no subprocess: <path>/.git must be a regular file holding a+ * "gitdir: <path>" pointer AND that gitdir must contain a `commondir` file.+ * The commondir check is what separates a linked worktree from a submodule —+ * a submodule's .git is also a gitlink file, but its gitdir+ * (<super>/.git/modules/<name>) has no commondir entry.+ *+ * Callers run this on every session start, so it stays fork-free; the richer+ * cbm_git_context_resolve() shells out to git and is not usable on that path. */+bool cbm_git_is_linked_worktree(const char *path);+int cbm_git_context_resolve(const char *path, cbm_git_context_t *out);void cbm_git_context_free(cbm_git_context_t *ctx);char *cbm_git_context_branch_qn(const char *project_name, const cbm_git_context_t *ctx);diff --git a/src/mcp/mcp.c b/src/mcp/mcp.cindex 78b8dccf9..41a63273e 100644--- a/src/mcp/mcp.c+++ b/src/mcp/mcp.c@@ -478,7 +478,10 @@ static const tool_def_t TOOLS[] = {"\"name\":{\"type\":\"string\",\"description\":""\"Name override; Non-ASCII bytes are encoded; unsafe characters normalized.\"},""\"persistence\":{\"type\":\"boolean\",\"default\":false,\"description\":"- "\"Write .codebase-memory/graph.db.zst.\"}"+ "\"Write .codebase-memory/graph.db.zst.\"},"+ "\"index_worktree\":{\"type\":\"boolean\",\"default\":false,\"description\":"+ "\"Index repo_path even when it is a linked git worktree and the "+ "ignore_worktrees config key is enabled. No effect otherwise.\"}""},\"required\":[\"repo_path\"]}"},{"search_graph",@@ -11174,6 +11177,20 @@ static char *handle_index_repository(cbm_mcp_server_t *srv, const char *args) {return cbm_mcp_text_result(boundary_err, true);}+ /* ignore_worktrees: an EXPLICIT index_repository call on a linked worktree+ * is refused with the two ways forward (per-call override, or turn the+ * setting off) rather than silently skipped — a silent success would be+ * indistinguishable from a real index to the caller. */+ if (cbm_mcp_ignore_worktrees_enabled(srv) && !cbm_mcp_get_bool_arg(args, "index_worktree") &&+ cbm_git_is_linked_worktree(repo_path)) {+ index_args_free(repo_path, mode_str, name_override);+ return cbm_mcp_text_result(+ "repo_path is a linked git worktree and ignore_worktrees is enabled. Pass "+ "index_worktree=true to index it anyway, or run: codebase-memory-mcp config set "+ "ignore_worktrees false",+ true);+ }+if (mode_str && strcmp(mode_str, "cross-repo-intelligence") == 0) {char *result = handle_cross_repo_mode(srv, repo_path, name_override, args);index_args_free(repo_path, mode_str, name_override);@@ -17613,6 +17630,17 @@ static bool auto_watch_enabled(cbm_mcp_server_t *srv) {return cbm_config_get_bool(srv->config, CBM_CONFIG_AUTO_WATCH, true);}+/* ignore_worktrees config: gates automatic indexing of LINKED git worktrees+ * (default off, so existing setups keep indexing them). Users who create many+ * short-lived worktrees can stop each throwaway checkout from registering a+ * new permanent project with `config set ignore_worktrees true`. */+bool cbm_mcp_ignore_worktrees_enabled(const cbm_mcp_server_t *srv) {+ if (!srv || !srv->config) {+ return false; /* default off */+ }+ return cbm_config_get_bool(srv->config, CBM_CONFIG_IGNORE_WORKTREES, false);+}+/* Register the session project with the background watcher for ongoing* change detection — unless auto_watch is disabled. */static void register_watcher_if_enabled(cbm_mcp_server_t *srv) {@@ -17765,6 +17793,12 @@ static void maybe_auto_index(cbm_mcp_server_t *srv) {return;}+ if (cbm_mcp_ignore_worktrees_enabled(srv) && cbm_git_is_linked_worktree(srv->session_root)) {+ cbm_log_info("autoindex.skip", "reason", "linked_worktree", "project",+ srv->session_project);+ return;+ }+/* Quick tracked-file count check to avoid OOM on massive repos. */int file_count = -1;#ifdef CBM_ENABLE_TEST_SEAMSdiff --git a/src/mcp/mcp_internal.h b/src/mcp/mcp_internal.hindex de170067a..8e78f9f40 100644--- a/src/mcp/mcp_internal.h+++ b/src/mcp/mcp_internal.h@@ -63,6 +63,11 @@ const char *cbm_mcp_edge_strategy_class(const char *strategy);bool cbm_mcp_auto_index_within_file_limit(const char *root_path, int file_limit,int *file_count_out);+/* True when the `ignore_worktrees` config key is on for this server (default+ * off). Callers pair it with cbm_git_is_linked_worktree() to decide whether an+ * automatic index of a linked worktree should be skipped. */+bool cbm_mcp_ignore_worktrees_enabled(const cbm_mcp_server_t *srv);+/* detect_changes seed scoping (#1363): does `node`'s line range overlap any* recorded hunk for `file`? Exposed for direct unit testing of the overlap* logic, independent of the git/subprocess/index plumbing around it. */diff --git a/tests/test_cli.c b/tests/test_cli.cindex 7cd44244e..14553ef68 100644--- a/tests/test_cli.c+++ b/tests/test_cli.c@@ -12536,14 +12536,18 @@ TEST(cli_hook_augment_subagent_tier_router_contract) {}TEST(cli_hook_augment_subagent_no_project_guidance_is_read_only) {- const char *session = cbm_hook_no_project_index_guidance_for_testing("SessionStart");- const char *subagent = cbm_hook_no_project_index_guidance_for_testing("SubagentStart");+ const char *session = cbm_hook_no_project_index_guidance_for_testing("SessionStart", false);+ const char *subagent = cbm_hook_no_project_index_guidance_for_testing("SubagentStart", false);+ const char *worktree = cbm_hook_no_project_index_guidance_for_testing("SessionStart", true);ASSERT_NOT_NULL(session);ASSERT_NOT_NULL(subagent);+ ASSERT_NOT_NULL(worktree);ASSERT(strstr(session, "Run index_repository") != NULL);ASSERT(strstr(subagent, "Ask the parent agent to run index_repository") != NULL);ASSERT(strstr(subagent, "do not attempt graph mutation") != NULL);ASSERT(strstr(subagent, "Run index_repository") == NULL);+ ASSERT(strstr(worktree, "ignore_worktrees is enabled") != NULL);+ ASSERT(strstr(worktree, "do not run index_repository") != NULL);PASS();}@@ -15941,6 +15945,19 @@ TEST(cli_ui_config_keys_are_discoverable_and_settable_issue1558) {PASS();}+TEST(cli_ignore_worktrees_config_key_is_discoverable) {+ bool listed = false;+ for (size_t i = 0; i < cbm_cli_config_key_count_for_testing(); i++) {+ const char *key = cbm_cli_config_key_at_for_testing(i);+ if (key && strcmp(key, CBM_CONFIG_IGNORE_WORKTREES) == 0) {+ listed = true;+ break;+ }+ }+ ASSERT_TRUE(listed);+ PASS();+}+TEST(cli_skill_frontmatter_scalars_with_colons_are_quoted_issue1554) {const cbm_skill_t *sk = cbm_get_skills();ASSERT_NOT_NULL(sk);@@ -16374,6 +16391,7 @@ SUITE(cli) {RUN_TEST(cli_update_download_failure_does_not_quiesce_sessions);RUN_TEST(cli_update_already_current_does_not_quiesce_sessions);RUN_TEST(cli_ui_config_keys_are_discoverable_and_settable_issue1558);+ RUN_TEST(cli_ignore_worktrees_config_key_is_discoverable);RUN_TEST(cli_skill_frontmatter_scalars_with_colons_are_quoted_issue1554);RUN_TEST(cli_external_manager_detection_needs_positive_evidence_issue1566);RUN_TEST(cli_clients_selector_vocabulary_is_complete_and_strict_issue1558);diff --git a/tests/test_git_context.c b/tests/test_git_context.cindex cc94f1d06..894cb68aa 100644--- a/tests/test_git_context.c+++ b/tests/test_git_context.c@@ -253,6 +253,118 @@ TEST(canonical_root_linked_worktree) {#endif /* _WIN32 */}+/* ── cbm_git_is_linked_worktree ─────────────────────────────────── */+/* Detection backing the `ignore_worktrees` config gate. The predicate must be+ * TRUE only for a linked worktree (`git worktree add`) — never for the main+ * checkout, a plain directory, or a submodule. The submodule case is the one a+ * naive "is .git a regular file?" check gets wrong: a submodule's .git is also a+ * gitlink file, and it is separated here by the absence of a `commondir` entry+ * in the pointed-at gitdir. */++TEST(is_linked_worktree_true_for_linked_worktree) {+#ifdef _WIN32+ SKIP_PLATFORM("git worktree test not implemented for Windows");+#else+ /* th_mktempdir() returns a static buffer — copy before the second call. */+ char main_tmp[256];+ char *raw = th_mktempdir("cbm_wt_main");+ if (!raw) FAIL("th_mktempdir returned NULL");+ strncpy(main_tmp, raw, sizeof(main_tmp) - 1);+ main_tmp[sizeof(main_tmp) - 1] = '\0';++ char wt_tmp[256];+ raw = th_mktempdir("cbm_wt_linked");+ if (!raw) FAIL("th_mktempdir returned NULL");+ strncpy(wt_tmp, raw, sizeof(wt_tmp) - 1);+ wt_tmp[sizeof(wt_tmp) - 1] = '\0';+ th_rmtree(wt_tmp); /* git worktree add creates it */++ if (make_git_repo(main_tmp) != 0) {+ th_rmtree(main_tmp);+ SKIP_PLATFORM("git not available to init a repo");+ }+ if (git_run(main_tmp, "branch wt-branch") != 0) {+ th_rmtree(main_tmp);+ FAIL("failed to create branch for worktree");+ }+ char wt_cmd[1024];+ snprintf(wt_cmd, sizeof(wt_cmd), "worktree add \"%s\" wt-branch", wt_tmp);+ if (git_run(main_tmp, wt_cmd) != 0) {+ th_rmtree(wt_tmp);+ th_rmtree(main_tmp);+ SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");+ }++ bool worktree_detected = cbm_git_is_linked_worktree(wt_tmp);+ /* The MAIN checkout of the very same repo must NOT be flagged — otherwise+ * enabling ignore_worktrees would stop indexing ordinary repositories. */+ bool main_detected = cbm_git_is_linked_worktree(main_tmp);++ git_run(main_tmp, "worktree prune");+ th_rmtree(main_tmp);+ th_rmtree(wt_tmp);++ ASSERT(worktree_detected);+ ASSERT(!main_detected);+ PASS();+#endif /* _WIN32 */+}++TEST(is_linked_worktree_false_for_submodule_and_nongit) {+#ifdef _WIN32+ SKIP_PLATFORM("git worktree test not implemented for Windows");+#else+ char super_tmp[256];+ char *raw = th_mktempdir("cbm_wt_super");+ if (!raw) FAIL("th_mktempdir returned NULL");+ strncpy(super_tmp, raw, sizeof(super_tmp) - 1);+ super_tmp[sizeof(super_tmp) - 1] = '\0';++ char child_tmp[256];+ raw = th_mktempdir("cbm_wt_child");+ if (!raw) FAIL("th_mktempdir returned NULL");+ strncpy(child_tmp, raw, sizeof(child_tmp) - 1);+ child_tmp[sizeof(child_tmp) - 1] = '\0';++ if (make_git_repo(super_tmp) != 0 || make_git_repo(child_tmp) != 0) {+ th_rmtree(super_tmp);+ th_rmtree(child_tmp);+ SKIP_PLATFORM("git not available to init a repo");+ }++ /* A plain directory that is not a git repo at all. */+ char plain[1024];+ snprintf(plain, sizeof(plain), "%s/plain", super_tmp);+ if (th_mkdir_p(plain) != 0) {+ th_rmtree(super_tmp);+ th_rmtree(child_tmp);+ FAIL("failed to create plain dir");+ }+ bool plain_detected = cbm_git_is_linked_worktree(plain);++ /* file:// submodules are refused by default since the CVE-2022-39253 fix. */+ char sub_cmd[1024];+ snprintf(sub_cmd, sizeof(sub_cmd),+ "-c protocol.file.allow=always submodule add -q \"%s\" subm", child_tmp);+ int sub_rc = git_run(super_tmp, sub_cmd);++ char subm[1024];+ snprintf(subm, sizeof(subm), "%s/subm", super_tmp);+ bool submodule_detected = sub_rc == 0 && cbm_git_is_linked_worktree(subm);++ th_rmtree(super_tmp);+ th_rmtree(child_tmp);++ ASSERT(!plain_detected);+ if (sub_rc != 0) {+ SKIP_PLATFORM("git submodule add unavailable in this environment");+ }+ /* A submodule gitlink has no commondir → must not be treated as a worktree. */+ ASSERT(!submodule_detected);+ PASS();+#endif /* _WIN32 */+}+/* ── Suite ──────────────────────────────────────────────────────── */SUITE(git_context) {@@ -260,4 +372,6 @@ SUITE(git_context) {RUN_TEST(canonical_root_repo_root);RUN_TEST(canonical_root_subdir);RUN_TEST(canonical_root_linked_worktree);+ RUN_TEST(is_linked_worktree_true_for_linked_worktree);+ RUN_TEST(is_linked_worktree_false_for_submodule_and_nongit);}diff --git a/tests/test_mcp.c b/tests/test_mcp.cindex 60649f505..b7b1335a1 100644--- a/tests/test_mcp.c+++ b/tests/test_mcp.c@@ -19335,6 +19335,291 @@ TEST(mcp_auto_watch_false_skips_watcher_on_connect) {PASS();}+/* ═══════════════════════════════════════════════════════════════+ * ignore_worktrees — explicit index_repository on a linked worktree+ * ═══════════════════════════════════════════════════════════════ */++/* An EXPLICIT index_repository call is refused only when ignore_worktrees is on+ * AND repo_path is a linked worktree AND no per-call override was passed. The+ * refusal must never fire for the MAIN checkout — that would break ordinary+ * indexing for anyone enabling the key — and index_worktree=true must escape it.+ *+ * Default-off is the regression class the project guards hardest: with the key+ * unset, a linked worktree still indexes exactly as today.+ *+ * Probe returns a bit set, or a negative fixture-setup code. */+enum {+ IGNORE_WT_REFUSED_WORKTREE = 1, /* expected when the key is on */+ IGNORE_WT_REFUSED_MAIN = 2, /* BUG if set */+ IGNORE_WT_REFUSED_OVERRIDE = 4, /* BUG if set */+};++#ifndef _WIN32+typedef struct {+ char cache[256];+ char main_repo[512];+ char wt_repo[512];+} ignore_wt_fixture_t;++static void ignore_wt_fixture_cleanup(ignore_wt_fixture_t *fx) {+ if (!fx) {+ return;+ }+ if (fx->main_repo[0]) {+ char prune[1024];+ snprintf(prune, sizeof(prune), "git -C \"%s\" worktree prune >/dev/null 2>&1", fx->main_repo);+ (void)system(prune);+ }+ if (fx->cache[0]) {+ th_rmtree(fx->cache);+ }+}++/* 0 = ready. -1 tmpdir, -2 mkdir, -3 git worktree fixture unavailable. */+static int ignore_wt_fixture_setup(ignore_wt_fixture_t *fx) {+ memset(fx, 0, sizeof(*fx));+ char *raw = th_mktempdir("cbm_ignorewt");+ if (!raw) {+ return -1;+ }+ snprintf(fx->cache, sizeof(fx->cache), "%s", raw);+ snprintf(fx->main_repo, sizeof(fx->main_repo), "%s/main", fx->cache);+ snprintf(fx->wt_repo, sizeof(fx->wt_repo), "%s/wt", fx->cache);+ if (th_mkdir_p(fx->main_repo) != 0) {+ ignore_wt_fixture_cleanup(fx);+ return -2;+ }++ char cmd[2048];+ snprintf(cmd, sizeof(cmd),+ "git -C \"%s\" init -q >/dev/null 2>&1 && "+ "git -C \"%s\" config user.email [email protected] && "+ "git -C \"%s\" config user.name T && touch \"%s/.keep\" && "+ "git -C \"%s\" add .keep && git -C \"%s\" commit -q -m init && "+ "git -C \"%s\" worktree add -q \"%s\" -b wtb",+ fx->main_repo, fx->main_repo, fx->main_repo, fx->main_repo, fx->main_repo,+ fx->main_repo, fx->main_repo, fx->wt_repo);+ if (system(cmd) != 0) {+ ignore_wt_fixture_cleanup(fx);+ return -3;+ }+ return 0;+}++static bool ignore_wt_refused(cbm_mcp_server_t *srv, const char *repo_path, bool override) {+ char args[2048];+ snprintf(args, sizeof(args), "{\"repo_path\":\"%s\"%s}", repo_path,+ override ? ",\"index_worktree\":true" : "");+ char *result = cbm_mcp_handle_tool(srv, "index_repository", args);+ bool refused = result && strstr(result, "ignore_worktrees is enabled") != NULL;+ free(result);+ return refused;+}++static int ignore_worktrees_index_probe(const char *ignore_value) {+ ignore_wt_fixture_t fx;+ int setup = ignore_wt_fixture_setup(&fx);+ if (setup < 0) {+ return setup;+ }++ const char *saved = getenv("CBM_CACHE_DIR");+ char *saved_copy = saved ? strdup(saved) : NULL;+ cbm_setenv("CBM_CACHE_DIR", fx.cache, 1);++ int bits = -4;+ cbm_config_t *cfg = cbm_config_open(fx.cache);+ if (cfg) {+ if (ignore_value) {+ cbm_config_set(cfg, CBM_CONFIG_IGNORE_WORKTREES, ignore_value);+ }+ cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);+ if (srv) {+ cbm_mcp_server_set_config(srv, cfg);+ bits = 0;+ if (ignore_wt_refused(srv, fx.wt_repo, false)) {+ bits |= IGNORE_WT_REFUSED_WORKTREE;+ }+ if (ignore_wt_refused(srv, fx.main_repo, false)) {+ bits |= IGNORE_WT_REFUSED_MAIN;+ }+ if (ignore_wt_refused(srv, fx.wt_repo, true)) {+ bits |= IGNORE_WT_REFUSED_OVERRIDE;+ }+ cbm_mcp_server_free(srv);+ }+ cbm_config_close(cfg);+ }++ restore_cache_dir(saved_copy);+ free(saved_copy);+ ignore_wt_fixture_cleanup(&fx);+ return bits;+}++#ifdef CBM_ENABLE_TEST_SEAMS+static void ignore_wt_count_started(void *context) {+ int *calls = context;+ (*calls)++;+}++/* Drive initialize → maybe_auto_index on a linked worktree. ignore_value NULL+ * leaves the key unset (default-off). The count hook fires only if auto-index+ * reaches discovery, so a skip for linked_worktree must leave it at 0. */+static int ignore_wt_autoindex_count_calls(const char *session_root, const char *ignore_value) {+ char *raw = th_mktempdir("cbm_ignorewt_auto");+ if (!raw) {+ return -1;+ }+ char cache[256];+ snprintf(cache, sizeof(cache), "%s", raw);++ const char *saved = getenv("CBM_CACHE_DIR");+ char *saved_copy = saved ? strdup(saved) : NULL;+ cbm_setenv("CBM_CACHE_DIR", cache, 1);++ char old_cwd[1024];+ if (!cbm_getcwd(old_cwd, sizeof(old_cwd)) || cbm_chdir(session_root) != 0) {+ restore_cache_dir(saved_copy);+ free(saved_copy);+ th_cleanup(cache);+ return -2;+ }++ int calls = -3;+ cbm_config_t *cfg = cbm_config_open(cache);+ cbm_mcp_server_t *srv = cfg ? cbm_mcp_server_new(NULL) : NULL;+ if (srv) {+ cbm_config_set(cfg, CBM_CONFIG_AUTO_INDEX, "true");+ /* Fail-closed on the actual count so this never launches an index thread. */+ cbm_config_set(cfg, CBM_CONFIG_AUTO_INDEX_LIMIT, "-1");+ if (ignore_value) {+ cbm_config_set(cfg, CBM_CONFIG_IGNORE_WORKTREES, ignore_value);+ }+ cbm_mcp_server_set_config(srv, cfg);+ calls = 0;+ cbm_mcp_server_set_auto_index_count_test_hook(srv, ignore_wt_count_started, &calls);+ char *response = cbm_mcp_server_handle(+ srv, "{\"jsonrpc\":\"2.0\",\"id\":1430,\"method\":\"initialize\",\"params\":{}}");+ free(response);+ cbm_mcp_server_free(srv);+ }+ if (cfg) {+ cbm_config_close(cfg);+ }++ (void)cbm_chdir(old_cwd);+ restore_cache_dir(saved_copy);+ free(saved_copy);+ th_cleanup(cache);+ return calls;+}+#endif /* CBM_ENABLE_TEST_SEAMS */+#endif /* !_WIN32 */++TEST(mcp_ignore_worktrees_gates_explicit_index_repository) {+#ifdef _WIN32+ SKIP_PLATFORM("git worktree fixture not implemented for Windows");+#else+ int bits = ignore_worktrees_index_probe("true");+ if (bits == -1) {+ FAIL("th_mktempdir returned NULL");+ }+ if (bits == -2) {+ FAIL("failed to create ignore_worktrees fixture directory");+ }+ if (bits < 0) {+ SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");+ }+ /* RED before the gate existed: nothing is ever refused. */+ ASSERT((bits & IGNORE_WT_REFUSED_WORKTREE) != 0);+ ASSERT((bits & IGNORE_WT_REFUSED_MAIN) == 0);+ ASSERT((bits & IGNORE_WT_REFUSED_OVERRIDE) == 0);+ PASS();+#endif /* _WIN32 */+}++/* Default-off pin: key unset, linked worktree still indexes. The gate is+ * opt-in; an unset key must be bit-for-bit today's behaviour. */+TEST(mcp_ignore_worktrees_default_off_still_indexes_worktree) {+#ifdef _WIN32+ SKIP_PLATFORM("git worktree fixture not implemented for Windows");+#else+ int bits = ignore_worktrees_index_probe(NULL);+ if (bits == -1) {+ FAIL("th_mktempdir returned NULL");+ }+ if (bits == -2) {+ FAIL("failed to create ignore_worktrees fixture directory");+ }+ if (bits < 0) {+ SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");+ }+ ASSERT((bits & IGNORE_WT_REFUSED_WORKTREE) == 0);+ ASSERT((bits & IGNORE_WT_REFUSED_MAIN) == 0);+ ASSERT((bits & IGNORE_WT_REFUSED_OVERRIDE) == 0);+ PASS();+#endif /* _WIN32 */+}++#ifdef CBM_ENABLE_TEST_SEAMS+TEST(mcp_ignore_worktrees_skips_auto_index_on_linked_worktree) {+#ifdef _WIN32+ SKIP_PLATFORM("git worktree fixture not implemented for Windows");+#else+ ignore_wt_fixture_t fx;+ int setup = ignore_wt_fixture_setup(&fx);+ if (setup == -1) {+ FAIL("th_mktempdir returned NULL");+ }+ if (setup == -2) {+ FAIL("failed to create ignore_worktrees fixture directory");+ }+ if (setup < 0) {+ SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");+ }+ int calls = ignore_wt_autoindex_count_calls(fx.wt_repo, "true");+ ignore_wt_fixture_cleanup(&fx);+ if (calls == -1) {+ FAIL("th_mktempdir returned NULL");+ }+ if (calls < 0) {+ FAIL("ignore_worktrees auto-index fixture failed");+ }+ ASSERT_EQ(calls, 0);+ PASS();+#endif /* _WIN32 */+}++TEST(mcp_ignore_worktrees_default_off_auto_index_reaches_count) {+#ifdef _WIN32+ SKIP_PLATFORM("git worktree fixture not implemented for Windows");+#else+ ignore_wt_fixture_t fx;+ int setup = ignore_wt_fixture_setup(&fx);+ if (setup == -1) {+ FAIL("th_mktempdir returned NULL");+ }+ if (setup == -2) {+ FAIL("failed to create ignore_worktrees fixture directory");+ }+ if (setup < 0) {+ SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");+ }+ int calls = ignore_wt_autoindex_count_calls(fx.wt_repo, NULL);+ ignore_wt_fixture_cleanup(&fx);+ if (calls == -1) {+ FAIL("th_mktempdir returned NULL");+ }+ if (calls < 0) {+ FAIL("ignore_worktrees auto-index fixture failed");+ }+ ASSERT_EQ(calls, 1);+ PASS();+#endif /* _WIN32 */+}+#endif /* CBM_ENABLE_TEST_SEAMS */+/* ══════════════════════════════════════════════════════════════════* #1466 / #713 — the auto_index_limit guard*@@ -20824,6 +21109,13 @@ SUITE(mcp) {RUN_TEST(autoindex_limit_guards_non_git_root_issue713);RUN_TEST(autoindex_limit_admits_non_git_root_under_limit_issue713);RUN_TEST(autoindex_limit_guards_git_root_issue713);+ /* ignore_worktrees gate */+ RUN_TEST(mcp_ignore_worktrees_gates_explicit_index_repository);+ RUN_TEST(mcp_ignore_worktrees_default_off_still_indexes_worktree);+#ifdef CBM_ENABLE_TEST_SEAMS+ RUN_TEST(mcp_ignore_worktrees_skips_auto_index_on_linked_worktree);+ RUN_TEST(mcp_ignore_worktrees_default_off_auto_index_reaches_count);+#endif}/* Kept separate so daemon-coordination regressions can be iterated without