.gitignore, Documentation/git-organize.adoc, Documentation/meson.build, Makefile, builtin.h, builtin/organize.c, command-list.txt, git.c, meson.build, organize/gitorganize-format.c, organize/gitorganize-format.h, organize/organize.c, organize/organize.h, t/meson.build, t/t0096-organize.sh

diff --git a/.gitignore b/.gitignore
index 4da58c6754..b85ce2b13a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -118,6 +118,7 @@
 /git-mv
 /git-name-rev
 /git-notes
+/git-organize
 /git-p4
 /git-pack-redundant
 /git-pack-objects
diff --git a/Documentation/git-organize.adoc b/Documentation/git-organize.adoc
new file mode 100644
index 0000000000..4ff76f5c13
--- /dev/null
+++ b/Documentation/git-organize.adoc
@@ -0,0 +1,82 @@
+git-organize(1)
+===============
+
+NAME
+----
+git-organize - Reconcile a source tree against a declared layout
+
+
+SYNOPSIS
+--------
+[verse]
+'git organize status'
+'git organize apply'
+
+
+DESCRIPTION
+-----------
+A project declares where each of its files belongs, and git organize
+reports the files that sit elsewhere and, on request, moves them into
+place. As `.gitignore` declares what stays untracked and `.mailmap`
+declares canonical author names, `.gitorganize` declares the directory a
+file belongs in.
+
+`.gitorganize` at the repository root has three sections. `[scope]` names
+the files in scope, one pathspec per line; with no `[scope]` section
+nothing is in scope. `[layout]` is the project's placement map, authored by
+hand: ordered `<label>:<value> = <directory>` rules (`.` is the repository
+root). A file's labels are matched against the rules in order, and the first
+rule it satisfies places it; a file matching no rule is the backlog.
+`[labels]` holds the recorded labels, one line per
+source in scope, `<path> <key>=<value> ...`, with every label the project
+defines. A placed file is listed too, so its `[labels]` line records its
+labels, independently of the directory name. Only a label named in a rule
+places a file.
+
+`git organize status` reads `[labels]` and reports the out-of-place files,
+the backlog, a file in scope that `[labels]` does not record, and a
+recorded path that no longer exists. It runs nothing and
+changes nothing.
+
+`git organize apply` reconciles the tree. It moves each out-of-place file
+into its directory. A move is a content-identical rename, so `git log
+--follow` and `git blame` track the file exactly. apply stages the result
+and repoints each carved file's `[labels]` line to its new path, carrying
+its labels. It commits nothing. apply requires a clean worktree.
+
+
+COMMANDS
+--------
+
+status::
+	Report the files whose placement value names a directory they are not
+	in (the moves), the backlog (recorded files with no matching
+	rule), a file in scope that `[labels]` does not record, and a recorded
+	path that no longer exists. Changes nothing.
+
+apply::
+	Move each out-of-place file into its directory as a content-identical
+	rename, repoint each carved file's `[labels]` line to its new path, and
+	stage the result. apply requires a clean worktree, so the change can be
+	discarded as a whole.
+
+
+FILES
+-----
+`.gitorganize`::
+	The declaration, at the repository root, in three sections. `[scope]`
+	names the files in scope, one pathspec per line; with no `[scope]`
+	section nothing is in scope. `[layout]` is the project's placement map:
+	ordered `<label>:<value> = <directory>` rules (`.` is the root), where a
+	file takes the directory of the first rule its labels satisfy, and a
+	file matching no rule is the backlog. `[labels]` holds the recorded
+	labels, one `<path> <key>=<value> ...` line per source in scope,
+	including placed files. The project writes `[scope]` and `[layout]`; the
+	move apply repoints a carved file's line. A `#` line is a comment; git
+	organize rewrites the file whole, keeping the hand-authored `[scope]`
+	and `[layout]` verbatim.
+
+
+GIT
+---
+Part of the linkgit:git[1] suite
diff --git a/Documentation/meson.build b/Documentation/meson.build
index f4854f802d..8793c927b5 100644
--- a/Documentation/meson.build
+++ b/Documentation/meson.build
@@ -98,6 +98,7 @@ manpages = {
   'git-mv.adoc' : 1,
   'git-name-rev.adoc' : 1,
   'git-notes.adoc' : 1,
+  'git-organize.adoc' : 1,
   'git-p4.adoc' : 1,
   'git-pack-objects.adoc' : 1,
   'git-pack-refs.adoc' : 1,
diff --git a/Makefile b/Makefile
index d4b775953d..da7c4df7d3 100644
--- a/Makefile
+++ b/Makefile
@@ -1237,6 +1237,8 @@ LIB_OBJS += oid-array.o
 LIB_OBJS += oidmap.o
 LIB_OBJS += oidset.o
 LIB_OBJS += oidtree.o
+LIB_OBJS += organize/gitorganize-format.o
+LIB_OBJS += organize/organize.o
 LIB_OBJS += pack-bitmap-write.o
 LIB_OBJS += pack-bitmap.o
 LIB_OBJS += pack-check.o
@@ -1465,6 +1467,7 @@ BUILTIN_OBJS += builtin/multi-pack-index.o
 BUILTIN_OBJS += builtin/mv.o
 BUILTIN_OBJS += builtin/name-rev.o
 BUILTIN_OBJS += builtin/notes.o
+BUILTIN_OBJS += builtin/organize.o
 BUILTIN_OBJS += builtin/pack-objects.o
 ifndef WITH_BREAKING_CHANGES
 BUILTIN_OBJS += builtin/pack-redundant.o
diff --git a/builtin.h b/builtin.h
index 4e47a4ebd3..0ac855e534 100644
--- a/builtin.h
+++ b/builtin.h
@@ -224,6 +224,7 @@ int cmd_multi_pack_index(int argc, const char **argv, const char *prefix, struct
 int cmd_mv(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_name_rev(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_notes(int argc, const char **argv, const char *prefix, struct repository *repo);
+int cmd_organize(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_pack_objects(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_pack_redundant(int argc, const char **argv, const char *prefix, struct repository *repo);
 int cmd_patch_id(int argc, const char **argv, const char *prefix, struct repository *repo);
diff --git a/builtin/organize.c b/builtin/organize.c
new file mode 100644
index 0000000000..9462d8687f
--- /dev/null
+++ b/builtin/organize.c
@@ -0,0 +1,110 @@
+/*
+ * "git organize": reconcile a source tree against a declared layout.
+ *
+ * cmd_organize parses arguments and drives the organize engine (organize.c).
+ * status reports the files in scope whose matching rule names a directory they
+ * are not in yet (the moves), the backlog (files with no matching rule), and a
+ * declared path that no longer exists. apply moves the misplaced files and
+ * stages the result.
+ */
+#include "builtin.h"
+#include "gettext.h"
+#include "organize/organize.h"
+#include "parse-options.h"
+#include "repository.h"
+
+static const char *const organize_usage[] = {
+	"git organize status",
+	"git organize apply",
+	NULL
+};
+
+static int organize_status(struct repository *repo)
+{
+	struct organize_plan plan = ORGANIZE_PLAN_INIT;
+	int to_move, backlog, unrecorded, orphans;
+
+	organize_plan_build(repo, &plan);
+	to_move = (int)plan.moves_nr;
+	backlog = (int)plan.backlog.nr;
+	unrecorded = (int)plan.unrecorded.nr;
+	orphans = (int)plan.orphans.nr;
+
+	/*
+	 * A summary over the files in scope: how many are already in place,
+	 * how many move, and how many match no rule.
+	 */
+	if (plan.in_scope)
+		printf(_("organize: %d in scope (%d in place, %d to move, "
+			 "%d backlog)\n"),
+		       plan.in_scope, plan.in_place, to_move, backlog);
+
+	if (to_move) {
+		printf(_("to move:\n"));
+		for (size_t i = 0; i < plan.moves_nr; i++)
+			printf("  %-32s -> %s\n", plan.moves[i].src,
+			       plan.moves[i].dst);
+		printf(_("%d file(s) would move\n"), to_move);
+	} else {
+		printf(_("in place; nothing to move\n"));
+	}
+	if (backlog) {
+		printf(_("backlog:\n"));
+		for (size_t i = 0; i < plan.backlog.nr; i++)
+			printf("  %s\n", plan.backlog.items[i].string);
+	}
+	if (unrecorded) {
+		printf(_("in scope but unrecorded:\n"));
+		for (size_t i = 0; i < plan.unrecorded.nr; i++)
+			printf("  %s\n", plan.unrecorded.items[i].string);
+	}
+	if (orphans) {
+		printf(_("declared but missing:\n"));
+		for (size_t i = 0; i < plan.orphans.nr; i++)
+			printf("  %s\n", plan.orphans.items[i].string);
+	}
+
+	organize_plan_release(&plan);
+	return 0;
+}
+
+static int organize_apply(struct repository *repo)
+{
+	struct organize_plan plan = ORGANIZE_PLAN_INIT;
+
+	organize_plan_build(repo, &plan);
+	if (!plan.moves_nr) {
+		printf(_("organize apply: nothing to do\n"));
+		organize_plan_release(&plan);
+		return 0;
+	}
+
+	organize_plan_apply(repo, &plan);
+
+	printf(_("organize apply: %d move(s).\n"), (int)plan.moves_nr);
+	printf(_("organize apply: the result is staged; nothing is committed.\n"));
+
+	organize_plan_release(&plan);
+	return 0;
+}
+
+int cmd_organize(int argc,
+		 const char **argv,
+		 const char *prefix,
+		 struct repository *repo)
+{
+	struct option options[] = {
+		OPT_END()
+	};
+	const char *subcmd;
+
+	argc = parse_options(argc, argv, prefix, options, organize_usage, 0);
+	subcmd = argc ? argv[0] : "status";
+	if (argc > 1)
+		die(_("git organize: too many arguments"));
+	if (!strcmp(subcmd, "status"))
+		return organize_status(repo);
+	else if (!strcmp(subcmd, "apply"))
+		return organize_apply(repo);
+	die(_("git organize: unknown subcommand '%s'"), subcmd);
+}
diff --git a/command-list.txt b/command-list.txt
index 21b802c420..c9892258f2 100644
--- a/command-list.txt
+++ b/command-list.txt
@@ -147,6 +147,7 @@ git-multi-pack-index                    plumbingmanipulators
 git-mv                                  mainporcelain           worktree
 git-name-rev                            plumbinginterrogators
 git-notes                               mainporcelain
+git-organize                            ancillarymanipulators           complete
 git-p4                                  foreignscminterface
 git-pack-objects                        plumbingmanipulators
 git-pack-redundant                      plumbinginterrogators
diff --git a/git.c b/git.c
index e5f1811b6b..cd2d325585 100644
--- a/git.c
+++ b/git.c
@@ -617,6 +617,7 @@ static struct cmd_struct commands[] = {
 	{ "mv", cmd_mv, RUN_SETUP | NEED_WORK_TREE },
 	{ "name-rev", cmd_name_rev, RUN_SETUP },
 	{ "notes", cmd_notes, RUN_SETUP },
+	{ "organize", cmd_organize, RUN_SETUP | NEED_WORK_TREE },
 	{ "pack-objects", cmd_pack_objects, RUN_SETUP },
 #ifndef WITH_BREAKING_CHANGES
 	{ "pack-redundant", cmd_pack_redundant, RUN_SETUP | NO_PARSEOPT | DEPRECATED },
diff --git a/meson.build b/meson.build
index d86f2acd2b..a2d987b124 100644
--- a/meson.build
+++ b/meson.build
@@ -442,6 +442,8 @@ libgit_sources = [
   'oidmap.c',
   'oidset.c',
   'oidtree.c',
+  'organize/gitorganize-format.c',
+  'organize/organize.c',
   'pack-bitmap-write.c',
   'pack-bitmap.c',
   'pack-check.c',
@@ -677,6 +679,7 @@ builtin_sources = [
   'builtin/mv.c',
   'builtin/name-rev.c',
   'builtin/notes.c',
+  'builtin/organize.c',
   'builtin/pack-objects.c',
   'builtin/pack-refs.c',
   'builtin/patch-id.c',
diff --git a/organize/gitorganize-format.c b/organize/gitorganize-format.c
new file mode 100644
index 0000000000..cdade12f5b
--- /dev/null
+++ b/organize/gitorganize-format.c
@@ -0,0 +1,261 @@
+#include "git-compat-util.h"
+#include "gitorganize-format.h"
+#include "gettext.h"
+#include "quote.h"
+#include "read-cache-ll.h"
+#include "strbuf.h"
+#include "string-list.h"
+#include "wrapper.h"
+
+void gitorganize_clear(struct gitorganize *g)
+{
+	for (size_t i = 0; i < g->rules_nr; i++) {
+		free(g->rules[i].label);
+		free(g->rules[i].value);
+		free(g->rules[i].dir);
+	}
+	FREE_AND_NULL(g->rules);
+	g->rules_nr = g->rules_alloc = 0;
+	strbuf_release(&g->header);
+	string_list_clear(&g->scope, 0);
+	string_list_clear(&g->records, 1);	/* util is an xstrdup'd string */
+}
+
+static void layout_add(struct gitorganize *g, const char *label,
+		       const char *value, const char *dir)
+{
+	struct layout_rule *rule;
+
+	ALLOC_GROW(g->rules, g->rules_nr + 1, g->rules_alloc);
+	rule = &g->rules[g->rules_nr++];
+	rule->label = xstrdup(label);
+	rule->value = xstrdup(value);
+	rule->dir = xstrdup(dir);
+}
+
+/* Read a path token (C-quoted or bare) at `p` into `out`; return its end. */
+const char *read_path_token(const char *p, struct strbuf *out)
+{
+	size_t len;
+
+	strbuf_reset(out);
+	if (*p == '"') {
+		const char *endp;
+		if (unquote_c_style(out, p, &endp))
+			die(_("organize: malformed quoted path"));
+		return endp;
+	}
+	len = strcspn(p, " \t\n");
+	strbuf_add(out, p, len);
+	return p + len;
+}
+
+/*
+ * Copy the value of `key` from the space-separated "k=value ..." string
+ * `labels` into `out`. Return out->buf, or NULL when `key` is absent.
+ */
+static const char *label_value(const char *labels, const char *key,
+			struct strbuf *out)
+{
+	size_t keylen = strlen(key);
+
+	while (*labels) {
+		const char *end = strchrnul(labels, ' ');	/* this token is [labels, end) */
+
+		if (!strncmp(labels, key, keylen) && labels[keylen] == '=') {
+			const char *value = labels + keylen + 1;	/* just past "key=" */
+
+			strbuf_reset(out);
+			strbuf_add(out, value, end - value);
+			return out->buf;
+		}
+		if (!*end)
+			break;		/* that was the last token */
+		labels = end + 1;	/* step over the space to the next */
+	}
+	return NULL;
+}
+
+/*
+ * The first rule a file's labels satisfy, or NULL (the backlog). Rules are
+ * tried in order, so an earlier rule takes precedence.
+ */
+struct layout_rule *layout_match(struct gitorganize *g, const char *labels,
+				 struct strbuf *value_buf)
+{
+	for (size_t i = 0; i < g->rules_nr; i++) {
+		struct layout_rule *rule = &g->rules[i];
+		const char *value = label_value(labels, rule->label, value_buf);
+
+		if (value && !strcmp(value, rule->value))
+			return rule;
+	}
+	return NULL;
+}
+
+/*
+ * Parse a `label:value = directory` [layout] rule and add it to `g`; die on a
+ * malformed rule or an unsafe directory. `line` is the original text, for
+ * error messages.
+ */
+static void parse_layout_rule(struct gitorganize *g, const char *trimmed,
+			      const char *line)
+{
+	const char *equals = strchr(trimmed, '='), *colon;
+	struct strbuf left = STRBUF_INIT, dir = STRBUF_INIT;
+	struct strbuf label = STRBUF_INIT, value = STRBUF_INIT;
+
+	if (!equals)
+		die(_("organize: .gitorganize: [layout] requires "
+		      "'label:value = directory' in: %s"), line);
+	strbuf_add(&left, trimmed, equals - trimmed);
+	strbuf_trim(&left);
+	strbuf_addstr(&dir, equals + 1);
+	strbuf_trim(&dir);
+	while (dir.len && dir.buf[dir.len - 1] == '/')
+		strbuf_setlen(&dir, dir.len - 1);	/* tolerate a trailing slash */
+	colon = strchr(left.buf, ':');
+	if (!colon)
+		die(_("organize: .gitorganize: [layout] requires "
+		      "'label:value = directory' in: %s"), line);
+	strbuf_add(&label, left.buf, colon - left.buf);
+	strbuf_trim(&label);
+	strbuf_addstr(&value, colon + 1);
+	strbuf_trim(&value);
+	if (!label.len || !value.len || !dir.len)
+		die(_("organize: .gitorganize: [layout] requires "
+		      "'label:value = directory' in: %s"), line);
+	if (strcmp(dir.buf, ".") && !verify_path(dir.buf, 0))
+		die(_("organize: .gitorganize: [layout] directory "
+		      "must be inside the tree: %s"), dir.buf);
+	layout_add(g, label.buf, value.buf, dir.buf);
+	strbuf_release(&left);
+	strbuf_release(&dir);
+	strbuf_release(&label);
+	strbuf_release(&value);
+}
+
+/*
+ * Parse .gitorganize into `g`: the [scope] pathspecs (g->scope), the [layout]
+ * rules (g->rules), the verbatim [scope] and [layout] header (g->header, kept
+ * for round-tripping on write), and the [labels] records (g->records, each
+ * path -> its "k=value k=value" string in util). A missing file leaves `g`
+ * empty.
+ */
+void gitorganize_read(struct gitorganize *g)
+{
+	struct strbuf buf = STRBUF_INIT;
+	struct string_list lines = STRING_LIST_INIT_NODUP;
+	struct strbuf path = STRBUF_INIT;
+	enum { NONE, SCOPE, LAYOUT, LABELS } section = NONE;
+
+	if (strbuf_read_file(&buf, ".gitorganize", 0) < 0) {
+		strbuf_release(&buf);
+		return;
+	}
+	string_list_split_in_place(&lines, buf.buf, "\n", -1);
+	for (size_t i = 0; i < lines.nr; i++) {
+		char *line = lines.items[i].string;
+		size_t len = strlen(line);
+		const char *trimmed;
+
+		if (len && line[len - 1] == '\r')
+			line[len - 1] = '\0';	/* tolerate CRLF line endings */
+		if (!*line && i + 1 == lines.nr)
+			continue;	/* trailing empty from the final newline */
+		trimmed = line + strspn(line, " \t");
+
+		if (!strcmp(trimmed, "[scope]")) {
+			section = SCOPE;
+			strbuf_addf(&g->header, "%s\n", line);
+			continue;
+		}
+		if (!strcmp(trimmed, "[layout]")) {
+			section = LAYOUT;
+			strbuf_addf(&g->header, "%s\n", line);
+			continue;
+		}
+		if (!strcmp(trimmed, "[labels]")) {
+			section = LABELS;
+			continue;
+		}
+
+		/*
+		 * [scope] and [layout] are hand-authored and round-tripped, so
+		 * every line (comments and blanks included) is kept in the
+		 * header; only a content line feeds the parsed rules.
+		 */
+		if (section == SCOPE || section == LAYOUT) {
+			strbuf_addf(&g->header, "%s\n", line);
+			if (!*trimmed || *trimmed == '#')
+				continue;
+			if (section == SCOPE)
+				string_list_append(&g->scope, trimmed);
+			else
+				parse_layout_rule(g, trimmed, line);
+			continue;
+		}
+
+		if (section == LABELS) {
+			const char *p;
+
+			if (!*trimmed || *trimmed == '#')
+				continue;
+			p = read_path_token(trimmed, &path);
+			if (!path.len)
+				die(_("organize: .gitorganize: [labels] line has "
+				      "no path: %s"), line);
+			/*
+			 * A quoted path token can end mid-line ("a"junk); a
+			 * label list must be set off by whitespace, so require
+			 * whitespace or end-of-line after the path.
+			 */
+			if (*p && *p != ' ' && *p != '\t' && *p != '\n')
+				die(_("organize: .gitorganize: trailing text "
+				      "after path: %s"), line);
+			p += strspn(p, " \t");
+			if (string_list_has_string(&g->records, path.buf))
+				die(_("organize: .gitorganize: '%s' listed twice"),
+				    path.buf);
+			string_list_insert(&g->records, path.buf)->util =
+				xstrdup(p);
+			continue;
+		}
+
+		if (*trimmed && *trimmed != '#')
+			die(_("organize: .gitorganize: line outside "
+			      "[scope]/[layout]/[labels]: %s"), line);
+	}
+	string_list_clear(&lines, 0);
+	strbuf_release(&path);
+	strbuf_release(&buf);
+}
+
+/*
+ * Write .gitorganize from `g`: its verbatim [scope] and [layout] header
+ * (g->header), then the [labels] records (g->records, each path -> its
+ * "k=value k=value" string in util), one `<path> <k=value ...>` line per entry
+ * in the list's sorted order. A path that needs it is C-quoted.
+ */
+void gitorganize_write(struct gitorganize *g)
+{
+	struct strbuf out = STRBUF_INIT;
+
+	if (g->header.len)
+		strbuf_addbuf(&out, &g->header);
+	else
+		strbuf_addstr(&out, "[layout]\n");
+	strbuf_addstr(&out, "[labels]\n");
+	for (size_t i = 0; i < g->records.nr; i++) {
+		const char *labels = g->records.items[i].util;
+
+		quote_c_style(g->records.items[i].string, &out, NULL, 0);
+		if (labels && *labels) {
+			strbuf_addch(&out, ' ');
+			strbuf_addstr(&out, labels);
+		}
+		strbuf_addch(&out, '\n');
+	}
+	write_file_buf(".gitorganize", out.buf, out.len);
+	strbuf_release(&out);
+}
diff --git a/organize/gitorganize-format.h b/organize/gitorganize-format.h
new file mode 100644
index 0000000000..d499545a25
--- /dev/null
+++ b/organize/gitorganize-format.h
@@ -0,0 +1,38 @@
+#ifndef GITORGANIZE_FORMAT_H
+#define GITORGANIZE_FORMAT_H
+
+#include "strbuf.h"
+#include "string-list.h"
+
+struct layout_rule {
+	char *label;
+	char *value;
+	char *dir;
+};
+
+/*
+ * The parsed .gitorganize file: the [scope] pathspecs, the [layout] rules, the
+ * verbatim [scope] and [layout] header (round-tripped on write), and the
+ * [labels] records (each path -> its "k=value ..." string in util).
+ */
+struct gitorganize {
+	struct string_list scope;
+	struct layout_rule *rules;
+	size_t rules_nr, rules_alloc;
+	struct strbuf header;
+	struct string_list records;
+};
+#define GITORGANIZE_INIT { \
+	.scope = STRING_LIST_INIT_DUP, \
+	.header = STRBUF_INIT, \
+	.records = STRING_LIST_INIT_DUP, \
+}
+
+void gitorganize_clear(struct gitorganize *g);
+const char *read_path_token(const char *p, struct strbuf *out);
+struct layout_rule *layout_match(struct gitorganize *g, const char *labels,
+				 struct strbuf *value_buf);
+void gitorganize_read(struct gitorganize *g);
+void gitorganize_write(struct gitorganize *g);
+
+#endif /* GITORGANIZE_FORMAT_H */
diff --git a/organize/organize.c b/organize/organize.c
new file mode 100644
index 0000000000..0d9850dfc0
--- /dev/null
+++ b/organize/organize.c
@@ -0,0 +1,320 @@
+#include "git-compat-util.h"
+#include "organize.h"
+#include "gitorganize-format.h"
+#include "gettext.h"
+#include "pathspec.h"
+#include "quote.h"
+#include "read-cache-ll.h"
+#include "repository.h"
+#include "run-command.h"
+#include "strbuf.h"
+#include "string-list.h"
+#include "strvec.h"
+#include "wrapper.h"
+#include "wt-status.h"
+
+/*
+ * The [layout] rule whose directory equals `path`'s directory, or NULL when
+ * `path` is a root file or its directory matches no rule. A file in a [layout]
+ * directory is in place, whatever its recorded label; its directory alone
+ * tells git organize it is in place.
+ */
+static struct layout_rule *layout_dir_rule(struct gitorganize *g,
+					   const char *path)
+{
+	const char *slash = strrchr(path, '/');
+	size_t dirlen;
+
+	if (!slash)
+		return NULL;		/* a root file */
+	dirlen = slash - path;
+	for (size_t i = 0; i < g->rules_nr; i++) {
+		struct layout_rule *r = &g->rules[i];
+
+		if (strcmp(r->dir, ".") && strlen(r->dir) == dirlen &&
+		    !strncmp(path, r->dir, dirlen))
+			return r;
+	}
+	return NULL;
+}
+
+/*
+ * Read the index once into two lists: every tracked file in `tracked_files`,
+ * and the governed subset in `scoped_files`. A file is governed when it matches
+ * the [scope] pathspecs (a candidate to label and move) or when it already sits
+ * in a [layout] directory (kept in scope so a file added under a carved
+ * directory does not slip in ungoverned). With no [scope] pathspecs and no
+ * [layout] rules, no file is governed.
+ */
+static void collect_index(struct repository *repo, struct gitorganize *g,
+			  struct string_list *scoped_files,
+			  struct string_list *tracked_files)
+{
+	struct pathspec pathspec;
+	struct strvec specs = STRVEC_INIT;
+
+	for (size_t i = 0; i < g->scope.nr; i++)
+		strvec_push(&specs, g->scope.items[i].string);
+	parse_pathspec(&pathspec, 0, PATHSPEC_PREFER_FULL, "", specs.v);
+
+	if (repo_read_index(repo) < 0)
+		die(_("organize: could not read the index"));
+	for (size_t i = 0; i < repo->index->cache_nr; i++) {
+		const char *name = repo->index->cache[i]->name;
+
+		string_list_insert(tracked_files, name);
+		if (g->scope.nr &&
+		    match_pathspec(repo->index, &pathspec, name,
+				   strlen(name), 0, NULL, 0))
+			string_list_insert(scoped_files, name);
+		else if (layout_dir_rule(g, name))
+			string_list_insert(scoped_files, name);
+	}
+	clear_pathspec(&pathspec);
+	strvec_clear(&specs);
+}
+
+/*
+ * The parsed .gitorganize (gitorg) and the tree state that status, apply, and
+ * labeling all read: the files in scope (scoped_files) and every tracked_files
+ * file.
+ */
+struct organize_ctx {
+	struct gitorganize gitorg;
+	struct string_list scoped_files;
+	struct string_list tracked_files;
+};
+#define ORGANIZE_CTX_INIT { \
+	.gitorg = GITORGANIZE_INIT, \
+	.scoped_files = STRING_LIST_INIT_DUP, \
+	.tracked_files = STRING_LIST_INIT_DUP, \
+}
+
+static void organize_ctx_load(struct repository *repo, struct organize_ctx *ctx)
+{
+	gitorganize_read(&ctx->gitorg);
+	collect_index(repo, &ctx->gitorg, &ctx->scoped_files,
+		      &ctx->tracked_files);
+}
+
+static void organize_ctx_release(struct organize_ctx *ctx)
+{
+	gitorganize_clear(&ctx->gitorg);
+	string_list_clear(&ctx->scoped_files, 0);
+	string_list_clear(&ctx->tracked_files, 0);
+}
+
+static void add_move(struct organize_plan *plan, const char *src,
+		     char *dst, const char *value)
+{
+	struct organize_move *m;
+
+	ALLOC_GROW(plan->moves, plan->moves_nr + 1, plan->moves_alloc);
+	m = &plan->moves[plan->moves_nr++];
+	m->src = xstrdup(src);
+	m->dst = dst;
+	m->rule_value = xstrdup(value);
+}
+
+void organize_plan_build(struct repository *repo, struct organize_plan *plan)
+{
+	struct organize_ctx ctx = ORGANIZE_CTX_INIT;
+	struct string_list seen = STRING_LIST_INIT_DUP;
+	struct strbuf value_buf = STRBUF_INIT;
+
+	organize_ctx_load(repo, &ctx);
+
+	/*
+	 * Classify each recorded entry by the rule its labels match. A file
+	 * already in the rule's directory is in place. A file in another
+	 * directory is a move. A file whose labels match no rule is backlog.
+	 */
+	for (size_t i = 0; i < ctx.gitorg.records.nr; i++) {
+		const char *path = ctx.gitorg.records.items[i].string;
+		const char *labels = ctx.gitorg.records.items[i].util;
+		const char *base, *target, *slash;
+		struct layout_rule *rule;
+		struct strbuf dst = STRBUF_INIT;
+
+		if (!string_list_has_string(&ctx.tracked_files, path))
+			continue;	/* an orphan, handled below */
+		string_list_insert(&seen, path);
+		plan->in_scope++;
+
+		rule = layout_match(&ctx.gitorg, labels, &value_buf);
+		if (!rule) {
+			string_list_append(&plan->backlog, path);
+			continue;
+		}
+		target = rule->dir;
+
+		/* the path the rule names: dir/base, or base at the root */
+		slash = strrchr(path, '/');
+		base = slash ? slash + 1 : path;
+		if (!strcmp(target, "."))
+			strbuf_addstr(&dst, base);
+		else
+			strbuf_addf(&dst, "%s/%s", target, base);
+
+		if (!strcmp(dst.buf, path))
+			plan->in_place++;	/* already in place */
+		else
+			add_move(plan, path, strbuf_detach(&dst, NULL), rule->value);
+		strbuf_release(&dst);
+	}
+
+	/*
+	 * The loop above covered every file with a [labels] line. A file in scope
+	 * with no such line falls into one of two groups. A file already in a
+	 * [layout] directory is in place; the tree is truth, so it needs no
+	 * [labels] line. A root file with no line is unrecorded; it is a mismatch
+	 * between the tree and [labels] and does not count toward in_scope, like
+	 * an orphan.
+	 */
+	for (size_t i = 0; i < ctx.scoped_files.nr; i++) {
+		const char *path = ctx.scoped_files.items[i].string;
+
+		if (string_list_has_string(&seen, path))
+			continue;
+		if (layout_dir_rule(&ctx.gitorg, path)) {
+			plan->in_scope++;
+			plan->in_place++;
+		} else {
+			string_list_append(&plan->unrecorded, path);
+		}
+	}
+
+	/* A recorded path that is no longer a tracked_files file is an orphan. */
+	for (size_t i = 0; i < ctx.gitorg.records.nr; i++)
+		if (!string_list_has_string(&ctx.tracked_files, ctx.gitorg.records.items[i].string))
+			string_list_append(&plan->orphans, ctx.gitorg.records.items[i].string);
+
+	organize_ctx_release(&ctx);
+	string_list_clear(&seen, 0);
+	strbuf_release(&value_buf);
+}
+
+/* Whether the worktree has staged or unstaged changes to any tracked file. */
+static int worktree_dirty(struct repository *repo)
+{
+	if (repo_read_index(repo) < 0)
+		die(_("organize: could not read the index"));
+	return has_unstaged_changes(repo, 0) || has_uncommitted_changes(repo, 0);
+}
+
+/* Map each move's src to its dst, in `dst_of`. */
+static void plan_dst_map(struct organize_plan *plan, struct string_list *dst_of)
+{
+	for (size_t i = 0; i < plan->moves_nr; i++)
+		string_list_insert(dst_of, plan->moves[i].src)->util =
+			plan->moves[i].dst;
+}
+
+/* A content-identical rename entry per move. */
+static void build_rename_patch(struct organize_plan *plan, struct strbuf *out)
+{
+	for (size_t i = 0; i < plan->moves_nr; i++) {
+		struct organize_move *m = &plan->moves[i];
+
+		/* These are tracked_files source paths, which need no quoting. */
+		strbuf_addf(out, "diff --git a/%s b/%s\n", m->src, m->dst);
+		strbuf_addstr(out, "similarity index 100%\n");
+		strbuf_addf(out, "rename from %s\n", m->src);
+		strbuf_addf(out, "rename to %s\n", m->dst);
+	}
+}
+
+static int git_apply_index(const char *patch, size_t len)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+
+	cp.git_cmd = 1;
+	strvec_pushl(&cp.args, "apply", "--index", NULL);
+	return pipe_command(&cp, patch, len, NULL, 0, NULL, 0);
+}
+
+/*
+ * Repoint each carved file's [labels] line to its new path, carrying its labels
+ * unchanged: only its location changes. Returns nonzero when [labels] changed.
+ */
+static int repoint_moved_declarations(struct organize_plan *plan)
+{
+	struct gitorganize g = GITORGANIZE_INIT;
+	struct string_list dst_of = STRING_LIST_INIT_NODUP;
+	struct string_list new_records = STRING_LIST_INIT_DUP;
+	int changed = 0;
+
+	plan_dst_map(plan, &dst_of);
+	gitorganize_read(&g);
+
+	/*
+	 * Rewrite [labels]: an entry whose file moved (found in dst_of) takes
+	 * its new path (dst_of's util) and keeps its labels (the record's util).
+	 */
+	for (size_t i = 0; i < g.records.nr; i++) {
+		const char *path = g.records.items[i].string;
+		const char *labels = g.records.items[i].util;
+		struct string_list_item *moved =
+			string_list_lookup(&dst_of, path);
+
+		if (moved) {
+			path = moved->util;
+			changed = 1;
+		}
+		string_list_insert(&new_records, path)->util = xstrdup(labels);
+	}
+
+	/* Install the rewritten [labels]; gitorganize_clear frees it below. */
+	string_list_clear(&g.records, 1);
+	g.records = new_records;
+	if (changed)
+		gitorganize_write(&g);
+
+	gitorganize_clear(&g);
+	string_list_clear(&dst_of, 0);
+	return changed;
+}
+
+void organize_plan_apply(struct repository *repo, struct organize_plan *plan)
+{
+	struct strbuf patch = STRBUF_INIT;
+
+	if (worktree_dirty(repo))
+		die(_("organize apply: the worktree has uncommitted changes; "
+		      "commit or stash first"));
+
+	/*
+	 * Content-identical renames for every move, applied as one
+	 * git apply --index transaction, so a failure leaves the tree untouched.
+	 */
+	build_rename_patch(plan, &patch);
+	if (patch.len && git_apply_index(patch.buf, patch.len))
+		die(_("organize apply: the change does not apply cleanly; "
+		      "nothing was changed"));
+
+	if (repoint_moved_declarations(plan)) {
+		struct child_process add = CHILD_PROCESS_INIT;
+
+		add.git_cmd = 1;
+		strvec_pushl(&add.args, "add", ".gitorganize", NULL);
+		if (run_command(&add))
+			die(_("organize apply: staging .gitorganize failed; "
+			      "restore with git reset --hard"));
+	}
+
+	strbuf_release(&patch);
+}
+
+void organize_plan_release(struct organize_plan *plan)
+{
+	for (size_t i = 0; i < plan->moves_nr; i++) {
+		free(plan->moves[i].src);
+		free(plan->moves[i].dst);
+		free(plan->moves[i].rule_value);
+	}
+	FREE_AND_NULL(plan->moves);
+	plan->moves_nr = plan->moves_alloc = 0;
+	string_list_clear(&plan->backlog, 0);
+	string_list_clear(&plan->unrecorded, 0);
+	string_list_clear(&plan->orphans, 0);
+}
diff --git a/organize/organize.h b/organize/organize.h
new file mode 100644
index 0000000000..c26453d2be
--- /dev/null
+++ b/organize/organize.h
@@ -0,0 +1,77 @@
+#ifndef ORGANIZE_H
+#define ORGANIZE_H
+
+#include "string-list.h"
+
+struct repository;
+
+/*
+ * The git organize engine. A project declares where each file belongs, and
+ * git organize reconciles the tree against that declaration.
+ *
+ * The committed declaration lives in .gitorganize, a file organize owns, in
+ * three sections:
+ *
+ *   [scope]    the scope pathspecs, one per line; no [scope] section means
+ *     nothing is in scope.
+ *
+ *   [layout]   the project's placement map, hand-authored: ordered
+ *     `<label>:<value> = <directory>` rules (`.` is the root). A file's labels
+ *     are matched against the rules in order, and the first rule it satisfies
+ *     places it; a file matching no rule is backlog. Only a label named in
+ *     a rule places a file.
+ *
+ *   [labels]   the recorded labels, one line per source in scope, `<path> <key>=
+ *     <value> ...`, with every label the project defines. Placed files are listed
+ *     too, so a placed file's [labels] line records its labels, independently of
+ *     the directory name.
+ *
+ *   status  Read [labels] and report the files in scope whose matching rule
+ *     names a directory they are not in yet (the moves), the backlog, and a
+ *     recorded path that no longer exists.
+ *
+ *   apply   Perform the moves. A move is a content-identical rename, applied as
+ *     one git apply --index transaction. A carved file's [labels] line is
+ *     repointed to its new path, carrying its labels.
+ */
+
+struct organize_move {
+	char *src;	/* current path */
+	char *dst;	/* declared path */
+	char *rule_value;	/* the matched rule's value */
+};
+
+struct organize_plan {
+	struct organize_move *moves;
+	size_t moves_nr, moves_alloc;
+	struct string_list backlog;	/* recorded files that match no rule */
+	struct string_list unrecorded;	/* scope files with no [labels] record */
+	struct string_list orphans;	/* declared paths that no longer exist */
+	int in_scope;			/* files in scope */
+	int in_place;			/* files in scope already at their declared location */
+};
+
+#define ORGANIZE_PLAN_INIT { \
+	.backlog = STRING_LIST_INIT_DUP, \
+	.unrecorded = STRING_LIST_INIT_DUP, \
+	.orphans = STRING_LIST_INIT_DUP, \
+}
+
+/*
+ * Read the .gitorganize declaration and record every file whose matching
+ * rule names a directory it is not in as a move. Also record the backlog
+ * (recorded files that match no rule), the unrecorded files (in scope,
+ * no [labels] line), and the orphans (declared paths
+ * that no longer exist).
+ */
+void organize_plan_build(struct repository *repo, struct organize_plan *plan);
+
+/*
+ * Perform the plan: apply the moves as one content-identical-rename
+ * transaction; the result is staged. Requires a clean worktree.
+ */
+void organize_plan_apply(struct repository *repo, struct organize_plan *plan);
+
+void organize_plan_release(struct organize_plan *plan);
+
+#endif /* ORGANIZE_H */
diff --git a/t/meson.build b/t/meson.build
index 2133c840da..fba20fc069 100644
--- a/t/meson.build
+++ b/t/meson.build
@@ -127,6 +127,7 @@ integration_tests = [
   't0092-diagnose.sh',
   't0093-verify-cache-df-gap.sh',
   't0095-bloom.sh',
+  't0096-organize.sh',
   't0100-previous.sh',
   't0101-at-syntax.sh',
   't0200-gettext-basic.sh',
diff --git a/t/t0096-organize.sh b/t/t0096-organize.sh
new file mode 100755
index 0000000000..a352a1c7d1
--- /dev/null
+++ b/t/t0096-organize.sh
@@ -0,0 +1,185 @@
+#!/bin/sh
+
+test_description='git organize reconciles a tree against a declared layout'
+
+. ./test-lib.sh
+
+# There is no labeler yet, so tests write .gitorganize by hand: root *.c/*.h in
+# scope, odb/refs components, and a [labels] census.
+write_declaration () {
+	cat >.gitorganize <<-\EOF
+	[scope]
+	:(glob)*.c
+	:(glob)*.h
+	[layout]
+	role:public = .
+	role:program = .
+	component:odb = odb
+	component:refs = refs
+	[labels]
+	blob.c component=odb role=lib
+	header.h component=? role=public
+	refs.c component=refs role=lib
+	EOF
+}
+
+test_expect_success 'setup a tree and a declaration' '
+	echo blob >blob.c &&
+	echo refs >refs.c &&
+	echo header >header.h &&
+	git add . &&
+	git commit -m init &&
+	write_declaration &&
+	git add .gitorganize &&
+	git commit -m declare
+'
+
+test_expect_success 'status reports the files to move' '
+	git organize status >actual &&
+	# header.h is public (in place at root); blob.c and refs.c move next
+	test_grep "organize: 3 in scope (1 in place, 2 to move, 0 backlog)" actual &&
+	test_grep "blob.c  *-> odb/blob.c" actual &&
+	test_grep "refs.c  *-> refs/refs.c" actual &&
+	test_grep ! header.h actual &&
+	test_grep "2 file(s) would move" actual
+'
+
+test_expect_success 'apply moves files as content-identical renames and repoints [labels]' '
+	git organize apply &&
+	git diff --cached -M --name-status >actual &&
+	test_grep "^R100.*blob.c.*odb/blob.c" actual &&
+	test_grep "^R100.*refs.c.*refs/refs.c" actual &&
+	test_path_is_file odb/blob.c &&
+	test_path_is_file refs/refs.c &&
+	test_path_is_file header.h &&
+	test_path_is_missing blob.c &&
+	test_path_is_missing refs.c &&
+	git diff --cached --name-only >staged &&
+	test_grep "^.gitorganize$" staged &&
+	git commit -m reconciled &&
+	git organize status >actual &&
+	test_grep "nothing to move" actual &&
+	test_grep "^odb/blob.c component=odb" .gitorganize &&
+	test_grep "^refs/refs.c component=refs" .gitorganize &&
+	test_grep ! "^blob.c " .gitorganize &&
+	test_grep ! "^refs.c " .gitorganize &&
+	test_grep "^header.h component=? role=public" .gitorganize
+'
+
+test_expect_success 'apply refuses a dirty worktree' '
+	git init dirty &&
+	(
+		cd dirty &&
+		echo blob >blob.c &&
+		echo other >other.c &&
+		git add . &&
+		git commit -m init &&
+		cat >.gitorganize <<-\EOF &&
+		[scope]
+		:(glob)*.c
+		[layout]
+		component:odb = odb
+		[labels]
+		blob.c component=odb
+		other.c component=?
+		EOF
+		git add .gitorganize &&
+		git commit -m declare &&
+		echo dirty >>other.c &&
+		test_must_fail git organize apply 2>err &&
+		test_grep "uncommitted changes" err
+	)
+'
+
+test_expect_success 'a file in scope with no matching rule is backlog' '
+	git init backlog &&
+	(
+		cd backlog &&
+		echo a >a.c &&
+		git add . &&
+		git commit -m init &&
+		cat >.gitorganize <<-\EOF &&
+		[scope]
+		:(glob)*.c
+		[layout]
+		component:odb = odb
+		[labels]
+		a.c component=?
+		EOF
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize status >actual &&
+		test_grep "backlog" actual &&
+		test_grep "^  a.c$" actual
+	)
+'
+
+test_expect_success 'status reports a declared path that no longer exists' '
+	git init orphan &&
+	(
+		cd orphan &&
+		echo a >a.c &&
+		echo b >b.c &&
+		git add . &&
+		git commit -m init &&
+		cat >.gitorganize <<-\EOF &&
+		[scope]
+		:(glob)*.c
+		[layout]
+		role:public = .
+		[labels]
+		a.c role=public
+		b.c role=public
+		EOF
+		git add .gitorganize &&
+		git commit -m declare &&
+		git rm -q b.c &&
+		git commit -m drop-b &&
+		git organize status >actual &&
+		test_grep "declared but missing" actual &&
+		test_grep "  b.c" actual
+	)
+'
+
+test_expect_success 'status rejects a malformed .gitorganize' '
+	git init bad &&
+	(
+		cd bad &&
+		echo a >a.c &&
+		git add . &&
+		git commit -m init &&
+		cat >.gitorganize <<-\EOF &&
+		[layout]
+		component:odb = odb
+		[labels]
+		a.c component=odb
+		a.c component=odb
+		EOF
+		test_must_fail git organize status 2>err &&
+		test_grep "listed twice" err &&
+		cat >.gitorganize <<-\EOF &&
+		[layout]
+		nocolon = .
+		EOF
+		test_must_fail git organize status 2>err &&
+		test_grep "label:value = directory" err &&
+		cat >.gitorganize <<-\EOF &&
+		[layout]
+		component:x = ../evil
+		EOF
+		test_must_fail git organize status 2>err &&
+		test_grep "must be inside the tree" err &&
+		cat >.gitorganize <<-\EOF &&
+		stray line
+		EOF
+		test_must_fail git organize status 2>err &&
+		test_grep "line outside" err
+	)
+'
+
+test_expect_success 'a subcommand rejects extra operands' '
+	test_must_fail git -C bad organize status junk 2>err &&
+	test_grep "too many arguments" err
+'
+
+test_done

Documentation/git-organize.adoc, builtin/organize.c, t/t0096-organize.sh

diff --git a/Documentation/git-organize.adoc b/Documentation/git-organize.adoc
index 8b216146b6..37ada38234 100644
--- a/Documentation/git-organize.adoc
+++ b/Documentation/git-organize.adoc
@@ -9,7 +9,7 @@ git-organize - Reconcile a source tree against a declared layout
 SYNOPSIS
 --------
 [verse]
-'git organize status'
+'git organize status' [--exit-code]
 'git organize apply'
 'git organize apply' --labels-only [--reseed]
 
@@ -44,7 +44,9 @@ is not in yet.
 `git organize status` reads `[labels]` and reports the out-of-place files,
 the backlog, a file in scope that `[labels]` does not record, and a
 recorded path that no longer exists. status runs no
-configured command and changes nothing.
+configured command and changes nothing. With `--exit-code` it exits
+non-zero when a file is out of place, a file in scope is unrecorded, or a
+recorded path is missing; a standing backlog alone does not fail it.
 
 `git organize apply` reconciles the tree. It moves each out-of-place file
 into its directory. A move that git organize makes on its own is a
@@ -72,7 +74,9 @@ status::
 	in (the moves), the backlog (recorded files with no matching
 	rule), a file in scope that `[labels]` does not record, and a recorded
 	path that no longer exists. Runs no configured
-	command and changes nothing.
+	command and changes nothing. With `--exit-code`, exit non-zero when a
+	file is out of place, a file in scope is unrecorded, or a recorded path
+	is missing.
 
 apply::
 	Move each out-of-place file into its directory as a content-identical
@@ -92,6 +96,11 @@ never do.
 OPTIONS
 -------
 
+--exit-code::
+	Exit non-zero from status when a file is out of place, a file in scope
+	is unrecorded, or a recorded path is missing. A standing backlog alone
+	does not fail it. Changes no output.
+
 --labels-only::
 	With apply, run the labeler and record the labels; move no file. A
 	recorded file keeps its line; the labeler only seeds a file that has no
diff --git a/builtin/organize.c b/builtin/organize.c
index 354ba2151f..35247c5aef 100644
--- a/builtin/organize.c
+++ b/builtin/organize.c
@@ -15,13 +15,13 @@
 #include "repository.h"
 
 static const char *const organize_usage[] = {
-	"git organize status",
+	"git organize status [--exit-code]",
 	"git organize apply",
 	"git organize apply --labels-only [--reseed]",
 	NULL
 };
 
-static int organize_status(struct repository *repo)
+static int organize_status(struct repository *repo, int exit_code)
 {
 	struct organize_plan plan = ORGANIZE_PLAN_INIT;
 	int to_move, backlog, unrecorded, orphans;
@@ -67,7 +67,7 @@ static int organize_status(struct repository *repo)
 	}
 
 	organize_plan_release(&plan);
-	return 0;
+	return exit_code && (to_move || unrecorded || orphans) ? 1 : 0;
 }
 
 static int organize_apply(struct repository *repo)
@@ -106,8 +106,10 @@ int cmd_organize(int argc,
 		 const char *prefix,
 		 struct repository *repo)
 {
-	int labels_only = 0, reseed = 0;
+	int exit_code = 0, labels_only = 0, reseed = 0;
 	struct option options[] = {
+		OPT_BOOL(0, "exit-code", &exit_code,
+			 N_("exit non-zero from status when a file is out of place")),
 		OPT_BOOL(0, "labels-only", &labels_only,
 			 N_("with apply, run the labeler and record the labels")),
 		OPT_BOOL(0, "reseed", &reseed,
@@ -126,7 +128,7 @@ int cmd_organize(int argc,
 	if (!strcmp(subcmd, "status")) {
 		if (labels_only)
 			die(_("git organize: --labels-only is an apply option"));
-		ret = organize_status(repo);
+		ret = organize_status(repo, exit_code);
 	} else if (!strcmp(subcmd, "apply")) {
 		if (labels_only) {
 			organize_run_labeler(repo, reseed);
diff --git a/t/t0096-organize.sh b/t/t0096-organize.sh
index c2e6539ef2..d8de3c7e90 100755
--- a/t/t0096-organize.sh
+++ b/t/t0096-organize.sh
@@ -156,6 +156,10 @@ test_expect_success 'status reports the files to move' '
 	test_grep "2 file(s) would move" actual
 '
 
+test_expect_success 'status --exit-code fails when a file is out of place' '
+	test_expect_code 1 git organize status --exit-code
+'
+
 test_expect_success 'apply moves files as content-identical renames and repoints [labels]' '
 	git organize apply &&
 	git diff --cached -M --name-status >actual &&
@@ -169,6 +173,7 @@ test_expect_success 'apply moves files as content-identical renames and repoints
 	git diff --cached --name-only >staged &&
 	test_grep "^.gitorganize$" staged &&
 	git commit -m reconciled &&
+	git organize status --exit-code &&
 	git organize status >actual &&
 	test_grep "nothing to move" actual &&
 	test_grep "^odb/blob.c component=odb" .gitorganize &&
@@ -435,7 +440,8 @@ test_expect_success 'a basename shared across directories does not collide' '
 		test_path_is_file odb/dup.c &&
 		test_path_is_file sub/dup.c &&
 		test_path_is_missing dup.c &&
-		git commit -m reconciled
+		git commit -m reconciled &&
+		git organize status --exit-code
 	)
 '
 
@@ -484,17 +490,20 @@ test_expect_success 'a file in scope with no recorded label is unrecorded' '
 		git commit -m declare &&
 		git organize apply --labels-only &&
 		git commit -m labels &&
-		# a.c is recorded but matches no rule: backlog
+		# a.c is recorded but matches no rule, so it is backlog; a
+		# standing backlog alone does not fail --exit-code
 		git organize status >actual &&
 		test_grep "backlog:" actual &&
 		test_grep "^  a.c$" actual &&
-		# a source in scope that [labels] never recorded is unrecorded
+		git organize status --exit-code &&
+		# a source in scope that [labels] never recorded is unrecorded drift
 		echo b >b.c &&
 		git add b.c &&
 		git commit -m add-b &&
 		git organize status >actual &&
 		test_grep "in scope but unrecorded:" actual &&
-		test_grep "^  b.c$" actual
+		test_grep "^  b.c$" actual &&
+		test_expect_code 1 git organize status --exit-code
 	)
 '
 
@@ -519,7 +528,8 @@ test_expect_success 'status reports a recorded path that no longer exists' '
 		git commit -m drop-b &&
 		git organize status >actual &&
 		test_grep "declared but missing" actual &&
-		test_grep "  b.c" actual
+		test_grep "  b.c" actual &&
+		test_expect_code 1 git organize status --exit-code
 	)
 '
 

Documentation/git-organize.adoc, Makefile, builtin/organize.c, contrib/organize/git-layout.map, contrib/organize/labeler, contrib/organize/organizer, meson.build, organize/gitorganize-format.c, organize/labeler-protocol.c, organize/labeler-protocol.h, organize/organize.c, organize/organize.h, organize/organizer-protocol.c, organize/organizer-protocol.h, t/t0096-organize.sh

diff --git a/Documentation/git-organize.adoc b/Documentation/git-organize.adoc
index 4ff76f5c13..8b216146b6 100644
--- a/Documentation/git-organize.adoc
+++ b/Documentation/git-organize.adoc
@@ -11,6 +11,7 @@ SYNOPSIS
 [verse]
 'git organize status'
 'git organize apply'
+'git organize apply' --labels-only [--reseed]
 
 
 DESCRIPTION
@@ -31,18 +32,36 @@ rule it satisfies places it; a file matching no rule is the backlog.
 source in scope, `<path> <key>=<value> ...`, with every label the project
 defines. A placed file is listed too, so its `[labels]` line records its
 labels, independently of the directory name. Only a label named in a rule
-places a file.
+places a file; a label named in no rule places nothing and is recorded for a
+reader.
+
+The labeler and organizer live in config: `organize.labeler` and
+`organize.organizer`. A label is a key and value the labeler attaches to a
+file. `git organize apply --labels-only` runs the labeler and records the
+labels. A file is out of place when its matching rule names a directory it
+is not in yet.
 
 `git organize status` reads `[labels]` and reports the out-of-place files,
 the backlog, a file in scope that `[labels]` does not record, and a
-recorded path that no longer exists. It runs nothing and
-changes nothing.
+recorded path that no longer exists. status runs no
+configured command and changes nothing.
 
 `git organize apply` reconciles the tree. It moves each out-of-place file
-into its directory. A move is a content-identical rename, so `git log
---follow` and `git blame` track the file exactly. apply stages the result
-and repoints each carved file's `[labels]` line to its new path, carrying
-its labels. It commits nothing. apply requires a clean worktree.
+into its directory. A move that git organize makes on its own is a
+content-identical rename, so `git log --follow` and `git blame` track the
+file exactly. apply stages the result and repoints each carved file's
+`[labels]` line to its new path, carrying its labels. It commits nothing.
+
+A move can require an edit elsewhere, such as repointing a reference in
+another file, or an edit to the moved file itself, such as repointing its
+own references. A project supplies those edits with an organizer, its
+`organize.organizer` command. apply hands the organizer its
+moves. The organizer returns a patch of the edits and, for any move it
+cannot complete, a reason to skip it. When the organizer edits a file as it
+moves, git's rename detection matches it while its similarity stays above
+the rename threshold. apply applies the moves and the patch as one
+transaction. With no organizer configured, apply moves the files and makes
+no other edit.
 
 
 COMMANDS
@@ -52,13 +71,59 @@ status::
 	Report the files whose placement value names a directory they are not
 	in (the moves), the backlog (recorded files with no matching
 	rule), a file in scope that `[labels]` does not record, and a recorded
-	path that no longer exists. Changes nothing.
+	path that no longer exists. Runs no configured
+	command and changes nothing.
 
 apply::
 	Move each out-of-place file into its directory as a content-identical
-	rename, repoint each carved file's `[labels]` line to its new path, and
-	stage the result. apply requires a clean worktree, so the change can be
-	discarded as a whole.
+	rename, apply the organizer's edits, repoint each carved file's
+	`[labels]` line to its new path, and stage the result. apply requires a
+	clean worktree, so the change can be discarded as a whole.
++
+With `--labels-only`, apply instead records the `[labels]` line for every root
+file in scope and stages the file. A file already recorded keeps its line, so a
+placement chosen by hand or in an earlier run stands; the labeler only seeds a
+file that has no line yet. With `--reseed`, re-derive every line from the
+labeler, discarding the recorded placements. This is the only path that runs a
+labeler; `git organize apply` without `--labels-only` and `git organize status`
+never do.
+
+
+OPTIONS
+-------
+
+--labels-only::
+	With apply, run the labeler and record the labels; move no file. A
+	recorded file keeps its line; the labeler only seeds a file that has no
+	line yet.
+
+--reseed::
+	With apply `--labels-only`, re-derive every `[labels]` line from the
+	labeler, discarding the recorded placements. Use it to re-apply the
+	labeler after its map changes; without it a recorded line is kept.
+
+
+CONFIGURATION
+-------------
+organize.labeler::
+	The command that records the labels. `git organize apply
+	--labels-only` runs it over the root files in scope. It writes one
+	record per file on its standard output: the path, a NUL, its
+	space-separated `key=value` labels, a NUL. A file in scope with no
+	record is unrecorded, reported apart from the backlog. Use user or
+	system config for this setting; do
+	not take it from a repository file.
+
+organize.organizer::
+	The command that returns move edits. apply runs it over the moves. It
+	reads the pending moves on its standard input and returns a patch and
+	any skip reasons; see PROTOCOL. Optional. Without it, apply performs the
+	moves and makes no other edit. Use user or system config for this
+	setting; do not take it from a repository file.
+
+The labeler and organizer are trusted, the way a clean or smudge filter or a
+hook is trusted. Set them in user or system config, so a repository you clone
+cannot supply its own.
 
 
 FILES
@@ -71,10 +136,23 @@ FILES
 	file takes the directory of the first rule its labels satisfy, and a
 	file matching no rule is the backlog. `[labels]` holds the recorded
 	labels, one `<path> <key>=<value> ...` line per source in scope,
-	including placed files. The project writes `[scope]` and `[layout]`; the
-	move apply repoints a carved file's line. A `#` line is a comment; git
-	organize rewrites the file whole, keeping the hand-authored `[scope]`
-	and `[layout]` verbatim.
+	including placed files. The project writes `[scope]` and `[layout]`;
+	`git organize apply --labels-only` writes `[labels]`, and the move apply
+	repoints a carved file's line. A `#` line is a comment; git organize
+	rewrites the file whole, keeping the hand-authored `[scope]` and
+	`[layout]` verbatim.
+
+
+PROTOCOL
+--------
+apply speaks a line protocol with the organizer over a pipe. It writes the
+version line `git-organize 1 organize`, then a `move <src> <dst> <label>`
+line per pending move, with C-quoted paths. The organizer replies with the
+same version line. For each declined move, it writes `reject <src>
+<reason>`. It may then write `patch`, followed by a git patch that runs to
+the end of its output. The patch may edit referring files and may rename a
+moved file as it edits it, but it must not add, delete, or copy files, and
+any rename must match a planned move.
 
 
 GIT
diff --git a/Makefile b/Makefile
index da7c4df7d3..86297e9459 100644
--- a/Makefile
+++ b/Makefile
@@ -1238,7 +1238,9 @@ LIB_OBJS += oidmap.o
 LIB_OBJS += oidset.o
 LIB_OBJS += oidtree.o
 LIB_OBJS += organize/gitorganize-format.o
+LIB_OBJS += organize/labeler-protocol.o
 LIB_OBJS += organize/organize.o
+LIB_OBJS += organize/organizer-protocol.o
 LIB_OBJS += pack-bitmap-write.o
 LIB_OBJS += pack-bitmap.o
 LIB_OBJS += pack-check.o
diff --git a/builtin/organize.c b/builtin/organize.c
index 9462d8687f..354ba2151f 100644
--- a/builtin/organize.c
+++ b/builtin/organize.c
@@ -5,7 +5,8 @@
  * status reports the files in scope whose matching rule names a directory they
  * are not in yet (the moves), the backlog (files with no matching rule), and a
  * declared path that no longer exists. apply moves the misplaced files and
- * stages the result.
+ * stages the result; apply --labels-only instead runs the labeler and records
+ * the labels.
  */
 #include "builtin.h"
 #include "gettext.h"
@@ -16,6 +17,7 @@
 static const char *const organize_usage[] = {
 	"git organize status",
 	"git organize apply",
+	"git organize apply --labels-only [--reseed]",
 	NULL
 };
 
@@ -71,6 +73,7 @@ static int organize_status(struct repository *repo)
 static int organize_apply(struct repository *repo)
 {
 	struct organize_plan plan = ORGANIZE_PLAN_INIT;
+	int moved = 0, rejected = 0;
 
 	organize_plan_build(repo, &plan);
 	if (!plan.moves_nr) {
@@ -81,7 +84,17 @@ static int organize_apply(struct repository *repo)
 
 	organize_plan_apply(repo, &plan);
 
-	printf(_("organize apply: %d move(s).\n"), (int)plan.moves_nr);
+	for (size_t i = 0; i < plan.moves_nr; i++) {
+		if (plan.moves[i].skip_reason)
+			rejected++;
+		else
+			moved++;
+	}
+	printf(_("organize apply: %d move(s), %d skipped.\n"), moved, rejected);
+	for (size_t i = 0; i < plan.moves_nr; i++)
+		if (plan.moves[i].skip_reason)
+			printf("  skipped %-28s %s\n", plan.moves[i].src,
+			       plan.moves[i].skip_reason);
 	printf(_("organize apply: the result is staged; nothing is committed.\n"));
 
 	organize_plan_release(&plan);
@@ -93,18 +106,39 @@ int cmd_organize(int argc,
 		 const char *prefix,
 		 struct repository *repo)
 {
+	int labels_only = 0, reseed = 0;
 	struct option options[] = {
+		OPT_BOOL(0, "labels-only", &labels_only,
+			 N_("with apply, run the labeler and record the labels")),
+		OPT_BOOL(0, "reseed", &reseed,
+			 N_("with apply --labels-only, re-derive every recorded label")),
 		OPT_END()
 	};
 	const char *subcmd;
+	int ret;
 
 	argc = parse_options(argc, argv, prefix, options, organize_usage, 0);
 	subcmd = argc ? argv[0] : "status";
 	if (argc > 1)
 		die(_("git organize: too many arguments"));
-	if (!strcmp(subcmd, "status"))
-		return organize_status(repo);
-	else if (!strcmp(subcmd, "apply"))
-		return organize_apply(repo);
-	die(_("git organize: unknown subcommand '%s'"), subcmd);
+	if (reseed && !labels_only)
+		die(_("git organize: --reseed is a --labels-only option"));
+	if (!strcmp(subcmd, "status")) {
+		if (labels_only)
+			die(_("git organize: --labels-only is an apply option"));
+		ret = organize_status(repo);
+	} else if (!strcmp(subcmd, "apply")) {
+		if (labels_only) {
+			organize_run_labeler(repo, reseed);
+			printf(_("organize apply --labels-only: the declaration is "
+				 "staged; nothing is committed.\n"));
+			ret = 0;
+		} else {
+			ret = organize_apply(repo);
+		}
+	} else {
+		die(_("git organize: unknown subcommand '%s'"), subcmd);
+	}
+
+	return ret;
 }
diff --git a/contrib/organize/git-layout.map b/contrib/organize/git-layout.map
new file mode 100644
index 0000000000..580d556b92
--- /dev/null
+++ b/contrib/organize/git-layout.map
@@ -0,0 +1,41 @@
+# Git component layout for the reference labeler, in two sections.
+#
+# [tokens] lists, per component directory, the commit-subject prefix tokens
+# that belong to it. A file is placed by the "area:" prefix its own commits
+# carry most often, mined with git log --follow. The area its authors name need
+# not be its filename (ws.c files under whitespace, diffcore-pickaxe.c under
+# pickaxe). The fine tokens consolidate into a component; that consolidation is
+# the project knowledge a mechanical pass cannot supply.
+#
+# [names] lists the filename token, the name before the first hyphen. A file
+# whose dominant prefix is a broad area name that also swept its neighbors
+# (commit, config, refs, ...), or whose commits name no area, is placed by
+# its filename instead. Program sources stay at the root.
+[tokens]
+odb: blob commit-slab fsck hash loose match-trees object object-file object-file-convert object-name odb oidmap oidset oidtree replace-object replace_object sha1-array sha1-lookup sha1_name tag tmp-objdir tree tree-walk
+refs: ls-refs pack-refs ref-filter reflog reflog-walk refspec worktree
+pack: bloom chunk-format commit-graph delta-islands diff-delta midx pack-bitmap pack-bitmap-write pack-check pack-mtimes pack-objects pack-revindex pack-write packfile patch-delta prune prune-packed pseudo-merge reachable repack repack-promisor server-info
+diff: combine-diff diff diff-merges diffcore-break diffcore-delta diffcore-order diffcore-rename patch-ids pickaxe range-diff tree-diff userdiff xdiff-interface
+merge: fmt-merge-msg ll-merge merge merge-blobs merge-ort rerere
+revision: bisect blame commit-reach decorate format-patch graph line-log line-range list list-objects list-objects-filter list-objects-filter-options pretty revision shallow
+index: cache-tree checkout dir dir-iterator entry fsmonitor fsmonitor--daemon fsmonitor-ll fsmonitor-settings name-hash parallel-checkout pathspec preload-index read-cache resolve-undo sparse-index split-index statinfo symlinks unpack-trees wt-status
+setup: alias hook ident repository setup version
+convert: attr convert whitespace
+transport: bundle bundle-uri cat-file connect connected fetch-negotiator fetch-pack http pkt-line promisor-remote protocol protocol-caps remote remote-curl send-pack serve sideband transport transport-helper upload-pack walker
+notes: notes notes-cache notes-merge
+submodule: submodule submodule-config
+archive: archive archive-tar archive-zip
+[names]
+odb: object odb oid oidmap oidset oidtree loose blob tag commit tree replace match tmp fsck hash sha1dc streaming
+refs: refs refspec reflog ref ls worktree
+pack: pack packfile midx delta prune reachable server bloom chunk pseudo repack
+diff: diff diffcore combine range userdiff xdiff patch pickaxe
+merge: merge rerere fmt
+revision: revision log bisect shallow blame line graph decorate list pretty
+index: read cache split sparse unpack name preload resolve statinfo entry parallel dir pathspec checkout symlinks fsmonitor wt
+setup: config setup environment repository repo ident alias version hook
+convert: attr convert ws whitespace
+transport: transport remote connect connected send fetch upload walker http protocol serve pkt sideband bundle promisor
+notes: notes
+submodule: submodule
+archive: archive
diff --git a/contrib/organize/labeler b/contrib/organize/labeler
new file mode 100755
index 0000000000..2116015f2d
--- /dev/null
+++ b/contrib/organize/labeler
@@ -0,0 +1,333 @@
+#!/usr/bin/perl
+# Reference labeler for git organize(1). This is a demonstration; a real
+# project supplies its own.
+#
+# git organize keeps the root *.c and *.h sources in scope. The labeler prints
+# one NUL-terminated label record per file,
+#
+#     <path> \0 component=<dir> role=<role> prefix=<token> \
+#               includes=<c>:<n>,... cochange=<c>:<n>,... \0
+#
+# component names the directory to move the file into. component and role are
+# the labels git organize acts on. prefix, includes, and cochange are advisory
+# signals the labeler records for a human to read.
+#
+# COMPONENT. The labeler names each file's component from the "area:" prefix its
+# own commits carry most often, mined with `git log --follow` over the file's
+# whole history. The area its authors name need not match its filename: ws.c
+# goes under whitespace, diffcore-pickaxe.c under pickaxe. The [tokens] section
+# of git-layout.map maps the fine prefix tokens to component directories. When a
+# file's dominant prefix is a broad area name that also swept its neighbors
+# (commit, config, refs, ...), or its commits name no area, the labeler falls
+# back to the file's name through the [names] section.
+# When neither section names a component, the labeler applies a co-change test:
+# a file that changes chiefly alongside one component moves there, and any other
+# file gets component=? (backlog). Programs (Makefile PROGRAM_OBJS) stay at the
+# root.
+#
+# ADVISORY. prefix is the dominant token itself. includes is the file's #include
+# coupling, each included in-scope header bucketed by its component. cochange
+# is the components the file co-changes with, mined from focused commits (<= 25
+# files). includes and cochange list the strongest components first, capped at
+# five. A human reads them to see where a file couples and whether git-layout.map
+# named a different component than a raw signal would.
+#
+# Usage:
+#     labeler                the label records on stdout
+
+use strict;
+use warnings;
+use File::Temp qw(tempdir);
+use POSIX ();
+
+my $CAP = 5;			# most-coupled components kept in an advisory list
+
+my $top = `git rev-parse --show-toplevel`;
+chomp $top;
+chdir $top or die "organize labeler: cannot cd to $top: $!\n";
+(my $here = $0) =~ s{/[^/]*$}{};
+my $mapfile = "$here/git-layout.map";
+
+# git-layout.map: [tokens] maps a commit-prefix token to its component, [names]
+# maps a filename token to its component.
+my (%tok_dir, %name_dir, $section);
+open my $map, '<', $mapfile or die "organize labeler: cannot read $mapfile: $!\n";
+while (<$map>) {
+	next if /^#/;
+	if (/^\[(\w+)\]\s*$/) { $section = $1; next; }
+	next unless /:/;
+	my ($dir, $tokens) = split /:/, $_, 2;
+	my $into = $section eq 'tokens' ? \%tok_dir : \%name_dir;
+	$into->{$_} = $dir for split ' ', $tokens;
+}
+close $map;
+
+# The standalone programs, from the Makefile.
+my %is_program;
+open my $mk, '<', 'Makefile' or die "organize labeler: cannot read Makefile: $!\n";
+while (<$mk>) {
+	$is_program{"$1.c"} = 1 if /^\s*PROGRAM_OBJS\s*\+?=\s*(\S+)\.o/;
+}
+close $mk;
+
+# Prefix tokens that name no area: mass-change and non-source markers. The
+# labeler ignores a commit subject led by one of these when tallying components.
+my %noise = map { $_ => 1 } qw(
+	treewide cocci coccinelle comments comment makefile doc docs
+	documentation style cleanup misc various global build ci test tests
+	config.mak wildmatch);
+
+# The name of a file with its extension and directory removed, lowercased.
+sub stem {
+	my ($p) = @_;
+	$p =~ s{.*/}{};
+	$p =~ s/\.[ch]$//;
+	return lc $p;
+}
+
+# The filename token: the stem up to its first hyphen (object-file -> object).
+sub name_token {
+	my ($s) = @_;
+	$s =~ s/-.*//;
+	return $s;
+}
+
+# A prefix token with a file-suffix variant folded to its base (commit.c and
+# serve.[ch] -> commit and serve), lowercased and trimmed.
+sub normalize {
+	my ($t) = @_;
+	$t = lc $t;
+	$t =~ s/^\s+//;
+	$t =~ s/\s+$//;
+	$t =~ s/\*?\.\[ch\]$//;
+	$t =~ s/\*?\.[ch]$//;
+	$t =~ s/\*?\.py$//;
+	return $t;
+}
+
+sub is_noise {
+	my ($t) = @_;
+	return 1 if $t eq '';
+	return 1 if $t =~ m{[ ,\[\]{}()*/'"]};
+	return 1 if $noise{$t};
+	return 0;
+}
+
+# The token matches the file's name: it is the stem, an extension of it, or a
+# hyphen-prefix of it. Used only to break a tie between equally frequent tokens.
+sub affinity {
+	my ($t, $s) = @_;
+	return 1 if $t eq $s;
+	return 1 if index($s, "$t-") == 0;
+	return 1 if index($t, $s) == 0;
+	return 0;
+}
+
+# The commit-prefix token a file's history carries most often, or undef when its
+# history names no area. Ties break toward a token that matches the file's name,
+# then by name.
+sub dominant_prefix {
+	my ($file) = @_;
+	my $s = stem($file);
+	my %count;
+	for my $subject (split /\n/, `git log --follow --no-merges --format=%s -- "$file"`) {
+		my $i = index($subject, ':');
+		next if $i <= 0;
+		my $t = normalize(substr($subject, 0, $i));
+		next if is_noise($t);
+		$count{$t} += 1;
+	}
+	return undef unless %count;
+	my @ranked = sort {
+		$count{$b} <=> $count{$a}
+			or affinity($b, $s) <=> affinity($a, $s)
+			or $a cmp $b
+	} keys %count;
+	return $ranked[0];
+}
+
+# The component and dominant prefix for a file: the component from the prefix
+# token via [tokens], else from the filename token via [names], else the
+# backlog. Programs stay at the root. Kept side-effect free so a worker process
+# can call it (see pass 1).
+sub classify {
+	my ($file) = @_;
+	my $p = dominant_prefix($file);
+	my $prefix = defined $p ? $p : '?';
+	return ('?', $prefix) if $is_program{$file};
+	return ($tok_dir{$p}, $prefix) if defined $p && exists $tok_dir{$p};
+	my $d = $name_dir{ name_token(stem($file)) };
+	return (defined $d ? $d : '?', $prefix);
+}
+
+# Pass 1: name the component for every scoped file, recording its component and
+# dominant prefix. The `git log --follow` mining dominates the run, so fan the
+# files across a pool of worker processes (ORGANIZE_JOBS, default the CPU count).
+# Each worker writes "path<TAB>component<TAB>prefix" for its share, and the
+# parent reads them back.
+my (%component, %prefix);
+my @files = grep { length } (split(/\n/, `git ls-files ':(glob)*.c'`),
+			     split(/\n/, `git ls-files ':(glob)*.h'`));
+{
+	my $jobs = $ENV{ORGANIZE_JOBS};
+	if (!$jobs) { chomp($jobs = `nproc 2>/dev/null`); $jobs ||= 4; }
+	$jobs = scalar(@files) if @files && $jobs > @files;
+	$jobs = 1 if $jobs < 1;
+	my $dir = tempdir(CLEANUP => 1);
+	my @pids;
+	for my $j (0 .. $jobs - 1) {
+		my $pid = fork();
+		die "organize labeler: cannot fork: $!\n" unless defined $pid;
+		if (!$pid) {
+			open my $out, '>', "$dir/$j" or POSIX::_exit(1);
+			my $n = 0;
+			for (my $i = $j; $i < @files; $i += $jobs) {
+				my ($c, $p) = classify($files[$i]);
+				print {$out} "$files[$i]\t$c\t$p\n";
+				$n++;
+			}
+			# Write a trailing sentinel line to prove the worker ran
+			# to the end. A worker that dies mid-run leaves a
+			# truncated file with no sentinel, which the parent
+			# rejects rather than read as a short but valid share.
+			# The parent matches this exact line, "# done <count>";
+			# a record line is TAB-separated, so it cannot collide.
+			print {$out} "# done $n\n";
+			close $out or POSIX::_exit(1);
+			POSIX::_exit(0);	# skip END/DESTROY so the tempdir survives
+		}
+		push @pids, $pid;
+	}
+	for my $pid (@pids) {
+		waitpid($pid, 0);
+		die "organize labeler: a worker failed\n" if $?;
+	}
+	for my $j (0 .. $jobs - 1) {
+		open my $in, '<', "$dir/$j"
+			or die "organize labeler: worker $j left no output\n";
+		my $sentinel = 0;
+		while (<$in>) {
+			chomp;
+			if (/^# done [0-9]+$/) { $sentinel = 1; next; }
+			my ($f, $c, $p) = split /\t/, $_, 3;
+			$component{$f} = $c;
+			$prefix{$f} = $p;
+		}
+		close $in;
+		die "organize labeler: worker $j left truncated output\n"
+			unless $sentinel;
+	}
+}
+
+# Pass 2a: the #include coupling profile, each included in-scope header
+# bucketed by its component.
+sub includes_profile {
+	my ($file) = @_;
+	open my $fh, '<', $file or return {};
+	my %prof;
+	while (<$fh>) {
+		next unless /^\s*#\s*include\s*"([^"]+)"/;
+		(my $inc = $1) =~ s{.*/}{};	# includes name the header directly
+		my $c = $component{$inc};
+		$prof{$c}++ if defined $c && $c ne '?';
+	}
+	close $fh;
+	return \%prof;
+}
+
+# Pass 2b: the co-change profile. A focused commit (<= 25 files) ties every pair
+# of files it touches; tally each file's scoped neighbors by their component.
+my %cochange;
+{
+	my @batch;
+	my $flush = sub {
+		return if @batch > 25;
+		my @scoped = grep { exists $component{$_} } @batch;
+		return if @scoped < 2;
+		for my $f (@scoped) {
+			for my $g (@scoped) {
+				next if $g eq $f;
+				my $c = $component{$g};
+				$cochange{$f}{$c}++ if $c ne '?';
+			}
+		}
+	};
+	open my $log, '-|', qw(git log --no-merges --format=%x01 --name-only)
+		or die "organize labeler: cannot read the commit log: $!\n";
+	my $started = 0;
+	while (my $line = <$log>) {
+		chomp $line;
+		if ($line =~ /^\x01/) {
+			$flush->() if $started;
+			@batch = ();
+			$started = 1;
+		} elsif ($line ne '') {
+			push @batch, $line;
+		}
+	}
+	$flush->() if $started;
+	close $log;
+}
+
+# Pass 3: promote a backlog file whose co-change coupling concentrates on one
+# component. The prefix and name gave this file no component, but it co-changes
+# chiefly with a single component, and its #includes do not point elsewhere, so
+# the labeler moves it to that component. A file that couples broadly stays at
+# the root. A .c and its .h combine their coupling and take the same component,
+# so a pair moves as one. The thresholds keep only a concentrated signal with
+# enough evidence behind it (alloc and cbtree join odb, git-curl-compat joins
+# transport; csum-file and mem-pool stay at the root as too diffuse or too
+# sparse).
+my $PROMOTE_SHARE = 0.60;
+my $PROMOTE_COUNT = 15;
+{
+	my %pair;
+	for my $file (@files) {
+		next if $component{$file} ne '?' || $is_program{$file};
+		(my $stem = $file) =~ s/\.[ch]$//;
+		push @{$pair{$stem}}, $file;
+	}
+	my @promote;			# [ [files], component ], decided before applying
+	for my $stem (sort keys %pair) {
+		my (%co, %inc);
+		for my $file (@{$pair{$stem}}) {
+			$co{$_}  += $cochange{$file}{$_} for keys %{$cochange{$file} || {}};
+			my $ip = includes_profile($file);
+			$inc{$_} += $ip->{$_} for keys %$ip;
+		}
+		next unless %co;
+		my $total = 0; $total += $_ for values %co;
+		my ($top) = sort { $co{$b} <=> $co{$a} or $a cmp $b } keys %co;
+		next unless $co{$top} >= $PROMOTE_COUNT
+			 && $co{$top} / $total >= $PROMOTE_SHARE;
+		if (%inc) {		# an #include profile must not point elsewhere
+			my ($itop) = sort { $inc{$b} <=> $inc{$a} or $a cmp $b } keys %inc;
+			next unless $itop eq $top;
+		}
+		push @promote, [ $pair{$stem}, $top ];
+	}
+	for my $p (@promote) {
+		$component{$_} = $p->[1] for @{$p->[0]};
+	}
+}
+
+# A "c:n,c:n" advisory list: the strongest components first, capped at $CAP.
+sub advisory {
+	my ($prof) = @_;
+	my @c = sort { $prof->{$b} <=> $prof->{$a} or $a cmp $b } keys %$prof;
+	@c = @c[0 .. $CAP - 1] if @c > $CAP;
+	return join ',', map { "$_:$prof->{$_}" } @c;
+}
+
+for my $file (@files) {
+	my $c = $component{$file};
+	my $role = $is_program{$file} ? 'program'
+		 : $file =~ /\.h$/ ? ($c eq '?' ? 'public' : 'header')
+		 : 'lib';
+	my $rec = "component=$c role=$role prefix=$prefix{$file}";
+	my $inc = advisory(includes_profile($file));
+	my $cox = advisory($cochange{$file} || {});
+	$rec .= " includes=$inc" if length $inc;
+	$rec .= " cochange=$cox" if length $cox;
+	print "$file\0$rec\0";
+}
diff --git a/contrib/organize/organizer b/contrib/organize/organizer
new file mode 100755
index 0000000000..56c805301b
--- /dev/null
+++ b/contrib/organize/organizer
@@ -0,0 +1,334 @@
+#!/usr/bin/perl
+# Reference organizer for git organize(1). This is a demonstration; a real
+# project supplies its own.
+#
+# When a .c source moves into a component directory, its build object moves
+# with it; when a .h header moves, every #include of it must be repointed to
+# the new path (the Git build uses -I. only, so an include names the full path).
+# The organizer reads the pending moves and returns a patch that repoints
+# every reference the reorganization leaves stale across Git's build systems:
+#
+#   Makefile                 the moved object list (stem.o/.s/.sp) and any
+#                            bare source name in a list (LOCALIZED_C_CORE)
+#   meson.build              the moved source path
+#   Documentation/Makefile   a moved header named by a ../<name>.h argument
+#   contrib/buildsystems/CMakeLists.txt
+#                            a moved .c named bare or by ${CMAKE_SOURCE_DIR}/
+#   #include "foo.h"         -> #include "dir/foo.h" in every C includer
+#   Documentation/**/*.adoc  a tutorial #include "foo.h" example line
+#
+# An include may name the header bare or by a ../ path (from a subdirectory),
+# and may write "#include" or "# include"; the repoint names the full path,
+# which -I. resolves from any directory. An includer that itself moves is
+# renamed-with-modification (its rename plus the repoint); a stationary
+# includer is edited in place. The .adoc tutorials always name the full new
+# path, so their #include example lines are repointed unconditionally, without
+# the shadow/depth resolution a real C include needs.
+#
+# The organizer declines any move whose references it cannot repoint. It
+# repoints every #include in the tracked C sources and tutorials, except that
+# frozen test data under t/tNNNN/ is deliberately left alone: those files are
+# fixtures (for example a mailinfo.c that git am replays byte for byte), so an
+# apparent #include in them is data, not a reference to follow. Outside those
+# fixtures, the only reference it can miss is one in a build file. After it
+# edits the build files above, it rejects a move whose old path a build file
+# still names (in a build file it does not edit, or in a form its edit missed).
+# That file stays at the root with its references intact, and apply moves the
+# rest.
+#
+# The code runs in four phases:
+#   Phase 1  read the "move <src> <dst>" lines from stdin.
+#   Phase 2  edit the build files as if every move happened, then reject a
+#            move a build file still names (build_edits, names_missing_path).
+#   Phase 3  build the new content of every file the accepted moves change
+#            (build_edits, include_edits, adoc_edits).
+#   Phase 4  emit one diff per changed file: a stationary file in place, an
+#            includer that itself moves as a rename-with-modification.
+# Name matching lives in the boundary regexes ($LB, $LB_ROOT, $RB) and in
+# include_names_root.
+
+use strict;
+use warnings;
+use File::Temp qw(tempdir);
+
+my $protocol = "git-organize 1 organize";
+chomp(my $top = `git rev-parse --show-toplevel`);
+chdir $top or die "organize organizer: cannot cd to $top: $!\n";
+
+sub unquote {
+	my ($s) = @_;
+	return $s unless $s =~ /\A"(.*)"\z/s;
+	my $body = $1;
+	my %esc = (a=>"\a", b=>"\b", t=>"\t", n=>"\n", v=>"\013",
+		f=>"\f", r=>"\r", '"'=>'"', '\\'=>'\\');
+	$body =~ s{\\([0-7]{1,3}|.)}
+		{ exists $esc{$1} ? $esc{$1} : $1 =~ /\A[0-7]/ ? chr(oct $1) : $1 }ges;
+	return $body;
+}
+sub shift_token {
+	$_[0] =~ s/\A\s+//;
+	my $tok = $_[0] =~ s/\A("(?:\\.|[^"\\])*")// ? $1 : $_[0] =~ s/\A(\S+)// ? $1
+		: die "organize organizer: malformed move line\n";
+	return unquote($tok);
+}
+sub slurp { open my $fh,'<',$_[0] or die "cannot read $_[0]: $!\n"; local $/; <$fh> }
+
+# Boundary vocabulary. A moved name matches only as a whole path component, so
+# remote.c never matches inside ls-remote.c and a subdirectory sibling
+# (builtin/remote.c) keeps its prefix and stays. Every name match below flanks
+# the name with these boundaries:
+#   $LB       left: not preceded by a name character
+#   $LB_ROOT  left, root only: also not preceded by a path separator
+#   $RB       right: the name token ends here
+#   $DIRS     an optional ../ and directory prefix before a name
+my $LB      = qr/(?<![A-Za-z0-9_.\-])/;
+my $LB_ROOT = qr/(?<![A-Za-z0-9_.\-\/])/;
+my $RB      = qr/(?![A-Za-z0-9])/;
+my $DIRS    = qr/(?:\.\.?\/)*(?:[A-Za-z0-9_.\-]+\/)*/;
+# bare_re: a bare root name, at a hard left boundary with no path separator, so
+# a subdir sibling (builtin/remote.c) keeps its prefix and stays.
+sub bare_re { my ($name) = @_; qr/$LB_ROOT\Q$name\E$RB/ }
+# cmake_re: a root .c named bare or as ${CMAKE_SOURCE_DIR}/<name> (captured in
+# $1). The name follows the CMAKE variable slash or a hard boundary, never a
+# real subdirectory component, so a nested source (compat/win32/headless.c)
+# stays.
+sub cmake_re {
+	my ($name) = @_;
+	qr/$LB(?:(\$\{CMAKE_SOURCE_DIR\}\/)|$LB_ROOT)\Q$name\E$RB/;
+}
+
+# === Phase 1: read the pending moves ===
+my @moves;
+while (my $line = <STDIN>) {
+	next unless $line =~ s/\Amove //;
+	my $src = shift_token($line); my $dst = shift_token($line);
+	push @moves, [$src, $dst];
+}
+
+# The build files the organizer edits. A moved .c is a build object (Makefile /
+# meson) and may also appear as a bare source name in a Makefile list and as a
+# path in the contrib CMake build. A moved .h is named by a ../ argument in
+# Documentation/Makefile. An absent build file is skipped.
+my @buildfiles = ('Makefile', 'meson.build',
+	'Documentation/Makefile', 'contrib/buildsystems/CMakeLists.txt');
+
+# Edit the build files for the given moves, returning path -> edited content
+# (undef for an absent file).
+sub build_edits {
+	my ($moves) = @_;
+	my %build = map { $_ => (-e $_ ? slurp($_) : undef) } @buildfiles;
+	for my $m (@$moves) {
+		my ($src, $dst) = @$m;
+		(my $stem = $src) =~ s/\.[ch]\z//;
+		(my $dir = $dst) =~ s{/[^/]*\z}{};
+		# A ../ argument in Documentation/Makefile names a moved header
+		# (../fsck.h feeds lint-fsck-msgids.perl). The ../ steps out of
+		# Documentation/ to the root, so ../<dst> names the new path.
+		if ($src !~ /\.c\z/) {
+			my $mk = 'Documentation/Makefile';
+			$build{$mk} =~ s{$LB\.\./\Q$src\E$RB}{../$dst}g
+				if defined $build{$mk};
+			next;
+		}
+		# A moved .c: Makefile object (stem.o/.s/.sp) and meson path.
+		$build{'Makefile'} =~ s{(^|\s)\Q$stem\E\.(sp|s|o)$RB}{$1$dir/$stem.$2}mg
+			if defined $build{'Makefile'};
+		$build{'meson.build'} =~ s{'\Q$src\E'}{'$dst'}g
+			if defined $build{'meson.build'};
+		# A bare source name in a Makefile list (LOCALIZED_C_CORE).
+		if (defined $build{'Makefile'}) {
+			my $re = bare_re($src);
+			$build{'Makefile'} =~ s{$re}{$dst}g;
+		}
+		# The contrib CMake names a .c bare or by ${CMAKE_SOURCE_DIR}/.
+		if (defined $build{'contrib/buildsystems/CMakeLists.txt'}) {
+			my $re = cmake_re($src);
+			$build{'contrib/buildsystems/CMakeLists.txt'} =~
+				s{$re}{($1 // '') . $dst}ge;
+		}
+	}
+	return \%build;
+}
+
+# The paths that exist once every move is made: the tracked files, less each
+# old path, plus each new path.
+my %exists = map { $_ => 1 } split /\n/, `git ls-files`;
+for my $m (@moves) { delete $exists{$m->[0]}; $exists{$m->[1]} = 1; }
+
+# A referenced path token, normalized to a repository-relative path.
+sub norm_ref {
+	my ($t) = @_;
+	while ($t =~ m{\A\.\.?/}) { $t =~ s{\A[^/]*/}{}; }
+	$t =~ s{\A/+}{};
+	return $t;
+}
+# Whether a build file's content still names $old at a path that will not exist
+# once the moves are made. A comment names a file rather than a rule, so it is
+# skipped.
+sub names_missing_path {
+	my ($content, $old) = @_;
+	(my $base = $old) =~ s{.*/}{};
+	for my $line (split /\n/, $content) {
+		next if $line =~ /\A\s*#/;
+		while ($line =~ /$LB($DIRS)\Q$base\E$RB/g) {
+			return 1 unless $exists{norm_ref($1 . $base)};
+		}
+	}
+	return 0;
+}
+
+# === Phase 2: decide the rejects (completeness contract) ===
+# Edit the build files as if every move happened, then a move whose old path a
+# build file still names is one the organizer cannot fully repoint. The search
+# covers the edited build files and every other build file in the tree.
+my $build_for_rejects = build_edits(\@moves);
+my @rejects;
+for my $m (@moves) {
+	my ($src) = @$m;
+	(my $base = $src) =~ s{.*/}{};
+	my $grep = "git grep -lF -e '$base' --"
+		. " '*Makefile' '*.mak' '*meson.build' '*CMakeLists.txt'"
+		. " 'config.mak*' 2>/dev/null";
+	my @files = grep { length } split /\n/, `$grep`;
+	for my $f (@files) {
+		my $edited = $build_for_rejects->{$f};
+		my $content = defined $edited ? $edited : slurp($f);
+		if (names_missing_path($content, $src)) {
+			push @rejects, [$src, "a build file names it and the "
+				. "organizer cannot repoint that reference"];
+			last;
+		}
+	}
+}
+
+my %rejected = map { $_->[0] => 1 } @rejects;
+my @accepted = grep { !$rejected{$_->[0]} } @moves;
+my %dst_of = map { $_->[0] => $_->[1] } @accepted;
+
+# Whether a #include names the moved ROOT header rather than a same-named header
+# in the includer's own directory. A ../ include names the root only when its
+# ../ count matches the includer's depth (one ../ from a depth-1 file reaches
+# the root). A bare include names the root unless a sibling header in the
+# includer's own directory shadows it (reftable/tree.h shadows a root tree.h).
+sub include_names_root {
+	my ($dots, $depth, $fdir, $src) = @_;
+	my $up = $dots =~ tr{/}{};
+	return $up == $depth if $up;
+	return $depth == 0 || !(-e "$fdir/$src");
+}
+
+# For each accepted header move, repoint #include "foo.h" (bare or ../ path) to
+# the full new path in every C includer, keeping an include that resolves to a
+# shadowing local header (per include_names_root) unchanged. Returns includer
+# path -> edited content.
+sub include_edits {
+	my ($moves) = @_;
+	my %repoint;   # includer -> list of [src, dst]
+	for my $m (@$moves) {
+		my ($src, $dst) = @$m;
+		next unless $src =~ /\.h\z/;
+		(my $re = $src) =~ s/\./\\./g;
+		my $pat = '#[[:blank:]]*include[[:blank:]]*"(\.\./)*' . $re . '"';
+		my $grep = "git grep -lE '$pat' --"
+			. " '*.c' '*.h' ':(exclude)t/t[0-9][0-9][0-9][0-9]/**'";
+		for my $inc (split /\n/, `$grep`) {
+			push @{$repoint{$inc}}, [$src, $dst];
+		}
+	}
+	my %edited;
+	for my $f (keys %repoint) {
+		my $text = slurp($f);
+		(my $fdir = $f) =~ s{/?[^/]*\z}{};
+		my $depth = $fdir eq '' ? 0 : 1 + ($fdir =~ tr{/}{});
+		for my $e (@{$repoint{$f}}) {
+			my ($src, $dst) = @$e;
+			$text =~ s{^(\h*#\h*include\h*")((?:\.\./)*)\Q$src\E(")}{
+				include_names_root($2, $depth, $fdir, $src)
+					? "$1$dst$3" : "$1$2$src$3"
+			}egm;
+		}
+		$edited{$f} = $text;
+	}
+	return \%edited;
+}
+
+# For each accepted header move, repoint the tutorial #include "foo.h" example
+# lines. A tutorial always names the full new path, so the repoint is
+# unconditional (no shadow/depth resolution) and matches the #include anywhere
+# in the line, at the start of a code block or in backticks mid-prose. Only the
+# quoted path changes; the #include spelling is left as written. Returns
+# tutorial path -> edited content.
+sub adoc_edits {
+	my ($moves) = @_;
+	my %repoint;   # tutorial -> list of [src, dst]
+	for my $m (@$moves) {
+		my ($src, $dst) = @$m;
+		next unless $src =~ /\.h\z/;
+		(my $re = $src) =~ s/\./\\./g;
+		my $apat = '#[[:blank:]]*include[[:blank:]]*"' . $re . '"';
+		my $grep = "git grep -lE '$apat' --"
+			. " 'Documentation/*.adoc' 'Documentation/**/*.adoc'"
+			. " ':(exclude)t/t[0-9][0-9][0-9][0-9]/**'";
+		for my $doc (split /\n/, `$grep`) {
+			push @{$repoint{$doc}}, [$src, $dst];
+		}
+	}
+	my %edited;
+	for my $f (keys %repoint) {
+		my $text = slurp($f);
+		for my $e (@{$repoint{$f}}) {
+			my ($src, $dst) = @$e;
+			$text =~ s{(#\h*include\h*")\Q$src\E(")}{$1$dst$2}g;
+		}
+		$edited{$f} = $text;
+	}
+	return \%edited;
+}
+
+# === Phase 3: collect the edits over the accepted moves ===
+# A rejected move stays at the root, so its build references, includers, and
+# tutorials keep naming it unchanged.
+my $build = build_edits(\@accepted);
+my $includers = include_edits(\@accepted);
+my $tutorials = adoc_edits(\@accepted);
+
+# === Phase 4: emit the patch ===
+my $tmp = tempdir(CLEANUP => 1);
+# hunk body (from the first @@) of a diff between $orig and the edited $text
+sub hunk {
+	my ($orig, $text) = @_;
+	open my $o, '>', "$tmp/e" or die; print {$o} $text; close $o;
+	my $d = `git diff --no-index -- "$orig" "$tmp/e"`;
+	my $i = index($d, "\n\@\@");
+	return $i < 0 ? '' : substr($d, $i + 1);
+}
+# A file's diff for the emitted patch: a plain hunk when $from and $to match, a
+# rename-with-modification when they differ. An empty $hunk yields no diff.
+sub diff_hunk {
+	my ($from, $to, $hunk) = @_;
+	return '' unless length $hunk;
+	my $out = "diff --git a/$from b/$to\n";
+	$out .= "rename from $from\nrename to $to\n" if $from ne $to;
+	return $out . "--- a/$from\n+++ b/$to\n$hunk";
+}
+
+# One diff per edited file, in a fixed order: build files, then includers, then
+# tutorials. A build file and a tutorial stay in place; an includer that itself
+# moves is a rename-with-modification (its new path is $dst_of{$f}).
+my $patch = '';
+for my $f (@buildfiles) {
+	next unless defined $build->{$f};
+	my $orig = slurp($f);
+	next if $build->{$f} eq $orig;
+	$patch .= diff_hunk($f, $f, hunk($f, $build->{$f}));
+}
+for my $f (sort keys %$includers) {
+	$patch .= diff_hunk($f, $dst_of{$f} // $f, hunk($f, $includers->{$f}));
+}
+for my $f (sort keys %$tutorials) {
+	$patch .= diff_hunk($f, $f, hunk($f, $tutorials->{$f}));
+}
+
+print "$protocol\n";
+print "reject $_->[0] $_->[1]\n" for @rejects;
+if (length $patch) { print "patch\n"; print $patch; }
diff --git a/meson.build b/meson.build
index a2d987b124..38ec7d4f40 100644
--- a/meson.build
+++ b/meson.build
@@ -443,7 +443,9 @@ libgit_sources = [
   'oidset.c',
   'oidtree.c',
   'organize/gitorganize-format.c',
+  'organize/labeler-protocol.c',
   'organize/organize.c',
+  'organize/organizer-protocol.c',
   'pack-bitmap-write.c',
   'pack-bitmap.c',
   'pack-check.c',
diff --git a/organize/gitorganize-format.c b/organize/gitorganize-format.c
index cdade12f5b..541dd373aa 100644
--- a/organize/gitorganize-format.c
+++ b/organize/gitorganize-format.c
@@ -246,6 +246,11 @@ void gitorganize_write(struct gitorganize *g)
 	else
 		strbuf_addstr(&out, "[layout]\n");
 	strbuf_addstr(&out, "[labels]\n");
+	strbuf_addstr(&out,
+		      "# The recorded placement of each source; edit a line to "
+		      "change it.\n"
+		      "# apply --labels-only fills in unrecorded sources; "
+		      "--reseed re-derives all.\n");
 	for (size_t i = 0; i < g->records.nr; i++) {
 		const char *labels = g->records.items[i].util;
 
diff --git a/organize/labeler-protocol.c b/organize/labeler-protocol.c
new file mode 100644
index 0000000000..6541412c18
--- /dev/null
+++ b/organize/labeler-protocol.c
@@ -0,0 +1,52 @@
+#include "git-compat-util.h"
+#include "labeler-protocol.h"
+#include "gettext.h"
+#include "run-command.h"
+#include "strbuf.h"
+#include "string-list.h"
+#include "strvec.h"
+#include "wrapper.h"
+
+/*
+ * Run the labeler and record, in `labeled` (path -> its "k=value k=value" string in
+ * util), each scoped_files file it labels. The labeler writes `path \0 labels \0`
+ * per file, where labels is its space-separated key=value labels.
+ */
+void run_labeler(const char *cmd, struct string_list *scoped_files,
+		 struct string_list *labeled)
+{
+	struct child_process cp = CHILD_PROCESS_INIT;
+	struct strbuf out = STRBUF_INIT;
+	const char *p, *end;
+
+	strvec_push(&cp.args, cmd);
+	cp.use_shell = 1;
+	if (capture_command(&cp, &out, 0))
+		die(_("organize apply --labels-only: labeler failed: %s"), cmd);
+
+	p = out.buf;
+	end = out.buf + out.len;
+	while (p < end) {
+		const char *path = p;
+		const char *labels;
+
+		p += strlen(p) + 1;
+		if (p > end)
+			die(_("organize apply --labels-only: truncated labeler record"));
+		labels = p;
+		p += strlen(p) + 1;
+		if (p > end)
+			die(_("organize apply --labels-only: truncated labeler record"));
+		if (strchr(labels, '\n'))
+			die(_("organize apply --labels-only: a label must not "
+			      "contain a newline: %s"), path);
+
+		if (!string_list_has_string(scoped_files, path))
+			continue;	/* not a scoped_files file */
+		if (string_list_has_string(labeled, path))
+			die(_("organize: duplicate labeler record for '%s'"),
+			    path);
+		string_list_insert(labeled, path)->util = xstrdup(labels);
+	}
+	strbuf_release(&out);
+}
diff --git a/organize/labeler-protocol.h b/organize/labeler-protocol.h
new file mode 100644
index 0000000000..0c2ea01686
--- /dev/null
+++ b/organize/labeler-protocol.h
@@ -0,0 +1,15 @@
+#ifndef LABELER_PROTOCOL_H
+#define LABELER_PROTOCOL_H
+
+struct string_list;
+
+/*
+ * The labeler protocol. git organize runs the configured labeler and
+ * records, in `labeled` (path -> its "k=value ..." string in util), the
+ * labels it returns for every file in `scoped_files`. The labeler writes one
+ * `path \0 labels \0` record per file.
+ */
+void run_labeler(const char *cmd, struct string_list *scoped_files,
+		 struct string_list *labeled);
+
+#endif /* LABELER_PROTOCOL_H */
diff --git a/organize/organize.c b/organize/organize.c
index 0d9850dfc0..8c623444c0 100644
--- a/organize/organize.c
+++ b/organize/organize.c
@@ -1,6 +1,9 @@
 #include "git-compat-util.h"
 #include "organize.h"
 #include "gitorganize-format.h"
+#include "labeler-protocol.h"
+#include "organizer-protocol.h"
+#include "config.h"
 #include "gettext.h"
 #include "pathspec.h"
 #include "quote.h"
@@ -13,6 +16,19 @@
 #include "wrapper.h"
 #include "wt-status.h"
 
+/* The configured command organize.<key> (labeler or organizer), or NULL. */
+static const char *organize_command(struct repository *repo, const char *key)
+{
+	struct strbuf k = STRBUF_INIT;
+	const char *cmd;
+
+	strbuf_addf(&k, "organize.%s", key);
+	if (repo_config_get_string_tmp(repo, k.buf, &cmd))
+		cmd = NULL;
+	strbuf_release(&k);
+	return cmd;
+}
+
 /*
  * The [layout] rule whose directory equals `path`'s directory, or NULL when
  * `path` is a root file or its directory matches no rule. A file in a [layout]
@@ -114,6 +130,7 @@ static void add_move(struct organize_plan *plan, const char *src,
 	m->src = xstrdup(src);
 	m->dst = dst;
 	m->rule_value = xstrdup(value);
+	m->skip_reason = NULL;
 }
 
 void organize_plan_build(struct repository *repo, struct organize_plan *plan)
@@ -202,25 +219,66 @@ static int worktree_dirty(struct repository *repo)
 	return has_unstaged_changes(repo, 0) || has_uncommitted_changes(repo, 0);
 }
 
-/* Map each move's src to its dst, in `dst_of`. */
+/* Map each standing (non-rejected) move's src to its dst, in `dst_of`. */
 static void plan_dst_map(struct organize_plan *plan, struct string_list *dst_of)
 {
 	for (size_t i = 0; i < plan->moves_nr; i++)
-		string_list_insert(dst_of, plan->moves[i].src)->util =
-			plan->moves[i].dst;
+		if (!plan->moves[i].skip_reason)
+			string_list_insert(dst_of, plan->moves[i].src)->util =
+				plan->moves[i].dst;
+}
+
+/*
+ * Emit `<prefix><name>` for a `diff --git` header the way git's diff does: when
+ * the prefixed path needs C-quoting, wrap the whole unit in one pair of double
+ * quotes ("a/<escaped>") rather than quoting the name alone. An ordinary path
+ * is emitted verbatim, so the header is byte-identical to git's diff.
+ */
+static void add_diff_git_path(struct strbuf *out, const char *prefix,
+			      const char *name)
+{
+	if (quote_c_style(prefix, NULL, NULL, CQUOTE_NODQ) ||
+	    quote_c_style(name, NULL, NULL, CQUOTE_NODQ)) {
+		strbuf_addch(out, '"');
+		quote_c_style(prefix, out, NULL, CQUOTE_NODQ);
+		quote_c_style(name, out, NULL, CQUOTE_NODQ);
+		strbuf_addch(out, '"');
+	} else {
+		strbuf_addstr(out, prefix);
+		strbuf_addstr(out, name);
+	}
 }
 
-/* A content-identical rename entry per move. */
-static void build_rename_patch(struct organize_plan *plan, struct strbuf *out)
+/*
+ * A content-identical rename entry per standing move the organizer did not
+ * claim. A claimed move is one the organizer renames itself, with content
+ * changes, so git leaves that entry to the organizer's patch.
+ */
+static void build_rename_patch(struct organize_plan *plan,
+			       struct string_list *claimed, struct strbuf *out)
 {
 	for (size_t i = 0; i < plan->moves_nr; i++) {
 		struct organize_move *m = &plan->moves[i];
 
-		/* These are tracked_files source paths, which need no quoting. */
-		strbuf_addf(out, "diff --git a/%s b/%s\n", m->src, m->dst);
+		if (m->skip_reason || string_list_has_string(claimed, m->src))
+			continue;
+		/*
+		 * C-quote the paths the way git's diff does, so a byte special
+		 * to the patch format (newline, quote, ...) is escaped. An
+		 * ordinary path passes through unquoted, so this is byte-for-
+		 * byte git's rename header.
+		 */
+		strbuf_addstr(out, "diff --git ");
+		add_diff_git_path(out, "a/", m->src);
+		strbuf_addch(out, ' ');
+		add_diff_git_path(out, "b/", m->dst);
+		strbuf_addch(out, '\n');
 		strbuf_addstr(out, "similarity index 100%\n");
-		strbuf_addf(out, "rename from %s\n", m->src);
-		strbuf_addf(out, "rename to %s\n", m->dst);
+		strbuf_addstr(out, "rename from ");
+		quote_c_style(m->src, out, NULL, 0);
+		strbuf_addstr(out, "\nrename to ");
+		quote_c_style(m->dst, out, NULL, 0);
+		strbuf_addch(out, '\n');
 	}
 }
 
@@ -235,7 +293,8 @@ static int git_apply_index(const char *patch, size_t len)
 
 /*
  * Repoint each carved file's [labels] line to its new path, carrying its labels
- * unchanged: only its location changes. Returns nonzero when [labels] changed.
+ * unchanged: only its location changes. A rejected move stays put and keeps its
+ * line. Returns nonzero when [labels] changed.
  */
 static int repoint_moved_declarations(struct organize_plan *plan)
 {
@@ -278,19 +337,32 @@ static int repoint_moved_declarations(struct organize_plan *plan)
 void organize_plan_apply(struct repository *repo, struct organize_plan *plan)
 {
 	struct strbuf patch = STRBUF_INIT;
+	struct strbuf combined = STRBUF_INIT;
+	struct string_list claimed = STRING_LIST_INIT_DUP;
+	const char *organizer;
 
 	if (worktree_dirty(repo))
 		die(_("organize apply: the worktree has uncommitted changes; "
 		      "commit or stash first"));
 
+	organizer = organize_command(repo, "organizer");
+	if (organizer)
+		run_organizer(organizer, plan, &patch, &claimed);
+
 	/*
-	 * Content-identical renames for every move, applied as one
-	 * git apply --index transaction, so a failure leaves the tree untouched.
+	 * Content-identical renames for every unclaimed move, then the
+	 * organizer's edits (when any), apply as one git apply --index: git
+	 * checks the whole patch before it writes, so a patch that does not
+	 * apply changes nothing. The [labels] update in .gitorganize follows the
+	 * apply and is staged separately rather than as part of it.
 	 */
-	build_rename_patch(plan, &patch);
-	if (patch.len && git_apply_index(patch.buf, patch.len))
+	build_rename_patch(plan, &claimed, &combined);
+	if (patch.len)
+		strbuf_addbuf(&combined, &patch);
+	if (combined.len && git_apply_index(combined.buf, combined.len))
 		die(_("organize apply: the change does not apply cleanly; "
 		      "nothing was changed"));
+	strbuf_release(&combined);
 
 	if (repoint_moved_declarations(plan)) {
 		struct child_process add = CHILD_PROCESS_INIT;
@@ -302,15 +374,80 @@ void organize_plan_apply(struct repository *repo, struct organize_plan *plan)
 			      "restore with git reset --hard"));
 	}
 
+	string_list_clear(&claimed, 0);
 	strbuf_release(&patch);
 }
 
+void organize_run_labeler(struct repository *repo, int reseed)
+{
+	struct organize_ctx ctx = ORGANIZE_CTX_INIT;
+	struct string_list labeled = STRING_LIST_INIT_DUP;
+	struct string_list records = STRING_LIST_INIT_DUP;
+	struct child_process add = CHILD_PROCESS_INIT;
+	const char *cmd;
+
+	organize_ctx_load(repo, &ctx);
+	cmd = organize_command(repo, "labeler");
+	if (!cmd)
+		die(_("organize: organize.labeler is not set"));
+	run_labeler(cmd, &ctx.scoped_files, &labeled);
+
+	/*
+	 * A [labels] line for every scoped_files file. A file already recorded
+	 * keeps its line: the recorded placement is authoritative, so a decision
+	 * made by hand or in an earlier run survives, and the labeler only seeds a
+	 * file it has not yet placed. With reseed, take the labeler's fresh label
+	 * for every file instead, discarding the recorded placements. Walking the
+	 * scoped_files set keeps a new, unrecorded source visible either way. The
+	 * loop below then preserves every placed file already listed.
+	 */
+	for (size_t i = 0; i < ctx.scoped_files.nr; i++) {
+		const char *path = ctx.scoped_files.items[i].string;
+		struct string_list_item *rec =
+			string_list_lookup(&ctx.gitorg.records, path);
+		struct string_list_item *it;
+
+		if (rec && !reseed) {
+			string_list_insert(&records, path)->util =
+				xstrdup((const char *)rec->util);
+			continue;
+		}
+		if (layout_dir_rule(&ctx.gitorg, path))
+			continue;	/* placed by its directory; no line needed */
+		it = string_list_lookup(&labeled, path);
+		string_list_insert(&records, path)->util =
+			xstrdup(it ? (const char *)it->util : "");
+	}
+	for (size_t i = 0; i < ctx.gitorg.records.nr; i++) {
+		const char *path = ctx.gitorg.records.items[i].string;
+
+		if (strchr(path, '/') &&
+		    string_list_has_string(&ctx.tracked_files, path) &&
+		    !string_list_has_string(&records, path))
+			string_list_insert(&records, path)->util =
+				xstrdup(ctx.gitorg.records.items[i].util);
+	}
+
+	string_list_clear(&ctx.gitorg.records, 1);
+	ctx.gitorg.records = records;	/* ctx.gitorg owns the fresh [labels] */
+	gitorganize_write(&ctx.gitorg);
+
+	add.git_cmd = 1;
+	strvec_pushl(&add.args, "add", ".gitorganize", NULL);
+	if (run_command(&add))
+		die(_("organize apply --labels-only: staging .gitorganize failed"));
+
+	organize_ctx_release(&ctx);
+	string_list_clear(&labeled, 1);
+}
+
 void organize_plan_release(struct organize_plan *plan)
 {
 	for (size_t i = 0; i < plan->moves_nr; i++) {
 		free(plan->moves[i].src);
 		free(plan->moves[i].dst);
 		free(plan->moves[i].rule_value);
+		free(plan->moves[i].skip_reason);
 	}
 	FREE_AND_NULL(plan->moves);
 	plan->moves_nr = plan->moves_alloc = 0;
diff --git a/organize/organize.h b/organize/organize.h
index c26453d2be..84e6558f8b 100644
--- a/organize/organize.h
+++ b/organize/organize.h
@@ -15,30 +15,42 @@ struct repository;
  *   [scope]    the scope pathspecs, one per line; no [scope] section means
  *     nothing is in scope.
  *
- *   [layout]   the project's placement map, hand-authored: ordered
- *     `<label>:<value> = <directory>` rules (`.` is the root). A file's labels
- *     are matched against the rules in order, and the first rule it satisfies
- *     places it; a file matching no rule is backlog. Only a label named in
- *     a rule places a file.
+ *   [layout]   the project's directory map, hand-authored: ordered
+ *     `<label>:<value> = <directory>` rules (`.` is the root). git organize
+ *     matches a file's labels against the rules in order; the first rule it
+ *     satisfies names the file's directory. A file matching no rule is backlog.
+ *     Only a rule named in [layout] moves a file.
  *
  *   [labels]   the recorded labels, one line per source in scope, `<path> <key>=
- *     <value> ...`, with every label the project defines. Placed files are listed
- *     too, so a placed file's [labels] line records its labels, independently of
- *     the directory name.
+ *     <value> ...`, with every label the project defines. A file already in its
+ *     directory is listed too, so its [labels] line records its labels, apart
+ *     from the directory name. A label named in no rule moves no file; git
+ *     organize records it for a reader.
+ *
+ * The labeler and organizer commands live in config, organize.labeler and
+ * organize.organizer.
  *
  *   status  Read [labels] and report the files in scope whose matching rule
  *     names a directory they are not in yet (the moves), the backlog, and a
  *     recorded path that no longer exists.
  *
- *   apply   Perform the moves. A move is a content-identical rename, applied as
- *     one git apply --index transaction. A carved file's [labels] line is
- *     repointed to its new path, carrying its labels.
+ *   apply   Perform the moves. A move is a content-preserving rename. When an
+ *     organizer is configured, hand it the moves; it returns edits to referring
+ *     files as a patch and a reason for any move it declines. Moves and the
+ *     patch apply as one git apply. With no organizer, each move is a plain git
+ *     mv. A carved file's [labels] line is repointed to its new path, carrying
+ *     its labels.
+ *
+ *   apply --labels-only  Run the labeler and write a [labels] line for every
+ *     file in scope, keeping the line of a file already in its directory.
+ *     Staged. This is the only path that runs a labeler.
  */
 
 struct organize_move {
 	char *src;	/* current path */
 	char *dst;	/* declared path */
-	char *rule_value;	/* the matched rule's value */
+	char *rule_value;	/* the matched rule's value, sent to the organizer */
+	char *skip_reason;	/* why the organizer declined it; NULL when it stands */
 };
 
 struct organize_plan {
@@ -67,11 +79,21 @@ struct organize_plan {
 void organize_plan_build(struct repository *repo, struct organize_plan *plan);
 
 /*
- * Perform the plan: apply the moves as one content-identical-rename
- * transaction; the result is staged. Requires a clean worktree.
+ * Perform the plan: consult the organizer when one is configured, then apply
+ * the standing moves and the organizer's patch; the result is staged.
+ * Requires a clean worktree. Records each declined move's reason in the plan.
  */
 void organize_plan_apply(struct repository *repo, struct organize_plan *plan);
 
+/*
+ * Fill the [labels] record for every file in scope, staged. A file already
+ * recorded keeps its line (the recorded placement is authoritative); an
+ * unrecorded file is seeded from the labeler (its labels, or empty when the
+ * labeler leaves it unplaced). With reseed, re-derive every line from the
+ * labeler, discarding the recorded placements.
+ */
+void organize_run_labeler(struct repository *repo, int reseed);
+
 void organize_plan_release(struct organize_plan *plan);
 
 #endif /* ORGANIZE_H */
diff --git a/organize/organizer-protocol.c b/organize/organizer-protocol.c
new file mode 100644
index 0000000000..d50617e010
--- /dev/null
+++ b/organize/organizer-protocol.c
@@ -0,0 +1,254 @@
+#include "git-compat-util.h"
+#include "organizer-protocol.h"
+#include "organize.h"
+#include "gitorganize-format.h"
+#include "apply.h"
+#include "gettext.h"
+#include "quote.h"
+#include "run-command.h"
+#include "strbuf.h"
+#include "string-list.h"
+#include "strvec.h"
+#include "wrapper.h"
+
+#define ORGANIZE_PROTOCOL "git-organize 1 organize"
+
+/* Record a skip reason for a standing move, taking ownership of `reason`. */
+static void reject_move(struct organize_plan *plan, const char *src,
+			char *reason)
+{
+	for (size_t move_idx = 0; move_idx < plan->moves_nr; move_idx++) {
+		struct organize_move *move = &plan->moves[move_idx];
+
+		if (!strcmp(move->src, src)) {
+			free(move->skip_reason);
+			move->skip_reason = reason;
+			return;
+		}
+	}
+	free(reason);	/* a skip_reason for a move we did not propose is ignored */
+}
+
+/* Serialize the standing moves as the organizer request. */
+static void build_request(struct organize_plan *plan, struct strbuf *request)
+{
+	strbuf_addstr(request, ORGANIZE_PROTOCOL "\n");
+	for (size_t move_idx = 0; move_idx < plan->moves_nr; move_idx++) {
+		struct organize_move *move = &plan->moves[move_idx];
+
+		if (move->skip_reason)
+			continue;
+		strbuf_addstr(request, "move ");
+		quote_c_style(move->src, request, NULL, 0);
+		strbuf_addch(request, ' ');
+		quote_c_style(move->dst, request, NULL, 0);
+		strbuf_addf(request, " %s\n", move->rule_value);
+	}
+}
+
+/* The next "diff --git " line, at column 0, at or after `from`, or `end`. */
+static const char *next_entry(const char *from, const char *end)
+{
+	while (from < end) {
+		if (starts_with(from, "diff --git "))
+			return from;
+		from = memchr(from, '\n', end - from);
+		if (!from)
+			return end;
+		from++;
+	}
+	return end;
+}
+
+/*
+ * Whether an entry's text mentions a directory the plan moves into, so that an
+ * in-place edit is one that repoints a reference toward a moved file rather
+ * than an edit of an unrelated file.
+ */
+static int repoints_a_move(const char *entry, const char *entry_end,
+			   const struct string_list *dstdirs)
+{
+	for (size_t i = 0; i < dstdirs->nr; i++) {
+		const char *dir = dstdirs->items[i].string;
+
+		if (memmem(entry, entry_end - entry, dir, strlen(dir)))
+			return 1;
+	}
+	return 0;
+}
+
+/*
+ * The organizer is a trusted command that the repository configures, like a
+ * clean or smudge filter. This is an integrity check on the organizer patch,
+ * not a sandbox against a hostile organizer. It reads each entry's per-entry
+ * header with git's own diff-header parser (parse_git_diff_header), the same
+ * names `git apply` acts on, and refuses a header that steps outside the plan.
+ * It does not confine what the hunks the applying patch carries may change.
+ *
+ * Check each entry's header and record which moves the patch claims. An entry
+ * is one of:
+ *   - old == new: an in-place edit. The file must stay put (not be a move) and
+ *     the edit must repoint a reference into a directory the plan moves a file
+ *     into, which bounds a mistaken organizer to files the moves touch.
+ *   - old != new: a rename-with-modification. It must match a planned move
+ *     (old -> new), which git organize then assigns to the organizer (a claim).
+ * Refuse a header that adds, deletes, or copies a file, or changes a file's
+ * mode; git organize controls which files exist and their modes. The patch
+ * must be in git diff format.
+ */
+static void validate_patch(struct organize_plan *plan,
+			   const struct strbuf *patch,
+			   struct string_list *claimed)
+{
+	struct string_list dst_map = STRING_LIST_INIT_NODUP;
+	struct string_list dstdirs = STRING_LIST_INIT_DUP;
+	struct strbuf root = STRBUF_INIT;
+	const char *cursor = patch->buf;
+	const char *end = patch->buf + patch->len;
+
+	for (size_t move_idx = 0; move_idx < plan->moves_nr; move_idx++) {
+		struct organize_move *move = &plan->moves[move_idx];
+		const char *slash;
+
+		if (move->skip_reason)
+			continue;
+		string_list_insert(&dst_map, move->src)->util = move->dst;
+		slash = strrchr(move->dst, '/');
+		if (slash) {
+			struct strbuf dir = STRBUF_INIT;
+
+			strbuf_add(&dir, move->dst, slash - move->dst + 1);
+			string_list_insert(&dstdirs, dir.buf);
+			strbuf_release(&dir);
+		}
+	}
+
+	while (cursor < end && *cursor == '\n')
+		cursor++;
+	if (cursor < end && !starts_with(cursor, "diff --git "))
+		die(_("organize apply: the organizer patch is not in git diff format"));
+
+	while (cursor < end && starts_with(cursor, "diff --git ")) {
+		const char *newline = memchr(cursor, '\n', end - cursor);
+		size_t first = newline ? (size_t)(newline - cursor + 1)
+				       : (size_t)(end - cursor);
+		struct patch entry;
+		int linenr = 0, hdrlen;
+		const char *old_name, *new_name, *entry_end;
+		struct string_list_item *dst;
+
+		memset(&entry, 0, sizeof(entry));
+		hdrlen = parse_git_diff_header(&root, NULL, &linenr, 1, cursor,
+					       first, end - cursor, &entry);
+		if (hdrlen < 0)
+			die(_("organize apply: cannot parse the organizer patch"));
+		entry_end = next_entry(cursor + hdrlen, end);
+		if (entry.is_new || entry.is_delete || entry.is_copy)
+			die(_("organize apply: the organizer patch must not add, "
+			      "delete, or copy files"));
+		if (entry.old_mode != entry.new_mode)
+			die(_("organize apply: the organizer patch must not change "
+			      "a file's mode"));
+		old_name = entry.old_name ? entry.old_name : entry.def_name;
+		new_name = entry.new_name ? entry.new_name : entry.def_name;
+		if (!old_name || !new_name)
+			die(_("organize apply: cannot tell which file the organizer "
+			      "patch touches"));
+
+		dst = string_list_lookup(&dst_map, old_name);
+		if (!strcmp(old_name, new_name)) {
+			if (dst)
+				die(_("organize apply: the organizer patch edits %s "
+				      "in place, but it is part of a move"), old_name);
+			if (!repoints_a_move(cursor, entry_end, &dstdirs))
+				die(_("organize apply: the organizer patch edits %s "
+				      "in place, but the edit does not repoint a "
+				      "move"), old_name);
+		} else if (!dst || strcmp(dst->util, new_name)) {
+			die(_("organize apply: the organizer patch renames %s to %s, "
+			      "which is not a planned move"), old_name, new_name);
+		} else {
+			string_list_insert(claimed, old_name);
+		}
+		release_patch(&entry);
+		cursor = entry_end;
+	}
+
+	string_list_clear(&dst_map, 0);
+	string_list_clear(&dstdirs, 0);
+	strbuf_release(&root);
+}
+
+/*
+ * Parse the organizer response: the version line, then the reject directives
+ * and the optional patch, which is validated against the plan.
+ */
+static void parse_response(struct organize_plan *plan,
+			   const struct strbuf *response, struct strbuf *patch,
+			   struct string_list *claimed)
+{
+	const char *cursor = response->buf;
+	const char *end = response->buf + response->len;
+	struct strbuf path = STRBUF_INIT;
+
+	if (!skip_prefix(cursor, ORGANIZE_PROTOCOL, &cursor) || *cursor != '\n')
+		die(_("organize: organizer did not send the protocol header '%s'"),
+		    ORGANIZE_PROTOCOL);
+	cursor++;
+
+	while (cursor < end) {
+		const char *newline = memchr(cursor, '\n', end - cursor);
+		const char *args;
+
+		if (!newline)
+			die(_("organize: truncated organizer response"));
+
+		if (skip_prefix(cursor, "reject ", &args)) {
+			const char *reason = read_path_token(args, &path);
+
+			/*
+			 * read_path_token on a quoted path unquotes past a raw
+			 * newline, so its end (or the trimmed reason) can lie
+			 * beyond this line's newline; a negative length would
+			 * wrap in xstrndup below.
+			 */
+			if (reason > newline)
+				die(_("organize: malformed reject line"));
+			while (reason < newline && *reason == ' ')
+				reason++;
+			reject_move(plan, path.buf,
+				    xstrndup(reason, newline - reason));
+			cursor = newline + 1;
+		} else if (starts_with(cursor, "patch\n")) {
+			const char *body = newline + 1;
+
+			strbuf_add(patch, body, end - body);
+			if (patch->len)
+				validate_patch(plan, patch, claimed);
+			break;
+		} else if (newline == cursor) {
+			cursor = newline + 1;	/* skip a blank line */
+		} else {
+			die(_("organize: unexpected organizer line"));
+		}
+	}
+	strbuf_release(&path);
+}
+
+/* Run the organizer over the standing moves, then validate its patch. */
+void run_organizer(const char *command, struct organize_plan *plan,
+		   struct strbuf *patch, struct string_list *claimed)
+{
+	struct child_process child = CHILD_PROCESS_INIT;
+	struct strbuf request = STRBUF_INIT, response = STRBUF_INIT;
+
+	build_request(plan, &request);
+	strvec_push(&child.args, command);
+	child.use_shell = 1;
+	if (pipe_command(&child, request.buf, request.len, &response,
+			 0, NULL, 0))
+		die(_("organize: organizer failed: %s"), command);
+	parse_response(plan, &response, patch, claimed);
+	strbuf_release(&request);
+	strbuf_release(&response);
+}
diff --git a/organize/organizer-protocol.h b/organize/organizer-protocol.h
new file mode 100644
index 0000000000..4159d4ef24
--- /dev/null
+++ b/organize/organizer-protocol.h
@@ -0,0 +1,18 @@
+#ifndef ORGANIZER_PROTOCOL_H
+#define ORGANIZER_PROTOCOL_H
+
+struct organize_plan;
+struct strbuf;
+struct string_list;
+
+/*
+ * The organizer protocol. git organize sends the standing moves to the
+ * configured organizer, which may reject moves or return a patch of content
+ * edits. run_organizer validates that patch against the plan, fills `patch`
+ * with the edits and `claimed` with the moves the organizer renames itself,
+ * and records each rejected move on the plan.
+ */
+void run_organizer(const char *command, struct organize_plan *plan,
+		   struct strbuf *patch, struct string_list *claimed);
+
+#endif /* ORGANIZER_PROTOCOL_H */
diff --git a/t/t0096-organize.sh b/t/t0096-organize.sh
index a352a1c7d1..c2e6539ef2 100755
--- a/t/t0096-organize.sh
+++ b/t/t0096-organize.sh
@@ -4,9 +4,39 @@ test_description='git organize reconciles a tree against a declared layout'
 
 . ./test-lib.sh
 
-# There is no labeler yet, so tests write .gitorganize by hand: root *.c/*.h in
-# scope, odb/refs components, and a [labels] census.
-write_declaration () {
+# A labeler records blob.c under odb, refs.c under refs, header.h as public.
+# It writes a NUL-separated path and key=value label record per file.
+write_labeler () {
+	write_script labeler <<-\EOF
+	printf 'blob.c\0component=odb role=lib\0'
+	printf 'refs.c\0component=refs role=lib\0'
+	printf 'header.h\0component=? role=public\0'
+	EOF
+}
+
+# Point a stub organizer at the patch on its standard input; $2, if given, is
+# the reason it declines a move.
+write_organizer () {
+	cat >"$1.patch" &&
+	write_script "$1" <<-EOF
+	cat >/dev/null
+	printf 'git-organize 1 organize\n'
+	${2:+printf 'reject %s\n' '$2'}
+	printf 'patch\n'
+	cat $1.patch
+	EOF
+}
+
+# Point organize at the given labeler (and optional organizer), the way a
+# project points a merge driver at a command, and write the project-authored
+# [scope] pathspecs and [layout] rules: role:public and role:program keep a
+# file at the root (first match wins), a component value routes to its directory.
+configure_organize () {
+	git config organize.labeler "$1" &&
+	if test $# -gt 1
+	then
+		git config organize.organizer "$2"
+	fi &&
 	cat >.gitorganize <<-\EOF
 	[scope]
 	:(glob)*.c
@@ -16,24 +46,106 @@ write_declaration () {
 	role:program = .
 	component:odb = odb
 	component:refs = refs
-	[labels]
-	blob.c component=odb role=lib
-	header.h component=? role=public
-	refs.c component=refs role=lib
 	EOF
 }
 
-test_expect_success 'setup a tree and a declaration' '
+test_expect_success 'setup a tree and a labeler' '
 	echo blob >blob.c &&
 	echo refs >refs.c &&
 	echo header >header.h &&
 	git add . &&
 	git commit -m init &&
-	write_declaration &&
+	write_labeler &&
+	configure_organize ./labeler &&
 	git add .gitorganize &&
 	git commit -m declare
 '
 
+test_expect_success 'apply --labels-only records the labels' '
+	git organize apply --labels-only &&
+	cat >expect <<-\EOF &&
+	[scope]
+	:(glob)*.c
+	:(glob)*.h
+	[layout]
+	role:public = .
+	role:program = .
+	component:odb = odb
+	component:refs = refs
+	[labels]
+	# The recorded placement of each source; edit a line to change it.
+	# apply --labels-only fills in unrecorded sources; --reseed re-derives all.
+	blob.c component=odb role=lib
+	header.h component=? role=public
+	refs.c component=refs role=lib
+	EOF
+	test_cmp expect .gitorganize &&
+	git diff --cached --name-only >staged &&
+	test_grep "^.gitorganize$" staged &&
+	git commit -m labels
+'
+
+test_expect_success 'apply --labels-only preserves a recorded label; --reseed re-derives' '
+	git init preserve &&
+	(
+		cd preserve &&
+		echo blob >blob.c &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		configure_organize ./labeler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		test_grep "^blob.c component=odb" .gitorganize &&
+		# a hand-made placement decision the labeler would not make
+		sed "s|^blob.c component=odb|blob.c component=refs|" .gitorganize >edited &&
+		mv edited .gitorganize &&
+		# a plain re-run keeps the recorded decision
+		git organize apply --labels-only &&
+		test_grep "^blob.c component=refs" .gitorganize &&
+		test_grep ! "^blob.c component=odb" .gitorganize &&
+		# --reseed discards it and re-derives from the labeler
+		git organize apply --labels-only --reseed &&
+		test_grep "^blob.c component=odb" .gitorganize
+	)
+'
+
+test_expect_success 'a file added under a carved directory is governed in place' '
+	git init subdirs &&
+	(
+		cd subdirs &&
+		echo blob >blob.c &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		configure_organize ./labeler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		git organize apply &&
+		git commit -m carve &&
+		test_path_is_file odb/blob.c &&
+		# the carved file alone is in scope and in place
+		git organize status >before &&
+		test_grep "1 in scope" before &&
+		# a NEW file added directly under the carved odb/ directory is
+		# governed by its location: in scope and in place, not invisible
+		echo extra >odb/extra.c &&
+		git add odb/extra.c &&
+		git organize status >after &&
+		test_grep "2 in scope (2 in place" after &&
+		git organize status --exit-code &&
+		# a file outside any [layout] directory stays ungoverned
+		mkdir vendor &&
+		echo v >vendor/z.c &&
+		git add vendor/z.c &&
+		git organize status >vend &&
+		test_grep "2 in scope" vend
+	)
+'
+
 test_expect_success 'status reports the files to move' '
 	git organize status >actual &&
 	# header.h is public (in place at root); blob.c and refs.c move next
@@ -74,47 +186,319 @@ test_expect_success 'apply refuses a dirty worktree' '
 		echo other >other.c &&
 		git add . &&
 		git commit -m init &&
-		cat >.gitorganize <<-\EOF &&
-		[scope]
-		:(glob)*.c
-		[layout]
-		component:odb = odb
-		[labels]
-		blob.c component=odb
-		other.c component=?
-		EOF
+		write_labeler &&
+		configure_organize ./labeler &&
 		git add .gitorganize &&
 		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
 		echo dirty >>other.c &&
 		test_must_fail git organize apply 2>err &&
 		test_grep "uncommitted changes" err
 	)
 '
 
-test_expect_success 'a file in scope with no matching rule is backlog' '
-	git init backlog &&
+test_expect_success 'organizer may decline a move and patch a referrer' '
+	git init sub &&
+	(
+		cd sub &&
+		echo blob >blob.c &&
+		echo refs >refs.c &&
+		printf "blob.o\n" >build.list &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		write_organizer organizer "refs.c held for test" <<-\EOF &&
+		diff --git a/build.list b/build.list
+		--- a/build.list
+		+++ b/build.list
+		@@ -1 +1 @@
+		-blob.o
+		+odb/blob.o
+		EOF
+		configure_organize ./labeler ./organizer &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		git organize apply >out &&
+		test_grep "1 move(s), 1 skipped" out &&
+		test_grep "skipped refs.c" out &&
+		git diff --cached -M --name-status >actual &&
+		test_grep "^R100.*blob.c.*odb/blob.c" actual &&
+		test_grep "^M.*build.list" actual &&
+		echo odb/blob.o >expect &&
+		test_cmp expect build.list &&
+		test_path_is_file refs.c &&
+		test_path_is_file odb/blob.c &&
+		test_path_is_missing blob.c &&
+		# the carved file is repointed; the declined file keeps its line
+		test_grep "^odb/blob.c component=odb" .gitorganize &&
+		test_grep "^refs.c component=refs" .gitorganize &&
+		test_grep ! "^blob.c " .gitorganize
+	)
+'
+
+test_expect_success 'apply rejects an in-place edit of a moved file' '
+	git init tamper &&
 	(
-		cd backlog &&
+		cd tamper &&
+		echo blob >blob.c &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		write_organizer tamper_organizer <<-\EOF &&
+		diff --git a/blob.c b/blob.c
+		--- a/blob.c
+		+++ b/blob.c
+		@@ -1 +1 @@
+		-blob
+		+tampered
+		EOF
+		configure_organize ./labeler ./tamper_organizer &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		test_must_fail git organize apply 2>err &&
+		test_grep "part of a move" err &&
+		# the rejected apply changed nothing
+		test_path_is_file blob.c &&
+		test_path_is_missing odb/blob.c
+	)
+'
+
+test_expect_success 'apply rejects a rename that is not a planned move' '
+	git init renamer &&
+	(
+		cd renamer &&
+		echo blob >blob.c &&
+		echo readme >README &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		write_organizer rename_organizer <<-\EOF &&
+		diff --git a/README b/MOVED
+		similarity index 100%
+		rename from README
+		rename to MOVED
+		EOF
+		configure_organize ./labeler ./rename_organizer &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		test_must_fail git organize apply 2>err &&
+		test_grep "not a planned move" err &&
+		# the rejected apply changed nothing
+		test_path_is_file README &&
+		test_path_is_missing MOVED &&
+		test_path_is_file blob.c
+	)
+'
+
+test_expect_success 'apply rejects a body that edits a file the header does not name' '
+	git init header-lies &&
+	(
+		cd header-lies &&
+		echo blob >blob.c &&
+		echo refs >refs.c &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		# the diff --git header claims the planned blob.c move, but the body
+		# edits refs.c (another moved file); apply resolves the real target
+		# from the patch, not the header, and rejects it.
+		write_organizer liar <<-\EOF &&
+		diff --git a/blob.c b/odb/blob.c
+		--- a/refs.c
+		+++ b/refs.c
+		@@ -1 +1 @@
+		-refs
+		+tampered
+		EOF
+		configure_organize ./labeler ./liar &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		test_must_fail git organize apply 2>err &&
+		test_grep "part of a move" err &&
+		# the rejected apply changed nothing
+		test_grep "^refs$" refs.c &&
+		test_path_is_missing refs/refs.c &&
+		test_path_is_missing odb/blob.c
+	)
+'
+
+test_expect_success 'apply rejects an in-place edit that repoints no move' '
+	git init meddle &&
+	(
+		cd meddle &&
+		echo blob >blob.c &&
+		echo other >other.c &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		# other.c does not move, and the edit names no directory the plan
+		# moves into, so it is not repointing a reference to a moved file
+		write_organizer meddler <<-\EOF &&
+		diff --git a/other.c b/other.c
+		--- a/other.c
+		+++ b/other.c
+		@@ -1 +1 @@
+		-other
+		+meddled
+		EOF
+		configure_organize ./labeler ./meddler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		test_must_fail git organize apply 2>err &&
+		test_grep "does not repoint" err &&
+		# the rejected apply changed nothing
+		test_grep "^other$" other.c &&
+		test_path_is_file blob.c &&
+		test_path_is_missing odb/blob.c
+	)
+'
+
+test_expect_success 'organizer may rename-with-modification a moved file' '
+	git init renamemod &&
+	(
+		cd renamemod &&
+		cat >blob.c <<-\EOF &&
+		#include "a.h"
+		#include "b.h"
+		#include "x.h"
+		#include "c.h"
+		#include "d.h"
+		EOF
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		write_organizer renamemod_organizer <<-\EOF &&
+		diff --git a/blob.c b/odb/blob.c
+		rename from blob.c
+		rename to odb/blob.c
+		--- a/blob.c
+		+++ b/odb/blob.c
+		@@ -1,5 +1,5 @@
+		 #include "a.h"
+		 #include "b.h"
+		-#include "x.h"
+		+#include "sub/x.h"
+		 #include "c.h"
+		 #include "d.h"
+		EOF
+		configure_organize ./labeler ./renamemod_organizer &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		git organize apply &&
+		test_path_is_file odb/blob.c &&
+		test_path_is_missing blob.c &&
+		test_grep "sub/x.h" odb/blob.c &&
+		git diff --cached -M --name-status >actual &&
+		test_grep "^R[0-9]*.*blob.c.*odb/blob.c" actual &&
+		test_grep "^odb/blob.c component=odb role=lib" .gitorganize &&
+		test_grep ! "^blob.c " .gitorganize &&
+		git diff --cached --name-only >staged &&
+		test_grep "^.gitorganize$" staged
+	)
+'
+
+test_expect_success 'a basename shared across directories does not collide' '
+	git init dup &&
+	(
+		cd dup &&
+		echo root >dup.c &&
+		mkdir sub &&
+		echo sub >sub/dup.c &&
+		git add . &&
+		git commit -m init &&
+		# a labeler that labels only the root dup.c
+		write_script duplabeler <<-\EOF &&
+		printf "dup.c\0component=odb role=lib\0"
+		EOF
+		configure_organize ./duplabeler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		git organize status >actual &&
+		test_grep "dup.c  *-> odb/dup.c" actual &&
+		test_grep ! "sub/dup.c" actual &&
+		git organize apply &&
+		test_path_is_file odb/dup.c &&
+		test_path_is_file sub/dup.c &&
+		test_path_is_missing dup.c &&
+		git commit -m reconciled
+	)
+'
+
+test_expect_success 'a rule that maps a label to the root keeps its file in place' '
+	git init prog &&
+	(
+		cd prog &&
+		echo lib >lib.c &&
+		echo tool >tool.c &&
+		git add . &&
+		git commit -m init &&
+		# tool.c carries role=program, which the layout maps to the root
+		# (role:program = .), so it stays; lib.c matches component:odb and moves
+		write_script proglabeler <<-\EOF &&
+		printf "lib.c\0component=odb role=lib\0"
+		printf "tool.c\0component=? role=program\0"
+		EOF
+		configure_organize ./proglabeler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		test_grep "^tool.c component=? role=program" .gitorganize &&
+		git commit -m labels &&
+		git organize status >actual &&
+		test_grep "organize: 2 in scope (1 in place, 1 to move, 0 backlog)" actual &&
+		test_grep ! "tool.c  *->" actual &&
+		git organize apply &&
+		test_path_is_file tool.c &&
+		test_path_is_file odb/lib.c &&
+		test_path_is_missing lib.c
+	)
+'
+
+test_expect_success 'a file in scope with no recorded label is unrecorded' '
+	git init scoped &&
+	(
+		cd scoped &&
 		echo a >a.c &&
 		git add . &&
 		git commit -m init &&
-		cat >.gitorganize <<-\EOF &&
-		[scope]
-		:(glob)*.c
-		[layout]
-		component:odb = odb
-		[labels]
-		a.c component=?
+		write_script alabeler <<-\EOF &&
+		printf "a.c\0component=? role=lib\0"
 		EOF
+		configure_organize ./alabeler &&
 		git add .gitorganize &&
 		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		# a.c is recorded but matches no rule: backlog
 		git organize status >actual &&
-		test_grep "backlog" actual &&
-		test_grep "^  a.c$" actual
+		test_grep "backlog:" actual &&
+		test_grep "^  a.c$" actual &&
+		# a source in scope that [labels] never recorded is unrecorded
+		echo b >b.c &&
+		git add b.c &&
+		git commit -m add-b &&
+		git organize status >actual &&
+		test_grep "in scope but unrecorded:" actual &&
+		test_grep "^  b.c$" actual
 	)
 '
 
-test_expect_success 'status reports a declared path that no longer exists' '
+test_expect_success 'status reports a recorded path that no longer exists' '
 	git init orphan &&
 	(
 		cd orphan &&
@@ -122,17 +506,15 @@ test_expect_success 'status reports a declared path that no longer exists' '
 		echo b >b.c &&
 		git add . &&
 		git commit -m init &&
-		cat >.gitorganize <<-\EOF &&
-		[scope]
-		:(glob)*.c
-		[layout]
-		role:public = .
-		[labels]
-		a.c role=public
-		b.c role=public
+		write_script twolabeler <<-\EOF &&
+		printf '\''a.c\0component=? role=public\0b.c\0component=? role=public\0'\''
 		EOF
+		configure_organize ./twolabeler &&
 		git add .gitorganize &&
 		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		# remove a recorded file outside the tool
 		git rm -q b.c &&
 		git commit -m drop-b &&
 		git organize status >actual &&
@@ -177,6 +559,25 @@ test_expect_success 'status rejects a malformed .gitorganize' '
 	)
 '
 
+test_expect_success 'the recorded labels carry arbitrary key=value pairs' '
+	git init extra &&
+	(
+		cd extra &&
+		echo z >z.c &&
+		git add . &&
+		git commit -m init &&
+		write_script extralabeler <<-\EOF &&
+		printf '\''z.c\0component=? role=lib note=demo\0'\''
+		EOF
+		configure_organize ./extralabeler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		# a label the engine does not place still round-trips into [labels]
+		test_grep "^z.c component=? role=lib note=demo" .gitorganize
+	)
+'
+
 test_expect_success 'a subcommand rejects extra operands' '
 	test_must_fail git -C bad organize status junk 2>err &&
 	test_grep "too many arguments" err

Documentation/git-organize.adoc, builtin/organize.c, organize/organize.c, organize/organize.h, t/t0096-organize.sh

diff --git a/Documentation/git-organize.adoc b/Documentation/git-organize.adoc
index 37ada38234..aca8934b26 100644
--- a/Documentation/git-organize.adoc
+++ b/Documentation/git-organize.adoc
@@ -9,8 +9,8 @@ git-organize - Reconcile a source tree against a declared layout
 SYNOPSIS
 --------
 [verse]
-'git organize status' [--exit-code]
-'git organize apply'
+'git organize status' [--exit-code] [--label <key[=value]>...]
+'git organize apply' [--label <key[=value]>...]
 'git organize apply' --labels-only [--reseed]
 
 
@@ -24,16 +24,18 @@ file belongs in.
 
 `.gitorganize` at the repository root has three sections. `[scope]` names
 the files in scope, one pathspec per line; with no `[scope]` section
-nothing is in scope. `[layout]` is the project's placement map, authored by
-hand: ordered `<label>:<value> = <directory>` rules (`.` is the repository
-root). A file's labels are matched against the rules in order, and the first
-rule it satisfies places it; a file matching no rule is the backlog.
-`[labels]` holds the recorded labels, one line per
-source in scope, `<path> <key>=<value> ...`, with every label the project
-defines. A placed file is listed too, so its `[labels]` line records its
-labels, independently of the directory name. Only a label named in a rule
-places a file; a label named in no rule places nothing and is recorded for a
-reader.
+nothing is in scope. `[layout]` is the project's map of where each file
+belongs, authored by hand: ordered `<label>:<value> = <directory>` rules
+(`.` is the repository root). A file's labels are matched against the rules in
+order, and the first rule it satisfies gives the file its directory; a file
+matching no rule is the backlog.
+`[labels]` holds the recorded labels: one line, `<path> <key>=<value>
+...`, per recorded in-scope source, with every label the project
+defines. apply repoints a moved file's line to its new path and keeps
+it, so a placed file keeps its record. A file that already sits inside a
+`[layout]` directory before it is recorded has no line; its location
+alone places it. Only a label named in a rule places a file; a label
+named in no rule places nothing and is recorded for a reader.
 
 The labeler and organizer live in config: `organize.labeler` and
 `organize.organizer`. A label is a key and value the labeler attaches to a
@@ -60,7 +62,7 @@ own references. A project supplies those edits with an organizer, its
 `organize.organizer` command. apply hands the organizer its
 moves. The organizer returns a patch of the edits and, for any move it
 cannot complete, a reason to skip it. When the organizer edits a file as it
-moves, git's rename detection matches it while its similarity stays above
+moves, Git's rename detection matches it while its similarity stays above
 the rename threshold. apply applies the moves and the patch as one
 transaction. With no organizer configured, apply moves the files and makes
 no other edit.
@@ -70,25 +72,28 @@ COMMANDS
 --------
 
 status::
-	Report the files whose placement value names a directory they are not
+	Report the files whose matching rule names a directory they are not
 	in (the moves), the backlog (recorded files with no matching
 	rule), a file in scope that `[labels]` does not record, and a recorded
 	path that no longer exists. Runs no configured
-	command and changes nothing. With `--exit-code`, exit non-zero when a
-	file is out of place, a file in scope is unrecorded, or a recorded path
-	is missing.
+	command and changes nothing. With `--label`, limit the moves to the
+	files a label selects (see OPTIONS); the backlog, unrecorded, and
+	missing lists are always reported. With `--exit-code`, exit non-zero
+	when a file is out of place, a file in scope is unrecorded, or a
+	recorded path is missing.
 
 apply::
 	Move each out-of-place file into its directory as a content-identical
 	rename, apply the organizer's edits, repoint each carved file's
-	`[labels]` line to its new path, and stage the result. apply requires a
-	clean worktree, so the change can be discarded as a whole.
+	`[labels]` line to its new path, and stage the result. With `--label`,
+	reconcile only the files a label selects. apply requires a clean
+	worktree, so the change can be discarded as a whole.
 +
 With `--labels-only`, apply instead records the `[labels]` line for every root
 file in scope and stages the file. A file already recorded keeps its line, so a
-placement chosen by hand or in an earlier run stands; the labeler only seeds a
+directory chosen by hand or in an earlier run stands; the labeler only seeds a
 file that has no line yet. With `--reseed`, re-derive every line from the
-labeler, discarding the recorded placements. This is the only path that runs a
+labeler, discarding the recorded lines. This is the only path that runs a
 labeler; `git organize apply` without `--labels-only` and `git organize status`
 never do.
 
@@ -96,6 +101,14 @@ never do.
 OPTIONS
 -------
 
+--label <key[=value]>::
+	Limit the moves that status reports and apply makes to the files a
+	label selects. A `<key>=<value>` selector matches a file whose
+	recorded labels include it; a bare `<key>` matches any value of that
+	label. A selector can name any recorded label, not only the ones
+	`[layout]` places files by. Repeatable; the selectors combine, so a
+	file matching any of them is included.
+
 --exit-code::
 	Exit non-zero from status when a file is out of place, a file in scope
 	is unrecorded, or a recorded path is missing. A standing backlog alone
@@ -107,9 +120,11 @@ OPTIONS
 	line yet.
 
 --reseed::
-	With apply `--labels-only`, re-derive every `[labels]` line from the
-	labeler, discarding the recorded placements. Use it to re-apply the
-	labeler after its map changes; without it a recorded line is kept.
+	With apply `--labels-only`, discard the recorded lines and re-derive
+	them from the labeler. A file already placed in a `[layout]`
+	directory keeps its line, because the labeler derives labels from the
+	sources at the root. Use it to re-apply the labeler after its map
+	changes; without it a recorded line is kept.
 
 
 CONFIGURATION
@@ -119,20 +134,23 @@ organize.labeler::
 	--labels-only` runs it over the root files in scope. It writes one
 	record per file on its standard output: the path, a NUL, its
 	space-separated `key=value` labels, a NUL. A file in scope with no
-	record is unrecorded, reported apart from the backlog. Use user or
-	system config for this setting; do
-	not take it from a repository file.
+	record is unrecorded, reported apart from the backlog. This command is
+	honored from config at any level, repo-local `.git/config` included, and
+	so requires the trust you give `core.hooksPath`.
 
 organize.organizer::
 	The command that returns move edits. apply runs it over the moves. It
 	reads the pending moves on its standard input and returns a patch and
 	any skip reasons; see PROTOCOL. Optional. Without it, apply performs the
-	moves and makes no other edit. Use user or system config for this
-	setting; do not take it from a repository file.
+	moves and makes no other edit. This command is honored from config at
+	any level, repo-local `.git/config` included, and so requires the trust
+	you give `core.hooksPath`.
 
 The labeler and organizer are trusted, the way a clean or smudge filter or a
-hook is trusted. Set them in user or system config, so a repository you clone
-cannot supply its own.
+hook is trusted. Both are honored from config at any level, repo-local
+`.git/config` included. A repository you clone does not ship its `.git/config`,
+so a clone cannot supply them by that route, but treat a command written into
+`.git/config` with the same care you give `core.hooksPath`.
 
 
 FILES
@@ -140,16 +158,17 @@ FILES
 `.gitorganize`::
 	The declaration, at the repository root, in three sections. `[scope]`
 	names the files in scope, one pathspec per line; with no `[scope]`
-	section nothing is in scope. `[layout]` is the project's placement map:
-	ordered `<label>:<value> = <directory>` rules (`.` is the root), where a
-	file takes the directory of the first rule its labels satisfy, and a
-	file matching no rule is the backlog. `[labels]` holds the recorded
-	labels, one `<path> <key>=<value> ...` line per source in scope,
-	including placed files. The project writes `[scope]` and `[layout]`;
-	`git organize apply --labels-only` writes `[labels]`, and the move apply
-	repoints a carved file's line. A `#` line is a comment; git organize
-	rewrites the file whole, keeping the hand-authored `[scope]` and
-	`[layout]` verbatim.
+	section nothing is in scope. `[layout]` is the project's map of where
+	each file belongs: ordered `<label>:<value> = <directory>` rules (`.` is
+	the root), where a file takes the directory of the first rule its labels
+	satisfy, and a file matching no rule is the backlog. `[labels]` holds
+	the recorded labels, one `<path> <key>=<value> ...` line per in-scope
+	source that a rule, not its location, places; a file already inside a
+	`[layout]` directory is placed by its location and has no line. The
+	project writes `[scope]` and `[layout]`; `git organize apply
+	--labels-only` writes `[labels]`, and the move apply repoints a carved
+	file's line. A `#` line is a comment; git organize rewrites the file
+	whole, keeping the hand-authored `[scope]` and `[layout]` verbatim.
 
 
 PROTOCOL
@@ -159,9 +178,20 @@ version line `git-organize 1 organize`, then a `move <src> <dst> <label>`
 line per pending move, with C-quoted paths. The organizer replies with the
 same version line. For each declined move, it writes `reject <src>
 <reason>`. It may then write `patch`, followed by a git patch that runs to
-the end of its output. The patch may edit referring files and may rename a
-moved file as it edits it, but it must not add, delete, or copy files, and
-any rename must match a planned move.
+the end of its output.
+
+Before it runs `git apply`, git organize checks each entry in the patch with
+Git's own diff-header parser and refuses the patch if an entry adds, deletes,
+or copies a file, changes a file's mode, or renames a file to anything but a
+planned move. An in-place edit must repoint a move: it must leave the file
+where it is and mention a directory the plan moves into. So the patch git
+organize accepts is limited to edits of referring files and to renames that
+match a planned move.
+
+The organizer is a trusted, config-defined command, honored the way a clean or
+smudge filter is. These checks catch a well-meaning organizer's mistakes; they
+do not sandbox a hostile one, and they do not certify that the whole patch is
+sound.
 
 
 GIT
diff --git a/builtin/organize.c b/builtin/organize.c
index 35247c5aef..925ef17128 100644
--- a/builtin/organize.c
+++ b/builtin/organize.c
@@ -6,27 +6,30 @@
  * are not in yet (the moves), the backlog (files with no matching rule), and a
  * declared path that no longer exists. apply moves the misplaced files and
  * stages the result; apply --labels-only instead runs the labeler and records
- * the labels.
+ * the labels. --label <key[=value]> (repeatable) limits status and the move
+ * apply to files carrying a matching label.
  */
 #include "builtin.h"
 #include "gettext.h"
 #include "organize/organize.h"
 #include "parse-options.h"
 #include "repository.h"
+#include "strvec.h"
 
 static const char *const organize_usage[] = {
-	"git organize status [--exit-code]",
-	"git organize apply",
+	"git organize status [--exit-code] [--label <key[=value]>...]",
+	"git organize apply [--label <key[=value]>...]",
 	"git organize apply --labels-only [--reseed]",
 	NULL
 };
 
-static int organize_status(struct repository *repo, int exit_code)
+static int organize_status(struct repository *repo,
+			   const struct strvec *selectors, int exit_code)
 {
 	struct organize_plan plan = ORGANIZE_PLAN_INIT;
 	int to_move, backlog, unrecorded, orphans;
 
-	organize_plan_build(repo, &plan);
+	organize_plan_build(repo, selectors, &plan);
 	to_move = (int)plan.moves_nr;
 	backlog = (int)plan.backlog.nr;
 	unrecorded = (int)plan.unrecorded.nr;
@@ -70,12 +73,12 @@ static int organize_status(struct repository *repo, int exit_code)
 	return exit_code && (to_move || unrecorded || orphans) ? 1 : 0;
 }
 
-static int organize_apply(struct repository *repo)
+static int organize_apply(struct repository *repo, const struct strvec *selectors)
 {
 	struct organize_plan plan = ORGANIZE_PLAN_INIT;
 	int moved = 0, rejected = 0;
 
-	organize_plan_build(repo, &plan);
+	organize_plan_build(repo, selectors, &plan);
 	if (!plan.moves_nr) {
 		printf(_("organize apply: nothing to do\n"));
 		organize_plan_release(&plan);
@@ -106,8 +109,11 @@ int cmd_organize(int argc,
 		 const char *prefix,
 		 struct repository *repo)
 {
+	struct strvec selectors = STRVEC_INIT;
 	int exit_code = 0, labels_only = 0, reseed = 0;
 	struct option options[] = {
+		OPT_STRVEC(0, "label", &selectors, N_("key[=value]"),
+			   N_("limit to files carrying a matching label (repeatable)")),
 		OPT_BOOL(0, "exit-code", &exit_code,
 			 N_("exit non-zero from status when a file is out of place")),
 		OPT_BOOL(0, "labels-only", &labels_only,
@@ -128,7 +134,7 @@ int cmd_organize(int argc,
 	if (!strcmp(subcmd, "status")) {
 		if (labels_only)
 			die(_("git organize: --labels-only is an apply option"));
-		ret = organize_status(repo, exit_code);
+		ret = organize_status(repo, &selectors, exit_code);
 	} else if (!strcmp(subcmd, "apply")) {
 		if (labels_only) {
 			organize_run_labeler(repo, reseed);
@@ -136,11 +142,12 @@ int cmd_organize(int argc,
 				 "staged; nothing is committed.\n"));
 			ret = 0;
 		} else {
-			ret = organize_apply(repo);
+			ret = organize_apply(repo, &selectors);
 		}
 	} else {
 		die(_("git organize: unknown subcommand '%s'"), subcmd);
 	}
 
+	strvec_clear(&selectors);
 	return ret;
 }
diff --git a/organize/organize.c b/organize/organize.c
index 8c623444c0..298557a3da 100644
--- a/organize/organize.c
+++ b/organize/organize.c
@@ -29,6 +29,30 @@ static const char *organize_command(struct repository *repo, const char *key)
 	return cmd;
 }
 
+/*
+ * Whether a file's labels satisfy any --label selector. labels is the file's
+ * space-separated "key=value" list. A "key=value" selector must equal a label
+ * exactly; a bare "key" matches any value of that label.
+ */
+static int label_selected(const char *labels, struct string_list *selectors)
+{
+	for (size_t i = 0; i < selectors->nr; i++) {
+		const char *selector = selectors->items[i].string;
+		size_t sellen = strlen(selector);
+		int bare = !strchr(selector, '=');
+
+		for (const char *l = labels; *l; ) {
+			const char *sp = strchrnul(l, ' ');
+
+			if (!strncmp(l, selector, sellen) &&
+			    (bare ? l[sellen] == '=' : sp == l + sellen))
+				return 1;
+			l = *sp ? sp + 1 : sp;
+		}
+	}
+	return 0;
+}
+
 /*
  * The [layout] rule whose directory equals `path`'s directory, or NULL when
  * `path` is a root file or its directory matches no rule. A file in a [layout]
@@ -133,14 +157,19 @@ static void add_move(struct organize_plan *plan, const char *src,
 	m->skip_reason = NULL;
 }
 
-void organize_plan_build(struct repository *repo, struct organize_plan *plan)
+void organize_plan_build(struct repository *repo, const struct strvec *selectors,
+			 struct organize_plan *plan)
 {
 	struct organize_ctx ctx = ORGANIZE_CTX_INIT;
+	struct string_list want = STRING_LIST_INIT_NODUP;
 	struct string_list seen = STRING_LIST_INIT_DUP;
 	struct strbuf value_buf = STRBUF_INIT;
 
 	organize_ctx_load(repo, &ctx);
 
+	for (size_t i = 0; i < selectors->nr; i++)
+		string_list_append(&want, selectors->v[i]);
+
 	/*
 	 * Classify each recorded entry by the rule its labels match. A file
 	 * already in the rule's directory is in place. A file in another
@@ -175,7 +204,7 @@ void organize_plan_build(struct repository *repo, struct organize_plan *plan)
 
 		if (!strcmp(dst.buf, path))
 			plan->in_place++;	/* already in place */
-		else
+		else if (!want.nr || label_selected(labels, &want))
 			add_move(plan, path, strbuf_detach(&dst, NULL), rule->value);
 		strbuf_release(&dst);
 	}
@@ -207,6 +236,7 @@ void organize_plan_build(struct repository *repo, struct organize_plan *plan)
 			string_list_append(&plan->orphans, ctx.gitorg.records.items[i].string);
 
 	organize_ctx_release(&ctx);
+	string_list_clear(&want, 0);
 	string_list_clear(&seen, 0);
 	strbuf_release(&value_buf);
 }
diff --git a/organize/organize.h b/organize/organize.h
index 84e6558f8b..358298376c 100644
--- a/organize/organize.h
+++ b/organize/organize.h
@@ -4,6 +4,7 @@
 #include "string-list.h"
 
 struct repository;
+struct strvec;
 
 /*
  * The git organize engine. A project declares where each file belongs, and
@@ -74,9 +75,11 @@ struct organize_plan {
  * rule names a directory it is not in as a move. Also record the backlog
  * (recorded files that match no rule), the unrecorded files (in scope,
  * no [labels] line), and the orphans (declared paths
- * that no longer exist).
+ * that no longer exist). selectors limit the moves to files carrying one of the
+ * named labels; an empty strvec keeps them all.
  */
-void organize_plan_build(struct repository *repo, struct organize_plan *plan);
+void organize_plan_build(struct repository *repo, const struct strvec *selectors,
+			 struct organize_plan *plan);
 
 /*
  * Perform the plan: consult the organizer when one is configured, then apply
diff --git a/t/t0096-organize.sh b/t/t0096-organize.sh
index d8de3c7e90..297e616021 100755
--- a/t/t0096-organize.sh
+++ b/t/t0096-organize.sh
@@ -160,6 +160,56 @@ test_expect_success 'status --exit-code fails when a file is out of place' '
 	test_expect_code 1 git organize status --exit-code
 '
 
+test_expect_success 'status --label filters by a recorded label' '
+	git organize status --label component=odb >actual &&
+	test_grep "blob.c  *-> odb/blob.c" actual &&
+	test_grep ! refs.c actual &&
+	# a non-placement label selects too (role, not just the placing component)
+	git organize status --label role=lib >bylib &&
+	test_grep "blob.c  *-> odb/blob.c" bylib &&
+	test_grep "refs.c  *-> refs/refs.c" bylib &&
+	# header.h (role=public, in place) is not over-included by the filter
+	test_grep ! "header.h" bylib &&
+	# a bare key matches any value of that label
+	git organize status --label component >bykey &&
+	test_grep "blob.c  *-> odb/blob.c" bykey &&
+	test_grep "refs.c  *-> refs/refs.c" bykey
+'
+
+test_expect_success 'apply --label moves only the selected files' '
+	git init bylabel &&
+	(
+		cd bylabel &&
+		echo blob >blob.c &&
+		echo refs >refs.c &&
+		echo header >header.h &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		configure_organize ./labeler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		# reconcile only the odb component; refs.c must stay put
+		git organize apply --label component=odb &&
+		git diff --cached -M --name-status >staged &&
+		test_grep "^R100.*blob.c.*odb/blob.c" staged &&
+		test_path_is_file odb/blob.c &&
+		test_path_is_missing blob.c &&
+		# refs.c is not selected: still at the root, absent from the staged set
+		test_path_is_file refs.c &&
+		test_path_is_missing refs/refs.c &&
+		test_grep ! "refs.c" staged &&
+		# [labels] repointed for odb only; the refs.c line is unchanged
+		test_grep "^odb/blob.c component=odb" .gitorganize &&
+		test_grep "^refs.c component=refs" .gitorganize &&
+		# refs.c is still reported as a pending move
+		git organize status >after &&
+		test_grep "refs.c  *-> refs/refs.c" after
+	)
+'
+
 test_expect_success 'apply moves files as content-identical renames and repoints [labels]' '
 	git organize apply &&
 	git diff --cached -M --name-status >actual &&
@@ -588,6 +638,99 @@ test_expect_success 'the recorded labels carry arbitrary key=value pairs' '
 	)
 '
 
+test_expect_success FUNNYNAMES 'apply moves a source whose name needs C-quoting' '
+	git init quoted &&
+	(
+		cd quoted &&
+		# a double-quote in the name forces the diff header to C-quote it
+		name="a\"b.c" &&
+		echo blob >"$name" &&
+		git add . &&
+		git commit -m init &&
+		# a labeler for the single quoted source; the NUL-separated
+		# record carries the quote literally
+		write_script quotedlabeler <<-\EOF &&
+		printf "a\"b.c\0component=odb role=lib\0"
+		EOF
+		configure_organize ./quotedlabeler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		# the rename header C-quotes the path; the move still applies
+		git organize apply &&
+		test_path_is_file "odb/$name" &&
+		test_path_is_missing "$name" &&
+		git diff --cached --name-only >staged &&
+		test_grep "odb/a" staged
+	)
+'
+
+test_expect_success 'apply rejects a malformed reject line' '
+	git init badreject &&
+	(
+		cd badreject &&
+		echo blob >blob.c &&
+		echo refs >refs.c &&
+		git add . &&
+		git commit -m init &&
+		write_labeler &&
+		# the reject path is quoted but unterminated on its line, so
+		# unquoting scans past the newline into the next line
+		write_script rejector <<-\EOF &&
+		cat >/dev/null
+		printf "git-organize 1 organize\n"
+		printf "reject \"a\nb.c\" reason\n"
+		EOF
+		configure_organize ./labeler ./rejector &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		git organize apply --labels-only &&
+		git commit -m labels &&
+		test_must_fail git organize apply 2>err &&
+		test_grep "malformed reject line" err
+	)
+'
+
+test_expect_success 'apply --labels-only rejects a duplicate labeler record' '
+	git init duprec &&
+	(
+		cd duprec &&
+		echo blob >blob.c &&
+		git add . &&
+		git commit -m init &&
+		# the labeler emits the same scoped path twice
+		write_script duprelabeler <<-\EOF &&
+		printf "blob.c\0component=odb role=lib\0"
+		printf "blob.c\0component=refs role=lib\0"
+		EOF
+		configure_organize ./duprelabeler &&
+		git add .gitorganize &&
+		git commit -m declare &&
+		test_must_fail git organize apply --labels-only 2>err &&
+		test_grep "duplicate labeler record" err
+	)
+'
+
+test_expect_success 'status rejects trailing junk after a quoted path' '
+	git init trailing &&
+	(
+		cd trailing &&
+		echo a >a.c &&
+		git add . &&
+		git commit -m init &&
+		# a quoted [labels] path with junk right after the close quote
+		cat >.gitorganize <<-\EOF &&
+		[layout]
+		component:odb = odb
+		[labels]
+		"a.c"junk component=odb
+		EOF
+		test_must_fail git organize status 2>err &&
+		test_grep "trailing text after path" err
+	)
+'
+
 test_expect_success 'a subcommand rejects extra operands' '
 	test_must_fail git -C bad organize status junk 2>err &&
 	test_grep "too many arguments" err

diff --git a/.gitorganize b/.gitorganize
new file mode 100644
index 0000000000..18cf3228a8
--- /dev/null
+++ b/.gitorganize
@@ -0,0 +1,19 @@
+[scope]
+:(glob)*.c
+:(glob)*.h
+[layout]
+role:public = .
+role:program = .
+component:odb = odb
+component:refs = refs
+component:pack = pack
+component:diff = diff
+component:merge = merge
+component:revision = revision
+component:index = index
+component:setup = setup
+component:convert = convert
+component:transport = transport
+component:notes = notes
+component:submodule = submodule
+component:archive = archive

diff --git a/.gitorganize b/.gitorganize
index 18cf3228a8..522821522e 100644
--- a/.gitorganize
+++ b/.gitorganize
@@ -17,3 +17,478 @@ component:transport = transport
 component:notes = notes
 component:submodule = submodule
 component:archive = archive
+[labels]
+# The recorded placement of each source; edit a line to change it.
+# apply --labels-only fills in unrecorded sources; --reseed re-derives all.
+abspath.c component=? role=lib prefix=abspath cochange=setup:12,diff:6,refs:5,index:3,submodule:3
+abspath.h component=? role=public prefix=abspath cochange=setup:1
+add-interactive.c component=? role=lib prefix=add-interactive includes=index:3,odb:2,diff:1,refs:1,revision:1 cochange=diff:19,index:16,revision:16,odb:7,refs:6
+add-interactive.h component=? role=public prefix=add-patch cochange=odb:2
+add-patch.c component=? role=lib prefix=add-patch includes=setup:3,index:2,odb:2,diff:1 cochange=index:10,transport:8,odb:6,merge:4,refs:4
+add-patch.h component=? role=public prefix=add-patch cochange=odb:1
+advice.c component=? role=lib prefix=advice includes=setup:2 cochange=transport:18,index:12,odb:9,diff:8,revision:8
+advice.h component=? role=public prefix=advice cochange=transport:14,index:9,odb:6,submodule:4,pack:3
+alias.c component=setup role=lib prefix=alias includes=setup:2 cochange=setup:8,diff:4,transport:3,convert:2,index:2
+alias.h component=setup role=header prefix=completion cochange=setup:3,transport:2,pack:1,revision:1
+alloc.c component=odb role=lib prefix=alloc includes=odb:6,setup:1 cochange=odb:54,revision:8,diff:6,pack:6,index:3
+alloc.h component=odb role=header prefix=alloc cochange=odb:16,refs:1,revision:1
+apply.c component=? role=lib prefix=apply includes=index:5,setup:4,odb:3,diff:2,merge:2 cochange=index:93,setup:43,diff:41,odb:26,merge:24
+apply.h component=? role=public prefix=apply includes=odb:1 cochange=diff:2
+archive-tar.c component=archive role=lib prefix=archive-tar includes=archive:1,odb:1,setup:1 cochange=archive:59,index:12,diff:9,odb:9,transport:8
+archive-zip.c component=archive role=lib prefix=archive-zip includes=diff:2,archive:1,odb:1,setup:1 cochange=archive:57,diff:12,odb:8,index:7,transport:6
+archive.c component=archive role=lib prefix=archive includes=odb:5,setup:3,convert:2,archive:1,index:1 cochange=archive:54,convert:42,odb:39,index:36,revision:31
+archive.h component=archive role=header prefix=archive includes=index:1 cochange=archive:58,index:3,revision:3,convert:2,diff:1
+attr.c component=convert role=lib prefix=attr includes=odb:3,setup:3,index:2,convert:1,refs:1 cochange=index:55,convert:54,diff:41,setup:26,revision:22
+attr.h component=convert role=header prefix=attr cochange=convert:50,index:13,diff:9,archive:8,setup:3
+banned.h component=? role=public prefix=banned
+base85.c component=? role=lib prefix=base85 cochange=diff:4,pack:2,convert:1,transport:1
+base85.h component=? role=public prefix=base85 cochange=diff:1
+bisect.c component=revision role=lib prefix=bisect includes=odb:5,revision:5,setup:2,diff:1,index:1 cochange=revision:61,odb:32,transport:31,refs:13,diff:9
+bisect.h component=revision role=header prefix=bisect cochange=revision:29,odb:2
+blame.c component=revision role=lib prefix=blame includes=odb:5,diff:2,index:2,pack:2,revision:2 cochange=diff:68,revision:66,odb:56,index:29,pack:22
+blame.h component=revision role=header prefix=blame includes=diff:1,odb:1 cochange=revision:19,odb:7,diff:4,archive:1,index:1
+blob.c component=odb role=lib prefix=object includes=odb:2 cochange=odb:131,transport:12,pack:11,revision:10,refs:5
+blob.h component=odb role=header prefix=blob includes=odb:1 cochange=odb:33,revision:4,pack:3,transport:2
+bloom.c component=pack role=lib prefix=bloom includes=odb:4,diff:2,pack:2,setup:2 cochange=pack:38,revision:25,diff:15,odb:6,index:2
+bloom.h component=pack role=header prefix=bloom cochange=pack:28,revision:12,odb:1
+branch.c component=? role=lib prefix=branch includes=refs:3,setup:3,odb:2,submodule:1,transport:1 cochange=refs:62,transport:41,setup:28,index:19,revision:12
+branch.h component=? role=public prefix=branch cochange=setup:8,refs:4,submodule:4
+builtin.h component=? role=public prefix=builtin includes=setup:1 cochange=diff:15,index:15,transport:12,odb:6,notes:5
+bundle-uri.c component=transport role=lib prefix=bundle-uri includes=transport:5,odb:1,refs:1,setup:1 cochange=transport:28,setup:7,odb:4,merge:2,pack:2
+bundle-uri.h component=transport role=header prefix=bundle-uri cochange=transport:14
+bundle.c component=transport role=lib prefix=bundle includes=odb:3,revision:3,setup:2,transport:2,diff:1 cochange=transport:63,odb:24,revision:21,refs:17,pack:10
+bundle.h component=transport role=header prefix=bundle includes=revision:1 cochange=transport:37,revision:5
+cache-tree.c component=index role=lib prefix=cache-tree includes=odb:5,index:2,setup:1,transport:1 cochange=index:94,odb:69,revision:27,transport:21,diff:20
+cache-tree.h component=index role=header prefix=cache-tree includes=odb:2 cochange=index:42,diff:4,revision:4,odb:3,refs:1
+cbtree.c component=odb role=lib prefix=cbtree includes=odb:1 cochange=odb:9,diff:1,merge:1,pack:1
+cbtree.h component=odb role=header prefix=cbtree cochange=odb:12,pack:3,setup:1,transport:1
+chdir-notify.c component=? role=lib prefix=chdir-notify includes=revision:1 cochange=index:2,archive:1,merge:1,revision:1
+chdir-notify.h component=? role=public prefix=chdir-notify
+checkout.c component=index role=lib prefix=checkout includes=setup:2,index:1,odb:1,refs:1,transport:1 cochange=transport:16,refs:6,setup:5,index:3,odb:2
+checkout.h component=index role=header prefix=checkout includes=odb:1 cochange=index:4,diff:1,odb:1,refs:1,revision:1
+chunk-format.c component=pack role=lib prefix=chunk-format includes=odb:1,pack:1 cochange=pack:20,odb:1,transport:1
+chunk-format.h component=pack role=header prefix=chunk-format includes=odb:1 cochange=pack:15,odb:2,setup:1,transport:1
+color.c component=? role=lib prefix=color includes=setup:1 cochange=diff:21,index:14,revision:13,setup:7,transport:7
+color.h component=? role=public prefix=color cochange=diff:18,index:12,revision:12,transport:2,odb:1
+column.c component=? role=lib prefix=column includes=setup:1 cochange=transport:6,setup:5,diff:4,revision:3,index:2
+column.h component=? role=public prefix=column
+combine-diff.c component=diff role=lib prefix=combine-diff includes=odb:5,diff:4,revision:2,convert:1,refs:1 cochange=diff:198,revision:67,index:35,odb:16,transport:16
+commit-graph.c component=pack role=lib prefix=commit-graph includes=odb:9,pack:4,setup:2,refs:1,revision:1 cochange=pack:206,odb:125,revision:47,transport:34,setup:22
+commit-graph.h component=pack role=header prefix=commit-graph includes=odb:2 cochange=pack:92,odb:14,setup:9,revision:8,transport:5
+commit-reach.c component=revision role=lib prefix=commit-reach includes=revision:3,odb:2,pack:1,refs:1 cochange=revision:38,odb:17,pack:15,transport:9,index:5
+commit-reach.h component=revision role=header prefix=commit-reach includes=odb:2 cochange=revision:32,odb:9,transport:8,pack:3,refs:3
+commit-slab-decl.h component=odb role=header prefix=commit-slab cochange=odb:6,revision:1
+commit-slab-impl.h component=odb role=header prefix=commit-slab cochange=odb:7,pack:3,revision:1,setup:1,transport:1
+commit-slab.h component=odb role=header prefix=commit-slab includes=odb:2 cochange=odb:8,revision:2,transport:2,index:1,merge:1
+commit.c component=odb role=lib prefix=commit includes=odb:10,setup:4,revision:3,diff:1,index:1 cochange=odb:403,revision:147,transport:87,pack:57,setup:45
+commit.h component=odb role=header prefix=commit includes=odb:1 cochange=odb:237,revision:205,transport:49,pack:25,notes:22
+common-exit.c component=? role=lib prefix=common-main
+common-init.c component=? role=lib prefix=common-main includes=odb:2,setup:2,convert:1 cochange=setup:1
+common-init.h component=? role=public prefix=common-main
+common-main.c component=? role=lib prefix=common-main cochange=setup:5,transport:4,convert:3,index:1
+config.c component=setup role=lib prefix=config includes=setup:4,odb:2,convert:1,index:1,refs:1 cochange=setup:274,index:93,diff:75,refs:48,revision:46
+config.h component=setup role=header prefix=config includes=setup:1 cochange=setup:100,index:30,transport:23,submodule:21,merge:6
+connect.c component=transport role=lib prefix=connect includes=transport:7,setup:4,odb:1,refs:1 cochange=transport:238,setup:19,diff:13,index:10,refs:10
+connect.h component=transport role=header prefix=connect includes=transport:1 cochange=transport:58,refs:1
+connected.c component=transport role=lib prefix=connected includes=transport:3,odb:1,pack:1 cochange=transport:39,pack:31,odb:7,diff:6,index:5
+connected.h component=transport role=header prefix=connected cochange=transport:23
+convert.c component=convert role=lib prefix=convert includes=convert:2,index:1,merge:1,odb:1,setup:1 cochange=convert:59,diff:43,index:41,setup:30,transport:30
+convert.h component=convert role=header prefix=convert includes=odb:1 cochange=convert:29,index:18,diff:8,setup:8,archive:4
+copy.c component=? role=lib prefix=copy cochange=pack:6,transport:5,diff:3,odb:3,merge:2
+copy.h component=? role=public prefix=copy cochange=transport:3,merge:2,convert:1,setup:1
+credential.c component=? role=lib prefix=credential includes=setup:3 cochange=transport:13,index:4,odb:4,convert:2,merge:2
+credential.h component=? role=public prefix=credential cochange=transport:6
+csum-file.c component=? role=lib prefix=csum-file includes=odb:1 cochange=pack:49,odb:13,index:10,transport:10,diff:8
+csum-file.h component=? role=public prefix=csum-file includes=odb:1 cochange=pack:44,odb:8,diff:5,index:5,transport:5
+ctype.c component=? role=lib prefix=ctype cochange=setup:3,index:2,odb:1,pack:1,refs:1
+daemon.c component=? role=program prefix=daemon includes=setup:3,transport:2 cochange=transport:77,index:14,setup:13,diff:7,refs:5
+date.c component=? role=lib prefix=date cochange=revision:17,odb:16,refs:14,setup:9,diff:7
+date.h component=? role=public prefix=date cochange=refs:7,revision:4,setup:2,archive:1,odb:1
+decorate.c component=revision role=lib prefix=decorate includes=odb:1,revision:1 cochange=diff:6,odb:5,revision:5,pack:2,transport:2
+decorate.h component=revision role=header prefix=decorate cochange=revision:4,odb:1
+delta-islands.c component=pack role=lib prefix=delta-islands includes=odb:6,pack:4,diff:1,refs:1,setup:1 cochange=pack:20,odb:17,revision:7,transport:7,diff:5
+delta-islands.h component=pack role=header prefix=delta-islands cochange=pack:6
+delta.h component=pack role=header prefix=diff-delta cochange=pack:27,odb:19,diff:5,transport:3,convert:1
+diagnose.c component=? role=lib prefix=diagnose includes=archive:1,index:1,odb:1,pack:1,setup:1 cochange=index:4,revision:4,odb:3,pack:3,transport:3
+diagnose.h component=? role=public prefix=diagnose cochange=revision:2,refs:1,transport:1
+diff-delta.c component=pack role=lib prefix=diff-delta includes=pack:1 cochange=pack:24,diff:7,index:2,odb:2,transport:2
+diff-lib.c component=diff role=lib prefix=diff includes=index:6,odb:3,diff:2,revision:2,refs:1 cochange=diff:150,index:124,revision:47,submodule:18,odb:8
+diff-merges.c component=diff role=lib prefix=diff-merges includes=diff:1,revision:1 cochange=revision:18,diff:17,odb:4,refs:3,index:2
+diff-merges.h component=diff role=header prefix=diff-merges cochange=diff:11,revision:4,merge:1
+diff-no-index.c component=diff role=lib prefix=diff includes=diff:2,index:2,odb:1,revision:1 cochange=diff:76,revision:21,index:19,refs:8,notes:7
+diff.c component=diff role=lib prefix=diff includes=odb:5,diff:4,setup:3,convert:2,index:2 cochange=diff:610,revision:121,index:100,transport:71,setup:69
+diff.h component=diff role=header prefix=diff includes=index:1,odb:1 cochange=diff:471,revision:83,index:29,submodule:18,odb:14
+diffcore-break.c component=diff role=lib prefix=diffcore-break includes=odb:2,diff:1,transport:1 cochange=diff:71,pack:8,revision:7,index:5,merge:3
+diffcore-delta.c component=diff role=lib prefix=diffcore-delta includes=diff:1 cochange=diff:26,revision:7,odb:4,index:2,refs:2
+diffcore-order.c component=diff role=lib prefix=diffcore-order includes=diff:2 cochange=diff:19,index:8,refs:7,revision:7,pack:5
+diffcore-pickaxe.c component=diff role=lib prefix=pickaxe includes=diff:3,odb:1,revision:1 cochange=diff:97,revision:15,notes:3,odb:3,merge:2
+diffcore-rename.c component=diff role=lib prefix=diffcore-rename includes=diff:2,odb:2,transport:1 cochange=diff:188,index:38,revision:37,odb:21,pack:17
+diffcore-rotate.c component=diff role=lib prefix=diff includes=diff:2 cochange=diff:14,revision:5,pack:2,merge:1,refs:1
+diffcore.h component=diff role=header prefix=diff includes=odb:1 cochange=diff:175,revision:11,merge:10,submodule:4,odb:2
+dir-iterator.c component=index role=lib prefix=dir-iterator includes=index:2 cochange=index:7,refs:1
+dir-iterator.h component=index role=header prefix=dir-iterator cochange=index:7,refs:1
+dir.c component=index role=lib prefix=dir includes=index:7,setup:4,odb:2,convert:1,refs:1 cochange=index:343,diff:61,setup:49,odb:37,convert:29
+dir.h component=index role=header prefix=dir includes=index:2,odb:1 cochange=index:236,odb:13,setup:12,submodule:11,convert:10
+editor.c component=? role=lib prefix=editor includes=setup:2 cochange=transport:20,setup:12,index:8,odb:4,submodule:4
+editor.h component=? role=public prefix=editor cochange=transport:1
+entry.c component=index role=lib prefix=entry includes=index:7,odb:1,setup:1,submodule:1 cochange=index:96,diff:28,convert:20,setup:17,odb:10
+entry.h component=index role=header prefix=entry includes=convert:1 cochange=index:18,submodule:4,revision:3,transport:2,convert:1
+environment.c component=setup role=lib prefix=environment includes=setup:5,convert:3,odb:2,merge:1,refs:1 cochange=setup:281,index:77,odb:48,refs:36,transport:28
+environment.h component=setup role=header prefix=environment includes=setup:1 cochange=setup:135,index:37,odb:15,refs:11,pack:9
+exec-cmd.c component=? role=lib prefix=strvec includes=setup:1
+exec-cmd.h component=? role=public prefix=argv-array cochange=refs:4,transport:4,odb:1,setup:1,submodule:1
+fetch-negotiator.c component=transport role=lib prefix=repo-settings includes=setup:1,transport:1 cochange=setup:8,transport:7,index:2,odb:1
+fetch-negotiator.h component=transport role=header prefix=fetch-negotiator cochange=transport:7,setup:3,odb:1,pack:1,revision:1
+fetch-object-info.c component=transport role=lib prefix=cat-file includes=transport:3,odb:2 cochange=transport:7,odb:1
+fetch-object-info.h component=transport role=header prefix=cat-file includes=transport:2 cochange=transport:7,odb:1
+fetch-pack.c component=transport role=lib prefix=fetch-pack includes=transport:8,odb:7,setup:4,pack:3,revision:2 cochange=transport:303,odb:96,revision:46,pack:40,setup:25
+fetch-pack.h component=transport role=header prefix=fetch-pack includes=odb:1,revision:1,transport:1 cochange=transport:108,odb:2,pack:2,refs:2,diff:1
+fmt-merge-msg.c component=merge role=lib prefix=fmt-merge-msg includes=odb:3,diff:2,revision:2,setup:2,merge:1 cochange=revision:10,odb:7,index:6,diff:4,setup:4
+fmt-merge-msg.h component=merge role=header prefix=fmt-merge-msg cochange=merge:3,setup:2
+for-each-ref.h component=? role=public prefix=?
+fsck.c component=odb role=lib prefix=fsck includes=odb:9,setup:3,convert:1,index:1,pack:1 cochange=odb:113,revision:46,transport:43,pack:20,setup:15
+fsck.h component=odb role=header prefix=fsck includes=odb:2 cochange=odb:50,diff:5,revision:5,transport:5,refs:4
+fsmonitor--daemon.h component=index role=header prefix=fsmonitor--daemon includes=index:1 cochange=index:1
+fsmonitor-ipc.c component=index role=lib prefix=fsmonitor includes=index:1,setup:1 cochange=index:6,transport:2,merge:1,notes:1,pack:1
+fsmonitor-ipc.h component=index role=header prefix=fsmonitor cochange=index:2
+fsmonitor-ll.h component=index role=header prefix=fsmonitor-ll cochange=index:4
+fsmonitor-path-utils.h component=index role=header prefix=fsmonitor cochange=index:2
+fsmonitor-settings.c component=index role=lib prefix=fsmonitor includes=index:3,setup:2 cochange=index:17,setup:10,transport:2,diff:1,odb:1
+fsmonitor-settings.h component=index role=header prefix=fsmonitor-settings cochange=index:11,setup:4
+fsmonitor.c component=index role=lib prefix=fsmonitor includes=index:4,setup:3 cochange=index:37,setup:16,transport:4,merge:2,refs:2
+fsmonitor.h component=index role=header prefix=fsmonitor includes=index:4,odb:1 cochange=index:24,setup:7,diff:3,submodule:1
+gettext.c component=? role=lib prefix=gettext includes=setup:1 cochange=pack:5,refs:3,setup:2,transport:2,merge:1
+gettext.h component=? role=public prefix=i18n cochange=transport:2,setup:1
+git-compat-util.h component=? role=public prefix=git-compat-util cochange=setup:48,index:35,odb:22,pack:21,diff:17
+git-curl-compat.h component=transport role=header prefix=git-curl-compat cochange=transport:22
+git-zlib.c component=? role=lib prefix=git-zlib cochange=archive:2,odb:1,transport:1
+git-zlib.h component=? role=public prefix=git-zlib cochange=archive:3,setup:2,odb:1,transport:1
+git.c component=? role=lib prefix=git includes=setup:4,odb:2,convert:1,index:1,revision:1 cochange=setup:70,revision:54,transport:47,index:28,diff:25
+gpg-interface.c component=? role=lib prefix=gpg-interface includes=setup:3,index:1,odb:1 cochange=revision:25,odb:22,setup:13,transport:11,diff:8
+gpg-interface.h component=? role=public prefix=gpg-interface cochange=odb:22,revision:15,merge:4,transport:3,refs:1
+graph.c component=revision role=lib prefix=graph includes=revision:2,odb:1,setup:1 cochange=revision:38,diff:23,index:4,odb:3,transport:3
+graph.h component=revision role=header prefix=graph includes=diff:1 cochange=revision:19,diff:2,odb:1
+grep.c component=? role=lib prefix=grep includes=diff:4,odb:1,revision:1,setup:1 cochange=diff:40,revision:28,transport:10,index:7,refs:7
+grep.h component=? role=public prefix=grep includes=diff:1 cochange=revision:23,diff:10,transport:4,index:2,refs:2
+hash-lookup.c component=odb role=lib prefix=hash includes=odb:2,index:1 cochange=pack:14,odb:12,diff:1,index:1,merge:1
+hash-lookup.h component=odb role=header prefix=hash-lookup cochange=odb:10,pack:8,diff:1,merge:1,revision:1
+hash.c component=odb role=lib prefix=hash includes=odb:1 cochange=odb:15,diff:2,setup:2,index:1,transport:1
+hash.h component=odb role=header prefix=hash includes=setup:1 cochange=odb:32,pack:11,index:9,diff:7,transport:4
+hashmap.c component=? role=lib prefix=hashmap cochange=diff:33,revision:19,index:17,refs:13,submodule:13
+hashmap.h component=? role=public prefix=hashmap cochange=diff:39,revision:23,index:18,submodule:14,refs:13
+help.c component=? role=lib prefix=help includes=setup:4,index:1,odb:1,refs:1,transport:1 cochange=setup:19,transport:19,diff:9,index:8,odb:7
+help.h component=? role=public prefix=help cochange=diff:1,odb:1,revision:1,transport:1
+hex-ll.c component=? role=lib prefix=hex-ll
+hex-ll.h component=? role=public prefix=hex-ll
+hex.c component=? role=lib prefix=hex includes=odb:1 cochange=odb:7,revision:5,notes:3,transport:3,refs:2
+hex.h component=? role=public prefix=hex includes=odb:1 cochange=revision:3,odb:2,convert:1,merge:1,pack:1
+hook.c component=setup role=lib prefix=hook includes=setup:4 cochange=setup:37,transport:10,odb:8,refs:5,diff:3
+hook.h component=setup role=header prefix=hook includes=setup:1 cochange=setup:34,transport:6,odb:5,refs:5,pack:3
+http-backend.c component=? role=program prefix=http-backend includes=setup:4,odb:3,transport:2,pack:1,refs:1 cochange=transport:57,pack:41,setup:19,refs:14,revision:13
+http-fetch.c component=? role=program prefix=http-fetch includes=setup:3,transport:2 cochange=transport:46,setup:10,pack:9,index:7,refs:7
+http-push.c component=? role=program prefix=http-push includes=odb:7,revision:3,setup:3,transport:2,diff:1 cochange=transport:272,odb:134,revision:82,pack:60,diff:34
+http-walker.c component=transport role=lib prefix=http includes=transport:3,odb:2,pack:1,revision:1,setup:1 cochange=transport:73,pack:40,odb:17,index:11,refs:7
+http.c component=transport role=lib prefix=http includes=transport:4,setup:3,odb:2,pack:2 cochange=transport:195,pack:71,odb:27,diff:8,setup:8
+http.h component=transport role=header prefix=http includes=transport:1 cochange=transport:149,pack:15,diff:6,odb:4,archive:3
+ident.c component=setup role=lib prefix=ident includes=setup:2 cochange=setup:19,revision:10,odb:6,refs:6,pack:4
+ident.h component=setup role=header prefix=ident cochange=setup:3,revision:1
+imap-send.c component=? role=program prefix=imap-send includes=setup:3,transport:1 cochange=transport:47,diff:16,index:16,refs:9,odb:8
+iterator.h component=? role=public prefix=refs cochange=index:2,refs:2
+json-writer.c component=? role=lib prefix=json-writer
+json-writer.h component=? role=public prefix=json-writer cochange=transport:1
+khash.h component=? role=public prefix=khash includes=odb:1 cochange=odb:7,pack:5,diff:4,revision:4,index:3
+kwset.c component=? role=lib prefix=kwset cochange=convert:2,diff:1,pack:1,revision:1
+kwset.h component=? role=public prefix=kwset
+levenshtein.c component=? role=lib prefix=? cochange=diff:2,revision:2,odb:1
+levenshtein.h component=? role=public prefix=? cochange=transport:2,diff:1,refs:1,setup:1
+line-log.c component=revision role=lib prefix=line-log includes=odb:4,revision:4,diff:3,setup:2,pack:1 cochange=revision:52,diff:48,odb:23,pack:15,notes:8
+line-log.h component=revision role=header prefix=line-log includes=diff:1 cochange=revision:20,odb:3,diff:2,setup:1,submodule:1
+line-range.c component=revision role=lib prefix=line-range includes=diff:2,revision:1 cochange=revision:14,diff:8,archive:1,odb:1,pack:1
+line-range.h component=revision role=header prefix=line-range cochange=revision:13
+linear-assignment.c component=? role=lib prefix=linear-assignment cochange=diff:1,revision:1
+linear-assignment.h component=? role=public prefix=linear-assignment
+list-objects-filter-options.c component=revision role=lib prefix=list-objects-filter-options includes=revision:1,setup:1,transport:1 cochange=revision:39,transport:21,setup:9,diff:6,index:4
+list-objects-filter-options.h component=revision role=header prefix=list-objects-filter includes=odb:1 cochange=revision:40,transport:17,odb:4,diff:3,refs:2
+list-objects-filter.c component=revision role=lib prefix=list-objects-filter includes=odb:5,revision:3,diff:1,index:1 cochange=revision:32,odb:13,index:10,diff:6,pack:3
+list-objects-filter.h component=revision role=header prefix=list-objects cochange=revision:16,odb:1
+list-objects.c component=revision role=lib prefix=list-objects includes=odb:6,revision:4,diff:1,pack:1,setup:1 cochange=revision:91,odb:68,pack:40,transport:28,index:15
+list-objects.h component=revision role=header prefix=list-objects cochange=revision:32,pack:13,transport:4,odb:1
+list.h component=revision role=header prefix=list cochange=submodule:2,transport:2,index:1,revision:1
+lockfile.c component=? role=lib prefix=lockfile includes=setup:1 cochange=refs:18,index:13,setup:9,diff:8,merge:3
+lockfile.h component=? role=public prefix=lockfile cochange=index:5,revision:4,diff:3,refs:3,odb:2
+log-tree.c component=revision role=lib prefix=format-patch includes=odb:8,revision:5,diff:3,setup:3,refs:2 cochange=revision:222,diff:112,odb:112,refs:31,transport:16
+log-tree.h component=revision role=header prefix=format-patch cochange=revision:64,diff:11,refs:3,odb:2,transport:2
+loose.c component=odb role=lib prefix=loose includes=odb:5,setup:1 cochange=odb:31,pack:18,setup:7,transport:6,refs:2
+loose.h component=odb role=header prefix=loose cochange=odb:8,setup:3
+ls-refs.c component=refs role=lib prefix=ls-refs includes=setup:3,refs:2,odb:1,transport:1 cochange=refs:26,transport:17,pack:10,revision:5,odb:4
+ls-refs.h component=refs role=header prefix=ls-refs cochange=transport:11,refs:5,submodule:1
+mailinfo.c component=? role=lib prefix=mailinfo includes=setup:2 cochange=transport:5,index:3,notes:3,odb:3,revision:3
+mailinfo.h component=? role=public prefix=mailinfo
+mailmap.c component=? role=lib prefix=mailmap includes=setup:3,odb:2 cochange=setup:13,transport:11,refs:10,index:8,revision:5
+mailmap.h component=? role=public prefix=mailmap cochange=setup:8,revision:4,transport:2,diff:1,index:1
+match-trees.c component=odb role=lib prefix=match-trees includes=odb:5,setup:1 cochange=odb:33,index:15,notes:15,revision:12,pack:10
+match-trees.h component=odb role=header prefix=match-trees cochange=merge:1,odb:1
+mem-pool.c component=? role=lib prefix=mem-pool cochange=index:6
+mem-pool.h component=? role=public prefix=mem-pool cochange=index:4
+merge-blobs.c component=merge role=lib prefix=object-store includes=merge:2,odb:2 cochange=merge:9,notes:3,diff:2,convert:1,odb:1
+merge-blobs.h component=merge role=header prefix=merge-blobs cochange=merge:2
+merge-ll.c component=merge role=lib prefix=merge-ll includes=convert:2,diff:1,merge:1,setup:1 cochange=merge:11,diff:6,transport:4,convert:2,index:2
+merge-ll.h component=merge role=header prefix=merge-ll cochange=merge:11,diff:2,convert:1,notes:1
+merge-ort-wrappers.c component=merge role=lib prefix=merge-ort includes=odb:4,merge:2,index:1,setup:1 cochange=merge:7,odb:2,notes:1,revision:1
+merge-ort-wrappers.h component=merge role=header prefix=merge includes=merge:1 cochange=merge:9,odb:2,revision:1
+merge-ort.c component=merge role=lib prefix=merge-ort includes=odb:8,index:6,diff:3,merge:2,revision:2 cochange=diff:41,merge:32,index:23,odb:23,revision:16
+merge-ort.h component=merge role=header prefix=merge-ort includes=odb:1 cochange=merge:19,odb:2,revision:2,diff:1
+merge.c component=merge role=lib prefix=merge includes=odb:4,index:2,merge:1,setup:1 cochange=index:22,merge:6,setup:4,diff:2,odb:2
+merge.h component=merge role=header prefix=merge cochange=merge:1
+mergesort.h component=? role=public prefix=mergesort cochange=odb:1
+midx-write.c component=pack role=lib prefix=midx-write includes=pack:5,odb:2,revision:2,refs:1,setup:1 cochange=pack:100,odb:20,refs:7,transport:6,setup:4
+midx.c component=pack role=lib prefix=midx includes=pack:5,index:1,odb:1,setup:1 cochange=pack:220,odb:34,transport:11,index:6,setup:4
+midx.h component=pack role=header prefix=midx cochange=pack:134,odb:5,setup:2,transport:2,refs:1
+name-hash.c component=index role=lib prefix=name-hash includes=index:3,odb:1,setup:1 cochange=diff:43,index:39,revision:18,setup:14,refs:12
+name-hash.h component=index role=header prefix=name-hash cochange=index:7
+notes-cache.c component=notes role=lib prefix=notes includes=odb:3,notes:1,refs:1,revision:1,setup:1 cochange=notes:37,odb:29,diff:10,index:10,revision:9
+notes-cache.h component=notes role=header prefix=notes-cache includes=notes:1 cochange=diff:7,notes:3
+notes-merge.c component=notes role=lib prefix=notes-merge includes=odb:4,diff:3,notes:3,index:1,merge:1 cochange=diff:54,revision:41,odb:37,notes:36,index:30
+notes-merge.h component=notes role=header prefix=notes-merge includes=notes:1 cochange=notes:18,odb:2
+notes-utils.c component=notes role=lib prefix=commit includes=setup:2,notes:1,odb:1,refs:1 cochange=notes:33,odb:15,refs:9,transport:9,revision:8
+notes-utils.h component=notes role=header prefix=notes includes=notes:1 cochange=notes:17,odb:6
+notes.c component=notes role=lib prefix=notes includes=odb:4,setup:2,notes:1,refs:1 cochange=notes:63,odb:58,revision:41,transport:36,index:24
+notes.h component=notes role=header prefix=notes cochange=notes:55,revision:20,setup:9,odb:3,refs:2
+object-file-convert.c component=odb role=lib prefix=object-file-convert includes=odb:5,setup:1 cochange=odb:8,setup:2,transport:1
+object-file-convert.h component=odb role=header prefix=object-file-convert includes=odb:1 cochange=odb:4
+object-file.c component=odb role=lib prefix=object-file includes=odb:6,index:2,pack:2,setup:2,convert:1 cochange=odb:183,pack:96,index:55,setup:30,transport:27
+object-file.h component=odb role=header prefix=object-file includes=odb:2 cochange=odb:113,pack:30,index:12,notes:5,transport:5
+object-name.c component=odb role=lib prefix=object-name includes=odb:8,setup:5,index:2,revision:2,pack:1 cochange=odb:46,pack:31,revision:23,setup:19,refs:18
+object-name.h component=odb role=header prefix=object-name includes=odb:1 cochange=odb:5,revision:3,refs:2,index:1
+object.c component=odb role=lib prefix=object includes=odb:8,index:1,pack:1 cochange=odb:265,pack:61,revision:55,transport:34,refs:17
+object.h component=odb role=header prefix=object includes=odb:1 cochange=odb:187,revision:54,transport:41,pack:29,refs:20
+odb.c component=odb role=lib prefix=odb includes=odb:7,pack:3,setup:3,index:1,submodule:1 cochange=odb:123,pack:64,setup:13,transport:12,index:8
+odb.h component=odb role=header prefix=odb includes=odb:3 cochange=odb:117,pack:71,transport:16,setup:13,index:10
+oid-array.c component=odb role=lib prefix=oid-array includes=odb:2 cochange=odb:13,pack:10,merge:2,diff:1,revision:1
+oid-array.h component=odb role=header prefix=oid-array includes=odb:1 cochange=odb:3,diff:1,index:1,refs:1,revision:1
+oidmap.c component=odb role=lib prefix=oidmap includes=odb:2 cochange=diff:11,revision:7,odb:6,refs:5,index:4
+oidmap.h component=odb role=header prefix=oidmap includes=odb:1 cochange=odb:6,revision:4,index:2,transport:2,convert:1
+oidset.c component=odb role=lib prefix=oidset includes=odb:1 cochange=odb:17,convert:2,diff:2,transport:2,index:1
+oidset.h component=odb role=header prefix=oidset cochange=odb:17,revision:1,transport:1
+oidtree.c component=odb role=lib prefix=oidtree includes=odb:2 cochange=odb:14,index:3,setup:2,diff:1,merge:1
+oidtree.h component=odb role=header prefix=oidtree includes=odb:2 cochange=odb:9
+pack-bitmap-write.c component=pack role=lib prefix=pack-bitmap-write includes=odb:7,pack:6,revision:2,setup:2,diff:1 cochange=pack:132,odb:32,revision:27,transport:10,diff:4
+pack-bitmap.c component=pack role=lib prefix=pack-bitmap includes=pack:7,odb:3,revision:3,setup:2,diff:1 cochange=pack:232,revision:30,odb:18,transport:14,refs:7
+pack-bitmap.h component=pack role=header prefix=pack-bitmap includes=pack:2,refs:1 cochange=pack:117,refs:5,odb:2,setup:2,revision:1
+pack-check.c component=pack role=lib prefix=pack-check includes=odb:2,pack:2,setup:2 cochange=pack:59,odb:26,transport:23,diff:11,index:10
+pack-mtimes.c component=pack role=lib prefix=pack-mtimes includes=pack:2,odb:1 cochange=pack:10,odb:3,transport:2,notes:1
+pack-mtimes.h component=pack role=header prefix=pack-mtimes cochange=pack:4,odb:2,setup:1,transport:1
+pack-objects.c component=pack role=lib prefix=pack-objects includes=pack:3,odb:1,setup:1 cochange=pack:66,diff:17,odb:16,transport:9,index:5
+pack-objects.h component=pack role=header prefix=pack-objects includes=pack:2,odb:1 cochange=pack:44,setup:5,odb:1
+pack-refs.c component=refs role=lib prefix=pack-refs includes=refs:2,setup:2,revision:1 cochange=refs:12,transport:8,index:2,merge:2,odb:2
+pack-refs.h component=refs role=header prefix=pack-refs cochange=refs:5
+pack-revindex.c component=pack role=lib prefix=pack-revindex includes=pack:3,odb:1,setup:1 cochange=pack:94,odb:7,index:6,transport:5,setup:4
+pack-revindex.h component=pack role=header prefix=pack-revindex cochange=pack:32,odb:1
+pack-write.c component=pack role=lib prefix=pack-write includes=pack:5,setup:2,odb:1,transport:1 cochange=pack:88,odb:21,transport:21,setup:14,index:10
+pack.h component=pack role=header prefix=pack-write includes=odb:1 cochange=pack:72,odb:13,transport:9,setup:5,revision:1
+packfile-list.c component=pack role=lib prefix=packfile includes=pack:2 cochange=pack:3
+packfile-list.h component=pack role=header prefix=packfile cochange=pack:3
+packfile.c component=pack role=lib prefix=packfile includes=odb:8,pack:7,setup:2,index:1,revision:1 cochange=pack:317,odb:134,transport:52,revision:36,index:27
+packfile.h component=pack role=header prefix=packfile includes=odb:3,pack:1,revision:1,setup:1 cochange=pack:234,odb:66,transport:32,revision:9,setup:7
+pager.c component=? role=lib prefix=pager includes=setup:4 cochange=setup:23,diff:9,transport:7,revision:3,submodule:3
+pager.h component=? role=public prefix=pager cochange=diff:3,setup:2,revision:1
+parallel-checkout.c component=index role=lib prefix=parallel-checkout includes=index:4,odb:1,setup:1,transport:1 cochange=index:26,transport:7,odb:6,diff:3,merge:3
+parallel-checkout.h component=index role=header prefix=parallel-checkout includes=convert:1 cochange=index:12,convert:1
+parse-options-cb.c component=? role=lib prefix=parse-options includes=odb:3,setup:2 cochange=revision:10,transport:10,diff:7,odb:4,refs:3
+parse-options.c component=? role=lib prefix=parse-options cochange=index:14,diff:12,setup:10,transport:10,odb:6
+parse-options.h component=? role=public prefix=parse-options cochange=diff:7,merge:4,archive:3,index:3,refs:3
+parse.c component=? role=lib prefix=parse cochange=setup:6,index:3,pack:2,convert:1
+parse.h component=? role=public prefix=config cochange=setup:6,index:3,pack:2,convert:1
+patch-delta.c component=pack role=lib prefix=patch-delta includes=pack:1 cochange=pack:23,diff:2,odb:2,transport:2,convert:1
+patch-ids.c component=diff role=lib prefix=patch-ids includes=diff:2,odb:2 cochange=diff:73,revision:34,index:14,odb:13,refs:12
+patch-ids.h component=diff role=header prefix=patch-ids includes=diff:1 cochange=diff:15,revision:3,index:1
+path-walk.c component=? role=lib prefix=path-walk includes=odb:9,revision:3,index:1,setup:1 cochange=index:2,revision:2,transport:2,odb:1,pack:1
+path-walk.h component=? role=public prefix=path-walk includes=odb:1 cochange=index:2
+path.c component=? role=lib prefix=path includes=setup:2,index:1,odb:1,pack:1,refs:1 cochange=setup:78,refs:29,index:26,transport:15,odb:12
+path.h component=? role=public prefix=path includes=setup:1 cochange=setup:23,refs:13,odb:11,index:10,pack:8
+pathspec.c component=index role=lib prefix=pathspec includes=index:4,setup:3,convert:1 cochange=index:89,setup:23,convert:16,diff:16,revision:9
+pathspec.h component=index role=header prefix=pathspec cochange=index:67,diff:11,odb:9,convert:6,submodule:4
+pkt-line.c component=transport role=lib prefix=pkt-line includes=transport:2 cochange=transport:102,pack:6,convert:5,diff:5,odb:3
+pkt-line.h component=transport role=header prefix=pkt-line cochange=transport:94,pack:5,convert:4,odb:2,diff:1
+preload-index.c component=index role=lib prefix=preload-index includes=index:6,setup:3 cochange=index:52,setup:15,diff:12,revision:5,merge:3
+preload-index.h component=index role=header prefix=preload-index cochange=index:2,setup:1
+pretty.c component=revision role=lib prefix=pretty includes=odb:3,revision:2,setup:2,diff:1,notes:1 cochange=revision:115,odb:72,refs:29,notes:23,transport:19
+pretty.h component=revision role=header prefix=pretty cochange=revision:26,refs:7,diff:5,odb:5,archive:4
+prio-queue.c component=? role=lib prefix=prio-queue cochange=odb:5,revision:5,diff:2,pack:2,transport:2
+prio-queue.h component=? role=public prefix=prio-queue cochange=odb:3,revision:2,transport:2,pack:1
+progress.c component=? role=lib prefix=progress includes=setup:1 cochange=index:11,diff:6,setup:6,pack:4,revision:2
+progress.h component=? role=public prefix=progress cochange=index:5,diff:3
+promisor-remote.c component=transport role=lib prefix=promisor-remote includes=setup:3,transport:2,odb:1,pack:1 cochange=transport:32,setup:15,odb:6,pack:5,index:4
+promisor-remote.h component=transport role=header prefix=promisor-remote includes=setup:1 cochange=transport:18,setup:7,diff:4,index:3,revision:3
+prompt.c component=? role=lib prefix=prompt includes=setup:2 cochange=index:7,setup:6,pack:4,diff:3,transport:2
+prompt.h component=? role=public prefix=prompt cochange=transport:1
+protocol-caps.c component=transport role=lib prefix=protocol-caps includes=odb:3,transport:2,setup:1 cochange=transport:6,odb:3,refs:2,merge:1,setup:1
+protocol-caps.h component=transport role=header prefix=protocol-caps cochange=transport:6,refs:2
+protocol.c component=transport role=lib prefix=protocol includes=setup:2,transport:1 cochange=transport:21,index:4,setup:4,refs:2,diff:1
+protocol.h component=transport role=header prefix=protocol cochange=transport:5
+prune-packed.c component=pack role=lib prefix=environment includes=pack:2,odb:1,setup:1 cochange=pack:13,odb:7,setup:5,diff:3,revision:3
+prune-packed.h component=pack role=header prefix=? cochange=pack:1
+pseudo-merge.c component=pack role=lib prefix=pseudo-merge includes=odb:3,pack:2,refs:1,setup:1 cochange=pack:21,refs:3
+pseudo-merge.h component=pack role=header prefix=pseudo-merge cochange=pack:17
+quote.c component=? role=lib prefix=quote cochange=index:15,diff:12,transport:7,odb:6,revision:6
+quote.h component=? role=public prefix=quote cochange=diff:8,transport:6,index:5,odb:5,refs:5
+range-diff.c component=diff role=lib prefix=range-diff includes=diff:4,odb:2,revision:2,setup:2 cochange=diff:49,revision:26,index:9,submodule:8,setup:7
+range-diff.h component=diff role=header prefix=range-diff includes=diff:1 cochange=diff:13,revision:4
+reachable.c component=pack role=lib prefix=reachable includes=pack:4,odb:3,refs:2,revision:2,diff:1 cochange=odb:60,pack:57,revision:47,transport:17,refs:14
+reachable.h component=pack role=header prefix=prune cochange=pack:5
+read-cache-ll.h component=index role=header prefix=read-cache includes=index:1,odb:1 cochange=index:8,diff:1,odb:1,revision:1
+read-cache.c component=index role=lib prefix=read-cache includes=index:10,odb:6,setup:4,diff:2,submodule:2 cochange=index:240,odb:81,setup:79,diff:67,pack:46
+read-cache.h component=index role=header prefix=read-cache includes=index:2,odb:1,setup:1 cochange=index:4,setup:4,diff:2
+rebase-interactive.c component=? role=lib prefix=rebase-interactive includes=odb:3,setup:3,index:1 cochange=revision:4,transport:4,index:3,odb:3,merge:2
+rebase-interactive.h component=? role=public prefix=rebase-interactive
+rebase.c component=? role=lib prefix=rebase cochange=index:3,pack:3,setup:2,convert:1,diff:1
+rebase.h component=? role=public prefix=pull
+ref-filter.c component=refs role=lib prefix=ref-filter includes=odb:6,setup:5,refs:3,revision:2,index:1 cochange=refs:112,revision:59,odb:41,transport:40,index:30
+ref-filter.h component=refs role=header prefix=ref-filter includes=odb:2,revision:1 cochange=refs:62,revision:7,transport:6,diff:5,index:4
+reflog-walk.c component=refs role=lib prefix=reflog-walk includes=refs:2,diff:1,odb:1,revision:1,setup:1 cochange=refs:34,revision:26,index:13,diff:9,transport:8
+reflog-walk.h component=refs role=header prefix=reflog-walk cochange=revision:23,refs:19,odb:6,archive:2,index:2
+reflog.c component=refs role=lib prefix=refs includes=odb:3,refs:2,setup:2,revision:1 cochange=refs:18,transport:13,odb:9,revision:7,diff:4
+reflog.h component=refs role=header prefix=reflog includes=refs:1 cochange=refs:8,odb:3,index:1,revision:1,transport:1
+refs.c component=refs role=lib prefix=refs includes=setup:6,odb:5,refs:2,submodule:1 cochange=refs:373,transport:133,setup:116,odb:82,revision:77
+refs.h component=refs role=header prefix=refs includes=odb:2,setup:2 cochange=refs:352,transport:55,revision:34,setup:25,odb:16
+refspec.c component=refs role=lib prefix=refspec includes=refs:2,odb:1,transport:1 cochange=refs:27,transport:26,index:2,submodule:2
+refspec.h component=refs role=header prefix=refspec cochange=transport:31,refs:29,submodule:3,index:2
+remote-curl.c component=transport role=lib prefix=remote-curl includes=transport:9,setup:3,odb:1 cochange=transport:226,diff:9,revision:6,setup:5,archive:4
+remote.c component=transport role=lib prefix=remote includes=odb:3,setup:3,transport:3,refs:2,revision:2 cochange=transport:272,refs:91,revision:56,index:51,odb:30
+remote.h component=transport role=header prefix=remote includes=odb:1,refs:1 cochange=transport:245,refs:24,index:12,revision:6,setup:2
+repack-cruft.c component=pack role=lib prefix=repack includes=pack:2,setup:1 cochange=pack:8,transport:2,odb:1
+repack-filtered.c component=pack role=lib prefix=repack includes=pack:1,setup:1 cochange=pack:1
+repack-geometry.c component=pack role=lib prefix=repack includes=pack:3,setup:1 cochange=pack:25,transport:2,odb:1
+repack-midx.c component=pack role=lib prefix=repack includes=odb:3,pack:3,refs:1 cochange=pack:23,refs:3,setup:2,merge:1,odb:1
+repack-promisor.c component=pack role=lib prefix=repack-promisor includes=pack:3,setup:1 cochange=pack:8,odb:3,revision:2
+repack.c component=pack role=lib prefix=repack includes=pack:3,index:1,odb:1,setup:1 cochange=pack:31,transport:2,odb:1
+repack.h component=pack role=header prefix=repack includes=revision:1 cochange=pack:28
+replace-object.c component=odb role=lib prefix=refs includes=odb:4,refs:1,setup:1 cochange=odb:8,setup:6,refs:5,pack:3,diff:2
+replace-object.h component=odb role=header prefix=replace-object includes=odb:2,setup:1 cochange=odb:11,setup:9,pack:4,revision:3,merge:1
+replay.c component=? role=lib prefix=replay includes=odb:2,merge:1,refs:1,revision:1,setup:1 cochange=transport:1
+replay.h component=? role=public prefix=replay includes=odb:1
+repo-settings.c component=setup role=lib prefix=repo-settings includes=setup:4,pack:2 cochange=setup:65,pack:17,index:8,transport:8,odb:6
+repo-settings.h component=setup role=header prefix=environment cochange=setup:40,pack:7,refs:6,odb:4,diff:2
+repository.c component=setup role=lib prefix=repository includes=setup:4,odb:3,index:2,transport:2,refs:1 cochange=setup:141,odb:39,index:27,refs:18,submodule:17
+repository.h component=setup role=header prefix=repository includes=setup:2 cochange=setup:157,index:31,refs:25,pack:22,odb:19
+rerere.c component=merge role=lib prefix=rerere includes=index:4,merge:2,odb:2,setup:2,diff:1 cochange=index:54,merge:29,pack:26,odb:25,transport:25
+rerere.h component=merge role=header prefix=rerere cochange=merge:16,odb:1
+reset.c component=? role=lib prefix=reset includes=odb:3,index:2,refs:1,setup:1 cochange=index:9,merge:5,odb:3,notes:2,revision:2
+reset.h component=? role=public prefix=reset includes=odb:1,setup:1
+resolve-undo.c component=index role=lib prefix=resolve-undo includes=index:4,odb:1 cochange=index:33,merge:5,revision:4,diff:3,notes:2
+resolve-undo.h component=index role=header prefix=resolve-undo includes=odb:1 cochange=index:12,merge:3,archive:1,revision:1
+revision.c component=revision role=lib prefix=revision includes=odb:9,revision:8,index:4,setup:4,diff:3 cochange=revision:379,diff:194,odb:181,refs:109,pack:101
+revision.h component=revision role=header prefix=revision includes=odb:4,revision:3,diff:1,notes:1,setup:1 cochange=revision:304,odb:48,diff:24,pack:19,refs:15
+run-command.c component=? role=lib prefix=run-command includes=setup:2,index:1,pack:1 cochange=transport:27,index:21,setup:14,odb:8,submodule:6
+run-command.h component=? role=public prefix=run-command cochange=transport:21,setup:8,odb:6,submodule:5,refs:4
+sane-ctype.h component=? role=public prefix=sane-ctype
+scalar.c component=? role=lib prefix=scalar includes=index:3,setup:2,pack:1,refs:1 cochange=setup:9,transport:7,pack:4,index:3,merge:3
+send-pack.c component=transport role=lib prefix=send-pack includes=transport:6,odb:3,setup:2,revision:1 cochange=transport:177,odb:29,revision:17,refs:15,pack:8
+send-pack.h component=transport role=header prefix=send-pack cochange=transport:39
+sequencer.c component=? role=lib prefix=sequencer includes=odb:8,index:5,merge:4,setup:4,revision:3 cochange=revision:84,odb:83,index:77,refs:60,transport:55
+sequencer.h component=? role=public prefix=sequencer includes=index:1 cochange=revision:5,index:4,notes:3,odb:3,transport:3
+serve.c component=transport role=lib prefix=serve includes=transport:6,setup:3,odb:1,refs:1 cochange=transport:53,refs:7,odb:4,setup:3,index:1
+serve.h component=transport role=header prefix=serve cochange=transport:9,refs:3,submodule:1
+server-info.c component=pack role=lib prefix=server-info includes=odb:5,pack:2,index:1,refs:1,setup:1 cochange=pack:40,transport:34,odb:33,setup:13,refs:10
+server-info.h component=pack role=header prefix=server-info cochange=pack:2
+setup.c component=setup role=lib prefix=setup includes=setup:4,odb:2,refs:2,index:1,revision:1 cochange=setup:177,refs:47,transport:44,index:39,odb:24
+setup.h component=setup role=header prefix=setup includes=refs:1 cochange=setup:70,refs:8,index:5,revision:4,submodule:4
+sh-i18n--envsubst.c component=? role=program prefix=sh-i18n--envsubst cochange=index:3,diff:1,transport:1
+sha1dc_git.c component=? role=lib prefix=sha1dc cochange=diff:3,odb:2,revision:2,setup:1
+sha1dc_git.h component=? role=public prefix=sha1dc cochange=odb:2
+shallow.c component=revision role=lib prefix=shallow includes=odb:5,revision:4,diff:1,index:1,refs:1 cochange=odb:83,transport:73,revision:31,index:20,refs:14
+shallow.h component=revision role=header prefix=shallow includes=odb:2,setup:1 cochange=revision:10,transport:7,odb:5,diff:3,index:2
+shell.c component=? role=program prefix=shell includes=setup:1 cochange=transport:10,setup:4,revision:2
+shortlog.h component=? role=public prefix=shortlog cochange=revision:2
+sideband.c component=transport role=lib prefix=sideband includes=transport:2,setup:1 cochange=transport:51,revision:6,diff:5,index:5,refs:4
+sideband.h component=transport role=header prefix=sideband cochange=transport:23
+sigchain.c component=? role=lib prefix=sigchain cochange=diff:2,transport:1
+sigchain.h component=? role=public prefix=sigchain cochange=diff:2
+simple-ipc.h component=? role=public prefix=simple-ipc includes=transport:1 cochange=submodule:1
+sparse-index.c component=index role=lib prefix=sparse-index includes=index:7,setup:3,odb:1 cochange=index:42,setup:17,diff:2,odb:2,revision:1
+sparse-index.h component=index role=header prefix=sparse-index cochange=index:16,setup:4,merge:1,revision:1
+split-index.c component=index role=lib prefix=split-index includes=index:2,odb:1,setup:1 cochange=index:46,odb:5,revision:4,pack:3,merge:2
+split-index.h component=index role=header prefix=split-index includes=odb:1 cochange=index:21,archive:1,merge:1,revision:1
+stable-qsort.c component=? role=lib prefix=stable-qsort
+statinfo.c component=index role=lib prefix=environment includes=setup:2,index:1 cochange=index:9,setup:6,diff:2,odb:1,revision:1
+statinfo.h component=index role=header prefix=statinfo cochange=index:8,odb:1,revision:1
+strbuf.c component=? role=lib prefix=strbuf cochange=index:16,odb:12,setup:11,revision:10,transport:10
+strbuf.h component=? role=public prefix=strbuf cochange=revision:15,index:14,odb:14,diff:7,setup:7
+string-list.c component=? role=lib prefix=string-list cochange=transport:14,index:8,notes:7,refs:7,diff:5
+string-list.h component=? role=public prefix=string-list cochange=transport:19,index:6,notes:6,diff:5,refs:5
+strmap.c component=? role=lib prefix=strmap
+strmap.h component=? role=public prefix=strmap
+strvec.c component=? role=lib prefix=strvec
+strvec.h component=? role=public prefix=strvec cochange=submodule:3,revision:2,index:1,transport:1
+sub-process.c component=? role=lib prefix=sub-process includes=transport:1 cochange=diff:19,convert:12,revision:11,index:8,refs:8
+sub-process.h component=? role=public prefix=sub-process cochange=convert:8,transport:6,refs:5,diff:4,odb:4
+submodule-config.c component=submodule role=lib prefix=submodule-config includes=odb:3,setup:3,submodule:2,index:1 cochange=submodule:60,setup:41,diff:36,revision:27,odb:22
+submodule-config.h component=submodule role=header prefix=submodule-config includes=odb:1,setup:1,submodule:1 cochange=submodule:54,setup:9,odb:3,diff:2,index:2
+submodule.c component=submodule role=lib prefix=submodule includes=odb:5,setup:4,diff:2,index:2,refs:2 cochange=submodule:134,diff:83,setup:66,index:60,revision:49
+submodule.h component=submodule role=header prefix=submodule cochange=submodule:128,index:22,diff:21,transport:17,setup:6
+symlinks.c component=index role=lib prefix=symlinks includes=index:1,setup:1 cochange=index:23,diff:3,archive:2,convert:1,revision:1
+symlinks.h component=index role=header prefix=symlinks cochange=index:9,diff:1
+tag.c component=odb role=lib prefix=tag includes=odb:7,setup:2,pack:1 cochange=odb:189,transport:36,pack:32,revision:29,refs:14
+tag.h component=odb role=header prefix=tag includes=odb:1 cochange=odb:60,transport:10,revision:8,refs:7,pack:6
+tar.h component=? role=public prefix=tar-tree
+tempfile.c component=? role=lib prefix=tempfile cochange=pack:5,setup:4,index:3,odb:3,revision:3
+tempfile.h component=? role=public prefix=tempfile includes=revision:1 cochange=revision:3,diff:2,index:2,setup:2
+thread-utils.c component=? role=lib prefix=thread-utils cochange=diff:1
+thread-utils.h component=? role=public prefix=thread-utils cochange=transport:1
+tmp-objdir.c component=odb role=lib prefix=tmp-objdir includes=odb:3,setup:2,index:1 cochange=pack:24,odb:23,setup:8,transport:5,revision:3
+tmp-objdir.h component=odb role=header prefix=tmp-objdir cochange=odb:8,revision:3,setup:1
+trace.c component=? role=lib prefix=trace includes=setup:2 cochange=setup:26,transport:13,index:11,odb:4,diff:2
+trace.h component=? role=public prefix=trace cochange=transport:6,index:5,odb:4,pack:3,revision:3
+trace2.c component=? role=lib prefix=trace2 includes=setup:2 cochange=setup:2
+trace2.h component=? role=public prefix=trace2 cochange=setup:2
+trailer.c component=? role=lib prefix=trailer includes=setup:2,odb:1,revision:1 cochange=transport:13,revision:12,odb:8,index:7,refs:6
+trailer.h component=? role=public prefix=trailer includes=revision:1 cochange=revision:7,refs:1
+transport-helper.c component=transport role=lib prefix=transport-helper includes=transport:4,odb:2,refs:2,setup:2,pack:1 cochange=transport:210,refs:23,revision:16,odb:14,index:12
+transport-internal.h component=transport role=header prefix=transport includes=transport:1 cochange=transport:42,refs:3,odb:1,submodule:1
+transport.c component=transport role=lib prefix=transport includes=transport:12,setup:3,odb:2,refs:2,submodule:1 cochange=transport:482,refs:35,setup:31,submodule:29,revision:21
+transport.h component=transport role=header prefix=transport includes=transport:2,revision:1 cochange=transport:249,submodule:6,odb:4,revision:2,diff:1
+tree-diff.c component=diff role=lib prefix=tree-diff includes=odb:3,diff:2,index:1,setup:1 cochange=diff:115,odb:56,revision:53,index:36,notes:12
+tree-walk.c component=odb role=lib prefix=tree-walk includes=odb:4,index:3,setup:1 cochange=odb:70,index:61,diff:31,revision:24,pack:13
+tree-walk.h component=odb role=header prefix=tree-walk includes=odb:1 cochange=odb:64,diff:23,index:23,revision:21,notes:7
+tree.c component=odb role=lib prefix=tree includes=odb:6,setup:2 cochange=odb:212,revision:45,index:36,pack:25,transport:21
+tree.h component=odb role=header prefix=tree includes=odb:1 cochange=odb:75,revision:12,archive:8,index:6,pack:5
+unicode-width.h component=? role=public prefix=unicode
+unix-socket.c component=? role=lib prefix=unix-socket cochange=diff:3,revision:2,setup:1
+unix-socket.h component=? role=public prefix=unix-socket
+unix-stream-server.c component=? role=lib prefix=unix-stream-server
+unix-stream-server.h component=? role=public prefix=unix-stream-server
+unpack-trees.c component=index role=lib prefix=unpack-trees includes=index:11,odb:3,setup:3,submodule:2,convert:1 cochange=index:262,odb:49,diff:41,transport:19,revision:18
+unpack-trees.h component=index role=header prefix=unpack-trees includes=convert:1,index:1,odb:1 cochange=index:75,diff:9,odb:6,setup:5,merge:4
+upload-pack.c component=transport role=lib prefix=upload-pack includes=transport:6,odb:4,revision:4,setup:4,diff:1 cochange=transport:198,odb:88,revision:80,refs:55,pack:34
+upload-pack.h component=transport role=header prefix=upload-pack cochange=transport:18,refs:5,submodule:1
+url.c component=? role=lib prefix=url cochange=transport:12,revision:8,diff:6,index:2,refs:2
+url.h component=? role=public prefix=url cochange=transport:9,revision:4,submodule:1
+urlmatch.c component=? role=lib prefix=urlmatch cochange=diff:3,odb:2,revision:2,setup:2,transport:2
+urlmatch.h component=? role=public prefix=urlmatch includes=setup:1 cochange=transport:1
+usage.c component=? role=lib prefix=usage cochange=index:3,odb:2,diff:1,revision:1,setup:1
+userdiff.c component=diff role=lib prefix=userdiff includes=setup:2,convert:1,diff:1 cochange=diff:41,convert:34,archive:11,index:7,transport:6
+userdiff.h component=diff role=header prefix=diff includes=notes:1 cochange=diff:40,notes:2,archive:1,merge:1,revision:1
+utf8.c component=? role=lib prefix=utf8 cochange=revision:6,index:3,setup:3,transport:2,convert:1
+utf8.h component=? role=public prefix=utf8 cochange=revision:6,index:2,setup:2,transport:2,convert:1
+varint.c component=? role=lib prefix=varint cochange=index:2,transport:1
+varint.h component=? role=public prefix=varint cochange=index:2,transport:1
+version.c component=setup role=lib prefix=version includes=setup:1 cochange=setup:8,transport:2
+version.h component=setup role=header prefix=version cochange=setup:8,transport:2
+versioncmp.c component=? role=lib prefix=versioncmp includes=setup:1 cochange=setup:5,pack:3,transport:3,index:2,refs:2
+versioncmp.h component=? role=public prefix=versioncmp cochange=refs:1
+walker.c component=transport role=lib prefix=refs includes=odb:6,refs:1,setup:1,transport:1 cochange=odb:70,transport:55,revision:42,refs:24,pack:17
+walker.h component=transport role=header prefix=walker includes=transport:1 cochange=transport:19
+wildmatch.c component=? role=lib prefix=hex cochange=index:4,refs:3,diff:1,odb:1,revision:1
+wildmatch.h component=? role=public prefix=? cochange=index:3,refs:2,diff:1,revision:1,setup:1
+worktree.c component=refs role=lib prefix=worktree includes=setup:4,index:2,refs:2 cochange=refs:73,setup:53,index:22,submodule:13,pack:11
+worktree.h component=refs role=header prefix=worktree includes=refs:1 cochange=refs:61,revision:10,pack:5,setup:5,odb:4
+wrapper.c component=? role=lib prefix=wrapper cochange=setup:21,index:16,pack:6,transport:5,convert:4
+wrapper.h component=? role=public prefix=wrapper cochange=index:2,revision:1,setup:1
+write-or-die.c component=? role=lib prefix=write-or-die cochange=pack:6,setup:6,index:4,transport:2,convert:1
+write-or-die.h component=? role=public prefix=write-or-die
+ws.c component=convert role=lib prefix=whitespace includes=convert:2 cochange=convert:24,diff:18,archive:9,index:5,setup:5
+ws.h component=convert role=header prefix=whitespace cochange=diff:5,convert:2,setup:2
+wt-status.c component=index role=lib prefix=wt-status includes=odb:5,index:4,setup:3,diff:2,refs:2 cochange=index:149,diff:83,transport:55,refs:45,revision:45
+wt-status.h component=index role=header prefix=wt-status includes=index:1,transport:1 cochange=index:89,diff:10,refs:9,revision:4,transport:4
+xdiff-interface.c component=diff role=lib prefix=xdiff-interface includes=setup:2,diff:1,odb:1 cochange=diff:73,index:5,merge:3,notes:3,refs:3
+xdiff-interface.h component=diff role=header prefix=xdiff-interface includes=odb:1 cochange=diff:62,index:2,notes:2,merge:1,odb:1

.gitorganize, Makefile, add-interactive.c, archive.c, attr.c, bisect.c, blame.c, branch.c, builtin/am.c, builtin/bisect.c, builtin/blame.c, builtin/branch.c, builtin/check-ref-format.c, builtin/checkout.c, builtin/clone.c, builtin/config.c, builtin/describe.c, builtin/fast-export.c, builtin/fast-import.c, builtin/fetch.c, builtin/for-each-ref.c, builtin/fsck.c, builtin/gc.c, builtin/history.c, builtin/init-db.c, builtin/log.c, builtin/ls-remote.c, builtin/merge.c, builtin/name-rev.c, builtin/notes.c, builtin/pack-objects.c, builtin/pack-refs.c, builtin/pull.c, builtin/push.c, builtin/rebase.c, builtin/receive-pack.c, builtin/reflog.c, builtin/refs.c, builtin/remote.c, builtin/replace.c, builtin/replay.c, builtin/repo.c, builtin/reset.c, builtin/rev-list.c, builtin/rev-parse.c, builtin/show-branch.c, builtin/sparse-checkout.c, builtin/stash.c, builtin/submodule--helper.c, builtin/symbolic-ref.c, builtin/tag.c, builtin/update-index.c, builtin/update-ref.c, builtin/var.c, builtin/verify-tag.c, builtin/worktree.c, bundle-uri.c, bundle.c, checkout.c, combine-diff.c, commit-graph.c, commit-reach.c, config.c, connect.c, delta-islands.c, diff-lib.c, dir.c, environment.c, fetch-pack.c, fmt-merge-msg.c, help.c, http-backend.c, log-tree.c, merge-ort.c, meson.build, midx-write.c, negotiator/default.c, negotiator/skipping.c, notes-cache.c, notes-merge.c, notes-utils.c, notes.c, odb/commit.c, odb/fsck.c, odb/object-name.c, odb/replace-object.c, pack-bitmap-write.c, pack-bitmap.h, path.c, pretty.c, pseudo-merge.c, reachable.c, read-cache.c, refs/files-backend.c, refs/iterator.c, ls-refs.c, refs/ls-refs.c, ls-refs.h, pack-refs.c, refs/pack-refs.c, pack-refs.h, refs/packed-backend.c, refs/ref-cache.c, ref-filter.c, refs/ref-filter.c, ref-filter.h, reflog-walk.c, refs/reflog-walk.c, reflog-walk.h, reflog.c, refs/reflog.c, reflog.h, refs/reflog.h, refs/refs-internal.h, refs.c, refs/refs.c, refs.h, refspec.c, refs/refspec.c, refspec.h, refs/reftable-backend.c, worktree.c, refs/worktree.c, worktree.h, refs/worktree.h, remote.c, remote.h, repack-midx.c, replay.c, repository.c, reset.c, revision.c, scalar.c, sequencer.c, serve.c, server-info.c, setup.c, setup.h, shallow.c, submodule.c, t/helper/test-reach.c, t/helper/test-ref-store.c, transport-helper.c, transport.c, unpack-trees.c, upload-pack.c, walker.c, wt-status.c

diff --git a/.gitorganize b/.gitorganize
index 5da6d0b2b1..e29497504a 100644
--- a/.gitorganize
+++ b/.gitorganize
@@ -201,8 +201,6 @@ lockfile.c component=? role=lib prefix=lockfile includes=setup:1 cochange=refs:1
 lockfile.h component=? role=public prefix=lockfile cochange=index:5,revision:4,diff:3,refs:3,odb:2
 log-tree.c component=revision role=lib prefix=format-patch includes=odb:8,revision:5,diff:3,setup:3,refs:2 cochange=revision:222,diff:112,odb:112,refs:31,transport:16
 log-tree.h component=revision role=header prefix=format-patch cochange=revision:64,diff:11,refs:3,odb:2,transport:2
-ls-refs.c component=refs role=lib prefix=ls-refs includes=setup:3,refs:2,odb:1,transport:1 cochange=refs:26,transport:17,pack:10,revision:5,odb:4
-ls-refs.h component=refs role=header prefix=ls-refs cochange=transport:11,refs:5,submodule:1
 mailinfo.c component=? role=lib prefix=mailinfo includes=setup:2 cochange=transport:5,index:3,notes:3,odb:3,revision:3
 mailinfo.h component=? role=public prefix=mailinfo
 mailmap.c component=? role=lib prefix=mailmap includes=setup:3,odb:2 cochange=setup:13,transport:11,refs:10,index:8,revision:5
@@ -290,8 +288,6 @@ pack-mtimes.c component=pack role=lib prefix=pack-mtimes includes=pack:2,odb:1 c
 pack-mtimes.h component=pack role=header prefix=pack-mtimes cochange=pack:4,odb:2,setup:1,transport:1
 pack-objects.c component=pack role=lib prefix=pack-objects includes=pack:3,odb:1,setup:1 cochange=pack:66,diff:17,odb:16,transport:9,index:5
 pack-objects.h component=pack role=header prefix=pack-objects includes=pack:2,odb:1 cochange=pack:44,setup:5,odb:1
-pack-refs.c component=refs role=lib prefix=pack-refs includes=refs:2,setup:2,revision:1 cochange=refs:12,transport:8,index:2,merge:2,odb:2
-pack-refs.h component=refs role=header prefix=pack-refs cochange=refs:5
 pack-revindex.c component=pack role=lib prefix=pack-revindex includes=pack:3,odb:1,setup:1 cochange=pack:94,odb:7,index:6,transport:5,setup:4
 pack-revindex.h component=pack role=header prefix=pack-revindex cochange=pack:32,odb:1
 pack-write.c component=pack role=lib prefix=pack-write includes=pack:5,setup:2,odb:1,transport:1 cochange=pack:88,odb:21,transport:21,setup:14,index:10
@@ -353,16 +349,22 @@ rebase-interactive.c component=? role=lib prefix=rebase-interactive includes=odb
 rebase-interactive.h component=? role=public prefix=rebase-interactive
 rebase.c component=? role=lib prefix=rebase cochange=index:3,pack:3,setup:2,convert:1,diff:1
 rebase.h component=? role=public prefix=pull
-ref-filter.c component=refs role=lib prefix=ref-filter includes=odb:6,setup:5,refs:3,revision:2,index:1 cochange=refs:112,revision:59,odb:41,transport:40,index:30
-ref-filter.h component=refs role=header prefix=ref-filter includes=odb:2,revision:1 cochange=refs:62,revision:7,transport:6,diff:5,index:4
-reflog-walk.c component=refs role=lib prefix=reflog-walk includes=refs:2,diff:1,odb:1,revision:1,setup:1 cochange=refs:34,revision:26,index:13,diff:9,transport:8
-reflog-walk.h component=refs role=header prefix=reflog-walk cochange=revision:23,refs:19,odb:6,archive:2,index:2
-reflog.c component=refs role=lib prefix=refs includes=odb:3,refs:2,setup:2,revision:1 cochange=refs:18,transport:13,odb:9,revision:7,diff:4
-reflog.h component=refs role=header prefix=reflog includes=refs:1 cochange=refs:8,odb:3,index:1,revision:1,transport:1
-refs.c component=refs role=lib prefix=refs includes=setup:6,odb:5,refs:2,submodule:1 cochange=refs:373,transport:133,setup:116,odb:82,revision:77
-refs.h component=refs role=header prefix=refs includes=odb:2,setup:2 cochange=refs:352,transport:55,revision:34,setup:25,odb:16
-refspec.c component=refs role=lib prefix=refspec includes=refs:2,odb:1,transport:1 cochange=refs:27,transport:26,index:2,submodule:2
-refspec.h component=refs role=header prefix=refspec cochange=transport:31,refs:29,submodule:3,index:2
+refs/ls-refs.c component=refs role=lib prefix=ls-refs includes=setup:3,refs:2,odb:1,transport:1 cochange=refs:26,transport:17,pack:10,revision:5,odb:4
+refs/ls-refs.h component=refs role=header prefix=ls-refs cochange=transport:11,refs:5,submodule:1
+refs/pack-refs.c component=refs role=lib prefix=pack-refs includes=refs:2,setup:2,revision:1 cochange=refs:12,transport:8,index:2,merge:2,odb:2
+refs/pack-refs.h component=refs role=header prefix=pack-refs cochange=refs:5
+refs/ref-filter.c component=refs role=lib prefix=ref-filter includes=odb:6,setup:5,refs:3,revision:2,index:1 cochange=refs:112,revision:59,odb:41,transport:40,index:30
+refs/ref-filter.h component=refs role=header prefix=ref-filter includes=odb:2,revision:1 cochange=refs:62,revision:7,transport:6,diff:5,index:4
+refs/reflog-walk.c component=refs role=lib prefix=reflog-walk includes=refs:2,diff:1,odb:1,revision:1,setup:1 cochange=refs:34,revision:26,index:13,diff:9,transport:8
+refs/reflog-walk.h component=refs role=header prefix=reflog-walk cochange=revision:23,refs:19,odb:6,archive:2,index:2
+refs/reflog.c component=refs role=lib prefix=refs includes=odb:3,refs:2,setup:2,revision:1 cochange=refs:18,transport:13,odb:9,revision:7,diff:4
+refs/reflog.h component=refs role=header prefix=reflog includes=refs:1 cochange=refs:8,odb:3,index:1,revision:1,transport:1
+refs/refs.c component=refs role=lib prefix=refs includes=setup:6,odb:5,refs:2,submodule:1 cochange=refs:373,transport:133,setup:116,odb:82,revision:77
+refs/refs.h component=refs role=header prefix=refs includes=odb:2,setup:2 cochange=refs:352,transport:55,revision:34,setup:25,odb:16
+refs/refspec.c component=refs role=lib prefix=refspec includes=refs:2,odb:1,transport:1 cochange=refs:27,transport:26,index:2,submodule:2
+refs/refspec.h component=refs role=header prefix=refspec cochange=transport:31,refs:29,submodule:3,index:2
+refs/worktree.c component=refs role=lib prefix=worktree includes=setup:4,index:2,refs:2 cochange=refs:73,setup:53,index:22,submodule:13,pack:11
+refs/worktree.h component=refs role=header prefix=worktree includes=refs:1 cochange=refs:61,revision:10,pack:5,setup:5,odb:4
 remote-curl.c component=transport role=lib prefix=remote-curl includes=transport:9,setup:3,odb:1 cochange=transport:226,diff:9,revision:6,setup:5,archive:4
 remote.c component=transport role=lib prefix=remote includes=odb:3,setup:3,transport:3,refs:2,revision:2 cochange=transport:272,refs:91,revision:56,index:51,odb:30
 remote.h component=transport role=header prefix=remote includes=odb:1,refs:1 cochange=transport:245,refs:24,index:12,revision:6,setup:2
@@ -480,8 +482,6 @@ walker.c component=transport role=lib prefix=refs includes=odb:6,refs:1,setup:1,
 walker.h component=transport role=header prefix=walker includes=transport:1 cochange=transport:19
 wildmatch.c component=? role=lib prefix=hex cochange=index:4,refs:3,diff:1,odb:1,revision:1
 wildmatch.h component=? role=public prefix=? cochange=index:3,refs:2,diff:1,revision:1,setup:1
-worktree.c component=refs role=lib prefix=worktree includes=setup:4,index:2,refs:2 cochange=refs:73,setup:53,index:22,submodule:13,pack:11
-worktree.h component=refs role=header prefix=worktree includes=refs:1 cochange=refs:61,revision:10,pack:5,setup:5,odb:4
 wrapper.c component=? role=lib prefix=wrapper cochange=setup:21,index:16,pack:6,transport:5,convert:4
 wrapper.h component=? role=public prefix=wrapper cochange=index:2,revision:1,setup:1
 write-or-die.c component=? role=lib prefix=write-or-die cochange=pack:6,setup:6,index:4,transport:2,convert:1
diff --git a/Makefile b/Makefile
index a95b87d970..f733ccfee0 100644
--- a/Makefile
+++ b/Makefile
@@ -1201,7 +1201,7 @@ LIB_OBJS += list-objects.o
 LIB_OBJS += lockfile.o
 LIB_OBJS += log-tree.o
 LIB_OBJS += odb/loose.o
-LIB_OBJS += ls-refs.o
+LIB_OBJS += refs/ls-refs.o
 LIB_OBJS += mailinfo.o
 LIB_OBJS += mailmap.o
 LIB_OBJS += odb/match-trees.o
@@ -1246,7 +1246,7 @@ LIB_OBJS += pack-bitmap.o
 LIB_OBJS += pack-check.o
 LIB_OBJS += pack-mtimes.o
 LIB_OBJS += pack-objects.o
-LIB_OBJS += pack-refs.o
+LIB_OBJS += refs/pack-refs.o
 LIB_OBJS += pack-revindex.o
 LIB_OBJS += pack-write.o
 LIB_OBJS += packfile.o
@@ -1278,17 +1278,17 @@ LIB_OBJS += reachable.o
 LIB_OBJS += read-cache.o
 LIB_OBJS += rebase-interactive.o
 LIB_OBJS += rebase.o
-LIB_OBJS += ref-filter.o
-LIB_OBJS += reflog-walk.o
-LIB_OBJS += reflog.o
-LIB_OBJS += refs.o
+LIB_OBJS += refs/ref-filter.o
+LIB_OBJS += refs/reflog-walk.o
+LIB_OBJS += refs/reflog.o
+LIB_OBJS += refs/refs.o
 LIB_OBJS += refs/debug.o
 LIB_OBJS += refs/files-backend.o
 LIB_OBJS += refs/reftable-backend.o
 LIB_OBJS += refs/iterator.o
 LIB_OBJS += refs/packed-backend.o
 LIB_OBJS += refs/ref-cache.o
-LIB_OBJS += refspec.o
+LIB_OBJS += refs/refspec.o
 LIB_OBJS += reftable/basics.o
 LIB_OBJS += reftable/block.o
 LIB_OBJS += reftable/blocksource.o
@@ -1377,7 +1377,7 @@ LIB_OBJS += version.o
 LIB_OBJS += versioncmp.o
 LIB_OBJS += walker.o
 LIB_OBJS += wildmatch.o
-LIB_OBJS += worktree.o
+LIB_OBJS += refs/worktree.o
 LIB_OBJS += wrapper.o
 LIB_OBJS += write-or-die.o
 LIB_OBJS += ws.o
diff --git a/add-interactive.c b/add-interactive.c
index 51ddcc4e87..67ee53f5cc 100644
--- a/add-interactive.c
+++ b/add-interactive.c
@@ -11,7 +11,7 @@
 #include "read-cache-ll.h"
 #include "repository.h"
 #include "revision.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "string-list.h"
 #include "lockfile.h"
 #include "dir.h"
diff --git a/archive.c b/archive.c
index c0d2e0c44b..53820bd859 100644
--- a/archive.c
+++ b/archive.c
@@ -13,7 +13,7 @@
 #include "path.h"
 #include "pretty.h"
 #include "setup.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/odb.h"
 #include "odb/commit.h"
 #include "odb/tree.h"
diff --git a/attr.c b/attr.c
index e829149cb4..e7c6562bee 100644
--- a/attr.c
+++ b/attr.c
@@ -20,7 +20,7 @@
 #include "utf8.h"
 #include "quote.h"
 #include "read-cache-ll.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "revision.h"
 #include "odb/odb.h"
 #include "setup.h"
diff --git a/bisect.c b/bisect.c
index 2dea7139ad..85c5a12ed2 100644
--- a/bisect.c
+++ b/bisect.c
@@ -9,7 +9,7 @@
 #include "gettext.h"
 #include "hex.h"
 #include "revision.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "list-objects.h"
 #include "quote.h"
 #include "run-command.h"
diff --git a/blame.c b/blame.c
index d1cba8811f..a594dc5f0e 100644
--- a/blame.c
+++ b/blame.c
@@ -2,7 +2,7 @@
 #define DISABLE_SIGN_COMPARE_WARNINGS
 
 #include "git-compat-util.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/odb.h"
 #include "cache-tree.h"
 #include "mergesort.h"
diff --git a/branch.c b/branch.c
index 7593a499a9..d752e55b88 100644
--- a/branch.c
+++ b/branch.c
@@ -9,13 +9,13 @@
 #include "hex.h"
 #include "odb/object-name.h"
 #include "path.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "remote.h"
 #include "repository.h"
 #include "sequencer.h"
 #include "odb/commit.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "submodule-config.h"
 #include "run-command.h"
 #include "strmap.h"
diff --git a/builtin/am.c b/builtin/am.c
index f138a8fe3d..d7e4e125d2 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -22,7 +22,7 @@
 #include "tempfile.h"
 #include "lockfile.h"
 #include "cache-tree.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/commit.h"
 #include "diff.h"
 #include "unpack-trees.h"
diff --git a/builtin/bisect.c b/builtin/bisect.c
index a1b7fc9407..51e2e949cc 100644
--- a/builtin/bisect.c
+++ b/builtin/bisect.c
@@ -9,7 +9,7 @@
 #include "odb/object-name.h"
 #include "parse-options.h"
 #include "bisect.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "strvec.h"
 #include "run-command.h"
 #include "odb/oid-array.h"
diff --git a/builtin/blame.c b/builtin/blame.c
index c88fc489f7..1662bd487d 100644
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@ -30,7 +30,7 @@
 #include "odb/odb.h"
 #include "pager.h"
 #include "blame.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "setup.h"
 #include "odb/tag.h"
 #include "write-or-die.h"
diff --git a/builtin/branch.c b/builtin/branch.c
index c50c28c720..7909f250aa 100644
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -12,7 +12,7 @@
 #include "color.h"
 #include "editor.h"
 #include "environment.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/commit.h"
 #include "gettext.h"
 #include "odb/object-name.h"
@@ -24,8 +24,8 @@
 #include "strmap.h"
 #include "column.h"
 #include "utf8.h"
-#include "ref-filter.h"
-#include "worktree.h"
+#include "refs/ref-filter.h"
+#include "refs/worktree.h"
 #include "help.h"
 #include "advice.h"
 #include "commit-reach.h"
diff --git a/builtin/check-ref-format.c b/builtin/check-ref-format.c
index fd1c9c0e0c..5de8c0e6f5 100644
--- a/builtin/check-ref-format.c
+++ b/builtin/check-ref-format.c
@@ -5,7 +5,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "builtin.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "setup.h"
 #include "strbuf.h"
 
diff --git a/builtin/checkout.c b/builtin/checkout.c
index 2dcebb2cb2..87c1f087b8 100644
--- a/builtin/checkout.c
+++ b/builtin/checkout.c
@@ -24,7 +24,7 @@
 #include "path.h"
 #include "preload-index.h"
 #include "read-cache.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "remote.h"
 #include "repo-settings.h"
 #include "resolve-undo.h"
diff --git a/builtin/clone.c b/builtin/clone.c
index 6d6a756a12..12170ae8f4 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -22,8 +22,8 @@
 #include "hex.h"
 #include "lockfile.h"
 #include "parse-options.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "odb/object-file.h"
 #include "odb/odb.h"
 #include "odb/tree.h"
diff --git a/builtin/config.c b/builtin/config.c
index 0882899c3f..15782dfe64 100644
--- a/builtin/config.c
+++ b/builtin/config.c
@@ -15,7 +15,7 @@
 #include "quote.h"
 #include "setup.h"
 #include "strbuf.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 
 static const char *const builtin_config_usage[] = {
 	N_("git config list [<file-option>] [<display-option>] [--includes]"),
diff --git a/builtin/describe.c b/builtin/describe.c
index 75961c5945..c16a1da092 100644
--- a/builtin/describe.c
+++ b/builtin/describe.c
@@ -9,7 +9,7 @@
 #include "lockfile.h"
 #include "odb/commit.h"
 #include "odb/tag.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/object-name.h"
 #include "parse-options.h"
 #include "read-cache-ll.h"
diff --git a/builtin/fast-export.c b/builtin/fast-export.c
index 472877f0e5..4a98f14d39 100644
--- a/builtin/fast-export.c
+++ b/builtin/fast-export.c
@@ -12,8 +12,8 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "odb/object-file.h"
 #include "odb/odb.h"
 #include "odb/commit.h"
diff --git a/builtin/fast-import.c b/builtin/fast-import.c
index 1d560d4e71..43bc72f05f 100644
--- a/builtin/fast-import.c
+++ b/builtin/fast-import.c
@@ -16,7 +16,7 @@
 #include "pack.h"
 #include "path.h"
 #include "read-cache-ll.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "csum-file.h"
 #include "quote.h"
 #include "dir.h"
diff --git a/builtin/fetch.c b/builtin/fetch.c
index 2089e7823e..ce46a709a6 100644
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -11,8 +11,8 @@
 #include "gettext.h"
 #include "environment.h"
 #include "hex.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "odb/object-name.h"
 #include "odb/odb.h"
 #include "odb/oidset.h"
diff --git a/builtin/for-each-ref.c b/builtin/for-each-ref.c
index d3399455ef..9b3f277cb8 100644
--- a/builtin/for-each-ref.c
+++ b/builtin/for-each-ref.c
@@ -6,7 +6,7 @@
 #include "gettext.h"
 #include "odb/object.h"
 #include "parse-options.h"
-#include "ref-filter.h"
+#include "refs/ref-filter.h"
 #include "strbuf.h"
 #include "strvec.h"
 
diff --git a/builtin/fsck.c b/builtin/fsck.c
index 3176941c1d..430cf28bd8 100644
--- a/builtin/fsck.c
+++ b/builtin/fsck.c
@@ -6,7 +6,7 @@
 #include "odb/tree.h"
 #include "odb/blob.h"
 #include "odb/tag.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "pack.h"
 #include "cache-tree.h"
 #include "odb/fsck.h"
@@ -23,7 +23,7 @@
 #include "resolve-undo.h"
 #include "run-command.h"
 #include "sparse-index.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "pack-revindex.h"
 #include "pack-bitmap.h"
 
diff --git a/builtin/gc.c b/builtin/gc.c
index f2fdc2c69d..1a71e6f908 100644
--- a/builtin/gc.c
+++ b/builtin/gc.c
@@ -32,17 +32,17 @@
 #include "odb/object-file.h"
 #include "odb/odb.h"
 #include "path.h"
-#include "reflog.h"
+#include "refs/reflog.h"
 #include "rerere.h"
 #include "revision.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "remote.h"
 #include "exec-cmd.h"
 #include "gettext.h"
 #include "hook.h"
 #include "setup.h"
 #include "trace2.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 
 #define FAILED_RUN "failed to run %s"
 
diff --git a/builtin/history.c b/builtin/history.c
index a2aa224bd1..56b5015bc0 100644
--- a/builtin/history.c
+++ b/builtin/history.c
@@ -15,7 +15,7 @@
 #include "parse-options.h"
 #include "path.h"
 #include "read-cache.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "replay.h"
 #include "reset.h"
 #include "revision.h"
diff --git a/builtin/init-db.c b/builtin/init-db.c
index e96b1283b7..f459635129 100644
--- a/builtin/init-db.c
+++ b/builtin/init-db.c
@@ -10,7 +10,7 @@
 #include "gettext.h"
 #include "parse-options.h"
 #include "path.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "setup.h"
 #include "strbuf.h"
 
diff --git a/builtin/log.c b/builtin/log.c
index ab381e529e..7099f5fcc5 100644
--- a/builtin/log.c
+++ b/builtin/log.c
@@ -13,7 +13,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/object-name.h"
 #include "odb/odb.h"
 #include "odb/streaming.h"
@@ -28,7 +28,7 @@
 #include "odb/oid-array.h"
 #include "odb/oidset.h"
 #include "odb/tag.h"
-#include "reflog-walk.h"
+#include "refs/reflog-walk.h"
 #include "patch-ids.h"
 #include "path.h"
 #include "shortlog.h"
diff --git a/builtin/ls-remote.c b/builtin/ls-remote.c
index fe77829557..1b12d6e6ec 100644
--- a/builtin/ls-remote.c
+++ b/builtin/ls-remote.c
@@ -4,7 +4,7 @@
 #include "hex.h"
 #include "transport.h"
 #include "pkt-line.h"
-#include "ref-filter.h"
+#include "refs/ref-filter.h"
 #include "remote.h"
 #include "parse-options.h"
 #include "wildmatch.h"
diff --git a/builtin/merge.c b/builtin/merge.c
index 56f89b2944..2369c3b6f9 100644
--- a/builtin/merge.c
+++ b/builtin/merge.c
@@ -26,8 +26,8 @@
 #include "hook.h"
 #include "diff.h"
 #include "diff-merges.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "odb/commit.h"
 #include "diffcore.h"
 #include "path.h"
diff --git a/builtin/name-rev.c b/builtin/name-rev.c
index d2870bd37c..4e0254d70e 100644
--- a/builtin/name-rev.c
+++ b/builtin/name-rev.c
@@ -8,7 +8,7 @@
 #include "config.h"
 #include "odb/commit.h"
 #include "odb/tag.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/object-name.h"
 #include "pager.h"
 #include "parse-options.h"
diff --git a/builtin/notes.c b/builtin/notes.c
index 2cf1437346..6ebb5db39c 100644
--- a/builtin/notes.c
+++ b/builtin/notes.c
@@ -20,14 +20,14 @@
 #include "path.h"
 
 #include "pretty.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "exec-cmd.h"
 #include "run-command.h"
 #include "parse-options.h"
 #include "string-list.h"
 #include "notes-merge.h"
 #include "notes-utils.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "write-or-die.h"
 
 static const char *separator = "\n";
diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 3e4c5442dc..69f35a727b 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -21,7 +21,7 @@
 #include "list-objects-filter-options.h"
 #include "pack-objects.h"
 #include "progress.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "thread-utils.h"
 #include "pack-bitmap.h"
 #include "delta-islands.h"
diff --git a/builtin/pack-refs.c b/builtin/pack-refs.c
index 3446b84cda..235ae2cc5a 100644
--- a/builtin/pack-refs.c
+++ b/builtin/pack-refs.c
@@ -1,6 +1,6 @@
 #include "builtin.h"
 #include "gettext.h"
-#include "pack-refs.h"
+#include "refs/pack-refs.h"
 
 int cmd_pack_refs(int argc,
 		  const char **argv,
diff --git a/builtin/pull.c b/builtin/pull.c
index cb3d76cb16..bc8dcde318 100644
--- a/builtin/pull.c
+++ b/builtin/pull.c
@@ -24,8 +24,8 @@
 #include "path.h"
 #include "read-cache-ll.h"
 #include "rebase.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "submodule.h"
 #include "submodule-config.h"
 #include "wt-status.h"
diff --git a/builtin/push.c b/builtin/push.c
index 2377b5af55..39b6ff4b8b 100644
--- a/builtin/push.c
+++ b/builtin/push.c
@@ -12,7 +12,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "refspec.h"
+#include "refs/refspec.h"
 #include "run-command.h"
 #include "remote.h"
 #include "transport.h"
diff --git a/builtin/rebase.c b/builtin/rebase.c
index 7b8366e5cd..983dbb7ce5 100644
--- a/builtin/rebase.c
+++ b/builtin/rebase.c
@@ -16,7 +16,7 @@
 #include "run-command.h"
 #include "strvec.h"
 #include "dir.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "config.h"
 #include "unpack-trees.h"
 #include "lockfile.h"
diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index 5ec79a4595..88cbaed133 100644
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -27,7 +27,7 @@
 #include "parse-options.h"
 #include "pkt-line.h"
 #include "protocol.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "remote.h"
 #include "run-command.h"
 #include "server-info.h"
@@ -40,7 +40,7 @@
 #include "trace.h"
 #include "trace2.h"
 #include "version.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 
 static const char * const receive_pack_usage[] = {
 	N_("git receive-pack <git-dir>"),
diff --git a/builtin/reflog.c b/builtin/reflog.c
index b709cb0e3c..fc0b74ed95 100644
--- a/builtin/reflog.c
+++ b/builtin/reflog.c
@@ -8,9 +8,9 @@
 #include "revision.h"
 #include "reachable.h"
 #include "wildmatch.h"
-#include "worktree.h"
-#include "reflog.h"
-#include "refs.h"
+#include "refs/worktree.h"
+#include "refs/reflog.h"
+#include "refs/refs.h"
 #include "parse-options.h"
 
 #define BUILTIN_REFLOG_SHOW_USAGE \
diff --git a/builtin/refs.c b/builtin/refs.c
index 37936353be..abfc0acdd2 100644
--- a/builtin/refs.c
+++ b/builtin/refs.c
@@ -1,11 +1,11 @@
 #include "builtin.h"
 #include "config.h"
 #include "odb/fsck.h"
-#include "pack-refs.h"
+#include "refs/pack-refs.h"
 #include "parse-options.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "strbuf.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "for-each-ref.h"
 #include "refs/refs-internal.h"
 
diff --git a/builtin/remote.c b/builtin/remote.c
index b5b54ded27..9a5df99c11 100644
--- a/builtin/remote.c
+++ b/builtin/remote.c
@@ -14,8 +14,8 @@
 #include "strbuf.h"
 #include "run-command.h"
 #include "rebase.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "odb/odb.h"
 #include "strvec.h"
 #include "commit-reach.h"
diff --git a/builtin/replace.c b/builtin/replace.c
index 793226006c..83497cd974 100644
--- a/builtin/replace.c
+++ b/builtin/replace.c
@@ -14,7 +14,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "parse-options.h"
 #include "path.h"
 #include "run-command.h"
diff --git a/builtin/replay.c b/builtin/replay.c
index 4ea7c42215..83b136a13e 100644
--- a/builtin/replay.c
+++ b/builtin/replay.c
@@ -9,7 +9,7 @@
 #include "hex.h"
 #include "odb/object-name.h"
 #include "parse-options.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "replay.h"
 #include "revision.h"
 
diff --git a/builtin/repo.c b/builtin/repo.c
index 473072b44d..e052e6c0ba 100644
--- a/builtin/repo.c
+++ b/builtin/repo.c
@@ -11,8 +11,8 @@
 #include "path-walk.h"
 #include "progress.h"
 #include "quote.h"
-#include "ref-filter.h"
-#include "refs.h"
+#include "refs/ref-filter.h"
+#include "refs/refs.h"
 #include "revision.h"
 #include "setup.h"
 #include "strbuf.h"
diff --git a/builtin/reset.c b/builtin/reset.c
index 55539f565c..c3bfbab7d5 100644
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -20,7 +20,7 @@
 #include "lockfile.h"
 #include "odb/object.h"
 #include "pretty.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "diff.h"
 #include "diffcore.h"
 #include "odb/tree.h"
diff --git a/builtin/rev-list.c b/builtin/rev-list.c
index 0c55dc5b96..466a0a515d 100644
--- a/builtin/rev-list.c
+++ b/builtin/rev-list.c
@@ -21,7 +21,7 @@
 #include "graph.h"
 #include "bisect.h"
 #include "progress.h"
-#include "reflog-walk.h"
+#include "refs/reflog-walk.h"
 #include "odb/oidset.h"
 #include "odb/oidmap.h"
 #include "packfile.h"
diff --git a/builtin/rev-parse.c b/builtin/rev-parse.c
index f3bf7831b7..2fb682d5a2 100644
--- a/builtin/rev-parse.c
+++ b/builtin/rev-parse.c
@@ -17,7 +17,7 @@
 #include "gettext.h"
 #include "odb/hash.h"
 #include "hex.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "quote.h"
 #include "odb/object-name.h"
 #include "parse-options.h"
diff --git a/builtin/show-branch.c b/builtin/show-branch.c
index c58abc872f..4da3330a26 100644
--- a/builtin/show-branch.c
+++ b/builtin/show-branch.c
@@ -8,7 +8,7 @@
 #include "odb/hash.h"
 #include "hex.h"
 #include "pretty.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "color.h"
 #include "strvec.h"
 #include "odb/object-name.h"
diff --git a/builtin/sparse-checkout.c b/builtin/sparse-checkout.c
index e2186fdd33..9b4cad87a5 100644
--- a/builtin/sparse-checkout.c
+++ b/builtin/sparse-checkout.c
@@ -19,7 +19,7 @@
 #include "quote.h"
 #include "setup.h"
 #include "sparse-index.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 
 static const char *empty_base = "";
 
diff --git a/builtin/stash.c b/builtin/stash.c
index 2af975aaff..62fec2f17f 100644
--- a/builtin/stash.c
+++ b/builtin/stash.c
@@ -9,7 +9,7 @@
 #include "hex.h"
 #include "odb/object-name.h"
 #include "parse-options.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "lockfile.h"
 #include "cache-tree.h"
 #include "unpack-trees.h"
@@ -27,8 +27,8 @@
 #include "sparse-index.h"
 #include "log-tree.h"
 #include "diffcore.h"
-#include "reflog.h"
-#include "reflog-walk.h"
+#include "refs/reflog.h"
+#include "refs/reflog-walk.h"
 #include "add-interactive.h"
 #include "odb/oid-array.h"
 #include "odb/commit.h"
diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
index 96c83476df..bf8b20247f 100644
--- a/builtin/submodule--helper.c
+++ b/builtin/submodule--helper.c
@@ -21,8 +21,8 @@
 #include "string-list.h"
 #include "run-command.h"
 #include "remote.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "revision.h"
 #include "diffcore.h"
 #include "diff.h"
diff --git a/builtin/symbolic-ref.c b/builtin/symbolic-ref.c
index 231e41e715..9ea9ca6500 100644
--- a/builtin/symbolic-ref.c
+++ b/builtin/symbolic-ref.c
@@ -3,7 +3,7 @@
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "parse-options.h"
 #include "strbuf.h"
 
diff --git a/builtin/tag.c b/builtin/tag.c
index e3eee35e88..d554ae8f81 100644
--- a/builtin/tag.c
+++ b/builtin/tag.c
@@ -16,7 +16,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/object-file.h"
 #include "odb/object-name.h"
 #include "odb/odb.h"
@@ -28,7 +28,7 @@
 #include "gpg-interface.h"
 #include "odb/oid-array.h"
 #include "column.h"
-#include "ref-filter.h"
+#include "refs/ref-filter.h"
 #include "date.h"
 #include "write-or-die.h"
 #include "odb/object-file-convert.h"
diff --git a/builtin/update-index.c b/builtin/update-index.c
index 992f496efd..54741c3241 100644
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -20,7 +20,7 @@
 #include "odb/object-file.h"
 #include "odb/odb.h"
 #include "odb/transaction.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "resolve-undo.h"
 #include "parse-options.h"
 #include "pathspec.h"
diff --git a/builtin/update-ref.c b/builtin/update-ref.c
index e7ac68f495..5bcd100e52 100644
--- a/builtin/update-ref.c
+++ b/builtin/update-ref.c
@@ -7,7 +7,7 @@
 #include "gettext.h"
 #include "odb/hash.h"
 #include "hex.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/object-name.h"
 #include "parse-options.h"
 #include "quote.h"
diff --git a/builtin/var.c b/builtin/var.c
index cc3a43cde2..d01c87dfa2 100644
--- a/builtin/var.c
+++ b/builtin/var.c
@@ -14,7 +14,7 @@
 #include "environment.h"
 #include "ident.h"
 #include "pager.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "path.h"
 #include "strbuf.h"
 #include "run-command.h"
diff --git a/builtin/verify-tag.c b/builtin/verify-tag.c
index 791679a4d8..460244f25b 100644
--- a/builtin/verify-tag.c
+++ b/builtin/verify-tag.c
@@ -13,7 +13,7 @@
 #include "odb/object-name.h"
 #include "parse-options.h"
 #include "gpg-interface.h"
-#include "ref-filter.h"
+#include "refs/ref-filter.h"
 
 static const char * const verify_tag_usage[] = {
 		N_("git verify-tag [-v | --verbose] [--format=<format>] [--raw] <tag>..."),
diff --git a/builtin/worktree.c b/builtin/worktree.c
index 7c2ed274f9..90af2193c1 100644
--- a/builtin/worktree.c
+++ b/builtin/worktree.c
@@ -18,14 +18,14 @@
 #include "strvec.h"
 #include "branch.h"
 #include "read-cache-ll.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "remote.h"
 #include "run-command.h"
 #include "hook.h"
 #include "sigchain.h"
 #include "submodule.h"
 #include "utf8.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "quote.h"
 
 #define BUILTIN_WORKTREE_ADD_USAGE \
diff --git a/bundle-uri.c b/bundle-uri.c
index 948265330b..96ddf92347 100644
--- a/bundle-uri.c
+++ b/bundle-uri.c
@@ -6,7 +6,7 @@
 #include "bundle.h"
 #include "copy.h"
 #include "gettext.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "run-command.h"
 #include "hashmap.h"
 #include "pkt-line.h"
diff --git a/bundle.c b/bundle.c
index 81d241e6d0..c64b14a05a 100644
--- a/bundle.c
+++ b/bundle.c
@@ -15,7 +15,7 @@
 #include "revision.h"
 #include "list-objects.h"
 #include "run-command.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "strvec.h"
 #include "list-objects-filter-options.h"
 #include "connected.h"
diff --git a/checkout.c b/checkout.c
index 966a70c267..e3b4d341da 100644
--- a/checkout.c
+++ b/checkout.c
@@ -3,7 +3,7 @@
 #include "git-compat-util.h"
 #include "odb/object-name.h"
 #include "remote.h"
-#include "refspec.h"
+#include "refs/refspec.h"
 #include "repository.h"
 #include "checkout.h"
 #include "config.h"
diff --git a/combine-diff.c b/combine-diff.c
index 1c33937f21..6f16e9ea38 100644
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -14,7 +14,7 @@
 #include "xdiff-interface.h"
 #include "xdiff/xmacros.h"
 #include "log-tree.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/tree.h"
 #include "userdiff.h"
 #include "odb/oid-array.h"
diff --git a/commit-graph.c b/commit-graph.c
index abf7c404b3..7c22588c46 100644
--- a/commit-graph.c
+++ b/commit-graph.c
@@ -10,7 +10,7 @@
 #include "packfile.h"
 #include "odb/commit.h"
 #include "odb/object.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/hash-lookup.h"
 #include "commit-graph.h"
 #include "odb/odb.h"
diff --git a/commit-reach.c b/commit-reach.c
index 9b4715fd65..9636b5b37f 100644
--- a/commit-reach.c
+++ b/commit-reach.c
@@ -6,7 +6,7 @@
 #include "decorate.h"
 #include "hex.h"
 #include "prio-queue.h"
-#include "ref-filter.h"
+#include "refs/ref-filter.h"
 #include "revision.h"
 #include "odb/tag.h"
 #include "commit-reach.h"
diff --git a/config.c b/config.c
index eacc6847a2..3f335dbec1 100644
--- a/config.c
+++ b/config.c
@@ -30,7 +30,7 @@
 #include "path.h"
 #include "utf8.h"
 #include "color.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "setup.h"
 #include "strvec.h"
 #include "trace2.h"
diff --git a/connect.c b/connect.c
index e54c88f5e2..a24b019b2c 100644
--- a/connect.c
+++ b/connect.c
@@ -7,7 +7,7 @@
 #include "hex.h"
 #include "pkt-line.h"
 #include "quote.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "run-command.h"
 #include "remote.h"
 #include "connect.h"
diff --git a/delta-islands.c b/delta-islands.c
index 0c0d222ab3..1c92cdf37c 100644
--- a/delta-islands.c
+++ b/delta-islands.c
@@ -11,7 +11,7 @@
 #include "odb/tree-walk.h"
 #include "diff.h"
 #include "progress.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "khash.h"
 #include "pack-bitmap.h"
 #include "pack-objects.h"
diff --git a/diff-lib.c b/diff-lib.c
index 313b6136b1..a5072c5f6d 100644
--- a/diff-lib.c
+++ b/diff-lib.c
@@ -17,7 +17,7 @@
 #include "revision.h"
 #include "cache-tree.h"
 #include "unpack-trees.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "repository.h"
 #include "submodule.h"
 #include "symlinks.h"
diff --git a/dir.c b/dir.c
index c9005a0ac1..d230ecdec1 100644
--- a/dir.c
+++ b/dir.c
@@ -19,7 +19,7 @@
 #include "name-hash.h"
 #include "odb/object-file.h"
 #include "path.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "repository.h"
 #include "wildmatch.h"
 #include "pathspec.h"
diff --git a/environment.c b/environment.c
index 40b993ec90..6066417b62 100644
--- a/environment.c
+++ b/environment.c
@@ -26,7 +26,7 @@
 #include "odb/object-name.h"
 #include "repository.h"
 #include "config.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "fmt-merge-msg.h"
 #include "odb/commit.h"
 #include "strvec.h"
diff --git a/fetch-pack.c b/fetch-pack.c
index b172114879..434b57e5b0 100644
--- a/fetch-pack.c
+++ b/fetch-pack.c
@@ -9,7 +9,7 @@
 #include "gettext.h"
 #include "hex.h"
 #include "lockfile.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "pkt-line.h"
 #include "odb/commit.h"
 #include "odb/tag.h"
diff --git a/fmt-merge-msg.c b/fmt-merge-msg.c
index 6e11ad0fa9..7fa8c4cd79 100644
--- a/fmt-merge-msg.c
+++ b/fmt-merge-msg.c
@@ -4,7 +4,7 @@
 #include "git-compat-util.h"
 #include "config.h"
 #include "environment.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/object-name.h"
 #include "odb/odb.h"
 #include "diff.h"
diff --git a/help.c b/help.c
index ccc42f09e0..96f98ec621 100644
--- a/help.c
+++ b/help.c
@@ -15,7 +15,7 @@
 #include "string-list.h"
 #include "column.h"
 #include "version.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "parse-options.h"
 #include "prompt.h"
 #include "fsmonitor-ipc.h"
diff --git a/http-backend.c b/http-backend.c
index 9b7ae96579..90624c3348 100644
--- a/http-backend.c
+++ b/http-backend.c
@@ -8,7 +8,7 @@
 #include "hex.h"
 #include "path.h"
 #include "repository.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "pkt-line.h"
 #include "odb/object.h"
 #include "odb/tag.h"
diff --git a/log-tree.c b/log-tree.c
index c9fde242a1..116bb7ea68 100644
--- a/log-tree.c
+++ b/log-tree.c
@@ -18,8 +18,8 @@
 #include "graph.h"
 #include "log-tree.h"
 #include "merge-ort.h"
-#include "reflog-walk.h"
-#include "refs.h"
+#include "refs/reflog-walk.h"
+#include "refs/refs.h"
 #include "odb/replace-object.h"
 #include "revision.h"
 #include "string-list.h"
diff --git a/merge-ort.c b/merge-ort.c
index 35d30dcf06..a12bf62a3d 100644
--- a/merge-ort.c
+++ b/merge-ort.c
@@ -44,7 +44,7 @@
 #include "path.h"
 #include "promisor-remote.h"
 #include "read-cache-ll.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "revision.h"
 #include "sparse-index.h"
 #include "strmap.h"
diff --git a/meson.build b/meson.build
index 6586f8ae9f..8dd613a8bb 100644
--- a/meson.build
+++ b/meson.build
@@ -406,7 +406,7 @@ libgit_sources = [
   'lockfile.c',
   'log-tree.c',
   'odb/loose.c',
-  'ls-refs.c',
+  'refs/ls-refs.c',
   'mailinfo.c',
   'mailmap.c',
   'odb/match-trees.c',
@@ -451,7 +451,7 @@ libgit_sources = [
   'pack-check.c',
   'pack-mtimes.c',
   'pack-objects.c',
-  'pack-refs.c',
+  'refs/pack-refs.c',
   'pack-revindex.c',
   'pack-write.c',
   'packfile.c',
@@ -483,17 +483,17 @@ libgit_sources = [
   'read-cache.c',
   'rebase-interactive.c',
   'rebase.c',
-  'ref-filter.c',
-  'reflog-walk.c',
-  'reflog.c',
-  'refs.c',
+  'refs/ref-filter.c',
+  'refs/reflog-walk.c',
+  'refs/reflog.c',
+  'refs/refs.c',
   'refs/debug.c',
   'refs/files-backend.c',
   'refs/reftable-backend.c',
   'refs/iterator.c',
   'refs/packed-backend.c',
   'refs/ref-cache.c',
-  'refspec.c',
+  'refs/refspec.c',
   'reftable/basics.c',
   'reftable/error.c',
   'reftable/block.c',
@@ -579,7 +579,7 @@ libgit_sources = [
   'versioncmp.c',
   'walker.c',
   'wildmatch.c',
-  'worktree.c',
+  'refs/worktree.c',
   'wrapper.c',
   'write-or-die.c',
   'ws.c',
diff --git a/midx-write.c b/midx-write.c
index bb4ceaede7..af4410a0b8 100644
--- a/midx-write.c
+++ b/midx-write.c
@@ -12,7 +12,7 @@
 #include "run-command.h"
 #include "chunk-format.h"
 #include "pack-bitmap.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "revision.h"
 #include "list-objects.h"
 #include "path.h"
diff --git a/negotiator/default.c b/negotiator/default.c
index 404db17785..7d67933e06 100644
--- a/negotiator/default.c
+++ b/negotiator/default.c
@@ -5,7 +5,7 @@
 #include "odb/commit.h"
 #include "../fetch-negotiator.h"
 #include "../prio-queue.h"
-#include "../refs.h"
+#include "refs/refs.h"
 #include "../repository.h"
 #include "odb/tag.h"
 
diff --git a/negotiator/skipping.c b/negotiator/skipping.c
index e1218d2a93..9e685f54a1 100644
--- a/negotiator/skipping.c
+++ b/negotiator/skipping.c
@@ -6,7 +6,7 @@
 #include "../fetch-negotiator.h"
 #include "../hex.h"
 #include "../prio-queue.h"
-#include "../refs.h"
+#include "refs/refs.h"
 #include "../repository.h"
 #include "odb/tag.h"
 
diff --git a/notes-cache.c b/notes-cache.c
index abe0964bba..02fb418c6f 100644
--- a/notes-cache.c
+++ b/notes-cache.c
@@ -7,7 +7,7 @@
 #include "pretty.h"
 #include "repository.h"
 #include "odb/commit.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "strbuf.h"
 
 static int notes_cache_match_validity(struct repository *r,
diff --git a/notes-merge.c b/notes-merge.c
index 2b025b6d3d..72a3b9479c 100644
--- a/notes-merge.c
+++ b/notes-merge.c
@@ -5,7 +5,7 @@
 #include "advice.h"
 #include "odb/commit.h"
 #include "gettext.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/object-file.h"
 #include "odb/object-name.h"
 #include "odb/odb.h"
diff --git a/notes-utils.c b/notes-utils.c
index b6275dfa26..491de7a7ce 100644
--- a/notes-utils.c
+++ b/notes-utils.c
@@ -5,7 +5,7 @@
 #include "odb/commit.h"
 #include "environment.h"
 #include "gettext.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "notes-utils.h"
 #include "strbuf.h"
 
diff --git a/notes.c b/notes.c
index ef44dae00d..5842226c68 100644
--- a/notes.c
+++ b/notes.c
@@ -13,7 +13,7 @@
 #include "strbuf.h"
 #include "odb/tree-walk.h"
 #include "string-list.h"
-#include "refs.h"
+#include "refs/refs.h"
 
 /*
  * Use a non-balancing simple 16-tree structure with struct int_node as
diff --git a/odb/commit.c b/odb/commit.c
index d0e036876c..dc98000ab2 100644
--- a/odb/commit.c
+++ b/odb/commit.c
@@ -22,7 +22,7 @@
 #include "odb/hash-lookup.h"
 #include "wt-status.h"
 #include "advice.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "commit-reach.h"
 #include "setup.h"
 #include "shallow.h"
diff --git a/odb/fsck.c b/odb/fsck.c
index e76779109a..75306dc8a3 100644
--- a/odb/fsck.c
+++ b/odb/fsck.c
@@ -14,7 +14,7 @@
 #include "odb/commit.h"
 #include "odb/tag.h"
 #include "odb/fsck.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "url.h"
 #include "utf8.h"
 #include "odb/oidset.h"
diff --git a/odb/object-name.c b/odb/object-name.c
index 98c88e7337..16b6cd8f12 100644
--- a/odb/object-name.c
+++ b/odb/object-name.c
@@ -12,7 +12,7 @@
 #include "odb/commit.h"
 #include "odb/tree.h"
 #include "odb/tree-walk.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "remote.h"
 #include "dir.h"
 #include "odb/odb.h"
diff --git a/odb/replace-object.c b/odb/replace-object.c
index 32d778f55e..c69c5aa200 100644
--- a/odb/replace-object.c
+++ b/odb/replace-object.c
@@ -4,7 +4,7 @@
 #include "odb/oidmap.h"
 #include "odb/odb.h"
 #include "odb/replace-object.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "repository.h"
 #include "odb/commit.h"
 
diff --git a/pack-bitmap-write.c b/pack-bitmap-write.c
index 64233d6cd0..b5e14b196f 100644
--- a/pack-bitmap-write.c
+++ b/pack-bitmap-write.c
@@ -23,7 +23,7 @@
 #include "odb/oid-array.h"
 #include "config.h"
 #include "odb/alloc.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "strmap.h"
 #include "midx.h"
 #include "pack-revindex.h"
diff --git a/pack-bitmap.h b/pack-bitmap.h
index 1385027c1f..b50ef0b4e4 100644
--- a/pack-bitmap.h
+++ b/pack-bitmap.h
@@ -5,7 +5,7 @@
 #include "khash.h"
 #include "pack.h"
 #include "pack-objects.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "string-list.h"
 
 struct commit;
diff --git a/path.c b/path.c
index 3a3a66155a..4afd1e3ffa 100644
--- a/path.c
+++ b/path.c
@@ -9,7 +9,7 @@
 #include "strbuf.h"
 #include "string-list.h"
 #include "dir.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "setup.h"
 #include "submodule-config.h"
 #include "path.h"
diff --git a/pretty.c b/pretty.c
index 461e8cd527..4575f3fde6 100644
--- a/pretty.c
+++ b/pretty.c
@@ -17,7 +17,7 @@
 #include "log-tree.h"
 #include "notes.h"
 #include "color.h"
-#include "reflog-walk.h"
+#include "refs/reflog-walk.h"
 #include "gpg-interface.h"
 #include "trailer.h"
 #include "run-command.h"
diff --git a/pseudo-merge.c b/pseudo-merge.c
index 0809a2bcb3..f87fd46b46 100644
--- a/pseudo-merge.c
+++ b/pseudo-merge.c
@@ -8,7 +8,7 @@
 #include "strbuf.h"
 #include "config.h"
 #include "string-list.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "pack-bitmap.h"
 #include "odb/commit.h"
 #include "odb/alloc.h"
diff --git a/reachable.c b/reachable.c
index 2a62adf7f5..a99699c6d8 100644
--- a/reachable.c
+++ b/reachable.c
@@ -3,7 +3,7 @@
 #include "git-compat-util.h"
 #include "gettext.h"
 #include "hex.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/commit.h"
 #include "odb/blob.h"
 #include "diff.h"
@@ -13,7 +13,7 @@
 #include "progress.h"
 #include "list-objects.h"
 #include "packfile.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "odb/object-file.h"
 #include "pack-bitmap.h"
 #include "pack-mtimes.h"
diff --git a/read-cache.c b/read-cache.c
index 8f6b812b5f..148a93f10e 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -16,7 +16,7 @@
 #include "tempfile.h"
 #include "lockfile.h"
 #include "cache-tree.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "dir.h"
 #include "odb/object-file.h"
 #include "odb/odb.h"
diff --git a/refs/files-backend.c b/refs/files-backend.c
index ef7532e727..35acc13ccc 100644
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -9,7 +9,7 @@
 #include "odb/hash.h"
 #include "../hex.h"
 #include "odb/fsck.h"
-#include "../refs.h"
+#include "refs/refs.h"
 #include "../repo-settings.h"
 #include "refs-internal.h"
 #include "ref-cache.h"
@@ -22,7 +22,7 @@
 #include "../dir.h"
 #include "../chdir-notify.h"
 #include "../setup.h"
-#include "../worktree.h"
+#include "refs/worktree.h"
 #include "../wrapper.h"
 #include "../write-or-die.h"
 #include "../revision.h"
diff --git a/refs/iterator.c b/refs/iterator.c
index d5cacde51b..08c80ee818 100644
--- a/refs/iterator.c
+++ b/refs/iterator.c
@@ -6,7 +6,7 @@
 #define DISABLE_SIGN_COMPARE_WARNINGS
 
 #include "git-compat-util.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "refs/refs-internal.h"
 #include "iterator.h"
 
diff --git a/ls-refs.c b/refs/ls-refs.c
similarity index 99%
rename from ls-refs.c
rename to refs/ls-refs.c
index e29ef0947f..75b9b5e620 100644
--- a/ls-refs.c
+++ b/refs/ls-refs.c
@@ -6,9 +6,9 @@
 #include "odb/hash.h"
 #include "hex.h"
 #include "repository.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "strvec.h"
-#include "ls-refs.h"
+#include "refs/ls-refs.h"
 #include "pkt-line.h"
 #include "config.h"
 #include "string-list.h"
diff --git a/ls-refs.h b/refs/ls-refs.h
similarity index 100%
rename from ls-refs.h
rename to refs/ls-refs.h
diff --git a/pack-refs.c b/refs/pack-refs.c
similarity index 97%
rename from pack-refs.c
rename to refs/pack-refs.c
index eb6b2ba2c2..c9f36872cc 100644
--- a/pack-refs.c
+++ b/refs/pack-refs.c
@@ -1,9 +1,9 @@
 #include "builtin.h"
 #include "config.h"
 #include "environment.h"
-#include "pack-refs.h"
+#include "refs/pack-refs.h"
 #include "parse-options.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "revision.h"
 
 int pack_refs_core(int argc,
diff --git a/pack-refs.h b/refs/pack-refs.h
similarity index 100%
rename from pack-refs.h
rename to refs/pack-refs.h
diff --git a/refs/packed-backend.c b/refs/packed-backend.c
index c7005a9ecc..afcb800a5f 100644
--- a/refs/packed-backend.c
+++ b/refs/packed-backend.c
@@ -7,14 +7,14 @@
 #include "../gettext.h"
 #include "odb/hash.h"
 #include "../hex.h"
-#include "../refs.h"
+#include "refs/refs.h"
 #include "refs-internal.h"
 #include "packed-backend.h"
 #include "../iterator.h"
 #include "../lockfile.h"
 #include "../chdir-notify.h"
 #include "../statinfo.h"
-#include "../worktree.h"
+#include "refs/worktree.h"
 #include "../wrapper.h"
 #include "../write-or-die.h"
 #include "../trace2.h"
diff --git a/refs/ref-cache.c b/refs/ref-cache.c
index a4182ea57f..3599199b8e 100644
--- a/refs/ref-cache.c
+++ b/refs/ref-cache.c
@@ -1,6 +1,6 @@
 #include "../git-compat-util.h"
 #include "odb/hash.h"
-#include "../refs.h"
+#include "refs/refs.h"
 #include "../repository.h"
 #include "refs-internal.h"
 #include "ref-cache.h"
diff --git a/ref-filter.c b/refs/ref-filter.c
similarity index 99%
rename from ref-filter.c
rename to refs/ref-filter.c
index 8a3d056577..e3de16b7a7 100644
--- a/ref-filter.c
+++ b/refs/ref-filter.c
@@ -9,7 +9,7 @@
 #include "hex.h"
 #include "parse-options.h"
 #include "run-command.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "wildmatch.h"
 #include "odb/object-name.h"
 #include "odb/odb.h"
@@ -23,7 +23,7 @@
 #include "color.h"
 #include "odb/tag.h"
 #include "quote.h"
-#include "ref-filter.h"
+#include "refs/ref-filter.h"
 #include "revision.h"
 #include "utf8.h"
 #include "versioncmp.h"
@@ -31,7 +31,7 @@
 #include "wt-status.h"
 #include "odb/commit-slab.h"
 #include "commit-reach.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "hashmap.h"
 
 static struct ref_msg {
diff --git a/ref-filter.h b/refs/ref-filter.h
similarity index 100%
rename from ref-filter.h
rename to refs/ref-filter.h
diff --git a/reflog-walk.c b/refs/reflog-walk.c
similarity index 99%
rename from reflog-walk.c
rename to refs/reflog-walk.c
index 4058cfa6df..711b71be66 100644
--- a/reflog-walk.c
+++ b/refs/reflog-walk.c
@@ -2,12 +2,12 @@
 
 #include "git-compat-util.h"
 #include "odb/commit.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "diff.h"
 #include "repository.h"
 #include "revision.h"
 #include "string-list.h"
-#include "reflog-walk.h"
+#include "refs/reflog-walk.h"
 
 struct complete_reflogs {
 	char *ref;
diff --git a/reflog-walk.h b/refs/reflog-walk.h
similarity index 100%
rename from reflog-walk.h
rename to refs/reflog-walk.h
diff --git a/reflog.c b/refs/reflog.c
similarity index 99%
rename from reflog.c
rename to refs/reflog.c
index 178ef7fe44..751485f885 100644
--- a/reflog.c
+++ b/refs/reflog.c
@@ -7,8 +7,8 @@
 #include "gettext.h"
 #include "parse-options.h"
 #include "odb/odb.h"
-#include "reflog.h"
-#include "refs.h"
+#include "refs/reflog.h"
+#include "refs/refs.h"
 #include "revision.h"
 #include "odb/tree.h"
 #include "odb/tree-walk.h"
diff --git a/reflog.h b/refs/reflog.h
similarity index 99%
rename from reflog.h
rename to refs/reflog.h
index b996712c00..ef39b0fcc5 100644
--- a/reflog.h
+++ b/refs/reflog.h
@@ -1,6 +1,6 @@
 #ifndef REFLOG_H
 #define REFLOG_H
-#include "refs.h"
+#include "refs/refs.h"
 
 #define REFLOG_EXPIRE_TOTAL   (1 << 0)
 #define REFLOG_EXPIRE_UNREACH (1 << 1)
diff --git a/refs/refs-internal.h b/refs/refs-internal.h
index c3ac7b556f..51be5be0fb 100644
--- a/refs/refs-internal.h
+++ b/refs/refs-internal.h
@@ -1,7 +1,7 @@
 #ifndef REFS_REFS_INTERNAL_H
 #define REFS_REFS_INTERNAL_H
 
-#include "refs.h"
+#include "refs/refs.h"
 #include "iterator.h"
 #include "string-list.h"
 
diff --git a/refs.c b/refs/refs.c
similarity index 99%
rename from refs.c
rename to refs/refs.c
index e01163be2a..2bc9c3cecd 100644
--- a/refs.c
+++ b/refs/refs.c
@@ -12,7 +12,7 @@
 #include "hex.h"
 #include "lockfile.h"
 #include "iterator.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "refs/refs-internal.h"
 #include "hook.h"
 #include "odb/object-name.h"
@@ -20,7 +20,7 @@
 #include "odb/object.h"
 #include "path.h"
 #include "submodule.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "strvec.h"
 #include "repo-settings.h"
 #include "setup.h"
diff --git a/refs.h b/refs/refs.h
similarity index 100%
rename from refs.h
rename to refs/refs.h
diff --git a/refspec.c b/refs/refspec.c
similarity index 99%
rename from refspec.c
rename to refs/refspec.c
index f3cb1b0748..324c274bff 100644
--- a/refspec.c
+++ b/refs/refspec.c
@@ -6,8 +6,8 @@
 #include "hex.h"
 #include "string-list.h"
 #include "strvec.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "remote.h"
 #include "strbuf.h"
 
diff --git a/refspec.h b/refs/refspec.h
similarity index 100%
rename from refspec.h
rename to refs/refspec.h
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 9d6194c4e6..120f9c947f 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -12,7 +12,7 @@
 #include "../iterator.h"
 #include "../parse.h"
 #include "../path.h"
-#include "../refs.h"
+#include "refs/refs.h"
 #include "../reftable/reftable-basics.h"
 #include "../reftable/reftable-error.h"
 #include "../reftable/reftable-fsck.h"
@@ -23,7 +23,7 @@
 #include "../setup.h"
 #include "../strmap.h"
 #include "../trace2.h"
-#include "../worktree.h"
+#include "refs/worktree.h"
 #include "../write-or-die.h"
 #include "refs-internal.h"
 
diff --git a/worktree.c b/refs/worktree.c
similarity index 99%
rename from worktree.c
rename to refs/worktree.c
index cbf95328a3..3578229534 100644
--- a/worktree.c
+++ b/refs/worktree.c
@@ -6,10 +6,10 @@
 #include "gettext.h"
 #include "path.h"
 #include "repository.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "setup.h"
 #include "strbuf.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "dir.h"
 #include "wt-status.h"
 #include "config.h"
diff --git a/worktree.h b/refs/worktree.h
similarity index 99%
rename from worktree.h
rename to refs/worktree.h
index fbb2757f5b..11cdc5f7fc 100644
--- a/worktree.h
+++ b/refs/worktree.h
@@ -1,7 +1,7 @@
 #ifndef WORKTREE_H
 #define WORKTREE_H
 
-#include "refs.h"
+#include "refs/refs.h"
 
 struct strbuf;
 
diff --git a/remote.c b/remote.c
index 89dc91429a..39e9f58cba 100644
--- a/remote.c
+++ b/remote.c
@@ -10,8 +10,8 @@
 #include "remote.h"
 #include "url.h"
 #include "urlmatch.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "odb/object-name.h"
 #include "odb/odb.h"
 #include "path.h"
diff --git a/remote.h b/remote.h
index fbf552cc2f..e094082e03 100644
--- a/remote.h
+++ b/remote.h
@@ -3,7 +3,7 @@
 
 #include "odb/hash.h"
 #include "hashmap.h"
-#include "refspec.h"
+#include "refs/refspec.h"
 #include "string-list.h"
 #include "strvec.h"
 
diff --git a/repack-midx.c b/repack-midx.c
index a9df431952..342deb798c 100644
--- a/repack-midx.c
+++ b/repack-midx.c
@@ -8,7 +8,7 @@
 #include "odb/oidset.h"
 #include "pack-bitmap.h"
 #include "path.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "run-command.h"
 #include "tempfile.h"
 #include "trace2.h"
diff --git a/replay.c b/replay.c
index 9e29f29ff6..8dd7b99502 100644
--- a/replay.c
+++ b/replay.c
@@ -5,7 +5,7 @@
 #include "hex.h"
 #include "merge-ort.h"
 #include "odb/object-name.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "replay.h"
 #include "revision.h"
 #include "sequencer.h"
diff --git a/repository.c b/repository.c
index 72434e3a50..b5e442f9f3 100644
--- a/repository.c
+++ b/repository.c
@@ -17,7 +17,7 @@
 #include "sparse-index.h"
 #include "trace2.h"
 #include "promisor-remote.h"
-#include "refs.h"
+#include "refs/refs.h"
 
 /*
  * We do not define `USE_THE_REPOSITORY_VARIABLE` in this file because we do
diff --git a/reset.c b/reset.c
index 950d45d07d..29bbeaa9d4 100644
--- a/reset.c
+++ b/reset.c
@@ -4,7 +4,7 @@
 #include "hex.h"
 #include "lockfile.h"
 #include "odb/object-name.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "reset.h"
 #include "odb/tree-walk.h"
 #include "odb/tree.h"
diff --git a/revision.c b/revision.c
index 9e90f909da..35a1893436 100644
--- a/revision.c
+++ b/revision.c
@@ -16,12 +16,12 @@
 #include "odb/commit.h"
 #include "diff.h"
 #include "diff-merges.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "revision.h"
 #include "repository.h"
 #include "graph.h"
 #include "grep.h"
-#include "reflog-walk.h"
+#include "refs/reflog-walk.h"
 #include "patch-ids.h"
 #include "decorate.h"
 #include "string-list.h"
@@ -32,7 +32,7 @@
 #include "cache-tree.h"
 #include "bisect.h"
 #include "packfile.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "path.h"
 #include "read-cache.h"
 #include "setup.h"
diff --git a/scalar.c b/scalar.c
index a80d8ee3ff..af3456b5d0 100644
--- a/scalar.c
+++ b/scalar.c
@@ -13,7 +13,7 @@
 #include "simple-ipc.h"
 #include "fsmonitor-ipc.h"
 #include "fsmonitor-settings.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "dir.h"
 #include "packfile.h"
 #include "help.h"
diff --git a/sequencer.c b/sequencer.c
index 67ab3cdf0d..d13721ab1f 100644
--- a/sequencer.c
+++ b/sequencer.c
@@ -29,7 +29,7 @@
 #include "merge.h"
 #include "merge-ort.h"
 #include "merge-ort-wrappers.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "sparse-index.h"
 #include "strvec.h"
 #include "quote.h"
diff --git a/serve.c b/serve.c
index 95cf3d8ea4..df3086fb3a 100644
--- a/serve.c
+++ b/serve.c
@@ -4,7 +4,7 @@
 #include "odb/hash.h"
 #include "pkt-line.h"
 #include "version.h"
-#include "ls-refs.h"
+#include "refs/ls-refs.h"
 #include "protocol-caps.h"
 #include "serve.h"
 #include "upload-pack.h"
diff --git a/server-info.c b/server-info.c
index 75ead482e1..3021ee8926 100644
--- a/server-info.c
+++ b/server-info.c
@@ -4,7 +4,7 @@
 #include "dir.h"
 #include "hex.h"
 #include "repository.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/object.h"
 #include "odb/commit.h"
 #include "odb/tag.h"
diff --git a/setup.c b/setup.c
index fe8e9ffdc5..925a600dba 100644
--- a/setup.c
+++ b/setup.c
@@ -9,7 +9,7 @@
 #include "hex.h"
 #include "odb/object-file.h"
 #include "odb/object-name.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "repository.h"
 #include "config.h"
 #include "dir.h"
@@ -22,7 +22,7 @@
 #include "quote.h"
 #include "trace.h"
 #include "trace2.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 
 enum allowed_bare_repo {
 	ALLOWED_BARE_REPO_EXPLICIT = 0,
diff --git a/setup.h b/setup.h
index 763fd384e8..7bfc5ce068 100644
--- a/setup.h
+++ b/setup.h
@@ -1,7 +1,7 @@
 #ifndef SETUP_H
 #define SETUP_H
 
-#include "refs.h"
+#include "refs/refs.h"
 #include "string-list.h"
 
 int is_inside_git_dir(struct repository *repo);
diff --git a/shallow.c b/shallow.c
index 25116d7a6e..daa6db8e0d 100644
--- a/shallow.c
+++ b/shallow.c
@@ -9,7 +9,7 @@
 #include "odb/commit.h"
 #include "odb/tag.h"
 #include "pkt-line.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "odb/oid-array.h"
 #include "path.h"
 #include "diff.h"
diff --git a/submodule.c b/submodule.c
index d091b484a4..32af65e6b8 100644
--- a/submodule.c
+++ b/submodule.c
@@ -16,14 +16,14 @@
 #include "revision.h"
 #include "run-command.h"
 #include "diffcore.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "string-list.h"
 #include "odb/oid-array.h"
 #include "strvec.h"
 #include "thread-utils.h"
 #include "path.h"
 #include "remote.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "parse-options.h"
 #include "odb/object-file.h"
 #include "odb/object-name.h"
diff --git a/t/helper/test-reach.c b/t/helper/test-reach.c
index 4151cfbe25..df1c677b9f 100644
--- a/t/helper/test-reach.c
+++ b/t/helper/test-reach.c
@@ -6,7 +6,7 @@
 #include "gettext.h"
 #include "hex.h"
 #include "odb/object-name.h"
-#include "ref-filter.h"
+#include "refs/ref-filter.h"
 #include "setup.h"
 #include "string-list.h"
 #include "odb/tag.h"
diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c
index 1fbdc52fc5..8c2fb0aad7 100644
--- a/t/helper/test-ref-store.c
+++ b/t/helper/test-ref-store.c
@@ -2,9 +2,9 @@
 
 #include "test-tool.h"
 #include "hex.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "setup.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "odb/odb.h"
 #include "path.h"
 #include "repository.h"
diff --git a/transport-helper.c b/transport-helper.c
index 59f61f23c6..55bd9291db 100644
--- a/transport-helper.c
+++ b/transport-helper.c
@@ -15,8 +15,8 @@
 #include "thread-utils.h"
 #include "sigchain.h"
 #include "strvec.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "transport-internal.h"
 #include "protocol.h"
 #include "packfile.h"
diff --git a/transport.c b/transport.c
index 5b83cf9e73..38915e5466 100644
--- a/transport.c
+++ b/transport.c
@@ -15,8 +15,8 @@
 #include "send-pack.h"
 #include "bundle.h"
 #include "gettext.h"
-#include "refs.h"
-#include "refspec.h"
+#include "refs/refs.h"
+#include "refs/refspec.h"
 #include "branch.h"
 #include "url.h"
 #include "submodule.h"
diff --git a/unpack-trees.c b/unpack-trees.c
index d6e05207a8..b911700d74 100644
--- a/unpack-trees.c
+++ b/unpack-trees.c
@@ -16,7 +16,7 @@
 #include "cache-tree.h"
 #include "unpack-trees.h"
 #include "progress.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "attr.h"
 #include "read-cache.h"
 #include "split-index.h"
diff --git a/upload-pack.c b/upload-pack.c
index 5c12af2219..80d2c95c9b 100644
--- a/upload-pack.c
+++ b/upload-pack.c
@@ -6,7 +6,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "pkt-line.h"
 #include "sideband.h"
 #include "repository.h"
diff --git a/walker.c b/walker.c
index 876865d20a..83f980c1f3 100644
--- a/walker.c
+++ b/walker.c
@@ -12,7 +12,7 @@
 #include "odb/tree-walk.h"
 #include "odb/tag.h"
 #include "odb/blob.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "progress.h"
 #include "prio-queue.h"
 
diff --git a/wt-status.c b/wt-status.c
index 950ebc3418..708366b973 100644
--- a/wt-status.c
+++ b/wt-status.c
@@ -21,7 +21,7 @@
 #include "run-command.h"
 #include "strvec.h"
 #include "remote.h"
-#include "refs.h"
+#include "refs/refs.h"
 #include "submodule.h"
 #include "column.h"
 #include "read-cache.h"
@@ -31,7 +31,7 @@
 #include "trace2.h"
 #include "odb/tree.h"
 #include "utf8.h"
-#include "worktree.h"
+#include "refs/worktree.h"
 #include "lockfile.h"
 #include "sequencer.h"
 #include "fsmonitor-settings.h"

.gitorganize, Documentation/Makefile, Documentation/MyFirstContribution.adoc, Documentation/MyFirstObjectWalk.adoc, Makefile, add-interactive.c, add-patch.c, apply.c, apply.h, archive-tar.c, archive-zip.c, archive.c, attr.c, bisect.c, blame.c, blame.h, bloom.c, branch.c, builtin/add.c, builtin/am.c, builtin/apply.c, builtin/backfill.c, builtin/bisect.c, builtin/blame.c, builtin/branch.c, builtin/cat-file.c, builtin/check-attr.c, builtin/checkout.c, builtin/clone.c, builtin/commit-graph.c, builtin/commit-tree.c, builtin/commit.c, builtin/count-objects.c, builtin/describe.c, builtin/diff-files.c, builtin/diff-index.c, builtin/diff-pairs.c, builtin/diff-tree.c, builtin/diff.c, builtin/difftool.c, builtin/fast-export.c, builtin/fast-import.c, builtin/fetch-pack.c, builtin/fetch.c, builtin/for-each-ref.c, builtin/fsck.c, builtin/gc.c, builtin/get-tar-commit-id.c, builtin/grep.c, builtin/hash-object.c, builtin/history.c, builtin/index-pack.c, builtin/last-modified.c, builtin/log.c, builtin/ls-files.c, builtin/ls-tree.c, builtin/merge-base.c, builtin/merge-file.c, builtin/merge-recursive.c, builtin/merge-tree.c, builtin/merge.c, builtin/mktag.c, builtin/mktree.c, builtin/multi-pack-index.c, builtin/mv.c, builtin/name-rev.c, builtin/notes.c, builtin/pack-objects.c, builtin/pack-redundant.c, builtin/patch-id.c, builtin/prune.c, builtin/pull.c, builtin/range-diff.c, builtin/read-tree.c, builtin/rebase.c, builtin/receive-pack.c, builtin/reflog.c, builtin/refs.c, builtin/remote.c, builtin/replace.c, builtin/replay.c, builtin/repo.c, builtin/reset.c, builtin/rev-list.c, builtin/rev-parse.c, builtin/rm.c, builtin/send-pack.c, builtin/shortlog.c, builtin/show-branch.c, builtin/show-index.c, builtin/show-ref.c, builtin/sparse-checkout.c, builtin/stash.c, builtin/submodule--helper.c, builtin/tag.c, builtin/unpack-file.c, builtin/unpack-objects.c, builtin/update-index.c, builtin/update-ref.c, builtin/upload-pack.c, builtin/verify-commit.c, builtin/verify-tag.c, builtin/worktree.c, builtin/write-tree.c, bundle-uri.c, bundle.c, cache-tree.c, cache-tree.h, checkout.c, checkout.h, chunk-format.c, chunk-format.h, combine-diff.c, commit-graph.c, commit-graph.h, commit-reach.c, commit-reach.h, common-init.c, compat/mingw.c, compat/sha1-chunked.c, config.c, connect.c, connected.c, convert.c, convert.h, csum-file.c, csum-file.h, decorate.c, delta-islands.c, diagnose.c, diff-lib.c, diff-no-index.c, diff.c, diff.h, diffcore-break.c, diffcore-pickaxe.c, diffcore-rename.c, diffcore.h, dir.c, dir.h, entry.c, environment.c, fetch-object-info.c, fetch-pack.c, fetch-pack.h, fmt-merge-msg.c, fsmonitor.h, git.c, gpg-interface.c, graph.c, grep.c, help.c, hex.c, hex.h, http-backend.c, http-push.c, http-walker.c, http.c, khash.h, line-log.c, list-objects-filter-options.h, list-objects-filter.c, list-objects.c, log-tree.c, ls-refs.c, mailmap.c, merge-blobs.c, merge-ort-wrappers.c, merge-ort.c, merge-ort.h, merge.c, meson.build, midx-write.c, midx.c, name-hash.c, negotiator/default.c, negotiator/skipping.c, notes-cache.c, notes-merge.c, notes-utils.c, notes.c, alloc.c, odb/alloc.c, alloc.h, blob.c, odb/blob.c, blob.h, odb/blob.h, cbtree.c, odb/cbtree.c, cbtree.h, commit-slab-decl.h, commit-slab-impl.h, commit-slab.h, odb/commit-slab.h, commit.c, odb/commit.c, commit.h, odb/commit.h, fsck.c, odb/fsck.c, fsck.h, odb/fsck.h, hash-lookup.c, odb/hash-lookup.c, hash-lookup.h, hash.c, odb/hash.c, hash.h, loose.c, odb/loose.c, loose.h, match-trees.c, odb/match-trees.c, match-trees.h, object-file-convert.c, odb/object-file-convert.c, object-file-convert.h, odb/object-file-convert.h, object-file.c, odb/object-file.c, object-file.h, odb/object-file.h, object-name.c, odb/object-name.c, object-name.h, odb/object-name.h, object.c, odb/object.c, object.h, odb/object.h, odb.c, odb/odb.c, odb.h, odb/odb.h, oid-array.c, odb/oid-array.c, oid-array.h, odb/oid-array.h, oidmap.c, odb/oidmap.c, oidmap.h, odb/oidmap.h, oidset.c, odb/oidset.c, oidset.h, oidtree.c, odb/oidtree.c, oidtree.h, odb/oidtree.h, replace-object.c, odb/replace-object.c, replace-object.h, odb/replace-object.h, odb/source-files.c, odb/source-inmemory.c, odb/source-loose.c, odb/source.c, odb/source.h, odb/streaming.c, odb/streaming.h, tag.c, odb/tag.c, tag.h, odb/tag.h, tmp-objdir.c, odb/tmp-objdir.c, tmp-objdir.h, odb/transaction.h, tree-walk.c, odb/tree-walk.c, tree-walk.h, odb/tree-walk.h, tree.c, odb/tree.c, tree.h, odb/tree.h, oss-fuzz/fuzz-pack-idx.c, pack-bitmap-write.c, pack-bitmap.c, pack-check.c, pack-mtimes.c, pack-objects.c, pack-objects.h, pack-revindex.c, pack-write.c, pack.h, packfile.c, packfile.h, parallel-checkout.c, parse-options-cb.c, patch-ids.c, path-walk.c, path-walk.h, path.c, pretty.c, promisor-remote.c, protocol-caps.c, prune-packed.c, pseudo-merge.c, range-diff.c, reachable.c, read-cache-ll.h, read-cache.c, read-cache.h, rebase-interactive.c, ref-filter.c, ref-filter.h, reflog-walk.c, reflog.c, refs.c, refs.h, refs/files-backend.c, refs/packed-backend.c, refs/ref-cache.c, refs/ref-cache.h, refs/reftable-backend.c, refspec.c, remote-curl.c, remote.c, remote.h, repack-midx.c, repack.c, replay.c, replay.h, repository.c, rerere.c, reset.c, reset.h, resolve-undo.c, resolve-undo.h, revision.c, revision.h, send-pack.c, sequencer.c, serve.c, server-info.c, setup.c, shallow.c, shallow.h, sparse-index.c, split-index.c, split-index.h, submodule-config.c, submodule-config.h, submodule.c, t/helper/test-bitmap.c, t/helper/test-bloom.c, t/helper/test-cache-tree.c, t/helper/test-dump-cache-tree.c, t/helper/test-find-pack.c, t/helper/test-hash-speed.c, t/helper/test-match-trees.c, t/helper/test-pack-deltas.c, t/helper/test-pack-mtimes.c, t/helper/test-partial-clone.c, t/helper/test-path-walk.c, t/helper/test-reach.c, t/helper/test-read-graph.c, t/helper/test-read-midx.c, t/helper/test-ref-store.c, t/helper/test-reftable.c, t/helper/test-repository.c, t/helper/test-revision-walking.c, t/helper/test-scrap-cache-tree.c, t/helper/test-sha1.c

diff --git a/.gitorganize b/.gitorganize
index 522821522e..5da6d0b2b1 100644
--- a/.gitorganize
+++ b/.gitorganize
@@ -30,8 +30,6 @@ advice.c component=? role=lib prefix=advice includes=setup:2 cochange=transport:
 advice.h component=? role=public prefix=advice cochange=transport:14,index:9,odb:6,submodule:4,pack:3
 alias.c component=setup role=lib prefix=alias includes=setup:2 cochange=setup:8,diff:4,transport:3,convert:2,index:2
 alias.h component=setup role=header prefix=completion cochange=setup:3,transport:2,pack:1,revision:1
-alloc.c component=odb role=lib prefix=alloc includes=odb:6,setup:1 cochange=odb:54,revision:8,diff:6,pack:6,index:3
-alloc.h component=odb role=header prefix=alloc cochange=odb:16,refs:1,revision:1
 apply.c component=? role=lib prefix=apply includes=index:5,setup:4,odb:3,diff:2,merge:2 cochange=index:93,setup:43,diff:41,odb:26,merge:24
 apply.h component=? role=public prefix=apply includes=odb:1 cochange=diff:2
 archive-tar.c component=archive role=lib prefix=archive-tar includes=archive:1,odb:1,setup:1 cochange=archive:59,index:12,diff:9,odb:9,transport:8
@@ -47,8 +45,6 @@ bisect.c component=revision role=lib prefix=bisect includes=odb:5,revision:5,set
 bisect.h component=revision role=header prefix=bisect cochange=revision:29,odb:2
 blame.c component=revision role=lib prefix=blame includes=odb:5,diff:2,index:2,pack:2,revision:2 cochange=diff:68,revision:66,odb:56,index:29,pack:22
 blame.h component=revision role=header prefix=blame includes=diff:1,odb:1 cochange=revision:19,odb:7,diff:4,archive:1,index:1
-blob.c component=odb role=lib prefix=object includes=odb:2 cochange=odb:131,transport:12,pack:11,revision:10,refs:5
-blob.h component=odb role=header prefix=blob includes=odb:1 cochange=odb:33,revision:4,pack:3,transport:2
 bloom.c component=pack role=lib prefix=bloom includes=odb:4,diff:2,pack:2,setup:2 cochange=pack:38,revision:25,diff:15,odb:6,index:2
 bloom.h component=pack role=header prefix=bloom cochange=pack:28,revision:12,odb:1
 branch.c component=? role=lib prefix=branch includes=refs:3,setup:3,odb:2,submodule:1,transport:1 cochange=refs:62,transport:41,setup:28,index:19,revision:12
@@ -60,8 +56,6 @@ bundle.c component=transport role=lib prefix=bundle includes=odb:3,revision:3,se
 bundle.h component=transport role=header prefix=bundle includes=revision:1 cochange=transport:37,revision:5
 cache-tree.c component=index role=lib prefix=cache-tree includes=odb:5,index:2,setup:1,transport:1 cochange=index:94,odb:69,revision:27,transport:21,diff:20
 cache-tree.h component=index role=header prefix=cache-tree includes=odb:2 cochange=index:42,diff:4,revision:4,odb:3,refs:1
-cbtree.c component=odb role=lib prefix=cbtree includes=odb:1 cochange=odb:9,diff:1,merge:1,pack:1
-cbtree.h component=odb role=header prefix=cbtree cochange=odb:12,pack:3,setup:1,transport:1
 chdir-notify.c component=? role=lib prefix=chdir-notify includes=revision:1 cochange=index:2,archive:1,merge:1,revision:1
 chdir-notify.h component=? role=public prefix=chdir-notify
 checkout.c component=index role=lib prefix=checkout includes=setup:2,index:1,odb:1,refs:1,transport:1 cochange=transport:16,refs:6,setup:5,index:3,odb:2
@@ -77,11 +71,6 @@ commit-graph.c component=pack role=lib prefix=commit-graph includes=odb:9,pack:4
 commit-graph.h component=pack role=header prefix=commit-graph includes=odb:2 cochange=pack:92,odb:14,setup:9,revision:8,transport:5
 commit-reach.c component=revision role=lib prefix=commit-reach includes=revision:3,odb:2,pack:1,refs:1 cochange=revision:38,odb:17,pack:15,transport:9,index:5
 commit-reach.h component=revision role=header prefix=commit-reach includes=odb:2 cochange=revision:32,odb:9,transport:8,pack:3,refs:3
-commit-slab-decl.h component=odb role=header prefix=commit-slab cochange=odb:6,revision:1
-commit-slab-impl.h component=odb role=header prefix=commit-slab cochange=odb:7,pack:3,revision:1,setup:1,transport:1
-commit-slab.h component=odb role=header prefix=commit-slab includes=odb:2 cochange=odb:8,revision:2,transport:2,index:1,merge:1
-commit.c component=odb role=lib prefix=commit includes=odb:10,setup:4,revision:3,diff:1,index:1 cochange=odb:403,revision:147,transport:87,pack:57,setup:45
-commit.h component=odb role=header prefix=commit includes=odb:1 cochange=odb:237,revision:205,transport:49,pack:25,notes:22
 common-exit.c component=? role=lib prefix=common-main
 common-init.c component=? role=lib prefix=common-main includes=odb:2,setup:2,convert:1 cochange=setup:1
 common-init.h component=? role=public prefix=common-main
@@ -146,8 +135,6 @@ fetch-pack.h component=transport role=header prefix=fetch-pack includes=odb:1,re
 fmt-merge-msg.c component=merge role=lib prefix=fmt-merge-msg includes=odb:3,diff:2,revision:2,setup:2,merge:1 cochange=revision:10,odb:7,index:6,diff:4,setup:4
 fmt-merge-msg.h component=merge role=header prefix=fmt-merge-msg cochange=merge:3,setup:2
 for-each-ref.h component=? role=public prefix=?
-fsck.c component=odb role=lib prefix=fsck includes=odb:9,setup:3,convert:1,index:1,pack:1 cochange=odb:113,revision:46,transport:43,pack:20,setup:15
-fsck.h component=odb role=header prefix=fsck includes=odb:2 cochange=odb:50,diff:5,revision:5,transport:5,refs:4
 fsmonitor--daemon.h component=index role=header prefix=fsmonitor--daemon includes=index:1 cochange=index:1
 fsmonitor-ipc.c component=index role=lib prefix=fsmonitor includes=index:1,setup:1 cochange=index:6,transport:2,merge:1,notes:1,pack:1
 fsmonitor-ipc.h component=index role=header prefix=fsmonitor cochange=index:2
@@ -170,10 +157,6 @@ graph.c component=revision role=lib prefix=graph includes=revision:2,odb:1,setup
 graph.h component=revision role=header prefix=graph includes=diff:1 cochange=revision:19,diff:2,odb:1
 grep.c component=? role=lib prefix=grep includes=diff:4,odb:1,revision:1,setup:1 cochange=diff:40,revision:28,transport:10,index:7,refs:7
 grep.h component=? role=public prefix=grep includes=diff:1 cochange=revision:23,diff:10,transport:4,index:2,refs:2
-hash-lookup.c component=odb role=lib prefix=hash includes=odb:2,index:1 cochange=pack:14,odb:12,diff:1,index:1,merge:1
-hash-lookup.h component=odb role=header prefix=hash-lookup cochange=odb:10,pack:8,diff:1,merge:1,revision:1
-hash.c component=odb role=lib prefix=hash includes=odb:1 cochange=odb:15,diff:2,setup:2,index:1,transport:1
-hash.h component=odb role=header prefix=hash includes=setup:1 cochange=odb:32,pack:11,index:9,diff:7,transport:4
 hashmap.c component=? role=lib prefix=hashmap cochange=diff:33,revision:19,index:17,refs:13,submodule:13
 hashmap.h component=? role=public prefix=hashmap cochange=diff:39,revision:23,index:18,submodule:14,refs:13
 help.c component=? role=lib prefix=help includes=setup:4,index:1,odb:1,refs:1,transport:1 cochange=setup:19,transport:19,diff:9,index:8,odb:7
@@ -218,16 +201,12 @@ lockfile.c component=? role=lib prefix=lockfile includes=setup:1 cochange=refs:1
 lockfile.h component=? role=public prefix=lockfile cochange=index:5,revision:4,diff:3,refs:3,odb:2
 log-tree.c component=revision role=lib prefix=format-patch includes=odb:8,revision:5,diff:3,setup:3,refs:2 cochange=revision:222,diff:112,odb:112,refs:31,transport:16
 log-tree.h component=revision role=header prefix=format-patch cochange=revision:64,diff:11,refs:3,odb:2,transport:2
-loose.c component=odb role=lib prefix=loose includes=odb:5,setup:1 cochange=odb:31,pack:18,setup:7,transport:6,refs:2
-loose.h component=odb role=header prefix=loose cochange=odb:8,setup:3
 ls-refs.c component=refs role=lib prefix=ls-refs includes=setup:3,refs:2,odb:1,transport:1 cochange=refs:26,transport:17,pack:10,revision:5,odb:4
 ls-refs.h component=refs role=header prefix=ls-refs cochange=transport:11,refs:5,submodule:1
 mailinfo.c component=? role=lib prefix=mailinfo includes=setup:2 cochange=transport:5,index:3,notes:3,odb:3,revision:3
 mailinfo.h component=? role=public prefix=mailinfo
 mailmap.c component=? role=lib prefix=mailmap includes=setup:3,odb:2 cochange=setup:13,transport:11,refs:10,index:8,revision:5
 mailmap.h component=? role=public prefix=mailmap cochange=setup:8,revision:4,transport:2,diff:1,index:1
-match-trees.c component=odb role=lib prefix=match-trees includes=odb:5,setup:1 cochange=odb:33,index:15,notes:15,revision:12,pack:10
-match-trees.h component=odb role=header prefix=match-trees cochange=merge:1,odb:1
 mem-pool.c component=? role=lib prefix=mem-pool cochange=index:6
 mem-pool.h component=? role=public prefix=mem-pool cochange=index:4
 merge-blobs.c component=merge role=lib prefix=object-store includes=merge:2,odb:2 cochange=merge:9,notes:3,diff:2,convert:1,odb:1
@@ -254,24 +233,55 @@ notes-utils.c component=notes role=lib prefix=commit includes=setup:2,notes:1,od
 notes-utils.h component=notes role=header prefix=notes includes=notes:1 cochange=notes:17,odb:6
 notes.c component=notes role=lib prefix=notes includes=odb:4,setup:2,notes:1,refs:1 cochange=notes:63,odb:58,revision:41,transport:36,index:24
 notes.h component=notes role=header prefix=notes cochange=notes:55,revision:20,setup:9,odb:3,refs:2
-object-file-convert.c component=odb role=lib prefix=object-file-convert includes=odb:5,setup:1 cochange=odb:8,setup:2,transport:1
-object-file-convert.h component=odb role=header prefix=object-file-convert includes=odb:1 cochange=odb:4
-object-file.c component=odb role=lib prefix=object-file includes=odb:6,index:2,pack:2,setup:2,convert:1 cochange=odb:183,pack:96,index:55,setup:30,transport:27
-object-file.h component=odb role=header prefix=object-file includes=odb:2 cochange=odb:113,pack:30,index:12,notes:5,transport:5
-object-name.c component=odb role=lib prefix=object-name includes=odb:8,setup:5,index:2,revision:2,pack:1 cochange=odb:46,pack:31,revision:23,setup:19,refs:18
-object-name.h component=odb role=header prefix=object-name includes=odb:1 cochange=odb:5,revision:3,refs:2,index:1
-object.c component=odb role=lib prefix=object includes=odb:8,index:1,pack:1 cochange=odb:265,pack:61,revision:55,transport:34,refs:17
-object.h component=odb role=header prefix=object includes=odb:1 cochange=odb:187,revision:54,transport:41,pack:29,refs:20
-odb.c component=odb role=lib prefix=odb includes=odb:7,pack:3,setup:3,index:1,submodule:1 cochange=odb:123,pack:64,setup:13,transport:12,index:8
-odb.h component=odb role=header prefix=odb includes=odb:3 cochange=odb:117,pack:71,transport:16,setup:13,index:10
-oid-array.c component=odb role=lib prefix=oid-array includes=odb:2 cochange=odb:13,pack:10,merge:2,diff:1,revision:1
-oid-array.h component=odb role=header prefix=oid-array includes=odb:1 cochange=odb:3,diff:1,index:1,refs:1,revision:1
-oidmap.c component=odb role=lib prefix=oidmap includes=odb:2 cochange=diff:11,revision:7,odb:6,refs:5,index:4
-oidmap.h component=odb role=header prefix=oidmap includes=odb:1 cochange=odb:6,revision:4,index:2,transport:2,convert:1
-oidset.c component=odb role=lib prefix=oidset includes=odb:1 cochange=odb:17,convert:2,diff:2,transport:2,index:1
-oidset.h component=odb role=header prefix=oidset cochange=odb:17,revision:1,transport:1
-oidtree.c component=odb role=lib prefix=oidtree includes=odb:2 cochange=odb:14,index:3,setup:2,diff:1,merge:1
-oidtree.h component=odb role=header prefix=oidtree includes=odb:2 cochange=odb:9
+odb/alloc.c component=odb role=lib prefix=alloc includes=odb:6,setup:1 cochange=odb:54,revision:8,diff:6,pack:6,index:3
+odb/alloc.h component=odb role=header prefix=alloc cochange=odb:16,refs:1,revision:1
+odb/blob.c component=odb role=lib prefix=object includes=odb:2 cochange=odb:131,transport:12,pack:11,revision:10,refs:5
+odb/blob.h component=odb role=header prefix=blob includes=odb:1 cochange=odb:33,revision:4,pack:3,transport:2
+odb/cbtree.c component=odb role=lib prefix=cbtree includes=odb:1 cochange=odb:9,diff:1,merge:1,pack:1
+odb/cbtree.h component=odb role=header prefix=cbtree cochange=odb:12,pack:3,setup:1,transport:1
+odb/commit-slab-decl.h component=odb role=header prefix=commit-slab cochange=odb:6,revision:1
+odb/commit-slab-impl.h component=odb role=header prefix=commit-slab cochange=odb:7,pack:3,revision:1,setup:1,transport:1
+odb/commit-slab.h component=odb role=header prefix=commit-slab includes=odb:2 cochange=odb:8,revision:2,transport:2,index:1,merge:1
+odb/commit.c component=odb role=lib prefix=commit includes=odb:10,setup:4,revision:3,diff:1,index:1 cochange=odb:403,revision:147,transport:87,pack:57,setup:45
+odb/commit.h component=odb role=header prefix=commit includes=odb:1 cochange=odb:237,revision:205,transport:49,pack:25,notes:22
+odb/fsck.c component=odb role=lib prefix=fsck includes=odb:9,setup:3,convert:1,index:1,pack:1 cochange=odb:113,revision:46,transport:43,pack:20,setup:15
+odb/fsck.h component=odb role=header prefix=fsck includes=odb:2 cochange=odb:50,diff:5,revision:5,transport:5,refs:4
+odb/hash-lookup.c component=odb role=lib prefix=hash includes=odb:2,index:1 cochange=pack:14,odb:12,diff:1,index:1,merge:1
+odb/hash-lookup.h component=odb role=header prefix=hash-lookup cochange=odb:10,pack:8,diff:1,merge:1,revision:1
+odb/hash.c component=odb role=lib prefix=hash includes=odb:1 cochange=odb:15,diff:2,setup:2,index:1,transport:1
+odb/hash.h component=odb role=header prefix=hash includes=setup:1 cochange=odb:32,pack:11,index:9,diff:7,transport:4
+odb/loose.c component=odb role=lib prefix=loose includes=odb:5,setup:1 cochange=odb:31,pack:18,setup:7,transport:6,refs:2
+odb/loose.h component=odb role=header prefix=loose cochange=odb:8,setup:3
+odb/match-trees.c component=odb role=lib prefix=match-trees includes=odb:5,setup:1 cochange=odb:33,index:15,notes:15,revision:12,pack:10
+odb/match-trees.h component=odb role=header prefix=match-trees cochange=merge:1,odb:1
+odb/object-file-convert.c component=odb role=lib prefix=object-file-convert includes=odb:5,setup:1 cochange=odb:8,setup:2,transport:1
+odb/object-file-convert.h component=odb role=header prefix=object-file-convert includes=odb:1 cochange=odb:4
+odb/object-file.c component=odb role=lib prefix=object-file includes=odb:6,index:2,pack:2,setup:2,convert:1 cochange=odb:183,pack:96,index:55,setup:30,transport:27
+odb/object-file.h component=odb role=header prefix=object-file includes=odb:2 cochange=odb:113,pack:30,index:12,notes:5,transport:5
+odb/object-name.c component=odb role=lib prefix=object-name includes=odb:8,setup:5,index:2,revision:2,pack:1 cochange=odb:46,pack:31,revision:23,setup:19,refs:18
+odb/object-name.h component=odb role=header prefix=object-name includes=odb:1 cochange=odb:5,revision:3,refs:2,index:1
+odb/object.c component=odb role=lib prefix=object includes=odb:8,index:1,pack:1 cochange=odb:265,pack:61,revision:55,transport:34,refs:17
+odb/object.h component=odb role=header prefix=object includes=odb:1 cochange=odb:187,revision:54,transport:41,pack:29,refs:20
+odb/odb.c component=odb role=lib prefix=odb includes=odb:7,pack:3,setup:3,index:1,submodule:1 cochange=odb:123,pack:64,setup:13,transport:12,index:8
+odb/odb.h component=odb role=header prefix=odb includes=odb:3 cochange=odb:117,pack:71,transport:16,setup:13,index:10
+odb/oid-array.c component=odb role=lib prefix=oid-array includes=odb:2 cochange=odb:13,pack:10,merge:2,diff:1,revision:1
+odb/oid-array.h component=odb role=header prefix=oid-array includes=odb:1 cochange=odb:3,diff:1,index:1,refs:1,revision:1
+odb/oidmap.c component=odb role=lib prefix=oidmap includes=odb:2 cochange=diff:11,revision:7,odb:6,refs:5,index:4
+odb/oidmap.h component=odb role=header prefix=oidmap includes=odb:1 cochange=odb:6,revision:4,index:2,transport:2,convert:1
+odb/oidset.c component=odb role=lib prefix=oidset includes=odb:1 cochange=odb:17,convert:2,diff:2,transport:2,index:1
+odb/oidset.h component=odb role=header prefix=oidset cochange=odb:17,revision:1,transport:1
+odb/oidtree.c component=odb role=lib prefix=oidtree includes=odb:2 cochange=odb:14,index:3,setup:2,diff:1,merge:1
+odb/oidtree.h component=odb role=header prefix=oidtree includes=odb:2 cochange=odb:9
+odb/replace-object.c component=odb role=lib prefix=refs includes=odb:4,refs:1,setup:1 cochange=odb:8,setup:6,refs:5,pack:3,diff:2
+odb/replace-object.h component=odb role=header prefix=replace-object includes=odb:2,setup:1 cochange=odb:11,setup:9,pack:4,revision:3,merge:1
+odb/tag.c component=odb role=lib prefix=tag includes=odb:7,setup:2,pack:1 cochange=odb:189,transport:36,pack:32,revision:29,refs:14
+odb/tag.h component=odb role=header prefix=tag includes=odb:1 cochange=odb:60,transport:10,revision:8,refs:7,pack:6
+odb/tmp-objdir.c component=odb role=lib prefix=tmp-objdir includes=odb:3,setup:2,index:1 cochange=pack:24,odb:23,setup:8,transport:5,revision:3
+odb/tmp-objdir.h component=odb role=header prefix=tmp-objdir cochange=odb:8,revision:3,setup:1
+odb/tree-walk.c component=odb role=lib prefix=tree-walk includes=odb:4,index:3,setup:1 cochange=odb:70,index:61,diff:31,revision:24,pack:13
+odb/tree-walk.h component=odb role=header prefix=tree-walk includes=odb:1 cochange=odb:64,diff:23,index:23,revision:21,notes:7
+odb/tree.c component=odb role=lib prefix=tree includes=odb:6,setup:2 cochange=odb:212,revision:45,index:36,pack:25,transport:21
+odb/tree.h component=odb role=header prefix=tree includes=odb:1 cochange=odb:75,revision:12,archive:8,index:6,pack:5
 pack-bitmap-write.c component=pack role=lib prefix=pack-bitmap-write includes=odb:7,pack:6,revision:2,setup:2,diff:1 cochange=pack:132,odb:32,revision:27,transport:10,diff:4
 pack-bitmap.c component=pack role=lib prefix=pack-bitmap includes=pack:7,odb:3,revision:3,setup:2,diff:1 cochange=pack:232,revision:30,odb:18,transport:14,refs:7
 pack-bitmap.h component=pack role=header prefix=pack-bitmap includes=pack:2,refs:1 cochange=pack:117,refs:5,odb:2,setup:2,revision:1
@@ -363,8 +373,6 @@ repack-midx.c component=pack role=lib prefix=repack includes=odb:3,pack:3,refs:1
 repack-promisor.c component=pack role=lib prefix=repack-promisor includes=pack:3,setup:1 cochange=pack:8,odb:3,revision:2
 repack.c component=pack role=lib prefix=repack includes=pack:3,index:1,odb:1,setup:1 cochange=pack:31,transport:2,odb:1
 repack.h component=pack role=header prefix=repack includes=revision:1 cochange=pack:28
-replace-object.c component=odb role=lib prefix=refs includes=odb:4,refs:1,setup:1 cochange=odb:8,setup:6,refs:5,pack:3,diff:2
-replace-object.h component=odb role=header prefix=replace-object includes=odb:2,setup:1 cochange=odb:11,setup:9,pack:4,revision:3,merge:1
 replay.c component=? role=lib prefix=replay includes=odb:2,merge:1,refs:1,revision:1,setup:1 cochange=transport:1
 replay.h component=? role=public prefix=replay includes=odb:1
 repo-settings.c component=setup role=lib prefix=repo-settings includes=setup:4,pack:2 cochange=setup:65,pack:17,index:8,transport:8,odb:6
@@ -428,15 +436,11 @@ submodule.c component=submodule role=lib prefix=submodule includes=odb:5,setup:4
 submodule.h component=submodule role=header prefix=submodule cochange=submodule:128,index:22,diff:21,transport:17,setup:6
 symlinks.c component=index role=lib prefix=symlinks includes=index:1,setup:1 cochange=index:23,diff:3,archive:2,convert:1,revision:1
 symlinks.h component=index role=header prefix=symlinks cochange=index:9,diff:1
-tag.c component=odb role=lib prefix=tag includes=odb:7,setup:2,pack:1 cochange=odb:189,transport:36,pack:32,revision:29,refs:14
-tag.h component=odb role=header prefix=tag includes=odb:1 cochange=odb:60,transport:10,revision:8,refs:7,pack:6
 tar.h component=? role=public prefix=tar-tree
 tempfile.c component=? role=lib prefix=tempfile cochange=pack:5,setup:4,index:3,odb:3,revision:3
 tempfile.h component=? role=public prefix=tempfile includes=revision:1 cochange=revision:3,diff:2,index:2,setup:2
 thread-utils.c component=? role=lib prefix=thread-utils cochange=diff:1
 thread-utils.h component=? role=public prefix=thread-utils cochange=transport:1
-tmp-objdir.c component=odb role=lib prefix=tmp-objdir includes=odb:3,setup:2,index:1 cochange=pack:24,odb:23,setup:8,transport:5,revision:3
-tmp-objdir.h component=odb role=header prefix=tmp-objdir cochange=odb:8,revision:3,setup:1
 trace.c component=? role=lib prefix=trace includes=setup:2 cochange=setup:26,transport:13,index:11,odb:4,diff:2
 trace.h component=? role=public prefix=trace cochange=transport:6,index:5,odb:4,pack:3,revision:3
 trace2.c component=? role=lib prefix=trace2 includes=setup:2 cochange=setup:2
@@ -448,10 +452,6 @@ transport-internal.h component=transport role=header prefix=transport includes=t
 transport.c component=transport role=lib prefix=transport includes=transport:12,setup:3,odb:2,refs:2,submodule:1 cochange=transport:482,refs:35,setup:31,submodule:29,revision:21
 transport.h component=transport role=header prefix=transport includes=transport:2,revision:1 cochange=transport:249,submodule:6,odb:4,revision:2,diff:1
 tree-diff.c component=diff role=lib prefix=tree-diff includes=odb:3,diff:2,index:1,setup:1 cochange=diff:115,odb:56,revision:53,index:36,notes:12
-tree-walk.c component=odb role=lib prefix=tree-walk includes=odb:4,index:3,setup:1 cochange=odb:70,index:61,diff:31,revision:24,pack:13
-tree-walk.h component=odb role=header prefix=tree-walk includes=odb:1 cochange=odb:64,diff:23,index:23,revision:21,notes:7
-tree.c component=odb role=lib prefix=tree includes=odb:6,setup:2 cochange=odb:212,revision:45,index:36,pack:25,transport:21
-tree.h component=odb role=header prefix=tree includes=odb:1 cochange=odb:75,revision:12,archive:8,index:6,pack:5
 unicode-width.h component=? role=public prefix=unicode
 unix-socket.c component=? role=lib prefix=unix-socket cochange=diff:3,revision:2,setup:1
 unix-socket.h component=? role=public prefix=unix-socket
diff --git a/Documentation/Makefile b/Documentation/Makefile
index 2699f0b24a..c5b52b6e7a 100644
--- a/Documentation/Makefile
+++ b/Documentation/Makefile
@@ -505,10 +505,10 @@ lint-docs-man-section-order: $(LINT_DOCS_MAN_SECTION_ORDER)
 .PHONY: lint-docs-fsck-msgids
 LINT_DOCS_FSCK_MSGIDS = .build/lint-docs/fsck-msgids.ok
 $(LINT_DOCS_FSCK_MSGIDS): lint-fsck-msgids.perl
-$(LINT_DOCS_FSCK_MSGIDS): ../fsck.h fsck-msgids.adoc
+$(LINT_DOCS_FSCK_MSGIDS): ../odb/fsck.h fsck-msgids.adoc
 	$(call mkdir_p_parent_template)
 	$(QUIET_GEN)$(PERL_PATH) lint-fsck-msgids.perl \
-		../fsck.h fsck-msgids.adoc $@
+		../odb/fsck.h fsck-msgids.adoc $@
 lint-docs-fsck-msgids: $(LINT_DOCS_FSCK_MSGIDS)
 
 ## Lint: delimited sections
diff --git a/Documentation/MyFirstContribution.adoc b/Documentation/MyFirstContribution.adoc
index 34bfa2e3a9..4b50aaa40e 100644
--- a/Documentation/MyFirstContribution.adoc
+++ b/Documentation/MyFirstContribution.adoc
@@ -428,7 +428,7 @@ require a full format object to be passed.
 Add the following includes:
 
 ----
-#include "commit.h"
+#include "odb/commit.h"
 #include "pretty.h"
 #include "strbuf.h"
 ----
diff --git a/Documentation/MyFirstObjectWalk.adoc b/Documentation/MyFirstObjectWalk.adoc
index 413a9fdb05..87b2433b2c 100644
--- a/Documentation/MyFirstObjectWalk.adoc
+++ b/Documentation/MyFirstObjectWalk.adoc
@@ -779,7 +779,7 @@ be processed in order to populate that list.
 First, add the `struct oidset` and related items we will use to iterate it:
 
 ----
-#include "oidset.h"
+#include "odb/oidset.h"
 
 ...
 
diff --git a/Makefile b/Makefile
index 86297e9459..a95b87d970 100644
--- a/Makefile
+++ b/Makefile
@@ -1103,7 +1103,7 @@ LIB_OBJS += add-interactive.o
 LIB_OBJS += add-patch.o
 LIB_OBJS += advice.o
 LIB_OBJS += alias.o
-LIB_OBJS += alloc.o
+LIB_OBJS += odb/alloc.o
 LIB_OBJS += apply.o
 LIB_OBJS += archive-tar.o
 LIB_OBJS += archive-zip.o
@@ -1112,13 +1112,13 @@ LIB_OBJS += attr.o
 LIB_OBJS += base85.o
 LIB_OBJS += bisect.o
 LIB_OBJS += blame.o
-LIB_OBJS += blob.o
+LIB_OBJS += odb/blob.o
 LIB_OBJS += bloom.o
 LIB_OBJS += branch.o
 LIB_OBJS += bundle-uri.o
 LIB_OBJS += bundle.o
 LIB_OBJS += cache-tree.o
-LIB_OBJS += cbtree.o
+LIB_OBJS += odb/cbtree.o
 LIB_OBJS += chdir-notify.o
 LIB_OBJS += checkout.o
 LIB_OBJS += chunk-format.o
@@ -1127,7 +1127,7 @@ LIB_OBJS += column.o
 LIB_OBJS += combine-diff.o
 LIB_OBJS += commit-graph.o
 LIB_OBJS += commit-reach.o
-LIB_OBJS += commit.o
+LIB_OBJS += odb/commit.o
 LIB_OBJS += common-exit.o
 LIB_OBJS += common-init.o
 LIB_OBJS += compat/nonblock.o
@@ -1172,7 +1172,7 @@ LIB_OBJS += fetch-negotiator.o
 LIB_OBJS += fetch-object-info.o
 LIB_OBJS += fetch-pack.o
 LIB_OBJS += fmt-merge-msg.o
-LIB_OBJS += fsck.o
+LIB_OBJS += odb/fsck.o
 LIB_OBJS += fsmonitor.o
 LIB_OBJS += fsmonitor-ipc.o
 LIB_OBJS += fsmonitor-settings.o
@@ -1181,8 +1181,8 @@ LIB_OBJS += git-zlib.o
 LIB_OBJS += gpg-interface.o
 LIB_OBJS += graph.o
 LIB_OBJS += grep.o
-LIB_OBJS += hash-lookup.o
-LIB_OBJS += hash.o
+LIB_OBJS += odb/hash-lookup.o
+LIB_OBJS += odb/hash.o
 LIB_OBJS += hashmap.o
 LIB_OBJS += help.o
 LIB_OBJS += hex.o
@@ -1200,11 +1200,11 @@ LIB_OBJS += list-objects-filter.o
 LIB_OBJS += list-objects.o
 LIB_OBJS += lockfile.o
 LIB_OBJS += log-tree.o
-LIB_OBJS += loose.o
+LIB_OBJS += odb/loose.o
 LIB_OBJS += ls-refs.o
 LIB_OBJS += mailinfo.o
 LIB_OBJS += mailmap.o
-LIB_OBJS += match-trees.o
+LIB_OBJS += odb/match-trees.o
 LIB_OBJS += mem-pool.o
 LIB_OBJS += merge-blobs.o
 LIB_OBJS += merge-ll.o
@@ -1221,11 +1221,11 @@ LIB_OBJS += notes-cache.o
 LIB_OBJS += notes-merge.o
 LIB_OBJS += notes-utils.o
 LIB_OBJS += notes.o
-LIB_OBJS += object-file-convert.o
-LIB_OBJS += object-file.o
-LIB_OBJS += object-name.o
-LIB_OBJS += object.o
-LIB_OBJS += odb.o
+LIB_OBJS += odb/object-file-convert.o
+LIB_OBJS += odb/object-file.o
+LIB_OBJS += odb/object-name.o
+LIB_OBJS += odb/object.o
+LIB_OBJS += odb/odb.o
 LIB_OBJS += odb/source.o
 LIB_OBJS += odb/source-files.o
 LIB_OBJS += odb/source-inmemory.o
@@ -1233,10 +1233,10 @@ LIB_OBJS += odb/source-loose.o
 LIB_OBJS += odb/source-packed.o
 LIB_OBJS += odb/streaming.o
 LIB_OBJS += odb/transaction.o
-LIB_OBJS += oid-array.o
-LIB_OBJS += oidmap.o
-LIB_OBJS += oidset.o
-LIB_OBJS += oidtree.o
+LIB_OBJS += odb/oid-array.o
+LIB_OBJS += odb/oidmap.o
+LIB_OBJS += odb/oidset.o
+LIB_OBJS += odb/oidtree.o
 LIB_OBJS += organize/gitorganize-format.o
 LIB_OBJS += organize/labeler-protocol.o
 LIB_OBJS += organize/organize.o
@@ -1310,7 +1310,7 @@ LIB_OBJS += repack-filtered.o
 LIB_OBJS += repack-geometry.o
 LIB_OBJS += repack-midx.o
 LIB_OBJS += repack-promisor.o
-LIB_OBJS += replace-object.o
+LIB_OBJS += odb/replace-object.o
 LIB_OBJS += replay.o
 LIB_OBJS += repo-settings.o
 LIB_OBJS += repository.o
@@ -1339,10 +1339,10 @@ LIB_OBJS += sub-process.o
 LIB_OBJS += submodule-config.o
 LIB_OBJS += submodule.o
 LIB_OBJS += symlinks.o
-LIB_OBJS += tag.o
+LIB_OBJS += odb/tag.o
 LIB_OBJS += tempfile.o
 LIB_OBJS += thread-utils.o
-LIB_OBJS += tmp-objdir.o
+LIB_OBJS += odb/tmp-objdir.o
 LIB_OBJS += trace.o
 LIB_OBJS += trace2.o
 LIB_OBJS += trace2/tr2_cfg.o
@@ -1361,8 +1361,8 @@ LIB_OBJS += trailer.o
 LIB_OBJS += transport-helper.o
 LIB_OBJS += transport.o
 LIB_OBJS += tree-diff.o
-LIB_OBJS += tree-walk.o
-LIB_OBJS += tree.o
+LIB_OBJS += odb/tree-walk.o
+LIB_OBJS += odb/tree.o
 LIB_OBJS += unpack-trees.o
 LIB_OBJS += upload-pack.o
 LIB_OBJS += url.o
diff --git a/add-interactive.c b/add-interactive.c
index 3cf8a1dbf8..51ddcc4e87 100644
--- a/add-interactive.c
+++ b/add-interactive.c
@@ -5,7 +5,7 @@
 #include "color.h"
 #include "diffcore.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "preload-index.h"
 #include "read-cache-ll.h"
@@ -17,7 +17,7 @@
 #include "dir.h"
 #include "run-command.h"
 #include "prompt.h"
-#include "tree.h"
+#include "odb/tree.h"
 
 void init_add_i_state(struct add_i_state *s, struct repository *r,
 		      struct interactive_options *opts)
diff --git a/add-patch.c b/add-patch.c
index f27edcbe8d..1b4c53e4ce 100644
--- a/add-patch.c
+++ b/add-patch.c
@@ -4,14 +4,14 @@
 #include "git-compat-util.h"
 #include "add-patch.h"
 #include "advice.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "config.h"
 #include "diff.h"
 #include "editor.h"
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "pager.h"
 #include "read-cache-ll.h"
 #include "repository.h"
diff --git a/apply.c b/apply.c
index f00b7ba4d3..ba486ab51d 100644
--- a/apply.c
+++ b/apply.c
@@ -14,7 +14,7 @@
 #include "abspath.h"
 #include "base85.h"
 #include "config.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "delta.h"
 #include "diff.h"
 #include "dir.h"
@@ -25,8 +25,8 @@
 #include "merge-ll.h"
 #include "lockfile.h"
 #include "name-hash.h"
-#include "object-name.h"
-#include "object-file.h"
+#include "odb/object-name.h"
+#include "odb/object-file.h"
 #include "parse-options.h"
 #include "path.h"
 #include "quote.h"
diff --git a/apply.h b/apply.h
index 5f2f03d3ed..7c22776d41 100644
--- a/apply.h
+++ b/apply.h
@@ -1,7 +1,7 @@
 #ifndef APPLY_H
 #define APPLY_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "lockfile.h"
 #include "string-list.h"
 #include "strmap.h"
diff --git a/archive-tar.c b/archive-tar.c
index 0fc70d13a8..318b9bcc24 100644
--- a/archive-tar.c
+++ b/archive-tar.c
@@ -11,7 +11,7 @@
 #include "hex.h"
 #include "tar.h"
 #include "archive.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 #include "strbuf.h"
 #include "run-command.h"
diff --git a/archive-zip.c b/archive-zip.c
index 97ea8d60d6..53c50ebc44 100644
--- a/archive-zip.c
+++ b/archive-zip.c
@@ -11,7 +11,7 @@
 #include "git-zlib.h"
 #include "hex.h"
 #include "utf8.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 #include "strbuf.h"
 #include "userdiff.h"
diff --git a/archive.c b/archive.c
index 59790be986..c0d2e0c44b 100644
--- a/archive.c
+++ b/archive.c
@@ -9,15 +9,15 @@
 #include "gettext.h"
 #include "git-zlib.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "path.h"
 #include "pretty.h"
 #include "setup.h"
 #include "refs.h"
-#include "odb.h"
-#include "commit.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/odb.h"
+#include "odb/commit.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "attr.h"
 #include "archive.h"
 #include "parse-options.h"
diff --git a/attr.c b/attr.c
index 0e63f1b6de..e829149cb4 100644
--- a/attr.c
+++ b/attr.c
@@ -22,11 +22,11 @@
 #include "read-cache-ll.h"
 #include "refs.h"
 #include "revision.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "setup.h"
 #include "thread-utils.h"
-#include "tree-walk.h"
-#include "object-name.h"
+#include "odb/tree-walk.h"
+#include "odb/object-name.h"
 
 char *git_attr_tree;
 
diff --git a/bisect.c b/bisect.c
index d426fcd5a9..2dea7139ad 100644
--- a/bisect.c
+++ b/bisect.c
@@ -3,7 +3,7 @@
 
 #include "git-compat-util.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "environment.h"
 #include "gettext.h"
@@ -15,12 +15,12 @@
 #include "run-command.h"
 #include "log-tree.h"
 #include "bisect.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "strvec.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "commit-reach.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "path.h"
 #include "dir.h"
 
diff --git a/blame.c b/blame.c
index 126e232416..d1cba8811f 100644
--- a/blame.c
+++ b/blame.c
@@ -3,10 +3,10 @@
 
 #include "git-compat-util.h"
 #include "refs.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "cache-tree.h"
 #include "mergesort.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "convert.h"
 #include "diff.h"
 #include "diffcore.h"
@@ -16,11 +16,11 @@
 #include "read-cache.h"
 #include "revision.h"
 #include "setup.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "trace2.h"
 #include "blame.h"
-#include "alloc.h"
-#include "commit-slab.h"
+#include "odb/alloc.h"
+#include "odb/commit-slab.h"
 #include "bloom.h"
 #include "commit-graph.h"
 
diff --git a/blame.h b/blame.h
index 3b34be0e5c..97137099e3 100644
--- a/blame.h
+++ b/blame.h
@@ -1,7 +1,7 @@
 #ifndef BLAME_H
 #define BLAME_H
 
-#include "oidset.h"
+#include "odb/oidset.h"
 #include "xdiff-interface.h"
 #include "prio-queue.h"
 
diff --git a/bloom.c b/bloom.c
index caf22f9831..e61cb05246 100644
--- a/bloom.c
+++ b/bloom.c
@@ -6,10 +6,10 @@
 #include "diffcore.h"
 #include "hashmap.h"
 #include "commit-graph.h"
-#include "commit.h"
-#include "commit-slab.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/commit.h"
+#include "odb/commit-slab.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "config.h"
 #include "repository.h"
 
diff --git a/branch.c b/branch.c
index 22f4f46b96..7593a499a9 100644
--- a/branch.c
+++ b/branch.c
@@ -7,14 +7,14 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "path.h"
 #include "refs.h"
 #include "refspec.h"
 #include "remote.h"
 #include "repository.h"
 #include "sequencer.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "worktree.h"
 #include "submodule-config.h"
 #include "run-command.h"
diff --git a/builtin/add.c b/builtin/add.c
index eab8f03cad..5d6dd91f70 100644
--- a/builtin/add.c
+++ b/builtin/add.c
@@ -14,8 +14,8 @@
 #include "gettext.h"
 #include "pathspec.h"
 #include "run-command.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/transaction.h"
 #include "parse-options.h"
 #include "path.h"
diff --git a/builtin/am.c b/builtin/am.c
index e9623b8307..f138a8fe3d 100644
--- a/builtin/am.c
+++ b/builtin/am.c
@@ -23,11 +23,11 @@
 #include "lockfile.h"
 #include "cache-tree.h"
 #include "refs.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "unpack-trees.h"
 #include "branch.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "preload-index.h"
 #include "sequencer.h"
 #include "revision.h"
diff --git a/builtin/apply.c b/builtin/apply.c
index d642a40251..5fb37cb965 100644
--- a/builtin/apply.c
+++ b/builtin/apply.c
@@ -1,7 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 #include "builtin.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "apply.h"
 
 static const char * const apply_usage[] = {
diff --git a/builtin/backfill.c b/builtin/backfill.c
index e71e0f4742..3685713205 100644
--- a/builtin/backfill.c
+++ b/builtin/backfill.c
@@ -6,16 +6,16 @@
 #include "config.h"
 #include "parse-options.h"
 #include "repository.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "dir.h"
 #include "environment.h"
 #include "hex.h"
-#include "tree.h"
-#include "tree-walk.h"
-#include "object.h"
-#include "odb.h"
-#include "oid-array.h"
-#include "oidset.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
+#include "odb/object.h"
+#include "odb/odb.h"
+#include "odb/oid-array.h"
+#include "odb/oidset.h"
 #include "promisor-remote.h"
 #include "strmap.h"
 #include "string-list.h"
diff --git a/builtin/bisect.c b/builtin/bisect.c
index 93420ac0ea..a1b7fc9407 100644
--- a/builtin/bisect.c
+++ b/builtin/bisect.c
@@ -6,13 +6,13 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "bisect.h"
 #include "refs.h"
 #include "strvec.h"
 #include "run-command.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "path.h"
 #include "prompt.h"
 #include "quote.h"
diff --git a/builtin/blame.c b/builtin/blame.c
index 48d5251c6d..c88fc489f7 100644
--- a/builtin/blame.c
+++ b/builtin/blame.c
@@ -13,7 +13,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "revision.h"
 #include "quote.h"
@@ -26,13 +26,13 @@
 #include "line-range.h"
 #include "line-log.h"
 #include "progress.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "pager.h"
 #include "blame.h"
 #include "refs.h"
 #include "setup.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "write-or-die.h"
 
 static const char blame_usage[] = N_("git blame [<options>] [<rev-opts>] [<rev>] [--] <file>");
diff --git a/builtin/branch.c b/builtin/branch.c
index a613148fc7..c50c28c720 100644
--- a/builtin/branch.c
+++ b/builtin/branch.c
@@ -13,9 +13,9 @@
 #include "editor.h"
 #include "environment.h"
 #include "refs.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "gettext.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "remote.h"
 #include "parse-options.h"
 #include "branch.h"
diff --git a/builtin/cat-file.c b/builtin/cat-file.c
index e85e2cfc1b..ccd6b33827 100644
--- a/builtin/cat-file.c
+++ b/builtin/cat-file.c
@@ -18,13 +18,13 @@
 #include "list-objects-filter-options.h"
 #include "parse-options.h"
 #include "userdiff.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "promisor-remote.h"
 #include "mailmap.h"
 #include "write-or-die.h"
diff --git a/builtin/check-attr.c b/builtin/check-attr.c
index 217d83ea7d..02ff3b4eb5 100644
--- a/builtin/check-attr.c
+++ b/builtin/check-attr.c
@@ -4,7 +4,7 @@
 #include "attr.h"
 #include "environment.h"
 #include "gettext.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "quote.h"
 #include "setup.h"
 #include "parse-options.h"
diff --git a/builtin/checkout.c b/builtin/checkout.c
index 55e3a89a85..2dcebb2cb2 100644
--- a/builtin/checkout.c
+++ b/builtin/checkout.c
@@ -6,7 +6,7 @@
 #include "branch.h"
 #include "cache-tree.h"
 #include "checkout.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "config.h"
 #include "diff.h"
 #include "dir.h"
@@ -17,9 +17,9 @@
 #include "merge-ll.h"
 #include "lockfile.h"
 #include "mem-pool.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "parse-options.h"
 #include "path.h"
 #include "preload-index.h"
@@ -36,8 +36,8 @@
 #include "submodule.h"
 #include "symlinks.h"
 #include "trace2.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "unpack-trees.h"
 #include "wt-status.h"
 #include "xdiff-interface.h"
diff --git a/builtin/clone.c b/builtin/clone.c
index 5b25cca510..6d6a756a12 100644
--- a/builtin/clone.c
+++ b/builtin/clone.c
@@ -24,10 +24,10 @@
 #include "parse-options.h"
 #include "refs.h"
 #include "refspec.h"
-#include "object-file.h"
-#include "odb.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "unpack-trees.h"
 #include "transport.h"
 #include "strbuf.h"
diff --git a/builtin/commit-graph.c b/builtin/commit-graph.c
index d62005edc0..0758af3b64 100644
--- a/builtin/commit-graph.c
+++ b/builtin/commit-graph.c
@@ -1,17 +1,17 @@
 #define USE_THE_REPOSITORY_VARIABLE
 #include "builtin.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
 #include "parse-options.h"
 #include "commit-graph.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "progress.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "strbuf.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "trace2.h"
 
 #define BUILTIN_COMMIT_GRAPH_VERIFY_USAGE \
diff --git a/builtin/commit-tree.c b/builtin/commit-tree.c
index 30535db131..598ef30372 100644
--- a/builtin/commit-tree.c
+++ b/builtin/commit-tree.c
@@ -9,10 +9,10 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 
-#include "commit.h"
+#include "odb/commit.h"
 #include "parse-options.h"
 
 static const char * const commit_tree_usage[] = {
diff --git a/builtin/commit.c b/builtin/commit.c
index 28f6174503..e5a6c0b889 100644
--- a/builtin/commit.c
+++ b/builtin/commit.c
@@ -18,14 +18,14 @@
 #include "editor.h"
 #include "environment.h"
 #include "diff.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "add-interactive.h"
 #include "gettext.h"
 #include "revision.h"
 #include "wt-status.h"
 #include "run-command.h"
 #include "strbuf.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "path.h"
 #include "preload-index.h"
diff --git a/builtin/count-objects.c b/builtin/count-objects.c
index 18f6e33b6f..e256779b1f 100644
--- a/builtin/count-objects.c
+++ b/builtin/count-objects.c
@@ -13,7 +13,7 @@
 #include "parse-options.h"
 #include "quote.h"
 #include "packfile.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 
 static unsigned long garbage;
 static off_t size_garbage;
diff --git a/builtin/describe.c b/builtin/describe.c
index c0abc931a5..75961c5945 100644
--- a/builtin/describe.c
+++ b/builtin/describe.c
@@ -7,10 +7,10 @@
 #include "gettext.h"
 #include "hex.h"
 #include "lockfile.h"
-#include "commit.h"
-#include "tag.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
 #include "refs.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "read-cache-ll.h"
 #include "revision.h"
@@ -19,12 +19,12 @@
 #include "setup.h"
 #include "strvec.h"
 #include "run-command.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "list-objects.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "wildmatch.h"
 #include "prio-queue.h"
-#include "oidset.h"
+#include "odb/oidset.h"
 
 #define MAX_TAGS	(FLAG_BITS - 1)
 #define DEFAULT_CANDIDATES 10
diff --git a/builtin/diff-files.c b/builtin/diff-files.c
index ea91347ce2..c5b7548e55 100644
--- a/builtin/diff-files.c
+++ b/builtin/diff-files.c
@@ -11,7 +11,7 @@
 #include "config.h"
 #include "diff.h"
 #include "diff-merges.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "preload-index.h"
 #include "revision.h"
 
diff --git a/builtin/diff-index.c b/builtin/diff-index.c
index 3db7cffede..a23f444348 100644
--- a/builtin/diff-index.c
+++ b/builtin/diff-index.c
@@ -5,7 +5,7 @@
 #include "config.h"
 #include "diff.h"
 #include "diff-merges.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "preload-index.h"
 #include "revision.h"
 #include "setup.h"
diff --git a/builtin/diff-pairs.c b/builtin/diff-pairs.c
index 71c045331a..315fc7357a 100644
--- a/builtin/diff-pairs.c
+++ b/builtin/diff-pairs.c
@@ -3,9 +3,9 @@
 #include "diff.h"
 #include "diffcore.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
-#include "object.h"
+#include "odb/object.h"
 #include "parse-options.h"
 #include "revision.h"
 #include "strbuf.h"
diff --git a/builtin/diff-tree.c b/builtin/diff-tree.c
index 8b8f8b54e4..a3e1e5e020 100644
--- a/builtin/diff-tree.c
+++ b/builtin/diff-tree.c
@@ -3,14 +3,14 @@
 #include "builtin.h"
 #include "config.h"
 #include "diff.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "gettext.h"
 #include "hex.h"
 #include "log-tree.h"
 #include "read-cache-ll.h"
 #include "revision.h"
-#include "tmp-objdir.h"
-#include "tree.h"
+#include "odb/tmp-objdir.h"
+#include "odb/tree.h"
 
 static struct rev_info log_tree_opt;
 
diff --git a/builtin/diff.c b/builtin/diff.c
index 18b1083e98..c9ccc7e6c5 100644
--- a/builtin/diff.c
+++ b/builtin/diff.c
@@ -12,9 +12,9 @@
 #include "ewah/ewok.h"
 #include "lockfile.h"
 #include "color.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "gettext.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "diff.h"
 #include "diff-merges.h"
 #include "diffcore.h"
@@ -23,8 +23,8 @@
 #include "revision.h"
 #include "log-tree.h"
 #include "setup.h"
-#include "oid-array.h"
-#include "tree.h"
+#include "odb/oid-array.h"
+#include "odb/tree.h"
 
 #define DIFF_NO_INDEX_EXPLICIT 1
 #define DIFF_NO_INDEX_IMPLICIT 2
diff --git a/builtin/difftool.c b/builtin/difftool.c
index bc7b2ea443..075112d344 100644
--- a/builtin/difftool.c
+++ b/builtin/difftool.c
@@ -29,8 +29,8 @@
 #include "strvec.h"
 #include "strbuf.h"
 #include "lockfile.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "dir.h"
 #include "entry.h"
 #include "setup.h"
diff --git a/builtin/fast-export.c b/builtin/fast-export.c
index 50278bef7a..472877f0e5 100644
--- a/builtin/fast-export.c
+++ b/builtin/fast-export.c
@@ -14,11 +14,11 @@
 #include "hex.h"
 #include "refs.h"
 #include "refspec.h"
-#include "object-file.h"
-#include "odb.h"
-#include "commit.h"
-#include "object.h"
-#include "tag.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
+#include "odb/commit.h"
+#include "odb/object.h"
+#include "odb/tag.h"
 #include "diff.h"
 #include "diffcore.h"
 #include "log-tree.h"
@@ -29,7 +29,7 @@
 #include "parse-options.h"
 #include "quote.h"
 #include "remote.h"
-#include "blob.h"
+#include "odb/blob.h"
 #include "gpg-interface.h"
 
 static const char *const fast_export_usage[] = {
diff --git a/builtin/fast-import.c b/builtin/fast-import.c
index 4bed9edd7d..1d560d4e71 100644
--- a/builtin/fast-import.c
+++ b/builtin/fast-import.c
@@ -8,10 +8,10 @@
 #include "hex.h"
 #include "config.h"
 #include "lockfile.h"
-#include "object.h"
-#include "blob.h"
-#include "tree.h"
-#include "commit.h"
+#include "odb/object.h"
+#include "odb/blob.h"
+#include "odb/tree.h"
+#include "odb/commit.h"
 #include "delta.h"
 #include "pack.h"
 #include "path.h"
@@ -22,9 +22,9 @@
 #include "dir.h"
 #include "run-command.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "mem-pool.h"
 #include "commit-reach.h"
 #include "khash.h"
diff --git a/builtin/fetch-pack.c b/builtin/fetch-pack.c
index 316badd969..c6ae0197ab 100644
--- a/builtin/fetch-pack.c
+++ b/builtin/fetch-pack.c
@@ -4,12 +4,12 @@
 #include "builtin.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "pkt-line.h"
 #include "fetch-pack.h"
 #include "remote.h"
 #include "connect.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "protocol.h"
 
 static const char fetch_pack_usage[] =
diff --git a/builtin/fetch.c b/builtin/fetch.c
index ab7db2be06..2089e7823e 100644
--- a/builtin/fetch.c
+++ b/builtin/fetch.c
@@ -13,11 +13,11 @@
 #include "hex.h"
 #include "refs.h"
 #include "refspec.h"
-#include "object-name.h"
-#include "odb.h"
-#include "oidset.h"
-#include "oid-array.h"
-#include "commit.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/oidset.h"
+#include "odb/oid-array.h"
+#include "odb/commit.h"
 #include "string-list.h"
 #include "remote.h"
 #include "transport.h"
diff --git a/builtin/for-each-ref.c b/builtin/for-each-ref.c
index 4a2fc421db..d3399455ef 100644
--- a/builtin/for-each-ref.c
+++ b/builtin/for-each-ref.c
@@ -1,10 +1,10 @@
 #include "builtin.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "config.h"
 #include "environment.h"
 #include "for-each-ref.h"
 #include "gettext.h"
-#include "object.h"
+#include "odb/object.h"
 #include "parse-options.h"
 #include "ref-filter.h"
 #include "strbuf.h"
diff --git a/builtin/fsck.c b/builtin/fsck.c
index a6c054e45b..3176941c1d 100644
--- a/builtin/fsck.c
+++ b/builtin/fsck.c
@@ -2,24 +2,24 @@
 #include "gettext.h"
 #include "hex.h"
 #include "config.h"
-#include "commit.h"
-#include "tree.h"
-#include "blob.h"
-#include "tag.h"
+#include "odb/commit.h"
+#include "odb/tree.h"
+#include "odb/blob.h"
+#include "odb/tag.h"
 #include "refs.h"
 #include "pack.h"
 #include "cache-tree.h"
-#include "fsck.h"
+#include "odb/fsck.h"
 #include "parse-options.h"
 #include "progress.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 #include "path.h"
 #include "read-cache-ll.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "resolve-undo.h"
 #include "run-command.h"
 #include "sparse-index.h"
diff --git a/builtin/gc.c b/builtin/gc.c
index de2f9e7fed..f2fdc2c69d 100644
--- a/builtin/gc.c
+++ b/builtin/gc.c
@@ -26,11 +26,11 @@
 #include "run-command.h"
 #include "sigchain.h"
 #include "strvec.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "commit-graph.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "path.h"
 #include "reflog.h"
 #include "rerere.h"
diff --git a/builtin/get-tar-commit-id.c b/builtin/get-tar-commit-id.c
index e4cd1627b4..d78ecd8ab9 100644
--- a/builtin/get-tar-commit-id.c
+++ b/builtin/get-tar-commit-id.c
@@ -2,7 +2,7 @@
  * Copyright (c) 2005, 2006 Rene Scharfe
  */
 #include "builtin.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "tar.h"
 
 static const char builtin_get_tar_commit_id_usage[] =
diff --git a/builtin/grep.c b/builtin/grep.c
index d3d86abe01..d13858caec 100644
--- a/builtin/grep.c
+++ b/builtin/grep.c
@@ -13,8 +13,8 @@
 #include "gettext.h"
 #include "hex.h"
 #include "config.h"
-#include "tag.h"
-#include "tree-walk.h"
+#include "odb/tag.h"
+#include "odb/tree-walk.h"
 #include "parse-options.h"
 #include "string-list.h"
 #include "run-command.h"
@@ -25,11 +25,11 @@
 #include "setup.h"
 #include "submodule.h"
 #include "submodule-config.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "odb/source.h"
-#include "oid-array.h"
-#include "oidset.h"
+#include "odb/oid-array.h"
+#include "odb/oidset.h"
 #include "pager.h"
 #include "path.h"
 #include "promisor-remote.h"
diff --git a/builtin/hash-object.c b/builtin/hash-object.c
index f306b0643f..335575862c 100644
--- a/builtin/hash-object.c
+++ b/builtin/hash-object.c
@@ -11,9 +11,9 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-file.h"
-#include "odb.h"
-#include "blob.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
+#include "odb/blob.h"
 #include "quote.h"
 #include "parse-options.h"
 #include "setup.h"
diff --git a/builtin/history.c b/builtin/history.c
index 000155ad9c..a2aa224bd1 100644
--- a/builtin/history.c
+++ b/builtin/history.c
@@ -2,7 +2,7 @@
 
 #include "builtin.h"
 #include "cache-tree.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "commit-reach.h"
 #include "config.h"
 #include "editor.h"
@@ -11,7 +11,7 @@
 #include "hex.h"
 #include "lockfile.h"
 #include "merge-ort.h"
-#include "oidmap.h"
+#include "odb/oidmap.h"
 #include "parse-options.h"
 #include "path.h"
 #include "read-cache.h"
@@ -21,8 +21,8 @@
 #include "revision.h"
 #include "sequencer.h"
 #include "strvec.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "unpack-trees.h"
 #include "wt-status.h"
 
diff --git a/builtin/index-pack.c b/builtin/index-pack.c
index bc86925ad0..aa0e04eeee 100644
--- a/builtin/index-pack.c
+++ b/builtin/index-pack.c
@@ -9,24 +9,24 @@
 #include "hex.h"
 #include "pack.h"
 #include "csum-file.h"
-#include "blob.h"
-#include "commit.h"
-#include "tag.h"
-#include "tree.h"
+#include "odb/blob.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
+#include "odb/tree.h"
 #include "progress.h"
-#include "fsck.h"
+#include "odb/fsck.h"
 #include "strbuf.h"
 #include "thread-utils.h"
 #include "packfile.h"
 #include "pack-revindex.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
-#include "oid-array.h"
-#include "oidset.h"
+#include "odb/oid-array.h"
+#include "odb/oidset.h"
 #include "path.h"
-#include "replace-object.h"
-#include "tree-walk.h"
+#include "odb/replace-object.h"
+#include "odb/tree-walk.h"
 #include "promisor-remote.h"
 #include "run-command.h"
 #include "setup.h"
diff --git a/builtin/last-modified.c b/builtin/last-modified.c
index 5478182f2e..e8827b5dc6 100644
--- a/builtin/last-modified.c
+++ b/builtin/last-modified.c
@@ -2,8 +2,8 @@
 #include "bloom.h"
 #include "builtin.h"
 #include "commit-graph.h"
-#include "commit-slab.h"
-#include "commit.h"
+#include "odb/commit-slab.h"
+#include "odb/commit.h"
 #include "config.h"
 #include "diff.h"
 #include "diffcore.h"
@@ -11,8 +11,8 @@
 #include "ewah/ewok.h"
 #include "hashmap.h"
 #include "hex.h"
-#include "object-name.h"
-#include "object.h"
+#include "odb/object-name.h"
+#include "odb/object.h"
 #include "parse-options.h"
 #include "prio-queue.h"
 #include "quote.h"
diff --git a/builtin/log.c b/builtin/log.c
index 350b35c556..ab381e529e 100644
--- a/builtin/log.c
+++ b/builtin/log.c
@@ -14,20 +14,20 @@
 #include "gettext.h"
 #include "hex.h"
 #include "refs.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 #include "pager.h"
 #include "color.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "diffcore.h"
 #include "diff-merges.h"
 #include "revision.h"
 #include "log-tree.h"
-#include "oid-array.h"
-#include "oidset.h"
-#include "tag.h"
+#include "odb/oid-array.h"
+#include "odb/oidset.h"
+#include "odb/tag.h"
 #include "reflog-walk.h"
 #include "patch-ids.h"
 #include "path.h"
@@ -40,15 +40,15 @@
 #include "version.h"
 #include "mailmap.h"
 #include "progress.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "advice.h"
 #include "utf8.h"
 
 #include "commit-reach.h"
 #include "promisor-remote.h"
 #include "range-diff.h"
-#include "tmp-objdir.h"
-#include "tree.h"
+#include "odb/tmp-objdir.h"
+#include "odb/tree.h"
 #include "userdiff.h"
 #include "write-or-die.h"
 
diff --git a/builtin/ls-files.c b/builtin/ls-files.c
index b044520f9e..fc3f8f4a72 100644
--- a/builtin/ls-files.c
+++ b/builtin/ls-files.c
@@ -15,7 +15,7 @@
 #include "quote.h"
 #include "dir.h"
 #include "gettext.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "strbuf.h"
 #include "parse-options.h"
 #include "resolve-undo.h"
@@ -26,7 +26,7 @@
 #include "setup.h"
 #include "sparse-index.h"
 #include "submodule.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "hex.h"
 
 
diff --git a/builtin/ls-tree.c b/builtin/ls-tree.c
index 46edaffc2e..4f7d1d2b6d 100644
--- a/builtin/ls-tree.c
+++ b/builtin/ls-tree.c
@@ -10,9 +10,9 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
-#include "odb.h"
-#include "tree.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/tree.h"
 #include "path.h"
 #include "quote.h"
 #include "parse-options.h"
diff --git a/builtin/merge-base.c b/builtin/merge-base.c
index a87011c6cd..191e4e7fa0 100644
--- a/builtin/merge-base.c
+++ b/builtin/merge-base.c
@@ -1,11 +1,11 @@
 #define USE_THE_REPOSITORY_VARIABLE
 #include "builtin.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "commit-reach.h"
 
diff --git a/builtin/merge-file.c b/builtin/merge-file.c
index 8fa5765239..22a6862a13 100644
--- a/builtin/merge-file.c
+++ b/builtin/merge-file.c
@@ -5,9 +5,9 @@
 #include "abspath.h"
 #include "diff.h"
 #include "hex.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "config.h"
 #include "gettext.h"
 #include "setup.h"
diff --git a/builtin/merge-recursive.c b/builtin/merge-recursive.c
index 17aa4db37a..2e7bef9ee4 100644
--- a/builtin/merge-recursive.c
+++ b/builtin/merge-recursive.c
@@ -2,9 +2,9 @@
 #include "builtin.h"
 #include "advice.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "merge-ort-wrappers.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 
 static const char builtin_merge_recursive_usage[] =
 	"git %s <base>... -- <head> <remote> ...";
diff --git a/builtin/merge-tree.c b/builtin/merge-tree.c
index 49f41e520f..27f2944ece 100644
--- a/builtin/merge-tree.c
+++ b/builtin/merge-tree.c
@@ -2,21 +2,21 @@
 
 #include "builtin.h"
 #include "environment.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 #include "xdiff-interface.h"
 #include "help.h"
 #include "gettext.h"
 #include "hex.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "commit-reach.h"
 #include "merge-ort.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "parse-options.h"
-#include "blob.h"
+#include "odb/blob.h"
 #include "merge-blobs.h"
 #include "quote.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "config.h"
 #include "strvec.h"
 #include "write-or-die.h"
diff --git a/builtin/merge.c b/builtin/merge.c
index 5b4eb23a83..56f89b2944 100644
--- a/builtin/merge.c
+++ b/builtin/merge.c
@@ -18,7 +18,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "lockfile.h"
 #include "repository.h"
@@ -28,7 +28,7 @@
 #include "diff-merges.h"
 #include "refs.h"
 #include "refspec.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diffcore.h"
 #include "path.h"
 #include "revision.h"
@@ -45,7 +45,7 @@
 #include "fmt-merge-msg.h"
 #include "sequencer.h"
 #include "string-list.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "alias.h"
 #include "branch.h"
 #include "commit-reach.h"
diff --git a/builtin/mktag.c b/builtin/mktag.c
index 37c17e6beb..eb25acc4a5 100644
--- a/builtin/mktag.c
+++ b/builtin/mktag.c
@@ -4,10 +4,10 @@
 #include "hex.h"
 #include "parse-options.h"
 #include "strbuf.h"
-#include "replace-object.h"
-#include "object-file.h"
-#include "odb.h"
-#include "fsck.h"
+#include "odb/replace-object.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
+#include "odb/fsck.h"
 #include "config.h"
 
 static char const * const builtin_mktag_usage[] = {
diff --git a/builtin/mktree.c b/builtin/mktree.c
index 4084e32476..fc414d5b31 100644
--- a/builtin/mktree.c
+++ b/builtin/mktree.c
@@ -8,10 +8,10 @@
 #include "hex.h"
 #include "quote.h"
 #include "strbuf.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "parse-options.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 
 static struct treeent {
 	unsigned mode;
diff --git a/builtin/multi-pack-index.c b/builtin/multi-pack-index.c
index 6e73c85cde..10af1beb5c 100644
--- a/builtin/multi-pack-index.c
+++ b/builtin/multi-pack-index.c
@@ -8,10 +8,10 @@
 #include "midx.h"
 #include "strbuf.h"
 #include "trace2.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "odb/source.h"
 #include "odb/source-files.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "repository.h"
 
 #define BUILTIN_MIDX_WRITE_USAGE \
diff --git a/builtin/mv.c b/builtin/mv.c
index 373d4aeba3..e347c100c0 100644
--- a/builtin/mv.c
+++ b/builtin/mv.c
@@ -14,7 +14,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "name-hash.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "path.h"
 #include "pathspec.h"
 #include "lockfile.h"
diff --git a/builtin/name-rev.c b/builtin/name-rev.c
index 60cbbfb4b7..d2870bd37c 100644
--- a/builtin/name-rev.c
+++ b/builtin/name-rev.c
@@ -6,14 +6,14 @@
 #include "gettext.h"
 #include "hex.h"
 #include "config.h"
-#include "commit.h"
-#include "tag.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
 #include "refs.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "pager.h"
 #include "parse-options.h"
-#include "hash-lookup.h"
-#include "commit-slab.h"
+#include "odb/hash-lookup.h"
+#include "odb/commit-slab.h"
 #include "commit-graph.h"
 #include "wildmatch.h"
 #include "mem-pool.h"
diff --git a/builtin/notes.c b/builtin/notes.c
index 9f1f0ec840..2cf1437346 100644
--- a/builtin/notes.c
+++ b/builtin/notes.c
@@ -14,9 +14,9 @@
 #include "gettext.h"
 #include "hex.h"
 #include "notes.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "path.h"
 
 #include "pretty.h"
diff --git a/builtin/pack-objects.c b/builtin/pack-objects.c
index 1ec5b6f206..3e4c5442dc 100644
--- a/builtin/pack-objects.c
+++ b/builtin/pack-objects.c
@@ -7,14 +7,14 @@
 #include "hex.h"
 #include "config.h"
 #include "attr.h"
-#include "object.h"
-#include "commit.h"
-#include "tag.h"
+#include "odb/object.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
 #include "delta.h"
 #include "pack.h"
 #include "pack-revindex.h"
 #include "csum-file.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 #include "diff.h"
 #include "revision.h"
 #include "list-objects.h"
@@ -26,16 +26,16 @@
 #include "pack-bitmap.h"
 #include "delta-islands.h"
 #include "reachable.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "strvec.h"
 #include "strmap.h"
 #include "list.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "object-file-convert.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-file-convert.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "dir.h"
 #include "midx.h"
 #include "trace2.h"
@@ -44,8 +44,8 @@
 #include "pack-mtimes.h"
 #include "parse-options.h"
 #include "pkt-line.h"
-#include "blob.h"
-#include "tree.h"
+#include "odb/blob.h"
+#include "odb/tree.h"
 #include "path-walk.h"
 
 /*
diff --git a/builtin/pack-redundant.c b/builtin/pack-redundant.c
index 86749bb7e7..10e1ce6ab5 100644
--- a/builtin/pack-redundant.c
+++ b/builtin/pack-redundant.c
@@ -13,7 +13,7 @@
 #include "hex.h"
 
 #include "packfile.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "strbuf.h"
 
 #define BLKSIZE 512
diff --git a/builtin/patch-id.c b/builtin/patch-id.c
index 22f36ecf80..e2c1375b41 100644
--- a/builtin/patch-id.c
+++ b/builtin/patch-id.c
@@ -5,7 +5,7 @@
 #include "diff.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "parse-options.h"
 #include "setup.h"
diff --git a/builtin/prune.c b/builtin/prune.c
index 55635a891f..301f59e897 100644
--- a/builtin/prune.c
+++ b/builtin/prune.c
@@ -1,7 +1,7 @@
 #define DISABLE_SIGN_COMPARE_WARNINGS
 
 #include "builtin.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "dir.h"
 #include "environment.h"
@@ -13,10 +13,10 @@
 #include "path.h"
 #include "progress.h"
 #include "prune-packed.h"
-#include "replace-object.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/replace-object.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "shallow.h"
 
 static const char * const prune_usage[] = {
diff --git a/builtin/pull.c b/builtin/pull.c
index db3ee0aab3..cb3d76cb16 100644
--- a/builtin/pull.c
+++ b/builtin/pull.c
@@ -15,10 +15,10 @@
 #include "gettext.h"
 #include "hex.h"
 #include "merge.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "run-command.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "remote.h"
 #include "dir.h"
 #include "path.h"
diff --git a/builtin/range-diff.c b/builtin/range-diff.c
index e54c0f7fe1..7e37a00d9e 100644
--- a/builtin/range-diff.c
+++ b/builtin/range-diff.c
@@ -2,7 +2,7 @@
 
 #include "builtin.h"
 #include "gettext.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "range-diff.h"
 #include "config.h"
diff --git a/builtin/read-tree.c b/builtin/read-tree.c
index 999a82ecdf..8898354baa 100644
--- a/builtin/read-tree.c
+++ b/builtin/read-tree.c
@@ -10,10 +10,10 @@
 #include "gettext.h"
 #include "hex.h"
 #include "lockfile.h"
-#include "object.h"
-#include "object-name.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/object.h"
+#include "odb/object-name.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "cache-tree.h"
 #include "unpack-trees.h"
 #include "parse-options.h"
diff --git a/builtin/rebase.c b/builtin/rebase.c
index 10a306310c..7b8366e5cd 100644
--- a/builtin/rebase.c
+++ b/builtin/rebase.c
@@ -20,11 +20,11 @@
 #include "config.h"
 #include "unpack-trees.h"
 #include "lockfile.h"
-#include "object-file.h"
-#include "object-name.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "path.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "wt-status.h"
 #include "revision.h"
diff --git a/builtin/receive-pack.c b/builtin/receive-pack.c
index 86933d8d7e..5ec79a4595 100644
--- a/builtin/receive-pack.c
+++ b/builtin/receive-pack.c
@@ -3,25 +3,25 @@
 
 #include "builtin.h"
 #include "abspath.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "commit-reach.h"
 #include "config.h"
 #include "connect.h"
 #include "connected.h"
 #include "environment.h"
 #include "exec-cmd.h"
-#include "fsck.h"
+#include "odb/fsck.h"
 #include "gettext.h"
 #include "gpg-interface.h"
 #include "hex.h"
 #include "hook.h"
 #include "lockfile.h"
-#include "object.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
-#include "oid-array.h"
-#include "oidset.h"
+#include "odb/object.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/oid-array.h"
+#include "odb/oidset.h"
 #include "pack.h"
 #include "packfile.h"
 #include "parse-options.h"
diff --git a/builtin/reflog.c b/builtin/reflog.c
index 1211c58fa4..b709cb0e3c 100644
--- a/builtin/reflog.c
+++ b/builtin/reflog.c
@@ -4,7 +4,7 @@
 #include "config.h"
 #include "gettext.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "revision.h"
 #include "reachable.h"
 #include "wildmatch.h"
diff --git a/builtin/refs.c b/builtin/refs.c
index 5cd21c25fe..37936353be 100644
--- a/builtin/refs.c
+++ b/builtin/refs.c
@@ -1,6 +1,6 @@
 #include "builtin.h"
 #include "config.h"
-#include "fsck.h"
+#include "odb/fsck.h"
 #include "pack-refs.h"
 #include "parse-options.h"
 #include "refs.h"
diff --git a/builtin/remote.c b/builtin/remote.c
index de989ea3ba..b5b54ded27 100644
--- a/builtin/remote.c
+++ b/builtin/remote.c
@@ -16,7 +16,7 @@
 #include "rebase.h"
 #include "refs.h"
 #include "refspec.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "strvec.h"
 #include "commit-reach.h"
 #include "progress.h"
diff --git a/builtin/replace.c b/builtin/replace.c
index aed6b2c8de..793226006c 100644
--- a/builtin/replace.c
+++ b/builtin/replace.c
@@ -18,11 +18,11 @@
 #include "parse-options.h"
 #include "path.h"
 #include "run-command.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
-#include "replace-object.h"
-#include "tag.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/replace-object.h"
+#include "odb/tag.h"
 #include "wildmatch.h"
 
 static const char * const git_replace_usage[] = {
diff --git a/builtin/replay.c b/builtin/replay.c
index 39e3a86f6c..4ea7c42215 100644
--- a/builtin/replay.c
+++ b/builtin/replay.c
@@ -7,7 +7,7 @@
 #include "builtin.h"
 #include "config.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "refs.h"
 #include "replay.h"
diff --git a/builtin/repo.c b/builtin/repo.c
index 84e012f83f..473072b44d 100644
--- a/builtin/repo.c
+++ b/builtin/repo.c
@@ -1,11 +1,11 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "builtin.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "environment.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "parse-options.h"
 #include "path.h"
 #include "path-walk.h"
@@ -18,8 +18,8 @@
 #include "strbuf.h"
 #include "string-list.h"
 #include "shallow.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "utf8.h"
 
 #define REPO_INFO_USAGE \
diff --git a/builtin/reset.c b/builtin/reset.c
index 78e69bd84b..55539f565c 100644
--- a/builtin/reset.c
+++ b/builtin/reset.c
@@ -15,17 +15,17 @@
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "lockfile.h"
-#include "object.h"
+#include "odb/object.h"
 #include "pretty.h"
 #include "refs.h"
 #include "diff.h"
 #include "diffcore.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "branch.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "path.h"
 #include "repository.h"
diff --git a/builtin/rev-list.c b/builtin/rev-list.c
index 02818b81c6..0c55dc5b96 100644
--- a/builtin/rev-list.c
+++ b/builtin/rev-list.c
@@ -3,7 +3,7 @@
 
 #include "builtin.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "environment.h"
 #include "gettext.h"
@@ -11,10 +11,10 @@
 #include "revision.h"
 #include "list-objects.h"
 #include "list-objects-filter-options.h"
-#include "object.h"
-#include "object-name.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object.h"
+#include "odb/object-name.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "pack-bitmap.h"
 #include "parse-options.h"
 #include "log-tree.h"
@@ -22,8 +22,8 @@
 #include "bisect.h"
 #include "progress.h"
 #include "reflog-walk.h"
-#include "oidset.h"
-#include "oidmap.h"
+#include "odb/oidset.h"
+#include "odb/oidmap.h"
 #include "packfile.h"
 #include "commit-reach.h"
 #include "quote.h"
diff --git a/builtin/rev-parse.c b/builtin/rev-parse.c
index 43693454d5..f3bf7831b7 100644
--- a/builtin/rev-parse.c
+++ b/builtin/rev-parse.c
@@ -12,14 +12,14 @@
 #include "abspath.h"
 #include "bisect.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "refs.h"
 #include "quote.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "path.h"
 #include "diff.h"
@@ -32,7 +32,7 @@
 #include "submodule.h"
 #include "commit-reach.h"
 #include "shallow.h"
-#include "object-file-convert.h"
+#include "odb/object-file-convert.h"
 
 #define DO_REVS		1
 #define DO_NOREV	2
diff --git a/builtin/rm.c b/builtin/rm.c
index 081d0bc375..c856b88d09 100644
--- a/builtin/rm.c
+++ b/builtin/rm.c
@@ -13,9 +13,9 @@
 #include "lockfile.h"
 #include "dir.h"
 #include "gettext.h"
-#include "hash.h"
-#include "tree-walk.h"
-#include "object-name.h"
+#include "odb/hash.h"
+#include "odb/tree-walk.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "read-cache.h"
 
diff --git a/builtin/send-pack.c b/builtin/send-pack.c
index d6cdbae472..2597a47bde 100644
--- a/builtin/send-pack.c
+++ b/builtin/send-pack.c
@@ -9,7 +9,7 @@
 #include "send-pack.h"
 #include "quote.h"
 #include "transport.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "gettext.h"
 #include "protocol.h"
 #include "parse-options.h"
diff --git a/builtin/shortlog.c b/builtin/shortlog.c
index 4c78d2e5ba..cbcf2fb637 100644
--- a/builtin/shortlog.c
+++ b/builtin/shortlog.c
@@ -2,7 +2,7 @@
 
 #include "builtin.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "environment.h"
 #include "gettext.h"
diff --git a/builtin/show-branch.c b/builtin/show-branch.c
index 2435e8aeda..c58abc872f 100644
--- a/builtin/show-branch.c
+++ b/builtin/show-branch.c
@@ -5,17 +5,17 @@
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "pretty.h"
 #include "refs.h"
 #include "color.h"
 #include "strvec.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 
 #include "dir.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "date.h"
 #include "wildmatch.h"
 #include "prio-queue.h"
diff --git a/builtin/show-index.c b/builtin/show-index.c
index 24f0230967..55c3c409ae 100644
--- a/builtin/show-index.c
+++ b/builtin/show-index.c
@@ -3,7 +3,7 @@
 
 #include "builtin.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "pack.h"
 #include "parse-options.h"
diff --git a/builtin/show-ref.c b/builtin/show-ref.c
index d508441632..e4b186b930 100644
--- a/builtin/show-ref.c
+++ b/builtin/show-ref.c
@@ -5,9 +5,9 @@
 #include "gettext.h"
 #include "hex.h"
 #include "refs/refs-internal.h"
-#include "object-name.h"
-#include "odb.h"
-#include "object.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/object.h"
 #include "string-list.h"
 #include "parse-options.h"
 
diff --git a/builtin/sparse-checkout.c b/builtin/sparse-checkout.c
index cb4a037b77..e2186fdd33 100644
--- a/builtin/sparse-checkout.c
+++ b/builtin/sparse-checkout.c
@@ -7,8 +7,8 @@
 #include "dir.h"
 #include "environment.h"
 #include "gettext.h"
-#include "object-file.h"
-#include "object-name.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "path.h"
 #include "pathspec.h"
diff --git a/builtin/stash.c b/builtin/stash.c
index 72c52571f8..2af975aaff 100644
--- a/builtin/stash.c
+++ b/builtin/stash.c
@@ -5,9 +5,9 @@
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "refs.h"
 #include "lockfile.h"
@@ -30,8 +30,8 @@
 #include "reflog.h"
 #include "reflog-walk.h"
 #include "add-interactive.h"
-#include "oid-array.h"
-#include "commit.h"
+#include "odb/oid-array.h"
+#include "odb/commit.h"
 
 #define INCLUDE_ALL_FILES 2
 
diff --git a/builtin/submodule--helper.c b/builtin/submodule--helper.c
index e7cd3225fa..96c83476df 100644
--- a/builtin/submodule--helper.c
+++ b/builtin/submodule--helper.c
@@ -26,9 +26,9 @@
 #include "revision.h"
 #include "diffcore.h"
 #include "diff.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "odb/source.h"
 #include "advice.h"
 #include "branch.h"
diff --git a/builtin/tag.c b/builtin/tag.c
index 06c125b53c..e3eee35e88 100644
--- a/builtin/tag.c
+++ b/builtin/tag.c
@@ -17,21 +17,21 @@
 #include "gettext.h"
 #include "hex.h"
 #include "refs.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "path.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "parse-options.h"
 #include "diff.h"
 #include "revision.h"
 #include "gpg-interface.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "column.h"
 #include "ref-filter.h"
 #include "date.h"
 #include "write-or-die.h"
-#include "object-file-convert.h"
+#include "odb/object-file-convert.h"
 #include "trailer.h"
 
 static const char * const git_tag_usage[] = {
diff --git a/builtin/unpack-file.c b/builtin/unpack-file.c
index 387389ed49..47f43f5a87 100644
--- a/builtin/unpack-file.c
+++ b/builtin/unpack-file.c
@@ -3,9 +3,9 @@
 #include "config.h"
 #include "environment.h"
 #include "hex.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 
 static char *create_temp_file(struct object_id *oid)
 {
diff --git a/builtin/unpack-objects.c b/builtin/unpack-objects.c
index 4263edfbec..e5891809dd 100644
--- a/builtin/unpack-objects.c
+++ b/builtin/unpack-objects.c
@@ -7,19 +7,19 @@
 #include "gettext.h"
 #include "git-zlib.h"
 #include "hex.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 #include "odb/transaction.h"
-#include "object.h"
+#include "odb/object.h"
 #include "delta.h"
 #include "pack.h"
-#include "blob.h"
-#include "replace-object.h"
+#include "odb/blob.h"
+#include "odb/replace-object.h"
 #include "strbuf.h"
 #include "progress.h"
 #include "decorate.h"
-#include "fsck.h"
+#include "odb/fsck.h"
 #include "packfile.h"
 
 static int dry_run, quiet, recover, has_errors, strict;
diff --git a/builtin/update-index.c b/builtin/update-index.c
index 241abd4332..992f496efd 100644
--- a/builtin/update-index.c
+++ b/builtin/update-index.c
@@ -11,14 +11,14 @@
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "lockfile.h"
 #include "quote.h"
 #include "cache-tree.h"
-#include "tree-walk.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/tree-walk.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/transaction.h"
 #include "refs.h"
 #include "resolve-undo.h"
diff --git a/builtin/update-ref.c b/builtin/update-ref.c
index 6355c3dd3e..e7ac68f495 100644
--- a/builtin/update-ref.c
+++ b/builtin/update-ref.c
@@ -5,10 +5,10 @@
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "refs.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "quote.h"
 
diff --git a/builtin/upload-pack.c b/builtin/upload-pack.c
index 32831fb879..dc37ffb70c 100644
--- a/builtin/upload-pack.c
+++ b/builtin/upload-pack.c
@@ -6,11 +6,11 @@
 #include "pkt-line.h"
 #include "parse-options.h"
 #include "protocol.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "upload-pack.h"
 #include "serve.h"
 #include "setup.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "environment.h"
 
 static const char * const upload_pack_usage[] = {
diff --git a/builtin/verify-commit.c b/builtin/verify-commit.c
index 62398acd72..3ec03f016c 100644
--- a/builtin/verify-commit.c
+++ b/builtin/verify-commit.c
@@ -9,8 +9,8 @@
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
-#include "object-name.h"
-#include "commit.h"
+#include "odb/object-name.h"
+#include "odb/commit.h"
 #include "parse-options.h"
 #include "gpg-interface.h"
 
diff --git a/builtin/verify-tag.c b/builtin/verify-tag.c
index 4a261b2369..791679a4d8 100644
--- a/builtin/verify-tag.c
+++ b/builtin/verify-tag.c
@@ -9,8 +9,8 @@
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
-#include "tag.h"
-#include "object-name.h"
+#include "odb/tag.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "gpg-interface.h"
 #include "ref-filter.h"
diff --git a/builtin/worktree.c b/builtin/worktree.c
index 654d27c3e1..7c2ed274f9 100644
--- a/builtin/worktree.c
+++ b/builtin/worktree.c
@@ -11,8 +11,8 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-file.h"
-#include "object-name.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
 #include "parse-options.h"
 #include "path.h"
 #include "strvec.h"
diff --git a/builtin/write-tree.c b/builtin/write-tree.c
index e3bd1a40db..2e463ab394 100644
--- a/builtin/write-tree.c
+++ b/builtin/write-tree.c
@@ -9,7 +9,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "cache-tree.h"
 #include "parse-options.h"
 
diff --git a/bundle-uri.c b/bundle-uri.c
index 2bb2eb99e4..948265330b 100644
--- a/bundle-uri.c
+++ b/bundle-uri.c
@@ -14,7 +14,7 @@
 #include "fetch-pack.h"
 #include "remote.h"
 #include "trace2.h"
-#include "odb.h"
+#include "odb/odb.h"
 
 static struct {
 	enum bundle_list_heuristic heuristic;
diff --git a/bundle.c b/bundle.c
index b64716f252..81d241e6d0 100644
--- a/bundle.c
+++ b/bundle.c
@@ -7,10 +7,10 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "repository.h"
-#include "object.h"
-#include "commit.h"
+#include "odb/object.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "revision.h"
 #include "list-objects.h"
diff --git a/cache-tree.c b/cache-tree.c
index d92f513286..1c4295761a 100644
--- a/cache-tree.c
+++ b/cache-tree.c
@@ -5,14 +5,14 @@
 #include "gettext.h"
 #include "hex.h"
 #include "lockfile.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "cache-tree.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/transaction.h"
 #include "read-cache-ll.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "repository.h"
 #include "promisor-remote.h"
 #include "trace.h"
diff --git a/cache-tree.h b/cache-tree.h
index f8bddae523..fbfa3691e1 100644
--- a/cache-tree.h
+++ b/cache-tree.h
@@ -1,8 +1,8 @@
 #ifndef CACHE_TREE_H
 #define CACHE_TREE_H
 
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 
 struct cache_tree;
 struct cache_tree_sub {
diff --git a/checkout.c b/checkout.c
index 1588b116ee..966a70c267 100644
--- a/checkout.c
+++ b/checkout.c
@@ -1,7 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "remote.h"
 #include "refspec.h"
 #include "repository.h"
diff --git a/checkout.h b/checkout.h
index 55920e7aeb..718e29080a 100644
--- a/checkout.h
+++ b/checkout.h
@@ -1,7 +1,7 @@
 #ifndef CHECKOUT_H
 #define CHECKOUT_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 /*
  * Check if the branch name uniquely matches a branch name on a remote
diff --git a/chunk-format.c b/chunk-format.c
index 51b5a2c959..08b90762d4 100644
--- a/chunk-format.c
+++ b/chunk-format.c
@@ -5,7 +5,7 @@
 #include "chunk-format.h"
 #include "csum-file.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "trace2.h"
 
 /*
diff --git a/chunk-format.h b/chunk-format.h
index 212a0a6af1..e10fcdbfcb 100644
--- a/chunk-format.h
+++ b/chunk-format.h
@@ -1,7 +1,7 @@
 #ifndef CHUNK_FORMAT_H
 #define CHUNK_FORMAT_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 struct hashfile;
 struct chunkfile;
diff --git a/combine-diff.c b/combine-diff.c
index 717d537688..1c33937f21 100644
--- a/combine-diff.c
+++ b/combine-diff.c
@@ -2,22 +2,22 @@
 #define DISABLE_SIGN_COMPARE_WARNINGS
 
 #include "git-compat-util.h"
-#include "odb.h"
-#include "commit.h"
+#include "odb/odb.h"
+#include "odb/commit.h"
 #include "convert.h"
 #include "diff.h"
 #include "diffcore.h"
 #include "environment.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "quote.h"
 #include "xdiff-interface.h"
 #include "xdiff/xmacros.h"
 #include "log-tree.h"
 #include "refs.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "userdiff.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "revision.h"
 
 static int compare_paths(const struct combine_diff_path *one,
diff --git a/commit-graph.c b/commit-graph.c
index 49e8f63930..abf7c404b3 100644
--- a/commit-graph.c
+++ b/commit-graph.c
@@ -8,24 +8,24 @@
 #include "hex.h"
 #include "lockfile.h"
 #include "packfile.h"
-#include "commit.h"
-#include "object.h"
+#include "odb/commit.h"
+#include "odb/object.h"
 #include "refs.h"
-#include "hash-lookup.h"
+#include "odb/hash-lookup.h"
 #include "commit-graph.h"
-#include "odb.h"
-#include "oid-array.h"
+#include "odb/odb.h"
+#include "odb/oid-array.h"
 #include "path.h"
-#include "alloc.h"
+#include "odb/alloc.h"
 #include "hashmap.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "progress.h"
 #include "bloom.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "shallow.h"
 #include "json-writer.h"
 #include "trace2.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "chunk-format.h"
 
 void git_test_write_commit_graph_or_die(struct odb_source *source)
diff --git a/commit-graph.h b/commit-graph.h
index 13ca4ff010..69ecf99feb 100644
--- a/commit-graph.h
+++ b/commit-graph.h
@@ -1,8 +1,8 @@
 #ifndef COMMIT_GRAPH_H
 #define COMMIT_GRAPH_H
 
-#include "odb.h"
-#include "oidset.h"
+#include "odb/odb.h"
+#include "odb/oidset.h"
 
 #define GIT_TEST_COMMIT_GRAPH "GIT_TEST_COMMIT_GRAPH"
 #define GIT_TEST_COMMIT_GRAPH_DIE_ON_PARSE "GIT_TEST_COMMIT_GRAPH_DIE_ON_PARSE"
diff --git a/commit-reach.c b/commit-reach.c
index b53c6b1cdf..9b4715fd65 100644
--- a/commit-reach.c
+++ b/commit-reach.c
@@ -1,14 +1,14 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "commit-graph.h"
 #include "decorate.h"
 #include "hex.h"
 #include "prio-queue.h"
 #include "ref-filter.h"
 #include "revision.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "commit-reach.h"
 #include "ewah/ewok.h"
 
diff --git a/commit-reach.h b/commit-reach.h
index f908d305b1..5d27ef9889 100644
--- a/commit-reach.h
+++ b/commit-reach.h
@@ -1,8 +1,8 @@
 #ifndef COMMIT_REACH_H
 #define COMMIT_REACH_H
 
-#include "commit.h"
-#include "commit-slab.h"
+#include "odb/commit.h"
+#include "odb/commit-slab.h"
 
 struct commit_list;
 struct ref_filter;
diff --git a/common-init.c b/common-init.c
index d26c9c1f20..7e6b392800 100644
--- a/common-init.c
+++ b/common-init.c
@@ -5,10 +5,10 @@
 #include "exec-cmd.h"
 #include "gettext.h"
 #include "attr.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "parse.h"
 #include "repository.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "setup.h"
 #include "strbuf.h"
 #include "trace2.h"
diff --git a/compat/mingw.c b/compat/mingw.c
index 4c2f26d454..785de5beb7 100644
--- a/compat/mingw.c
+++ b/compat/mingw.c
@@ -3,7 +3,7 @@
 
 #include "git-compat-util.h"
 #include "abspath.h"
-#include "alloc.h"
+#include "odb/alloc.h"
 #include "config.h"
 #include "dir.h"
 #include "environment.h"
diff --git a/compat/sha1-chunked.c b/compat/sha1-chunked.c
index 0446f9983f..30a0d96e92 100644
--- a/compat/sha1-chunked.c
+++ b/compat/sha1-chunked.c
@@ -1,5 +1,5 @@
 #include "git-compat-util.h"
-#include "hash.h"
+#include "odb/hash.h"
 
 int git_SHA1_Update_Chunked(platform_SHA_CTX *c, const void *data, size_t len)
 {
diff --git a/config.c b/config.c
index 1bdd702e7a..eacc6847a2 100644
--- a/config.c
+++ b/config.c
@@ -25,8 +25,8 @@
 #include "quote.h"
 #include "hashmap.h"
 #include "string-list.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "path.h"
 #include "utf8.h"
 #include "color.h"
diff --git a/connect.c b/connect.c
index feb0420b0f..e54c88f5e2 100644
--- a/connect.c
+++ b/connect.c
@@ -13,7 +13,7 @@
 #include "connect.h"
 #include "url.h"
 #include "string-list.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "path.h"
 #include "transport.h"
 #include "trace2.h"
diff --git a/connected.c b/connected.c
index 929b9bd28d..1aafa86101 100644
--- a/connected.c
+++ b/connected.c
@@ -3,7 +3,7 @@
 #include "git-compat-util.h"
 #include "gettext.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "run-command.h"
 #include "sigchain.h"
 #include "connected.h"
diff --git a/convert.c b/convert.c
index 036506842c..25c800eea2 100644
--- a/convert.c
+++ b/convert.c
@@ -8,7 +8,7 @@
 #include "copy.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "attr.h"
 #include "run-command.h"
 #include "quote.h"
diff --git a/convert.h b/convert.h
index 0a6e4086b8..dc6a49dc7d 100644
--- a/convert.h
+++ b/convert.h
@@ -4,7 +4,7 @@
 #ifndef CONVERT_H
 #define CONVERT_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "string-list.h"
 
 struct index_state;
diff --git a/csum-file.c b/csum-file.c
index fe18ee1de3..483608d1ec 100644
--- a/csum-file.c
+++ b/csum-file.c
@@ -11,7 +11,7 @@
 #include "git-compat-util.h"
 #include "csum-file.h"
 #include "git-zlib.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "progress.h"
 
 static void verify_buffer_or_die(struct hashfile *f,
diff --git a/csum-file.h b/csum-file.h
index 6ed74d1637..dd7aeb2813 100644
--- a/csum-file.h
+++ b/csum-file.h
@@ -1,7 +1,7 @@
 #ifndef CSUM_FILE_H
 #define CSUM_FILE_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "write-or-die.h"
 
 struct progress;
diff --git a/decorate.c b/decorate.c
index 9f24925263..262c9198eb 100644
--- a/decorate.c
+++ b/decorate.c
@@ -4,7 +4,7 @@
  */
 
 #include "git-compat-util.h"
-#include "object.h"
+#include "odb/object.h"
 #include "decorate.h"
 
 static unsigned int hash_obj(const struct object *obj, unsigned int n)
diff --git a/delta-islands.c b/delta-islands.c
index e71a7e1c05..0c0d222ab3 100644
--- a/delta-islands.c
+++ b/delta-islands.c
@@ -1,14 +1,14 @@
 #define DISABLE_SIGN_COMPARE_WARNINGS
 
 #include "git-compat-util.h"
-#include "object.h"
-#include "commit.h"
+#include "odb/object.h"
+#include "odb/commit.h"
 #include "gettext.h"
 #include "hex.h"
-#include "tag.h"
-#include "tree.h"
+#include "odb/tag.h"
+#include "odb/tree.h"
 #include "pack.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 #include "diff.h"
 #include "progress.h"
 #include "refs.h"
@@ -16,7 +16,7 @@
 #include "pack-bitmap.h"
 #include "pack-objects.h"
 #include "delta-islands.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "config.h"
 
 KHASH_INIT(str, const char *, void *, 1, kh_str_hash_func, kh_str_hash_equal)
diff --git a/diagnose.c b/diagnose.c
index 5092bf80d3..6858f39f45 100644
--- a/diagnose.c
+++ b/diagnose.c
@@ -7,7 +7,7 @@
 #include "gettext.h"
 #include "hex.h"
 #include "strvec.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "packfile.h"
 #include "parse-options.h"
 #include "repository.h"
diff --git a/diff-lib.c b/diff-lib.c
index 086476bd77..313b6136b1 100644
--- a/diff-lib.c
+++ b/diff-lib.c
@@ -6,13 +6,13 @@
 #define DISABLE_SIGN_COMPARE_WARNINGS
 
 #include "git-compat-util.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "diffcore.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "read-cache.h"
 #include "revision.h"
 #include "cache-tree.h"
diff --git a/diff-no-index.c b/diff-no-index.c
index f320424f05..552cd95679 100644
--- a/diff-no-index.c
+++ b/diff-no-index.c
@@ -9,7 +9,7 @@
 #include "git-compat-util.h"
 #include "abspath.h"
 #include "color.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "diffcore.h"
 #include "gettext.h"
diff --git a/diff.c b/diff.c
index cfe515af4e..22265895a7 100644
--- a/diff.c
+++ b/diff.c
@@ -23,7 +23,7 @@
 #include "color.h"
 #include "run-command.h"
 #include "utf8.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "userdiff.h"
 #include "submodule.h"
 #include "hashmap.h"
@@ -31,17 +31,17 @@
 #include "merge-ll.h"
 #include "string-list.h"
 #include "strvec.h"
-#include "tmp-objdir.h"
+#include "odb/tmp-objdir.h"
 #include "graph.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "packfile.h"
 #include "pager.h"
 #include "parse-options.h"
 #include "help.h"
 #include "promisor-remote.h"
 #include "dir.h"
-#include "object-file.h"
-#include "object-name.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
 #include "read-cache-ll.h"
 #include "setup.h"
 #include "strmap.h"
diff --git a/diff.h b/diff.h
index bb5cddaf34..502bf24432 100644
--- a/diff.h
+++ b/diff.h
@@ -4,7 +4,7 @@
 #ifndef DIFF_H
 #define DIFF_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "pathspec.h"
 #include "strbuf.h"
 #include "color.h"
diff --git a/diffcore-break.c b/diffcore-break.c
index b5bcc956cc..70860c8abc 100644
--- a/diffcore-break.c
+++ b/diffcore-break.c
@@ -6,8 +6,8 @@
 
 #include "git-compat-util.h"
 #include "diffcore.h"
-#include "hash.h"
-#include "object.h"
+#include "odb/hash.h"
+#include "odb/object.h"
 #include "promisor-remote.h"
 
 static int should_break(struct repository *r,
diff --git a/diffcore-pickaxe.c b/diffcore-pickaxe.c
index b0915be86f..f7a745fb49 100644
--- a/diffcore-pickaxe.c
+++ b/diffcore-pickaxe.c
@@ -10,7 +10,7 @@
 #include "diffcore.h"
 #include "xdiff-interface.h"
 #include "kwset.h"
-#include "oidset.h"
+#include "odb/oidset.h"
 #include "pretty.h"
 #include "quote.h"
 
diff --git a/diffcore-rename.c b/diffcore-rename.c
index c797d8ed2f..68abf77c4d 100644
--- a/diffcore-rename.c
+++ b/diffcore-rename.c
@@ -8,10 +8,10 @@
 #include "git-compat-util.h"
 #include "diff.h"
 #include "diffcore.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "hashmap.h"
 #include "mem-pool.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "progress.h"
 #include "promisor-remote.h"
 #include "string-list.h"
diff --git a/diffcore.h b/diffcore.h
index d75038d1b3..fa6125d0bf 100644
--- a/diffcore.h
+++ b/diffcore.h
@@ -4,7 +4,7 @@
 #ifndef DIFFCORE_H
 #define DIFFCORE_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 struct diff_options;
 struct mem_pool;
diff --git a/dir.c b/dir.c
index 95d8a1cce9..c9005a0ac1 100644
--- a/dir.c
+++ b/dir.c
@@ -17,7 +17,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "name-hash.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "path.h"
 #include "refs.h"
 #include "repository.h"
@@ -34,7 +34,7 @@
 #include "submodule-config.h"
 #include "symlinks.h"
 #include "trace2.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "hex.h"
 
  /*
diff --git a/dir.h b/dir.h
index 83e0f648a8..239c7efb1e 100644
--- a/dir.h
+++ b/dir.h
@@ -1,7 +1,7 @@
 #ifndef DIR_H
 #define DIR_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "hashmap.h"
 #include "pathspec.h"
 #include "statinfo.h"
diff --git a/entry.c b/entry.c
index 1c4f0f4407..823a433539 100644
--- a/entry.c
+++ b/entry.c
@@ -1,7 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 #include "dir.h"
 #include "environment.h"
diff --git a/environment.c b/environment.c
index 76ee65e62b..40b993ec90 100644
--- a/environment.c
+++ b/environment.c
@@ -23,12 +23,12 @@
 #include "ident.h"
 #include "lockfile.h"
 #include "mailmap.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "repository.h"
 #include "config.h"
 #include "refs.h"
 #include "fmt-merge-msg.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "strvec.h"
 #include "pager.h"
 #include "path.h"
diff --git a/fetch-object-info.c b/fetch-object-info.c
index ba7e179c44..30cf131aed 100644
--- a/fetch-object-info.c
+++ b/fetch-object-info.c
@@ -3,8 +3,8 @@
 #include "hex.h"
 #include "pkt-line.h"
 #include "connect.h"
-#include "oid-array.h"
-#include "odb.h"
+#include "odb/oid-array.h"
+#include "odb/odb.h"
 #include "fetch-object-info.h"
 #include "string-list.h"
 
diff --git a/fetch-pack.c b/fetch-pack.c
index 626f799712..b172114879 100644
--- a/fetch-pack.c
+++ b/fetch-pack.c
@@ -11,8 +11,8 @@
 #include "lockfile.h"
 #include "refs.h"
 #include "pkt-line.h"
-#include "commit.h"
-#include "tag.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
 #include "pack.h"
 #include "sideband.h"
 #include "fetch-pack.h"
@@ -21,15 +21,15 @@
 #include "connect.h"
 #include "trace2.h"
 #include "version.h"
-#include "oid-array.h"
-#include "oidset.h"
+#include "odb/oid-array.h"
+#include "odb/oidset.h"
 #include "packfile.h"
-#include "odb.h"
-#include "object-name.h"
+#include "odb/odb.h"
+#include "odb/object-name.h"
 #include "path.h"
 #include "connected.h"
 #include "fetch-negotiator.h"
-#include "fsck.h"
+#include "odb/fsck.h"
 #include "shallow.h"
 #include "commit-reach.h"
 #include "commit-graph.h"
diff --git a/fetch-pack.h b/fetch-pack.h
index 6d0dec7f41..14e4ba1079 100644
--- a/fetch-pack.h
+++ b/fetch-pack.h
@@ -4,7 +4,7 @@
 #include "string-list.h"
 #include "protocol.h"
 #include "list-objects-filter-options.h"
-#include "oidset.h"
+#include "odb/oidset.h"
 
 struct oid_array;
 
diff --git a/fmt-merge-msg.c b/fmt-merge-msg.c
index 14441f23ae..6e11ad0fa9 100644
--- a/fmt-merge-msg.c
+++ b/fmt-merge-msg.c
@@ -5,13 +5,13 @@
 #include "config.h"
 #include "environment.h"
 #include "refs.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "diff.h"
 #include "diff-merges.h"
 #include "hex.h"
 #include "revision.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "string-list.h"
 #include "branch.h"
 #include "fmt-merge-msg.h"
diff --git a/fsmonitor.h b/fsmonitor.h
index 5195a8624d..59591ee49e 100644
--- a/fsmonitor.h
+++ b/fsmonitor.h
@@ -4,7 +4,7 @@
 #include "fsmonitor-ll.h"
 #include "dir.h"
 #include "fsmonitor-settings.h"
-#include "object.h"
+#include "odb/object.h"
 #include "read-cache-ll.h"
 #include "trace.h"
 
diff --git a/git.c b/git.c
index cd2d325585..619219afef 100644
--- a/git.c
+++ b/git.c
@@ -6,12 +6,12 @@
 #include "exec-cmd.h"
 #include "gettext.h"
 #include "help.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "pager.h"
 #include "read-cache-ll.h"
 #include "run-command.h"
 #include "alias.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "setup.h"
 #include "attr.h"
 #include "shallow.h"
diff --git a/gpg-interface.c b/gpg-interface.c
index 95abf1ef4e..034bed7aaa 100644
--- a/gpg-interface.c
+++ b/gpg-interface.c
@@ -1,7 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "config.h"
 #include "date.h"
 #include "gettext.h"
diff --git a/graph.c b/graph.c
index 28bef1b88f..66c2be423e 100644
--- a/graph.c
+++ b/graph.c
@@ -3,7 +3,7 @@
 #include "git-compat-util.h"
 #include "gettext.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "color.h"
 #include "graph.h"
 #include "revision.h"
diff --git a/grep.c b/grep.c
index 1d75d31421..5041c388b9 100644
--- a/grep.c
+++ b/grep.c
@@ -5,7 +5,7 @@
 #include "gettext.h"
 #include "grep.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "pretty.h"
 #include "userdiff.h"
 #include "xdiff-interface.h"
diff --git a/help.c b/help.c
index 46241492ce..ccc42f09e0 100644
--- a/help.c
+++ b/help.c
@@ -9,7 +9,7 @@
 #include "run-command.h"
 #include "levenshtein.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "help.h"
 #include "command-list.h"
 #include "string-list.h"
diff --git a/hex.c b/hex.c
index f02832140d..6aabaf45e7 100644
--- a/hex.c
+++ b/hex.c
@@ -1,7 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "strbuf.h"
 
diff --git a/hex.h b/hex.h
index f15c7e2220..e6dd268faf 100644
--- a/hex.h
+++ b/hex.h
@@ -1,7 +1,7 @@
 #ifndef HEX_H
 #define HEX_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex-ll.h"
 
 /*
diff --git a/http-backend.c b/http-backend.c
index c7566b1d12..9b7ae96579 100644
--- a/http-backend.c
+++ b/http-backend.c
@@ -10,8 +10,8 @@
 #include "repository.h"
 #include "refs.h"
 #include "pkt-line.h"
-#include "object.h"
-#include "tag.h"
+#include "odb/object.h"
+#include "odb/tag.h"
 #include "exec-cmd.h"
 #include "run-command.h"
 #include "string-list.h"
@@ -19,7 +19,7 @@
 #include "setup.h"
 #include "strvec.h"
 #include "packfile.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "protocol.h"
 #include "date.h"
 #include "write-or-die.h"
diff --git a/http-push.c b/http-push.c
index 786a2e9c0d..858aa9db33 100644
--- a/http-push.c
+++ b/http-push.c
@@ -4,9 +4,9 @@
 #include "environment.h"
 #include "hex.h"
 #include "repository.h"
-#include "commit.h"
-#include "tag.h"
-#include "blob.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
+#include "odb/blob.h"
 #include "http.h"
 #include "diff.h"
 #include "revision.h"
@@ -15,12 +15,12 @@
 #include "setup.h"
 #include "sigchain.h"
 #include "strvec.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "url.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "commit-reach.h"
 
 #ifdef EXPAT_NEEDS_XMLPARSE_H
diff --git a/http-walker.c b/http-walker.c
index abafca84d6..dba84c0ef5 100644
--- a/http-walker.c
+++ b/http-walker.c
@@ -9,8 +9,8 @@
 #include "list.h"
 #include "transport.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 
 struct alt_base {
 	char *base;
diff --git a/http.c b/http.c
index a0d399b274..81b58bd8d2 100644
--- a/http.c
+++ b/http.c
@@ -19,8 +19,8 @@
 #include "transport.h"
 #include "packfile.h"
 #include "string-list.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "tempfile.h"
 #include "date.h"
 #include "trace2.h"
diff --git a/khash.h b/khash.h
index ff88163177..665ade151f 100644
--- a/khash.h
+++ b/khash.h
@@ -26,7 +26,7 @@
 #ifndef __AC_KHASH_H
 #define __AC_KHASH_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 #define AC_VERSION_KHASH_H "0.2.8"
 
diff --git a/line-log.c b/line-log.c
index 0179f138f7..2c9c11e5d3 100644
--- a/line-log.c
+++ b/line-log.c
@@ -4,10 +4,10 @@
 #include "diffcore.h"
 #include "line-range.h"
 #include "hex.h"
-#include "tag.h"
-#include "tree.h"
+#include "odb/tag.h"
+#include "odb/tree.h"
 #include "diff.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "decorate.h"
 #include "repository.h"
 #include "revision.h"
@@ -17,7 +17,7 @@
 #include "setup.h"
 #include "strvec.h"
 #include "bloom.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 
 static void range_set_grow(struct range_set *rs, size_t extra)
 {
diff --git a/list-objects-filter-options.h b/list-objects-filter-options.h
index 77d7bbc846..96cbe9c89b 100644
--- a/list-objects-filter-options.h
+++ b/list-objects-filter-options.h
@@ -2,7 +2,7 @@
 #define LIST_OBJECTS_FILTER_OPTIONS_H
 
 #include "gettext.h"
-#include "object.h"
+#include "odb/object.h"
 #include "strbuf.h"
 
 struct option;
diff --git a/list-objects-filter.c b/list-objects-filter.c
index c912ff3079..a34e07c061 100644
--- a/list-objects-filter.c
+++ b/list-objects-filter.c
@@ -4,15 +4,15 @@
 #include "dir.h"
 #include "gettext.h"
 #include "hex.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "revision.h"
 #include "list-objects-filter.h"
 #include "list-objects-filter-options.h"
-#include "oidmap.h"
-#include "oidset.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/oidmap.h"
+#include "odb/oidset.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 
 /* Remember to update object flag allocation in object.h */
 /*
diff --git a/list-objects.c b/list-objects.c
index 724d723c48..b8a673ed69 100644
--- a/list-objects.c
+++ b/list-objects.c
@@ -1,20 +1,20 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "tag.h"
-#include "commit.h"
+#include "odb/tag.h"
+#include "odb/commit.h"
 #include "gettext.h"
 #include "hex.h"
-#include "tree.h"
-#include "blob.h"
+#include "odb/tree.h"
+#include "odb/blob.h"
 #include "diff.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 #include "revision.h"
 #include "list-objects.h"
 #include "list-objects-filter.h"
 #include "list-objects-filter-options.h"
 #include "packfile.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "trace.h"
 #include "environment.h"
 
diff --git a/log-tree.c b/log-tree.c
index 83a3c4bf9b..c9fde242a1 100644
--- a/log-tree.c
+++ b/log-tree.c
@@ -3,24 +3,24 @@
 
 #include "git-compat-util.h"
 #include "commit-reach.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "config.h"
 #include "diff.h"
 #include "diffcore.h"
 #include "environment.h"
 #include "hex.h"
-#include "object-name.h"
-#include "object-file.h"
+#include "odb/object-name.h"
+#include "odb/object-file.h"
 #include "repository.h"
-#include "tmp-objdir.h"
-#include "commit.h"
-#include "tag.h"
+#include "odb/tmp-objdir.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
 #include "graph.h"
 #include "log-tree.h"
 #include "merge-ort.h"
 #include "reflog-walk.h"
 #include "refs.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "revision.h"
 #include "string-list.h"
 #include "color.h"
@@ -30,7 +30,7 @@
 #include "help.h"
 #include "range-diff.h"
 #include "strmap.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "wildmatch.h"
 #include "write-or-die.h"
 #include "pager.h"
diff --git a/ls-refs.c b/ls-refs.c
index 9759826ca7..e29ef0947f 100644
--- a/ls-refs.c
+++ b/ls-refs.c
@@ -3,7 +3,7 @@
 #include "git-compat-util.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "repository.h"
 #include "refs.h"
diff --git a/mailmap.c b/mailmap.c
index 1386ab208c..558b1972f8 100644
--- a/mailmap.c
+++ b/mailmap.c
@@ -2,8 +2,8 @@
 #include "environment.h"
 #include "string-list.h"
 #include "mailmap.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "setup.h"
 #include "config.h"
 
diff --git a/merge-blobs.c b/merge-blobs.c
index 16a75bd1e3..96210edd16 100644
--- a/merge-blobs.c
+++ b/merge-blobs.c
@@ -2,9 +2,9 @@
 
 #include "git-compat-util.h"
 #include "merge-ll.h"
-#include "blob.h"
+#include "odb/blob.h"
 #include "merge-blobs.h"
-#include "odb.h"
+#include "odb/odb.h"
 
 static int fill_mmfile_blob(mmfile_t *f, struct blob *obj)
 {
diff --git a/merge-ort-wrappers.c b/merge-ort-wrappers.c
index 2110844f53..846753abdf 100644
--- a/merge-ort-wrappers.c
+++ b/merge-ort-wrappers.c
@@ -1,16 +1,16 @@
 #include "git-compat-util.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "lockfile.h"
 #include "merge-ort.h"
 #include "merge-ort-wrappers.h"
 #include "read-cache-ll.h"
 #include "repository.h"
-#include "tag.h"
-#include "tree.h"
+#include "odb/tag.h"
+#include "odb/tree.h"
 
-#include "commit.h"
+#include "odb/commit.h"
 
 static int unclean(struct merge_options *opt, struct tree *head)
 {
diff --git a/merge-ort.c b/merge-ort.c
index c410a5d353..35d30dcf06 100644
--- a/merge-ort.c
+++ b/merge-ort.c
@@ -20,11 +20,11 @@
 #include "git-compat-util.h"
 #include "merge-ort.h"
 
-#include "alloc.h"
+#include "odb/alloc.h"
 #include "advice.h"
 #include "attr.h"
 #include "cache-tree.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "commit-reach.h"
 #include "config.h"
 #include "diff.h"
@@ -35,12 +35,12 @@
 #include "hex.h"
 #include "entry.h"
 #include "merge-ll.h"
-#include "match-trees.h"
+#include "odb/match-trees.h"
 #include "mem-pool.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
-#include "oid-array.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/oid-array.h"
 #include "path.h"
 #include "promisor-remote.h"
 #include "read-cache-ll.h"
@@ -49,7 +49,7 @@
 #include "sparse-index.h"
 #include "strmap.h"
 #include "trace2.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "unpack-trees.h"
 #include "xdiff-interface.h"
 
diff --git a/merge-ort.h b/merge-ort.h
index 6045579825..da1d63131a 100644
--- a/merge-ort.h
+++ b/merge-ort.h
@@ -1,7 +1,7 @@
 #ifndef MERGE_ORT_H
 #define MERGE_ORT_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "strbuf.h"
 
 struct commit;
diff --git a/merge.c b/merge.c
index 0f5e823e63..f46d968b70 100644
--- a/merge.c
+++ b/merge.c
@@ -2,16 +2,16 @@
 
 #include "git-compat-util.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "lockfile.h"
 #include "merge.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "repository.h"
 #include "run-command.h"
 #include "resolve-undo.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "unpack-trees.h"
 
 static const char *merge_argument(struct commit *commit)
diff --git a/meson.build b/meson.build
index 38ec7d4f40..6586f8ae9f 100644
--- a/meson.build
+++ b/meson.build
@@ -312,7 +312,7 @@ libgit_sources = [
   'add-patch.c',
   'advice.c',
   'alias.c',
-  'alloc.c',
+  'odb/alloc.c',
   'apply.c',
   'archive-tar.c',
   'archive-zip.c',
@@ -321,13 +321,13 @@ libgit_sources = [
   'base85.c',
   'bisect.c',
   'blame.c',
-  'blob.c',
+  'odb/blob.c',
   'bloom.c',
   'branch.c',
   'bundle-uri.c',
   'bundle.c',
   'cache-tree.c',
-  'cbtree.c',
+  'odb/cbtree.c',
   'chdir-notify.c',
   'checkout.c',
   'chunk-format.c',
@@ -336,7 +336,7 @@ libgit_sources = [
   'combine-diff.c',
   'commit-graph.c',
   'commit-reach.c',
-  'commit.c',
+  'odb/commit.c',
   'common-exit.c',
   'common-init.c',
   'compiler-tricks/not-constant.c',
@@ -377,7 +377,7 @@ libgit_sources = [
   'fetch-object-info.c',
   'fetch-pack.c',
   'fmt-merge-msg.c',
-  'fsck.c',
+  'odb/fsck.c',
   'fsmonitor.c',
   'fsmonitor-ipc.c',
   'fsmonitor-settings.c',
@@ -386,8 +386,8 @@ libgit_sources = [
   'gpg-interface.c',
   'graph.c',
   'grep.c',
-  'hash-lookup.c',
-  'hash.c',
+  'odb/hash-lookup.c',
+  'odb/hash.c',
   'hashmap.c',
   'help.c',
   'hex.c',
@@ -405,11 +405,11 @@ libgit_sources = [
   'list-objects.c',
   'lockfile.c',
   'log-tree.c',
-  'loose.c',
+  'odb/loose.c',
   'ls-refs.c',
   'mailinfo.c',
   'mailmap.c',
-  'match-trees.c',
+  'odb/match-trees.c',
   'mem-pool.c',
   'merge-blobs.c',
   'merge-ll.c',
@@ -426,11 +426,11 @@ libgit_sources = [
   'notes-merge.c',
   'notes-utils.c',
   'notes.c',
-  'object-file-convert.c',
-  'object-file.c',
-  'object-name.c',
-  'object.c',
-  'odb.c',
+  'odb/object-file-convert.c',
+  'odb/object-file.c',
+  'odb/object-name.c',
+  'odb/object.c',
+  'odb/odb.c',
   'odb/source.c',
   'odb/source-files.c',
   'odb/source-inmemory.c',
@@ -438,10 +438,10 @@ libgit_sources = [
   'odb/source-packed.c',
   'odb/streaming.c',
   'odb/transaction.c',
-  'oid-array.c',
-  'oidmap.c',
-  'oidset.c',
-  'oidtree.c',
+  'odb/oid-array.c',
+  'odb/oidmap.c',
+  'odb/oidset.c',
+  'odb/oidtree.c',
   'organize/gitorganize-format.c',
   'organize/labeler-protocol.c',
   'organize/organize.c',
@@ -515,7 +515,7 @@ libgit_sources = [
   'repack-geometry.c',
   'repack-midx.c',
   'repack-promisor.c',
-  'replace-object.c',
+  'odb/replace-object.c',
   'replay.c',
   'repo-settings.c',
   'repository.c',
@@ -544,10 +544,10 @@ libgit_sources = [
   'submodule-config.c',
   'submodule.c',
   'symlinks.c',
-  'tag.c',
+  'odb/tag.c',
   'tempfile.c',
   'thread-utils.c',
-  'tmp-objdir.c',
+  'odb/tmp-objdir.c',
   'trace.c',
   'trace2.c',
   'trace2/tr2_cfg.c',
@@ -566,8 +566,8 @@ libgit_sources = [
   'transport-helper.c',
   'transport.c',
   'tree-diff.c',
-  'tree-walk.c',
-  'tree.c',
+  'odb/tree-walk.c',
+  'odb/tree.c',
   'unpack-trees.c',
   'upload-pack.c',
   'url.c',
diff --git a/midx-write.c b/midx-write.c
index 580724d21a..bb4ceaede7 100644
--- a/midx-write.c
+++ b/midx-write.c
@@ -4,8 +4,8 @@
 #include "hex.h"
 #include "lockfile.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "hash-lookup.h"
+#include "odb/object-file.h"
+#include "odb/hash-lookup.h"
 #include "midx.h"
 #include "progress.h"
 #include "trace2.h"
diff --git a/midx.c b/midx.c
index 76c3f92cc3..47f67c4295 100644
--- a/midx.c
+++ b/midx.c
@@ -5,7 +5,7 @@
 #include "dir.h"
 #include "hex.h"
 #include "packfile.h"
-#include "hash-lookup.h"
+#include "odb/hash-lookup.h"
 #include "midx.h"
 #include "progress.h"
 #include "trace2.h"
diff --git a/name-hash.c b/name-hash.c
index 83757db874..1464b6d066 100644
--- a/name-hash.c
+++ b/name-hash.c
@@ -13,7 +13,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "name-hash.h"
-#include "object.h"
+#include "odb/object.h"
 #include "read-cache-ll.h"
 #include "thread-utils.h"
 #include "trace.h"
diff --git a/negotiator/default.c b/negotiator/default.c
index 19cdf3808c..404db17785 100644
--- a/negotiator/default.c
+++ b/negotiator/default.c
@@ -2,12 +2,12 @@
 
 #include "git-compat-util.h"
 #include "default.h"
-#include "../commit.h"
+#include "odb/commit.h"
 #include "../fetch-negotiator.h"
 #include "../prio-queue.h"
 #include "../refs.h"
 #include "../repository.h"
-#include "../tag.h"
+#include "odb/tag.h"
 
 /* Remember to update object flag allocation in object.h */
 #define COMMON		(1U << 2)
diff --git a/negotiator/skipping.c b/negotiator/skipping.c
index db90fa77b5..e1218d2a93 100644
--- a/negotiator/skipping.c
+++ b/negotiator/skipping.c
@@ -2,13 +2,13 @@
 
 #include "git-compat-util.h"
 #include "skipping.h"
-#include "../commit.h"
+#include "odb/commit.h"
 #include "../fetch-negotiator.h"
 #include "../hex.h"
 #include "../prio-queue.h"
 #include "../refs.h"
 #include "../repository.h"
-#include "../tag.h"
+#include "odb/tag.h"
 
 /* Remember to update object flag allocation in object.h */
 /*
diff --git a/notes-cache.c b/notes-cache.c
index 74cef802bd..abe0964bba 100644
--- a/notes-cache.c
+++ b/notes-cache.c
@@ -2,11 +2,11 @@
 
 #include "git-compat-util.h"
 #include "notes-cache.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "pretty.h"
 #include "repository.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "refs.h"
 #include "strbuf.h"
 
diff --git a/notes-merge.c b/notes-merge.c
index 118cad2518..2b025b6d3d 100644
--- a/notes-merge.c
+++ b/notes-merge.c
@@ -3,12 +3,12 @@
 
 #include "git-compat-util.h"
 #include "advice.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "gettext.h"
 #include "refs.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "path.h"
 #include "repository.h"
 #include "diff.h"
diff --git a/notes-utils.c b/notes-utils.c
index 5c1c75d5b8..b6275dfa26 100644
--- a/notes-utils.c
+++ b/notes-utils.c
@@ -2,7 +2,7 @@
 
 #include "git-compat-util.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "environment.h"
 #include "gettext.h"
 #include "refs.h"
diff --git a/notes.c b/notes.c
index ec9c2cb150..ef44dae00d 100644
--- a/notes.c
+++ b/notes.c
@@ -6,12 +6,12 @@
 #include "environment.h"
 #include "hex.h"
 #include "notes.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "utf8.h"
 #include "strbuf.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 #include "string-list.h"
 #include "refs.h"
 
diff --git a/alloc.c b/odb/alloc.c
similarity index 95%
rename from alloc.c
rename to odb/alloc.c
index 533a045c2a..e0f0146bf8 100644
--- a/alloc.c
+++ b/odb/alloc.c
@@ -9,13 +9,13 @@
  * for the new allocation is.
  */
 #include "git-compat-util.h"
-#include "object.h"
-#include "blob.h"
-#include "tree.h"
-#include "commit.h"
+#include "odb/object.h"
+#include "odb/blob.h"
+#include "odb/tree.h"
+#include "odb/commit.h"
 #include "repository.h"
-#include "tag.h"
-#include "alloc.h"
+#include "odb/tag.h"
+#include "odb/alloc.h"
 
 #define BLOCKING 1024
 
diff --git a/alloc.h b/odb/alloc.h
similarity index 100%
rename from alloc.h
rename to odb/alloc.h
diff --git a/blob.c b/odb/blob.c
similarity index 89%
rename from blob.c
rename to odb/blob.c
index 3fb2922b1a..cd4b34a2b3 100644
--- a/blob.c
+++ b/odb/blob.c
@@ -1,6 +1,6 @@
 #include "git-compat-util.h"
-#include "blob.h"
-#include "alloc.h"
+#include "odb/blob.h"
+#include "odb/alloc.h"
 
 const char *blob_type = "blob";
 
diff --git a/blob.h b/odb/blob.h
similarity index 96%
rename from blob.h
rename to odb/blob.h
index 74555c90c4..cebe385c9b 100644
--- a/blob.h
+++ b/odb/blob.h
@@ -1,7 +1,7 @@
 #ifndef BLOB_H
 #define BLOB_H
 
-#include "object.h"
+#include "odb/object.h"
 
 extern const char *blob_type;
 
diff --git a/cbtree.c b/odb/cbtree.c
similarity index 99%
rename from cbtree.c
rename to odb/cbtree.c
index 8f5edbb80a..6f1699385e 100644
--- a/cbtree.c
+++ b/odb/cbtree.c
@@ -5,7 +5,7 @@
  * git clone https://github.com/agl/critbit.git
  */
 #include "git-compat-util.h"
-#include "cbtree.h"
+#include "odb/cbtree.h"
 
 static inline uint8_t *cb_node_key(struct cb_tree *t, struct cb_node *node)
 {
diff --git a/cbtree.h b/odb/cbtree.h
similarity index 100%
rename from cbtree.h
rename to odb/cbtree.h
diff --git a/commit-slab-decl.h b/odb/commit-slab-decl.h
similarity index 100%
rename from commit-slab-decl.h
rename to odb/commit-slab-decl.h
diff --git a/commit-slab-impl.h b/odb/commit-slab-impl.h
similarity index 100%
rename from commit-slab-impl.h
rename to odb/commit-slab-impl.h
diff --git a/commit-slab.h b/odb/commit-slab.h
similarity index 97%
rename from commit-slab.h
rename to odb/commit-slab.h
index 8e72a30536..8a736bdf72 100644
--- a/commit-slab.h
+++ b/odb/commit-slab.h
@@ -1,8 +1,8 @@
 #ifndef COMMIT_SLAB_H
 #define COMMIT_SLAB_H
 
-#include "commit-slab-decl.h"
-#include "commit-slab-impl.h"
+#include "odb/commit-slab-decl.h"
+#include "odb/commit-slab-impl.h"
 
 /*
  * define_commit_slab(slabname, elemtype) creates boilerplate code to define
diff --git a/commit.c b/odb/commit.c
similarity index 99%
rename from commit.c
rename to odb/commit.c
index ad26f0b40a..d0e036876c 100644
--- a/commit.c
+++ b/odb/commit.c
@@ -1,36 +1,36 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "tag.h"
-#include "commit.h"
+#include "odb/tag.h"
+#include "odb/commit.h"
 #include "commit-graph.h"
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
 #include "repository.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "utf8.h"
 #include "diff.h"
 #include "revision.h"
 #include "notes.h"
-#include "alloc.h"
+#include "odb/alloc.h"
 #include "gpg-interface.h"
 #include "mergesort.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "prio-queue.h"
-#include "hash-lookup.h"
+#include "odb/hash-lookup.h"
 #include "wt-status.h"
 #include "advice.h"
 #include "refs.h"
 #include "commit-reach.h"
 #include "setup.h"
 #include "shallow.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "hook.h"
 #include "parse.h"
-#include "object-file.h"
-#include "object-file-convert.h"
+#include "odb/object-file.h"
+#include "odb/object-file-convert.h"
 
 static struct commit_extra_header *read_commit_extra_header_lines(const char *buf, size_t len, const char **);
 
diff --git a/commit.h b/odb/commit.h
similarity index 99%
rename from commit.h
rename to odb/commit.h
index 1061ed791b..a93c0f8d65 100644
--- a/commit.h
+++ b/odb/commit.h
@@ -1,7 +1,7 @@
 #ifndef COMMIT_H
 #define COMMIT_H
 
-#include "object.h"
+#include "odb/object.h"
 #include "add-interactive.h"
 
 struct signature_check;
diff --git a/fsck.c b/odb/fsck.c
similarity index 99%
rename from fsck.c
rename to odb/fsck.c
index 94c8651c7d..e76779109a 100644
--- a/fsck.c
+++ b/odb/fsck.c
@@ -3,21 +3,21 @@
 #include "dir.h"
 #include "environment.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "path.h"
 #include "repository.h"
-#include "object.h"
+#include "odb/object.h"
 #include "attr.h"
-#include "blob.h"
-#include "tree.h"
-#include "tree-walk.h"
-#include "commit.h"
-#include "tag.h"
-#include "fsck.h"
+#include "odb/blob.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
+#include "odb/fsck.h"
 #include "refs.h"
 #include "url.h"
 #include "utf8.h"
-#include "oidset.h"
+#include "odb/oidset.h"
 #include "packfile.h"
 #include "submodule-config.h"
 #include "config.h"
diff --git a/fsck.h b/odb/fsck.h
similarity index 99%
rename from fsck.h
rename to odb/fsck.h
index e77935c8a9..1e3fc862de 100644
--- a/fsck.h
+++ b/odb/fsck.h
@@ -1,8 +1,8 @@
 #ifndef GIT_FSCK_H
 #define GIT_FSCK_H
 
-#include "object.h"
-#include "oidset.h"
+#include "odb/object.h"
+#include "odb/oidset.h"
 
 enum fsck_msg_type {
 	/* for internal use only */
diff --git a/hash-lookup.c b/odb/hash-lookup.c
similarity index 98%
rename from hash-lookup.c
rename to odb/hash-lookup.c
index 5f808caa51..cf2d4a0245 100644
--- a/hash-lookup.c
+++ b/odb/hash-lookup.c
@@ -1,8 +1,8 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "hash.h"
-#include "hash-lookup.h"
+#include "odb/hash.h"
+#include "odb/hash-lookup.h"
 #include "read-cache-ll.h"
 
 static uint32_t take2(const struct object_id *oid, size_t ofs)
diff --git a/hash-lookup.h b/odb/hash-lookup.h
similarity index 100%
rename from hash-lookup.h
rename to odb/hash-lookup.h
diff --git a/hash.c b/odb/hash.c
similarity index 99%
rename from hash.c
rename to odb/hash.c
index 82f7e24404..e02dcea558 100644
--- a/hash.c
+++ b/odb/hash.c
@@ -1,5 +1,5 @@
 #include "git-compat-util.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 
 static const struct object_id empty_tree_oid = {
diff --git a/hash.h b/odb/hash.h
similarity index 100%
rename from hash.h
rename to odb/hash.h
diff --git a/loose.c b/odb/loose.c
similarity index 98%
rename from loose.c
rename to odb/loose.c
index aa3cb1b4fc..58af1f7910 100644
--- a/loose.c
+++ b/odb/loose.c
@@ -1,16 +1,16 @@
 #include "git-compat-util.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "path.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/source-files.h"
 #include "hex.h"
 #include "repository.h"
 #include "wrapper.h"
 #include "gettext.h"
-#include "loose.h"
+#include "odb/loose.h"
 #include "lockfile.h"
-#include "oidtree.h"
+#include "odb/oidtree.h"
 
 static const char *loose_object_header = "# loose-object-idx\n";
 
diff --git a/loose.h b/odb/loose.h
similarity index 100%
rename from loose.h
rename to odb/loose.h
diff --git a/match-trees.c b/odb/match-trees.c
similarity index 98%
rename from match-trees.c
rename to odb/match-trees.c
index 2a43c0fa1a..4062373e11 100644
--- a/match-trees.c
+++ b/odb/match-trees.c
@@ -2,12 +2,12 @@
 
 #include "git-compat-util.h"
 #include "hex.h"
-#include "match-trees.h"
+#include "odb/match-trees.h"
 #include "strbuf.h"
-#include "tree.h"
-#include "tree-walk.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "repository.h"
 
 static int score_missing(unsigned mode)
diff --git a/match-trees.h b/odb/match-trees.h
similarity index 100%
rename from match-trees.h
rename to odb/match-trees.h
diff --git a/object-file-convert.c b/odb/object-file-convert.c
similarity index 98%
rename from object-file-convert.c
rename to odb/object-file-convert.c
index 63ee18630b..cad75963f7 100644
--- a/object-file-convert.c
+++ b/odb/object-file-convert.c
@@ -5,12 +5,12 @@
 #include "strbuf.h"
 #include "hex.h"
 #include "repository.h"
-#include "hash.h"
-#include "object.h"
-#include "loose.h"
-#include "commit.h"
+#include "odb/hash.h"
+#include "odb/object.h"
+#include "odb/loose.h"
+#include "odb/commit.h"
 #include "gpg-interface.h"
-#include "object-file-convert.h"
+#include "odb/object-file-convert.h"
 
 int repo_oid_to_algop(struct repository *repo, const struct object_id *srcoid,
 		      const struct git_hash_algo *to, struct object_id *dest)
diff --git a/object-file-convert.h b/odb/object-file-convert.h
similarity index 96%
rename from object-file-convert.h
rename to odb/object-file-convert.h
index 9b3cc5e533..a9c454e76e 100644
--- a/object-file-convert.h
+++ b/odb/object-file-convert.h
@@ -5,7 +5,7 @@ struct repository;
 struct object_id;
 struct git_hash_algo;
 struct strbuf;
-#include "object.h"
+#include "odb/object.h"
 
 int repo_oid_to_algop(struct repository *repo, const struct object_id *src,
 		      const struct git_hash_algo *to, struct object_id *dest);
diff --git a/object-file.c b/odb/object-file.c
similarity index 99%
rename from object-file.c
rename to odb/object-file.c
index ec35c318bc..c4841cc289 100644
--- a/object-file.c
+++ b/odb/object-file.c
@@ -13,13 +13,13 @@
 #include "convert.h"
 #include "dir.h"
 #include "environment.h"
-#include "fsck.h"
+#include "odb/fsck.h"
 #include "gettext.h"
 #include "hex.h"
-#include "loose.h"
-#include "object-file-convert.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/loose.h"
+#include "odb/object-file-convert.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 #include "odb/transaction.h"
 #include "pack.h"
@@ -29,7 +29,7 @@
 #include "setup.h"
 #include "strvec.h"
 #include "tempfile.h"
-#include "tmp-objdir.h"
+#include "odb/tmp-objdir.h"
 
 static int get_conv_flags(unsigned flags)
 {
diff --git a/object-file.h b/odb/object-file.h
similarity index 99%
rename from object-file.h
rename to odb/object-file.h
index 805f2cfa28..5e9b61fe17 100644
--- a/object-file.h
+++ b/odb/object-file.h
@@ -2,8 +2,8 @@
 #define OBJECT_FILE_H
 
 #include "git-zlib.h"
-#include "object.h"
-#include "odb.h"
+#include "odb/object.h"
+#include "odb/odb.h"
 #include "odb/source-loose.h"
 #include "odb/transaction.h"
 
diff --git a/object-name.c b/odb/object-name.c
similarity index 99%
rename from object-name.c
rename to odb/object-name.c
index 83efba0ba6..98c88e7337 100644
--- a/object-name.c
+++ b/odb/object-name.c
@@ -2,21 +2,21 @@
 #define DISABLE_SIGN_COMPARE_WARNINGS
 
 #include "git-compat-util.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "advice.h"
 #include "config.h"
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "tag.h"
-#include "commit.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tag.h"
+#include "odb/commit.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "refs.h"
 #include "remote.h"
 #include "dir.h"
-#include "odb.h"
-#include "oid-array.h"
+#include "odb/odb.h"
+#include "odb/oid-array.h"
 #include "pretty.h"
 #include "read-cache-ll.h"
 #include "repo-settings.h"
@@ -25,7 +25,7 @@
 #include "midx.h"
 #include "commit-reach.h"
 #include "date.h"
-#include "object-file-convert.h"
+#include "odb/object-file-convert.h"
 #include "prio-queue.h"
 
 static int get_oid_oneline(struct repository *r, const char *, struct object_id *,
diff --git a/object-name.h b/odb/object-name.h
similarity index 99%
rename from object-name.h
rename to odb/object-name.h
index 167a9154ea..ecc161a086 100644
--- a/object-name.h
+++ b/odb/object-name.h
@@ -1,7 +1,7 @@
 #ifndef OBJECT_NAME_H
 #define OBJECT_NAME_H
 
-#include "object.h"
+#include "odb/object.h"
 #include "strbuf.h"
 
 struct object_id;
diff --git a/object.c b/odb/object.c
similarity index 98%
rename from object.c
rename to odb/object.c
index 23b84aa7e2..8a34e52eca 100644
--- a/object.c
+++ b/odb/object.c
@@ -3,16 +3,16 @@
 #include "git-compat-util.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object.h"
-#include "replace-object.h"
-#include "object-file.h"
+#include "odb/object.h"
+#include "odb/replace-object.h"
+#include "odb/object-file.h"
 #include "odb/streaming.h"
-#include "blob.h"
+#include "odb/blob.h"
 #include "statinfo.h"
-#include "tree.h"
-#include "commit.h"
-#include "tag.h"
-#include "alloc.h"
+#include "odb/tree.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
+#include "odb/alloc.h"
 #include "commit-graph.h"
 
 unsigned int get_max_object_index(const struct repository *repo)
diff --git a/object.h b/odb/object.h
similarity index 99%
rename from object.h
rename to odb/object.h
index 8fb03ff90a..8070b40b5e 100644
--- a/object.h
+++ b/odb/object.h
@@ -1,7 +1,7 @@
 #ifndef OBJECT_H
 #define OBJECT_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 struct buffer_slab;
 struct repository;
diff --git a/odb.c b/odb/odb.c
similarity index 99%
rename from odb.c
rename to odb/odb.c
index bd02d8ad54..ffa2881e9f 100644
--- a/odb.c
+++ b/odb/odb.c
@@ -8,24 +8,24 @@
 #include "hex.h"
 #include "khash.h"
 #include "lockfile.h"
-#include "loose.h"
+#include "odb/loose.h"
 #include "midx.h"
-#include "object-file-convert.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file-convert.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "odb/source-inmemory.h"
 #include "packfile.h"
 #include "path.h"
 #include "promisor-remote.h"
 #include "quote.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 #include "run-command.h"
 #include "setup.h"
 #include "strbuf.h"
 #include "strvec.h"
 #include "submodule.h"
-#include "tmp-objdir.h"
+#include "odb/tmp-objdir.h"
 #include "trace2.h"
 #include "write-or-die.h"
 
diff --git a/odb.h b/odb/odb.h
similarity index 99%
rename from odb.h
rename to odb/odb.h
index 8eb4e85d64..476660a706 100644
--- a/odb.h
+++ b/odb/odb.h
@@ -1,9 +1,9 @@
 #ifndef ODB_H
 #define ODB_H
 
-#include "object.h"
-#include "oidset.h"
-#include "oidmap.h"
+#include "odb/object.h"
+#include "odb/oidset.h"
+#include "odb/oidmap.h"
 #include "string-list.h"
 #include "thread-utils.h"
 
diff --git a/oid-array.c b/odb/oid-array.c
similarity index 97%
rename from oid-array.c
rename to odb/oid-array.c
index 9cac974395..15425abc3f 100644
--- a/oid-array.c
+++ b/odb/oid-array.c
@@ -1,8 +1,8 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "oid-array.h"
-#include "hash-lookup.h"
+#include "odb/oid-array.h"
+#include "odb/hash-lookup.h"
 
 void oid_array_append(struct oid_array *array, const struct object_id *oid)
 {
diff --git a/oid-array.h b/odb/oid-array.h
similarity index 99%
rename from oid-array.h
rename to odb/oid-array.h
index f60f9af674..fdde085587 100644
--- a/oid-array.h
+++ b/odb/oid-array.h
@@ -1,7 +1,7 @@
 #ifndef OID_ARRAY_H
 #define OID_ARRAY_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 /**
  * The API provides storage and manipulation of sets of object identifiers.
diff --git a/oidmap.c b/odb/oidmap.c
similarity index 97%
rename from oidmap.c
rename to odb/oidmap.c
index a1ef53577f..80c5605bb6 100644
--- a/oidmap.c
+++ b/odb/oidmap.c
@@ -1,6 +1,6 @@
 #include "git-compat-util.h"
-#include "hash.h"
-#include "oidmap.h"
+#include "odb/hash.h"
+#include "odb/oidmap.h"
 
 static int oidmap_neq(const void *hashmap_cmp_fn_data UNUSED,
 		      const struct hashmap_entry *e1,
diff --git a/oidmap.h b/odb/oidmap.h
similarity index 99%
rename from oidmap.h
rename to odb/oidmap.h
index acddcaecdd..f0cdebf688 100644
--- a/oidmap.h
+++ b/odb/oidmap.h
@@ -1,7 +1,7 @@
 #ifndef OIDMAP_H
 #define OIDMAP_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "hashmap.h"
 
 /*
diff --git a/oidset.c b/odb/oidset.c
similarity index 99%
rename from oidset.c
rename to odb/oidset.c
index c8ff0b385c..c37bb183eb 100644
--- a/oidset.c
+++ b/odb/oidset.c
@@ -1,5 +1,5 @@
 #include "git-compat-util.h"
-#include "oidset.h"
+#include "odb/oidset.h"
 #include "hex.h"
 #include "strbuf.h"
 
diff --git a/oidset.h b/odb/oidset.h
similarity index 100%
rename from oidset.h
rename to odb/oidset.h
diff --git a/oidtree.c b/odb/oidtree.c
similarity index 98%
rename from oidtree.c
rename to odb/oidtree.c
index e43f18026e..b1f4c1d232 100644
--- a/oidtree.c
+++ b/odb/oidtree.c
@@ -3,8 +3,8 @@
  * May be used to replace oid-array for prefix (abbreviation) matches
  */
 #include "git-compat-util.h"
-#include "oidtree.h"
-#include "hash.h"
+#include "odb/oidtree.h"
+#include "odb/hash.h"
 
 struct oidtree_node {
 	struct cb_node base;
diff --git a/oidtree.h b/odb/oidtree.h
similarity index 97%
rename from oidtree.h
rename to odb/oidtree.h
index baa5a436ea..41d241a5de 100644
--- a/oidtree.h
+++ b/odb/oidtree.h
@@ -1,8 +1,8 @@
 #ifndef OIDTREE_H
 #define OIDTREE_H
 
-#include "cbtree.h"
-#include "hash.h"
+#include "odb/cbtree.h"
+#include "odb/hash.h"
 #include "mem-pool.h"
 
 /*
diff --git a/replace-object.c b/odb/replace-object.c
similarity index 96%
rename from replace-object.c
rename to odb/replace-object.c
index 03d0f1f083..32d778f55e 100644
--- a/replace-object.c
+++ b/odb/replace-object.c
@@ -1,12 +1,12 @@
 #include "git-compat-util.h"
 #include "gettext.h"
 #include "hex.h"
-#include "oidmap.h"
-#include "odb.h"
-#include "replace-object.h"
+#include "odb/oidmap.h"
+#include "odb/odb.h"
+#include "odb/replace-object.h"
 #include "refs.h"
 #include "repository.h"
-#include "commit.h"
+#include "odb/commit.h"
 
 static int register_replace_ref(const struct reference *ref, void *cb_data)
 {
diff --git a/replace-object.h b/odb/replace-object.h
similarity index 97%
rename from replace-object.h
rename to odb/replace-object.h
index 4c9f2a2383..d7139028a3 100644
--- a/replace-object.h
+++ b/odb/replace-object.h
@@ -1,9 +1,9 @@
 #ifndef REPLACE_OBJECT_H
 #define REPLACE_OBJECT_H
 
-#include "oidmap.h"
+#include "odb/oidmap.h"
 #include "repository.h"
-#include "odb.h"
+#include "odb/odb.h"
 
 struct replace_object {
 	struct oidmap_entry original;
diff --git a/odb/source-files.c b/odb/source-files.c
index 4f8e7ad7e3..279a2ccab6 100644
--- a/odb/source-files.c
+++ b/odb/source-files.c
@@ -1,12 +1,12 @@
 #include "git-compat-util.h"
 #include "abspath.h"
-#include "blob.h"
+#include "odb/blob.h"
 #include "chdir-notify.h"
 #include "config.h"
 #include "gettext.h"
 #include "lockfile.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/source.h"
 #include "odb/source-files.h"
 #include "odb/source-loose.h"
@@ -19,7 +19,7 @@
 #include "strbuf.h"
 #include "string-list.h"
 #include "strvec.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "write-or-die.h"
 
 static void odb_source_files_reparent(const char *name UNUSED,
diff --git a/odb/source-inmemory.c b/odb/source-inmemory.c
index 3e71611b8e..288b51848e 100644
--- a/odb/source-inmemory.c
+++ b/odb/source-inmemory.c
@@ -1,9 +1,9 @@
 #include "git-compat-util.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/source-inmemory.h"
 #include "odb/streaming.h"
-#include "oidtree.h"
+#include "odb/oidtree.h"
 #include "repository.h"
 
 struct inmemory_object {
diff --git a/odb/source-loose.c b/odb/source-loose.c
index a292eb7efc..2b073d2a22 100644
--- a/odb/source-loose.c
+++ b/odb/source-loose.c
@@ -3,14 +3,14 @@
 #include "chdir-notify.h"
 #include "gettext.h"
 #include "hex.h"
-#include "loose.h"
-#include "object-file.h"
-#include "object-file-convert.h"
-#include "odb.h"
+#include "odb/loose.h"
+#include "odb/object-file.h"
+#include "odb/object-file-convert.h"
+#include "odb/odb.h"
 #include "odb/source-files.h"
 #include "odb/source-loose.h"
 #include "odb/streaming.h"
-#include "oidtree.h"
+#include "odb/oidtree.h"
 #include "path.h"
 #include "repository.h"
 #include "strbuf.h"
diff --git a/odb/source.c b/odb/source.c
index 30188b806d..2a2e1d0060 100644
--- a/odb/source.c
+++ b/odb/source.c
@@ -1,5 +1,5 @@
 #include "git-compat-util.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "odb/source-files.h"
 #include "odb/source.h"
 #include "packfile.h"
diff --git a/odb/source.h b/odb/source.h
index 4bc037b8d6..8f063363cb 100644
--- a/odb/source.h
+++ b/odb/source.h
@@ -1,8 +1,8 @@
 #ifndef ODB_SOURCE_H
 #define ODB_SOURCE_H
 
-#include "object.h"
-#include "odb.h"
+#include "odb/object.h"
+#include "odb/odb.h"
 #include "odb/transaction.h"
 
 enum odb_source_type {
diff --git a/odb/streaming.c b/odb/streaming.c
index 20531e864c..c3a06f5622 100644
--- a/odb/streaming.c
+++ b/odb/streaming.c
@@ -6,10 +6,10 @@
 #include "convert.h"
 #include "environment.h"
 #include "repository.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "odb/source.h"
 #include "odb/streaming.h"
-#include "replace-object.h"
+#include "odb/replace-object.h"
 
 #define FILTER_BUFFER (1024*16)
 
diff --git a/odb/streaming.h b/odb/streaming.h
index c023671780..552239e80e 100644
--- a/odb/streaming.h
+++ b/odb/streaming.h
@@ -4,8 +4,8 @@
 #ifndef STREAMING_H
 #define STREAMING_H 1
 
-#include "object.h"
-#include "odb.h"
+#include "odb/object.h"
+#include "odb/odb.h"
 
 struct object_database;
 struct odb_read_stream;
diff --git a/tag.c b/odb/tag.c
similarity index 97%
rename from tag.c
rename to odb/tag.c
index 1a00ded6eb..7be23b04c1 100644
--- a/tag.c
+++ b/odb/tag.c
@@ -2,13 +2,13 @@
 
 #include "git-compat-util.h"
 #include "environment.h"
-#include "tag.h"
-#include "object-name.h"
-#include "odb.h"
-#include "commit.h"
-#include "tree.h"
-#include "blob.h"
-#include "alloc.h"
+#include "odb/tag.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/commit.h"
+#include "odb/tree.h"
+#include "odb/blob.h"
+#include "odb/alloc.h"
 #include "gpg-interface.h"
 #include "hex.h"
 #include "packfile.h"
diff --git a/tag.h b/odb/tag.h
similarity index 96%
rename from tag.h
rename to odb/tag.h
index 534687c4ca..bfac5aa506 100644
--- a/tag.h
+++ b/odb/tag.h
@@ -1,7 +1,7 @@
 #ifndef TAG_H
 #define TAG_H
 
-#include "object.h"
+#include "odb/object.h"
 
 extern const char *tag_type;
 
diff --git a/tmp-objdir.c b/odb/tmp-objdir.c
similarity index 99%
rename from tmp-objdir.c
rename to odb/tmp-objdir.c
index d199d39e7c..b9ba5c4cd3 100644
--- a/tmp-objdir.c
+++ b/odb/tmp-objdir.c
@@ -1,16 +1,16 @@
 #include "git-compat-util.h"
-#include "tmp-objdir.h"
+#include "odb/tmp-objdir.h"
 #include "abspath.h"
 #include "chdir-notify.h"
 #include "dir.h"
 #include "environment.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "path.h"
 #include "string-list.h"
 #include "strbuf.h"
 #include "strvec.h"
 #include "quote.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "odb/source.h"
 #include "repository.h"
 
diff --git a/tmp-objdir.h b/odb/tmp-objdir.h
similarity index 100%
rename from tmp-objdir.h
rename to odb/tmp-objdir.h
diff --git a/odb/transaction.h b/odb/transaction.h
index 4cb2eafcbf..56c8bec5f9 100644
--- a/odb/transaction.h
+++ b/odb/transaction.h
@@ -2,7 +2,7 @@
 #define ODB_TRANSACTION_H
 
 #include "gettext.h"
-#include "odb.h"
+#include "odb/odb.h"
 
 /*
  * A transaction may be started for an object database prior to writing new
diff --git a/tree-walk.c b/odb/tree-walk.c
similarity index 99%
rename from tree-walk.c
rename to odb/tree-walk.c
index a67f06b9eb..51e8037ef5 100644
--- a/tree-walk.c
+++ b/odb/tree-walk.c
@@ -1,14 +1,14 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 #include "dir.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "trace2.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "pathspec.h"
 #include "json-writer.h"
 #include "environment.h"
diff --git a/tree-walk.h b/odb/tree-walk.h
similarity index 99%
rename from tree-walk.h
rename to odb/tree-walk.h
index 9646c47ac5..cada7e93c6 100644
--- a/tree-walk.h
+++ b/odb/tree-walk.h
@@ -1,7 +1,7 @@
 #ifndef TREE_WALK_H
 #define TREE_WALK_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 struct index_state;
 struct repository;
diff --git a/tree.c b/odb/tree.c
similarity index 97%
rename from tree.c
rename to odb/tree.c
index 53f7395e9f..f1a9779d1a 100644
--- a/tree.c
+++ b/odb/tree.c
@@ -1,11 +1,11 @@
 #include "git-compat-util.h"
 #include "hex.h"
-#include "tree.h"
-#include "object-name.h"
-#include "odb.h"
-#include "commit.h"
-#include "alloc.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/commit.h"
+#include "odb/alloc.h"
+#include "odb/tree-walk.h"
 #include "repository.h"
 #include "environment.h"
 
diff --git a/tree.h b/odb/tree.h
similarity index 98%
rename from tree.h
rename to odb/tree.h
index 677382eed8..cebfcfe80e 100644
--- a/tree.h
+++ b/odb/tree.h
@@ -1,7 +1,7 @@
 #ifndef TREE_H
 #define TREE_H
 
-#include "object.h"
+#include "odb/object.h"
 
 struct pathspec;
 struct repository;
diff --git a/oss-fuzz/fuzz-pack-idx.c b/oss-fuzz/fuzz-pack-idx.c
index d2a92f34d9..5b033dbd93 100644
--- a/oss-fuzz/fuzz-pack-idx.c
+++ b/oss-fuzz/fuzz-pack-idx.c
@@ -1,5 +1,5 @@
 #include "git-compat-util.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "packfile.h"
 
 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
diff --git a/pack-bitmap-write.c b/pack-bitmap-write.c
index acbea89031..64233d6cd0 100644
--- a/pack-bitmap-write.c
+++ b/pack-bitmap-write.c
@@ -4,25 +4,25 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "odb.h"
-#include "commit.h"
+#include "odb/odb.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "revision.h"
 #include "progress.h"
 #include "pack.h"
 #include "pack-bitmap.h"
-#include "hash-lookup.h"
+#include "odb/hash-lookup.h"
 #include "pack-objects.h"
 #include "path.h"
 #include "commit-reach.h"
 #include "prio-queue.h"
 #include "trace2.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "pseudo-merge.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "config.h"
-#include "alloc.h"
+#include "odb/alloc.h"
 #include "refs.h"
 #include "strmap.h"
 #include "midx.h"
diff --git a/pack-bitmap.c b/pack-bitmap.c
index e85bd69ba4..908a00ec0c 100644
--- a/pack-bitmap.c
+++ b/pack-bitmap.c
@@ -1,11 +1,11 @@
 #define DISABLE_SIGN_COMPARE_WARNINGS
 
 #include "git-compat-util.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "gettext.h"
 #include "hex.h"
 #include "strbuf.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "diff.h"
 #include "revision.h"
 #include "progress.h"
@@ -17,7 +17,7 @@
 #include "packfile.h"
 #include "repository.h"
 #include "trace2.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "list-objects-filter-options.h"
 #include "midx.h"
 #include "config.h"
diff --git a/pack-check.c b/pack-check.c
index c3b8db7c5c..358c68ef11 100644
--- a/pack-check.c
+++ b/pack-check.c
@@ -7,8 +7,8 @@
 #include "pack.h"
 #include "progress.h"
 #include "packfile.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 
 struct idx_entry {
diff --git a/pack-mtimes.c b/pack-mtimes.c
index 8e1f2dec0e..903c1039c8 100644
--- a/pack-mtimes.c
+++ b/pack-mtimes.c
@@ -1,7 +1,7 @@
 #include "git-compat-util.h"
 #include "gettext.h"
 #include "pack-mtimes.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "packfile.h"
 #include "strbuf.h"
 
diff --git a/pack-objects.c b/pack-objects.c
index 48510dd343..35ecc8831e 100644
--- a/pack-objects.c
+++ b/pack-objects.c
@@ -1,5 +1,5 @@
 #include "git-compat-util.h"
-#include "object.h"
+#include "odb/object.h"
 #include "pack.h"
 #include "pack-objects.h"
 #include "packfile.h"
diff --git a/pack-objects.h b/pack-objects.h
index e97e84ddcb..8b9fc2e36b 100644
--- a/pack-objects.h
+++ b/pack-objects.h
@@ -1,7 +1,7 @@
 #ifndef PACK_OBJECTS_H
 #define PACK_OBJECTS_H
 
-#include "odb.h"
+#include "odb/odb.h"
 #include "thread-utils.h"
 #include "pack.h"
 #include "packfile.h"
diff --git a/pack-revindex.c b/pack-revindex.c
index 62387ae632..613d1bb897 100644
--- a/pack-revindex.c
+++ b/pack-revindex.c
@@ -1,7 +1,7 @@
 #include "git-compat-util.h"
 #include "gettext.h"
 #include "pack-revindex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "packfile.h"
 #include "strbuf.h"
 #include "trace2.h"
diff --git a/pack-write.c b/pack-write.c
index 24033a9101..86af0ac730 100644
--- a/pack-write.c
+++ b/pack-write.c
@@ -6,7 +6,7 @@
 #include "csum-file.h"
 #include "remote.h"
 #include "chunk-format.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "pack-mtimes.h"
 #include "pack-objects.h"
 #include "pack-revindex.h"
diff --git a/pack.h b/pack.h
index 1cde92082b..2b0be52ded 100644
--- a/pack.h
+++ b/pack.h
@@ -1,7 +1,7 @@
 #ifndef PACK_H
 #define PACK_H
 
-#include "object.h"
+#include "odb/object.h"
 #include "csum-file.h"
 
 struct packed_git;
diff --git a/packfile.c b/packfile.c
index 0eee45055f..2936cbf3fa 100644
--- a/packfile.c
+++ b/packfile.c
@@ -10,15 +10,15 @@
 #include "dir.h"
 #include "packfile.h"
 #include "delta.h"
-#include "hash-lookup.h"
-#include "commit.h"
-#include "object.h"
-#include "tag.h"
+#include "odb/hash-lookup.h"
+#include "odb/commit.h"
+#include "odb/object.h"
+#include "odb/tag.h"
 #include "trace.h"
-#include "tree-walk.h"
-#include "tree.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/tree-walk.h"
+#include "odb/tree.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/streaming.h"
 #include "midx.h"
 #include "commit-graph.h"
diff --git a/packfile.h b/packfile.h
index e1f77152b5..9859bfb5e0 100644
--- a/packfile.h
+++ b/packfile.h
@@ -2,11 +2,11 @@
 #define PACKFILE_H
 
 #include "list.h"
-#include "object.h"
-#include "odb.h"
+#include "odb/object.h"
+#include "odb/odb.h"
 #include "odb/source-files.h"
 #include "odb/source-packed.h"
-#include "oidset.h"
+#include "odb/oidset.h"
 #include "packfile-list.h"
 #include "repository.h"
 
diff --git a/parallel-checkout.c b/parallel-checkout.c
index 0bf4bd6d4a..85d1c25a81 100644
--- a/parallel-checkout.c
+++ b/parallel-checkout.c
@@ -5,7 +5,7 @@
 #include "config.h"
 #include "entry.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "parallel-checkout.h"
 #include "pkt-line.h"
diff --git a/parse-options-cb.c b/parse-options-cb.c
index 976cc86385..7826b8ad43 100644
--- a/parse-options-cb.c
+++ b/parse-options-cb.c
@@ -3,16 +3,16 @@
 #include "git-compat-util.h"
 #include "parse-options.h"
 #include "branch.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "color.h"
 #include "date.h"
 #include "environment.h"
 #include "gettext.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "setup.h"
 #include "string-list.h"
 #include "strvec.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 
 /*----- some often used options -----*/
 
diff --git a/patch-ids.c b/patch-ids.c
index 1fbc88cbec..946744e7d9 100644
--- a/patch-ids.c
+++ b/patch-ids.c
@@ -1,7 +1,7 @@
 #include "git-compat-util.h"
 #include "diff.h"
-#include "commit.h"
-#include "hash.h"
+#include "odb/commit.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "patch-ids.h"
 
diff --git a/path-walk.c b/path-walk.c
index 9ca3248ea8..ed4d3211d2 100644
--- a/path-walk.c
+++ b/path-walk.c
@@ -3,27 +3,27 @@
  */
 #include "git-compat-util.h"
 #include "path-walk.h"
-#include "blob.h"
-#include "commit.h"
+#include "odb/blob.h"
+#include "odb/commit.h"
 #include "dir.h"
 #include "hashmap.h"
 #include "hex.h"
 #include "list-objects.h"
 #include "list-objects-filter-options.h"
-#include "object-name.h"
-#include "odb.h"
-#include "object.h"
-#include "oid-array.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/object.h"
+#include "odb/oid-array.h"
 #include "path.h"
 #include "prio-queue.h"
 #include "repository.h"
 #include "revision.h"
 #include "string-list.h"
 #include "strmap.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "trace2.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 
 static const char *root_path = "";
 
diff --git a/path-walk.h b/path-walk.h
index a2652b2d46..f094610500 100644
--- a/path-walk.h
+++ b/path-walk.h
@@ -2,7 +2,7 @@
  * path-walk.h : Methods and structures for walking the object graph in batches
  * by the paths that can reach those objects.
  */
-#include "object.h" /* Required for 'enum object_type'. */
+#include "odb/object.h" /* Required for 'enum object_type'. */
 
 struct rev_info;
 struct oid_array;
diff --git a/path.c b/path.c
index c3a709a928..3a3a66155a 100644
--- a/path.c
+++ b/path.c
@@ -14,7 +14,7 @@
 #include "submodule-config.h"
 #include "path.h"
 #include "packfile.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "lockfile.h"
 #include "exec-cmd.h"
 
diff --git a/pretty.c b/pretty.c
index d8a9f370f6..461e8cd527 100644
--- a/pretty.c
+++ b/pretty.c
@@ -3,10 +3,10 @@
 
 #include "git-compat-util.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "environment.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "utf8.h"
 #include "diff.h"
@@ -21,7 +21,7 @@
 #include "gpg-interface.h"
 #include "trailer.h"
 #include "run-command.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 
 /*
  * The limit for formatting directives, which enable the caller to append
diff --git a/promisor-remote.c b/promisor-remote.c
index 43505d1e1a..b2188d34c7 100644
--- a/promisor-remote.c
+++ b/promisor-remote.c
@@ -3,7 +3,7 @@
 #include "git-compat-util.h"
 #include "gettext.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "promisor-remote.h"
 #include "config.h"
 #include "trace2.h"
diff --git a/protocol-caps.c b/protocol-caps.c
index 02261be14d..edac5dbd05 100644
--- a/protocol-caps.c
+++ b/protocol-caps.c
@@ -3,9 +3,9 @@
 #include "gettext.h"
 #include "hex.h"
 #include "pkt-line.h"
-#include "hash.h"
-#include "object.h"
-#include "odb.h"
+#include "odb/hash.h"
+#include "odb/object.h"
+#include "odb/odb.h"
 #include "repository.h"
 #include "string-list.h"
 #include "strbuf.h"
diff --git a/prune-packed.c b/prune-packed.c
index d49dc11957..f536ef1eaf 100644
--- a/prune-packed.c
+++ b/prune-packed.c
@@ -2,7 +2,7 @@
 
 #include "git-compat-util.h"
 #include "gettext.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "packfile.h"
 #include "progress.h"
 #include "prune-packed.h"
diff --git a/pseudo-merge.c b/pseudo-merge.c
index 22b8600d68..0809a2bcb3 100644
--- a/pseudo-merge.c
+++ b/pseudo-merge.c
@@ -4,14 +4,14 @@
 #include "git-compat-util.h"
 #include "pseudo-merge.h"
 #include "date.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "strbuf.h"
 #include "config.h"
 #include "string-list.h"
 #include "refs.h"
 #include "pack-bitmap.h"
-#include "commit.h"
-#include "alloc.h"
+#include "odb/commit.h"
+#include "odb/alloc.h"
 #include "progress.h"
 #include "hex.h"
 
diff --git a/range-diff.c b/range-diff.c
index 8e2dd2eb19..be9f872396 100644
--- a/range-diff.c
+++ b/range-diff.c
@@ -5,7 +5,7 @@
 #include "environment.h"
 #include "gettext.h"
 #include "range-diff.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "string-list.h"
 #include "run-command.h"
 #include "strvec.h"
@@ -13,7 +13,7 @@
 #include "xdiff-interface.h"
 #include "linear-assignment.h"
 #include "diffcore.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "pager.h"
 #include "pretty.h"
 #include "repository.h"
diff --git a/reachable.c b/reachable.c
index 3079d2c5f4..2a62adf7f5 100644
--- a/reachable.c
+++ b/reachable.c
@@ -4,8 +4,8 @@
 #include "gettext.h"
 #include "hex.h"
 #include "refs.h"
-#include "commit.h"
-#include "blob.h"
+#include "odb/commit.h"
+#include "odb/blob.h"
 #include "diff.h"
 #include "revision.h"
 #include "reachable.h"
@@ -14,7 +14,7 @@
 #include "list-objects.h"
 #include "packfile.h"
 #include "worktree.h"
-#include "object-file.h"
+#include "odb/object-file.h"
 #include "pack-bitmap.h"
 #include "pack-mtimes.h"
 #include "config.h"
diff --git a/read-cache-ll.h b/read-cache-ll.h
index 8eb266cfd1..312e65ff3c 100644
--- a/read-cache-ll.h
+++ b/read-cache-ll.h
@@ -1,7 +1,7 @@
 #ifndef READ_CACHE_LL_H
 #define READ_CACHE_LL_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "hashmap.h"
 #include "statinfo.h"
 
diff --git a/read-cache.c b/read-cache.c
index c076984858..8f6b812b5f 100644
--- a/read-cache.c
+++ b/read-cache.c
@@ -18,17 +18,17 @@
 #include "cache-tree.h"
 #include "refs.h"
 #include "dir.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "odb/transaction.h"
-#include "oid-array.h"
-#include "tree.h"
-#include "commit.h"
+#include "odb/oid-array.h"
+#include "odb/tree.h"
+#include "odb/commit.h"
 #include "environment.h"
 #include "gettext.h"
 #include "mem-pool.h"
 #include "name-hash.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "path.h"
 #include "preload-index.h"
 #include "read-cache.h"
diff --git a/read-cache.h b/read-cache.h
index ab9d40aa81..69a7118a66 100644
--- a/read-cache.h
+++ b/read-cache.h
@@ -2,7 +2,7 @@
 #define READ_CACHE_H
 
 #include "read-cache-ll.h"
-#include "object.h"
+#include "odb/object.h"
 #include "pathspec.h"
 #include "environment.h"
 
diff --git a/rebase-interactive.c b/rebase-interactive.c
index 809f76a87b..df9c2d1275 100644
--- a/rebase-interactive.c
+++ b/rebase-interactive.c
@@ -1,7 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "editor.h"
 #include "environment.h"
 #include "gettext.h"
@@ -9,10 +9,10 @@
 #include "rebase-interactive.h"
 #include "repository.h"
 #include "strbuf.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "config.h"
 #include "dir.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 
 static const char edit_todo_list_advice[] =
 N_("You can fix this with 'git rebase --edit-todo' "
diff --git a/ref-filter.c b/ref-filter.c
index bdf54f6f59..8a3d056577 100644
--- a/ref-filter.c
+++ b/ref-filter.c
@@ -11,17 +11,17 @@
 #include "run-command.h"
 #include "refs.h"
 #include "wildmatch.h"
-#include "object-name.h"
-#include "odb.h"
-#include "oid-array.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/oid-array.h"
 #include "repo-settings.h"
 #include "repository.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "mailmap.h"
 #include "ident.h"
 #include "remote.h"
 #include "color.h"
-#include "tag.h"
+#include "odb/tag.h"
 #include "quote.h"
 #include "ref-filter.h"
 #include "revision.h"
@@ -29,7 +29,7 @@
 #include "versioncmp.h"
 #include "trailer.h"
 #include "wt-status.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "commit-reach.h"
 #include "worktree.h"
 #include "hashmap.h"
diff --git a/ref-filter.h b/ref-filter.h
index 9361296e2a..11180f9570 100644
--- a/ref-filter.h
+++ b/ref-filter.h
@@ -2,8 +2,8 @@
 #define REF_FILTER_H
 
 #include "gettext.h"
-#include "oid-array.h"
-#include "commit.h"
+#include "odb/oid-array.h"
+#include "odb/commit.h"
 #include "string-list.h"
 #include "strvec.h"
 #include "commit-reach.h"
diff --git a/reflog-walk.c b/reflog-walk.c
index 4dbeaa93a7..4058cfa6df 100644
--- a/reflog-walk.c
+++ b/reflog-walk.c
@@ -1,7 +1,7 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "git-compat-util.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "refs.h"
 #include "diff.h"
 #include "repository.h"
diff --git a/reflog.c b/reflog.c
index 04edbe5670..178ef7fe44 100644
--- a/reflog.c
+++ b/reflog.c
@@ -6,12 +6,12 @@
 #include "environment.h"
 #include "gettext.h"
 #include "parse-options.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "reflog.h"
 #include "refs.h"
 #include "revision.h"
-#include "tree.h"
-#include "tree-walk.h"
+#include "odb/tree.h"
+#include "odb/tree-walk.h"
 #include "wildmatch.h"
 
 static struct reflog_expire_entry_option *find_cfg_ent(struct reflog_expire_options *opts,
diff --git a/refs.c b/refs.c
index 92d5df5b71..e01163be2a 100644
--- a/refs.c
+++ b/refs.c
@@ -15,9 +15,9 @@
 #include "refs.h"
 #include "refs/refs-internal.h"
 #include "hook.h"
-#include "object-name.h"
-#include "odb.h"
-#include "object.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/object.h"
 #include "path.h"
 #include "submodule.h"
 #include "worktree.h"
@@ -25,10 +25,10 @@
 #include "repo-settings.h"
 #include "setup.h"
 #include "date.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "wildmatch.h"
 #include "ident.h"
-#include "fsck.h"
+#include "odb/fsck.h"
 
 /*
  * List of all available backends
diff --git a/refs.h b/refs.h
index 9979446d15..1746d1035c 100644
--- a/refs.h
+++ b/refs.h
@@ -1,8 +1,8 @@
 #ifndef REFS_H
 #define REFS_H
 
-#include "object-name.h"
-#include "commit.h"
+#include "odb/object-name.h"
+#include "odb/commit.h"
 #include "repository.h"
 #include "repo-settings.h"
 
diff --git a/refs/files-backend.c b/refs/files-backend.c
index 1cc20aa486..ef7532e727 100644
--- a/refs/files-backend.c
+++ b/refs/files-backend.c
@@ -6,9 +6,9 @@
 #include "../copy.h"
 #include "../environment.h"
 #include "../gettext.h"
-#include "../hash.h"
+#include "odb/hash.h"
 #include "../hex.h"
-#include "../fsck.h"
+#include "odb/fsck.h"
 #include "../refs.h"
 #include "../repo-settings.h"
 #include "refs-internal.h"
diff --git a/refs/packed-backend.c b/refs/packed-backend.c
index b9b04b7010..c7005a9ecc 100644
--- a/refs/packed-backend.c
+++ b/refs/packed-backend.c
@@ -3,9 +3,9 @@
 #include "../git-compat-util.h"
 #include "../config.h"
 #include "../dir.h"
-#include "../fsck.h"
+#include "odb/fsck.h"
 #include "../gettext.h"
-#include "../hash.h"
+#include "odb/hash.h"
 #include "../hex.h"
 #include "../refs.h"
 #include "refs-internal.h"
diff --git a/refs/ref-cache.c b/refs/ref-cache.c
index ffef01a597..a4182ea57f 100644
--- a/refs/ref-cache.c
+++ b/refs/ref-cache.c
@@ -1,5 +1,5 @@
 #include "../git-compat-util.h"
-#include "../hash.h"
+#include "odb/hash.h"
 #include "../refs.h"
 #include "../repository.h"
 #include "refs-internal.h"
diff --git a/refs/ref-cache.h b/refs/ref-cache.h
index f635d2d824..7a4fe77a41 100644
--- a/refs/ref-cache.h
+++ b/refs/ref-cache.h
@@ -1,7 +1,7 @@
 #ifndef REFS_REF_CACHE_H
 #define REFS_REF_CACHE_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 struct ref_dir;
 struct ref_store;
diff --git a/refs/reftable-backend.c b/refs/reftable-backend.c
index 028f0211af..9d6194c4e6 100644
--- a/refs/reftable-backend.c
+++ b/refs/reftable-backend.c
@@ -4,9 +4,9 @@
 #include "../config.h"
 #include "../dir.h"
 #include "../environment.h"
-#include "../fsck.h"
+#include "odb/fsck.h"
 #include "../gettext.h"
-#include "../hash.h"
+#include "odb/hash.h"
 #include "../hex.h"
 #include "../ident.h"
 #include "../iterator.h"
diff --git a/refspec.c b/refspec.c
index 7cb479983b..f3cb1b0748 100644
--- a/refspec.c
+++ b/refspec.c
@@ -2,7 +2,7 @@
 
 #include "git-compat-util.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "string-list.h"
 #include "strvec.h"
diff --git a/remote-curl.c b/remote-curl.c
index 2c35dd5240..a6a145c046 100644
--- a/remote-curl.c
+++ b/remote-curl.c
@@ -17,7 +17,7 @@
 #include "string-list.h"
 #include "strvec.h"
 #include "credential.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "send-pack.h"
 #include "setup.h"
 #include "protocol.h"
diff --git a/remote.c b/remote.c
index fe62068463..89dc91429a 100644
--- a/remote.c
+++ b/remote.c
@@ -12,10 +12,10 @@
 #include "urlmatch.h"
 #include "refs.h"
 #include "refspec.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "path.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "revision.h"
 #include "dir.h"
diff --git a/remote.h b/remote.h
index cca02033b9..fbf552cc2f 100644
--- a/remote.h
+++ b/remote.h
@@ -1,7 +1,7 @@
 #ifndef REMOTE_H
 #define REMOTE_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "hashmap.h"
 #include "refspec.h"
 #include "string-list.h"
diff --git a/repack-midx.c b/repack-midx.c
index 64c7f8d0f4..a9df431952 100644
--- a/repack-midx.c
+++ b/repack-midx.c
@@ -1,11 +1,11 @@
 #include "git-compat-util.h"
 #include "repack.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "lockfile.h"
 #include "midx.h"
-#include "odb.h"
-#include "oidset.h"
+#include "odb/odb.h"
+#include "odb/oidset.h"
 #include "pack-bitmap.h"
 #include "path.h"
 #include "refs.h"
diff --git a/repack.c b/repack.c
index d2aa58e134..16da2e35cb 100644
--- a/repack.c
+++ b/repack.c
@@ -1,7 +1,7 @@
 #include "git-compat-util.h"
 #include "dir.h"
 #include "midx.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "packfile.h"
 #include "path.h"
 #include "repack.h"
diff --git a/replay.c b/replay.c
index 463c900d6c..9e29f29ff6 100644
--- a/replay.c
+++ b/replay.c
@@ -4,13 +4,13 @@
 #include "environment.h"
 #include "hex.h"
 #include "merge-ort.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "refs.h"
 #include "replay.h"
 #include "revision.h"
 #include "sequencer.h"
 #include "strmap.h"
-#include "tree.h"
+#include "odb/tree.h"
 
 /*
  * We technically need USE_THE_REPOSITORY_VARIABLE for DEFAULT_ABBREV, but
diff --git a/replay.h b/replay.h
index 491db145e3..7ec371d6a5 100644
--- a/replay.h
+++ b/replay.h
@@ -1,7 +1,7 @@
 #ifndef REPLAY_H
 #define REPLAY_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 struct repository;
 struct rev_info;
diff --git a/repository.c b/repository.c
index db4f9d006e..72434e3a50 100644
--- a/repository.c
+++ b/repository.c
@@ -2,17 +2,17 @@
 #include "abspath.h"
 #include "repository.h"
 #include "hook.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "odb/source.h"
 #include "config.h"
 #include "gettext.h"
-#include "object.h"
+#include "odb/object.h"
 #include "lockfile.h"
 #include "path.h"
 #include "read-cache-ll.h"
 #include "remote.h"
 #include "setup.h"
-#include "loose.h"
+#include "odb/loose.h"
 #include "submodule-config.h"
 #include "sparse-index.h"
 #include "trace2.h"
diff --git a/rerere.c b/rerere.c
index 3d3bd0db16..6ff20d0692 100644
--- a/rerere.c
+++ b/rerere.c
@@ -18,8 +18,8 @@
 #include "merge-ll.h"
 #include "path.h"
 #include "pathspec.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "strmap.h"
 
 #define RESOLVED 0
diff --git a/reset.c b/reset.c
index 71254bde93..950d45d07d 100644
--- a/reset.c
+++ b/reset.c
@@ -3,11 +3,11 @@
 #include "gettext.h"
 #include "hex.h"
 #include "lockfile.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "refs.h"
 #include "reset.h"
-#include "tree-walk.h"
-#include "tree.h"
+#include "odb/tree-walk.h"
+#include "odb/tree.h"
 #include "unpack-trees.h"
 #include "hook.h"
 
diff --git a/reset.h b/reset.h
index 4c992ba671..52055ad68d 100644
--- a/reset.h
+++ b/reset.h
@@ -1,7 +1,7 @@
 #ifndef RESET_H
 #define RESET_H
 
-#include "hash.h"
+#include "odb/hash.h"
 #include "repository.h"
 
 #define GIT_REFLOG_ACTION_ENVIRONMENT "GIT_REFLOG_ACTION"
diff --git a/resolve-undo.c b/resolve-undo.c
index 52c45e5a49..a54b6c0f79 100644
--- a/resolve-undo.c
+++ b/resolve-undo.c
@@ -2,7 +2,7 @@
 
 #include "git-compat-util.h"
 #include "dir.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "read-cache.h"
 #include "resolve-undo.h"
 #include "sparse-index.h"
diff --git a/resolve-undo.h b/resolve-undo.h
index 7ed11a1c59..b10c197cf0 100644
--- a/resolve-undo.h
+++ b/resolve-undo.h
@@ -6,7 +6,7 @@ struct index_state;
 struct pathspec;
 struct string_list;
 
-#include "hash.h"
+#include "odb/hash.h"
 
 struct resolve_undo_info {
 	unsigned int mode[3];
diff --git a/revision.c b/revision.c
index 50dc8b1991..9e90f909da 100644
--- a/revision.c
+++ b/revision.c
@@ -6,14 +6,14 @@
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
-#include "object-file.h"
-#include "odb.h"
-#include "oidset.h"
-#include "tag.h"
-#include "blob.h"
-#include "tree.h"
-#include "commit.h"
+#include "odb/object-name.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
+#include "odb/oidset.h"
+#include "odb/tag.h"
+#include "odb/blob.h"
+#include "odb/tree.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "diff-merges.h"
 #include "refs.h"
@@ -28,7 +28,7 @@
 #include "line-log.h"
 #include "log-tree.h"
 #include "mailmap.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "cache-tree.h"
 #include "bisect.h"
 #include "packfile.h"
diff --git a/revision.h b/revision.h
index acf6d06b24..e0ff7aa0f2 100644
--- a/revision.h
+++ b/revision.h
@@ -1,14 +1,14 @@
 #ifndef REVISION_H
 #define REVISION_H
 
-#include "commit.h"
+#include "odb/commit.h"
 #include "grep.h"
 #include "notes.h"
-#include "object-name.h"
-#include "oidset.h"
+#include "odb/object-name.h"
+#include "odb/oidset.h"
 #include "pretty.h"
 #include "diff.h"
-#include "commit-slab-decl.h"
+#include "odb/commit-slab-decl.h"
 #include "decorate.h"
 #include "ident.h"
 #include "list-objects-filter-options.h"
diff --git a/send-pack.c b/send-pack.c
index 3bb5afc687..97dcfac586 100644
--- a/send-pack.c
+++ b/send-pack.c
@@ -1,10 +1,10 @@
 #include "git-compat-util.h"
 #include "config.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "date.h"
 #include "gettext.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "pkt-line.h"
 #include "sideband.h"
 #include "run-command.h"
@@ -13,7 +13,7 @@
 #include "send-pack.h"
 #include "transport.h"
 #include "version.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "gpg-interface.h"
 #include "shallow.h"
 #include "parse-options.h"
diff --git a/sequencer.c b/sequencer.c
index 83c3849205..67ab3cdf0d 100644
--- a/sequencer.c
+++ b/sequencer.c
@@ -11,12 +11,12 @@
 #include "hex.h"
 #include "lockfile.h"
 #include "dir.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
-#include "object.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
+#include "odb/object.h"
 #include "pager.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "sequencer.h"
 #include "run-command.h"
 #include "hook.h"
@@ -40,9 +40,9 @@
 #include "notes-utils.h"
 #include "sigchain.h"
 #include "unpack-trees.h"
-#include "oidmap.h"
-#include "oidset.h"
-#include "commit-slab.h"
+#include "odb/oidmap.h"
+#include "odb/oidset.h"
+#include "odb/commit-slab.h"
 #include "alias.h"
 #include "commit-reach.h"
 #include "rebase-interactive.h"
diff --git a/serve.c b/serve.c
index 2b07d922b3..95cf3d8ea4 100644
--- a/serve.c
+++ b/serve.c
@@ -1,7 +1,7 @@
 #include "git-compat-util.h"
 #include "repository.h"
 #include "config.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "pkt-line.h"
 #include "version.h"
 #include "ls-refs.h"
diff --git a/server-info.c b/server-info.c
index 4243e24edc..75ead482e1 100644
--- a/server-info.c
+++ b/server-info.c
@@ -5,13 +5,13 @@
 #include "hex.h"
 #include "repository.h"
 #include "refs.h"
-#include "object.h"
-#include "commit.h"
-#include "tag.h"
+#include "odb/object.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
 #include "packfile.h"
 #include "path.h"
-#include "object-file.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/odb.h"
 #include "server-info.h"
 #include "strbuf.h"
 #include "tempfile.h"
diff --git a/setup.c b/setup.c
index 20d29f31f4..fe8e9ffdc5 100644
--- a/setup.c
+++ b/setup.c
@@ -7,8 +7,8 @@
 #include "exec-cmd.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-file.h"
-#include "object-name.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
 #include "refs.h"
 #include "repository.h"
 #include "config.h"
diff --git a/shallow.c b/shallow.c
index 8e244a5669..25116d7a6e 100644
--- a/shallow.c
+++ b/shallow.c
@@ -5,16 +5,16 @@
 #include "repository.h"
 #include "tempfile.h"
 #include "lockfile.h"
-#include "odb.h"
-#include "commit.h"
-#include "tag.h"
+#include "odb/odb.h"
+#include "odb/commit.h"
+#include "odb/tag.h"
 #include "pkt-line.h"
 #include "refs.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "path.h"
 #include "diff.h"
 #include "revision.h"
-#include "commit-slab.h"
+#include "odb/commit-slab.h"
 #include "list-objects.h"
 #include "commit-reach.h"
 #include "shallow.h"
diff --git a/shallow.h b/shallow.h
index 6a64db42c9..0cb1d5ba70 100644
--- a/shallow.h
+++ b/shallow.h
@@ -1,9 +1,9 @@
 #ifndef SHALLOW_H
 #define SHALLOW_H
 
-#include "commit.h"
+#include "odb/commit.h"
 #include "lockfile.h"
-#include "object.h"
+#include "odb/object.h"
 #include "repository.h"
 #include "strbuf.h"
 
diff --git a/sparse-index.c b/sparse-index.c
index c1fa231a89..8e00862442 100644
--- a/sparse-index.c
+++ b/sparse-index.c
@@ -9,7 +9,7 @@
 #include "read-cache-ll.h"
 #include "repository.h"
 #include "sparse-index.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "pathspec.h"
 #include "trace2.h"
 #include "cache-tree.h"
diff --git a/split-index.c b/split-index.c
index 6ba210738c..2737cc6118 100644
--- a/split-index.c
+++ b/split-index.c
@@ -2,7 +2,7 @@
 
 #include "git-compat-util.h"
 #include "gettext.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "mem-pool.h"
 #include "read-cache-ll.h"
 #include "repository.h"
diff --git a/split-index.h b/split-index.h
index 1a153f47ba..6bfab742aa 100644
--- a/split-index.h
+++ b/split-index.h
@@ -1,7 +1,7 @@
 #ifndef SPLIT_INDEX_H
 #define SPLIT_INDEX_H
 
-#include "hash.h"
+#include "odb/hash.h"
 
 struct index_state;
 struct strbuf;
diff --git a/submodule-config.c b/submodule-config.c
index f75997402a..094e64d8fd 100644
--- a/submodule-config.c
+++ b/submodule-config.c
@@ -12,12 +12,12 @@
 #include "submodule-config.h"
 #include "submodule.h"
 #include "strbuf.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "odb/source.h"
 #include "parse-options.h"
 #include "thread-utils.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 #include "url.h"
 #include "urlmatch.h"
 
diff --git a/submodule-config.h b/submodule-config.h
index f55d4e3b61..3f4f0bf454 100644
--- a/submodule-config.h
+++ b/submodule-config.h
@@ -3,7 +3,7 @@
 
 #include "config.h"
 #include "submodule.h"
-#include "tree-walk.h"
+#include "odb/tree-walk.h"
 
 /**
  * The submodule config cache API allows to read submodule
diff --git a/submodule.c b/submodule.c
index 5c92575888..d091b484a4 100644
--- a/submodule.c
+++ b/submodule.c
@@ -9,7 +9,7 @@
 #include "submodule.h"
 #include "dir.h"
 #include "diff.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "environment.h"
 #include "gettext.h"
 #include "hex.h"
@@ -18,16 +18,16 @@
 #include "diffcore.h"
 #include "refs.h"
 #include "string-list.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 #include "strvec.h"
 #include "thread-utils.h"
 #include "path.h"
 #include "remote.h"
 #include "worktree.h"
 #include "parse-options.h"
-#include "object-file.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-file.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "commit-reach.h"
 #include "read-cache-ll.h"
 #include "setup.h"
diff --git a/t/helper/test-bitmap.c b/t/helper/test-bitmap.c
index 8547ef67e2..f1f48e973d 100644
--- a/t/helper/test-bitmap.c
+++ b/t/helper/test-bitmap.c
@@ -3,7 +3,7 @@
 #include "test-tool.h"
 #include "git-compat-util.h"
 #include "hex.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "pack-bitmap.h"
 #include "pseudo-merge.h"
 #include "setup.h"
diff --git a/t/helper/test-bloom.c b/t/helper/test-bloom.c
index 0c65befbf0..48ff2c6024 100644
--- a/t/helper/test-bloom.c
+++ b/t/helper/test-bloom.c
@@ -3,7 +3,7 @@
 #include "test-tool.h"
 #include "bloom.h"
 #include "hex.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "repository.h"
 #include "setup.h"
 
diff --git a/t/helper/test-cache-tree.c b/t/helper/test-cache-tree.c
index d42e260092..9f613d2911 100644
--- a/t/helper/test-cache-tree.c
+++ b/t/helper/test-cache-tree.c
@@ -4,7 +4,7 @@
 #include "test-tool.h"
 #include "gettext.h"
 #include "hex.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "cache-tree.h"
 #include "parse-options.h"
 #include "read-cache-ll.h"
diff --git a/t/helper/test-dump-cache-tree.c b/t/helper/test-dump-cache-tree.c
index ccb41a4239..849727d69b 100644
--- a/t/helper/test-dump-cache-tree.c
+++ b/t/helper/test-dump-cache-tree.c
@@ -1,9 +1,9 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "test-tool.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "cache-tree.h"
 #include "read-cache-ll.h"
 #include "repository.h"
diff --git a/t/helper/test-find-pack.c b/t/helper/test-find-pack.c
index 28d5b1fe09..c7475ed4d9 100644
--- a/t/helper/test-find-pack.c
+++ b/t/helper/test-find-pack.c
@@ -1,8 +1,8 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "test-tool.h"
-#include "object-name.h"
-#include "odb.h"
+#include "odb/object-name.h"
+#include "odb/odb.h"
 #include "packfile.h"
 #include "parse-options.h"
 #include "setup.h"
diff --git a/t/helper/test-hash-speed.c b/t/helper/test-hash-speed.c
index 89b0268011..4c71b04c57 100644
--- a/t/helper/test-hash-speed.c
+++ b/t/helper/test-hash-speed.c
@@ -1,5 +1,5 @@
 #include "test-tool.h"
-#include "hash.h"
+#include "odb/hash.h"
 
 #define NUM_SECONDS 3
 
diff --git a/t/helper/test-match-trees.c b/t/helper/test-match-trees.c
index 006ce5278e..b6122af08f 100644
--- a/t/helper/test-match-trees.c
+++ b/t/helper/test-match-trees.c
@@ -2,11 +2,11 @@
 
 #include "test-tool.h"
 #include "hex.h"
-#include "match-trees.h"
-#include "object-name.h"
+#include "odb/match-trees.h"
+#include "odb/object-name.h"
 #include "repository.h"
 #include "setup.h"
-#include "tree.h"
+#include "odb/tree.h"
 
 int cmd__match_trees(int ac UNUSED, const char **av)
 {
diff --git a/t/helper/test-pack-deltas.c b/t/helper/test-pack-deltas.c
index 840797cf0d..7e5791c7ab 100644
--- a/t/helper/test-pack-deltas.c
+++ b/t/helper/test-pack-deltas.c
@@ -4,7 +4,7 @@
 #include "git-compat-util.h"
 #include "delta.h"
 #include "git-zlib.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "pack.h"
 #include "pack-objects.h"
diff --git a/t/helper/test-pack-mtimes.c b/t/helper/test-pack-mtimes.c
index b774056799..b915059322 100644
--- a/t/helper/test-pack-mtimes.c
+++ b/t/helper/test-pack-mtimes.c
@@ -3,7 +3,7 @@
 #include "test-tool.h"
 #include "hex.h"
 #include "strbuf.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "packfile.h"
 #include "pack-mtimes.h"
 #include "setup.h"
diff --git a/t/helper/test-partial-clone.c b/t/helper/test-partial-clone.c
index 87c59108e0..76fc0329fc 100644
--- a/t/helper/test-partial-clone.c
+++ b/t/helper/test-partial-clone.c
@@ -3,7 +3,7 @@
 #include "test-tool.h"
 #include "hex.h"
 #include "repository.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "setup.h"
 
 /*
diff --git a/t/helper/test-path-walk.c b/t/helper/test-path-walk.c
index 4233badb58..f41c6be2c6 100644
--- a/t/helper/test-path-walk.c
+++ b/t/helper/test-path-walk.c
@@ -5,15 +5,15 @@
 #include "environment.h"
 #include "hex.h"
 #include "list-objects-filter-options.h"
-#include "object-name.h"
-#include "object.h"
+#include "odb/object-name.h"
+#include "odb/object.h"
 #include "pretty.h"
 #include "revision.h"
 #include "setup.h"
 #include "parse-options.h"
 #include "strbuf.h"
 #include "path-walk.h"
-#include "oid-array.h"
+#include "odb/oid-array.h"
 
 static const char * const path_walk_usage[] = {
 	N_("test-tool path-walk <options> -- <revision-options>"),
diff --git a/t/helper/test-reach.c b/t/helper/test-reach.c
index 5d86a96c17..4151cfbe25 100644
--- a/t/helper/test-reach.c
+++ b/t/helper/test-reach.c
@@ -1,15 +1,15 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "test-tool.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "commit-reach.h"
 #include "gettext.h"
 #include "hex.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "ref-filter.h"
 #include "setup.h"
 #include "string-list.h"
-#include "tag.h"
+#include "odb/tag.h"
 
 static void print_sorted_commit_ids(struct commit_list *list)
 {
diff --git a/t/helper/test-read-graph.c b/t/helper/test-read-graph.c
index 9f07b9c25a..965700a698 100644
--- a/t/helper/test-read-graph.c
+++ b/t/helper/test-read-graph.c
@@ -3,7 +3,7 @@
 #include "test-tool.h"
 #include "commit-graph.h"
 #include "repository.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "bloom.h"
 #include "setup.h"
 
diff --git a/t/helper/test-read-midx.c b/t/helper/test-read-midx.c
index fb16ec0176..9be143ee6c 100644
--- a/t/helper/test-read-midx.c
+++ b/t/helper/test-read-midx.c
@@ -4,7 +4,7 @@
 #include "hex.h"
 #include "midx.h"
 #include "repository.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "pack-bitmap.h"
 #include "packfile.h"
 #include "setup.h"
diff --git a/t/helper/test-ref-store.c b/t/helper/test-ref-store.c
index 5a9a3053d9..1fbdc52fc5 100644
--- a/t/helper/test-ref-store.c
+++ b/t/helper/test-ref-store.c
@@ -5,7 +5,7 @@
 #include "refs.h"
 #include "setup.h"
 #include "worktree.h"
-#include "odb.h"
+#include "odb/odb.h"
 #include "path.h"
 #include "repository.h"
 #include "strbuf.h"
diff --git a/t/helper/test-reftable.c b/t/helper/test-reftable.c
index fc49fafc34..e469f850ce 100644
--- a/t/helper/test-reftable.c
+++ b/t/helper/test-reftable.c
@@ -1,5 +1,5 @@
 #include "git-compat-util.h"
-#include "hash.h"
+#include "odb/hash.h"
 #include "hex.h"
 #include "reftable/system.h"
 #include "reftable/reftable-constants.h"
diff --git a/t/helper/test-repository.c b/t/helper/test-repository.c
index 9ba94cdffa..530e37b01d 100644
--- a/t/helper/test-repository.c
+++ b/t/helper/test-repository.c
@@ -2,13 +2,13 @@
 
 #include "test-tool.h"
 #include "commit-graph.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "environment.h"
 #include "hex.h"
-#include "object.h"
+#include "odb/object.h"
 #include "repository.h"
 #include "setup.h"
-#include "tree.h"
+#include "odb/tree.h"
 
 static void test_parse_commit_in_graph(const char *gitdir, const char *worktree,
 				       const struct object_id *commit_oid)
diff --git a/t/helper/test-revision-walking.c b/t/helper/test-revision-walking.c
index 24d7f29417..1b7f569f01 100644
--- a/t/helper/test-revision-walking.c
+++ b/t/helper/test-revision-walking.c
@@ -11,10 +11,10 @@
 #define USE_THE_REPOSITORY_VARIABLE
 
 #include "test-tool.h"
-#include "commit.h"
+#include "odb/commit.h"
 #include "diff.h"
 #include "line-log.h"
-#include "object-name.h"
+#include "odb/object-name.h"
 #include "repository.h"
 #include "revision.h"
 #include "setup.h"
diff --git a/t/helper/test-scrap-cache-tree.c b/t/helper/test-scrap-cache-tree.c
index 7b5ce501d9..f4f7df067d 100644
--- a/t/helper/test-scrap-cache-tree.c
+++ b/t/helper/test-scrap-cache-tree.c
@@ -5,7 +5,7 @@
 #include "read-cache-ll.h"
 #include "repository.h"
 #include "setup.h"
-#include "tree.h"
+#include "odb/tree.h"
 #include "cache-tree.h"
 
 int cmd__scrap_cache_tree(int ac UNUSED, const char **av UNUSED)
diff --git a/t/helper/test-sha1.c b/t/helper/test-sha1.c
index 349540c4df..c45e56c23f 100644
--- a/t/helper/test-sha1.c
+++ b/t/helper/test-sha1.c
@@ -1,5 +1,5 @@
 #include "test-tool.h"
-#include "