Skip to content

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.

feat(config): add ignore_worktrees to skip linked git worktrees

Nohj16698e8193fa
diff --git a/README.md b/README.md
index 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 settings
codebase-memory-mcp config set auto_index true # auto-index on session start
codebase-memory-mcp config set auto_index_limit 50000 # max files for auto-index
codebase-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 limit
codebase-memory-mcp config set index_max_source_mb 16384 # optional per-index source-size limit
diff --git a/docs/CONFIGURATION.md b/docs/CONFIGURATION.md
index 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, and
error-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 Settings
The optional built-in graph UI stores its settings in:
diff --git a/src/cli/cli.c b/src/cli/cli.c
index 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.h
index 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 rather
diff --git a/src/cli/hook_augment.c b/src/cli/hook_augment.c
index 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.c
index 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.c
index 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.h
index 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.c
index 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_SEAMS
diff --git a/src/mcp/mcp_internal.h b/src/mcp/mcp_internal.h
index 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.c
index 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.c
index 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.c
index 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