@agentsfleet/orly 0.10.14 → 0.12.0

package/src/gates_spec.test.ts

@@ -2,13 +2,18 @@ import { afterEach, describe, expect, test } from "bun:test";
 import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 
-import { activeSpecPath, closedSpecPath, runGate } from "./gates";
+import { activeSpecPath, closedSpecPath, runGate, specPathFor } from "./gates";
 import {
   cleanupTemporaryDirectories, closedSpecRepository, fixtureRegistry, git, modelFor,
   newRepository, newSpecRepository, orly, SPEC_RELATIVE, specFixture,
 } from "./gates_test_support";
 
 const BASELINE_FIXTURE = "**Test Baseline:** unit=0 integration=0";
+const OTHER_ACTIVE_SPEC = "docs/v1/active/M100_001_P2_CLI_OTHER.md";
+const CLOSED_SPEC = "docs/v1/done/M99_001_P2_CLI_FIXTURE.md";
+const CLOSED_BRANCH = "feat/closed-owner";
+const OTHER_BRANCH = "feat/other";
+const ACTIVE_SPECS_DIRECTORY = "docs/v1/active";
 
 afterEach(cleanupTemporaryDirectories);
 
@@ -31,6 +36,47 @@ describe("spec discovery", () => {
     expect(activeSpecPath(project)).toContain("docs/v0.9.2/active");
   });
 
+  test.each([false, true])("active ownership follows the branch with quoted header %s", async (quoted) => {
+    const project = newSpecRepository();
+    const branch = "feat/owned";
+    git(project, "checkout", "-q", "-b", branch);
+    const header = quoted ? `**Branch:** \`${branch}\`` : `**Branch:** ${branch}`;
+    await Bun.write(join(project, SPEC_RELATIVE), specFixture(undefined, undefined, [header]));
+    await Bun.write(join(project, OTHER_ACTIVE_SPEC), specFixture(undefined, OTHER_BRANCH));
+
+    expect(activeSpecPath(project)).toBe(join(project, SPEC_RELATIVE));
+  });
+
+  test.each([false, true])("an unrelated active spec cannot hide a closed owner with quoted header %s", async (quoted) => {
+    const branch = CLOSED_BRANCH;
+    const project = closedSpecRepository(branch);
+    const path = join(project, CLOSED_SPEC);
+    const header = quoted ? `**Branch:** \`${branch}\`` : `**Branch:** ${branch}`;
+    await Bun.write(path, specFixture("DONE", undefined, [header]));
+    mkdirSync(join(project, ACTIVE_SPECS_DIRECTORY), { recursive: true });
+    await Bun.write(join(project, OTHER_ACTIVE_SPEC), specFixture(undefined, OTHER_BRANCH));
+
+    expect(specPathFor(project)).toEqual({ path, closed: true });
+  });
+
+  test("an active spec without branch ownership still gates", async () => {
+    const project = closedSpecRepository(CLOSED_BRANCH);
+    mkdirSync(join(project, ACTIVE_SPECS_DIRECTORY), { recursive: true });
+    await Bun.write(join(project, SPEC_RELATIVE), specFixture());
+
+    expect(specPathFor(project)).toEqual({ path: join(project, SPEC_RELATIVE), closed: false });
+  });
+
+  test("two active owners on the current branch remain an error", async () => {
+    const project = newSpecRepository();
+    const branch = "feat/shared-owners";
+    git(project, "checkout", "-q", "-b", branch);
+    await Bun.write(join(project, SPEC_RELATIVE), specFixture(undefined, branch));
+    await Bun.write(join(project, OTHER_ACTIVE_SPEC), specFixture(undefined, branch));
+
+    expect(() => activeSpecPath(project)).toThrow("one stream per worktree");
+  });
+
   test("two active specs are a hard error — one stream per worktree", () => {
     const project = newSpecRepository();
     mkdirSync(join(project, "docs/v2/active"), { recursive: true });
@@ -39,12 +85,12 @@ describe("spec discovery", () => {
     expect(() => activeSpecPath(project)).toThrow("one stream per worktree");
   });
 
-  test("a folded active spec yields ownership to the spec it names", async () => {
+  test.each([false, true])("a folded active spec yields ownership with quoted header %s", async (quoted) => {
     const project = newSpecRepository();
     mkdirSync(join(project, "docs/v2/active"), { recursive: true });
     await Bun.write(
       join(project, "docs/v2/active/M100_001_P2_CLI_FOLDED.md"),
-      specFixture(undefined, undefined, ["**Folded-into:** `M99_001`"]),
+      specFixture(undefined, undefined, [quoted ? "**Folded-into:** `M99_001`" : "**Folded-into:** M99_001"]),
     );
 
     expect(activeSpecPath(project)).toEndWith("M99_001_P2_CLI_FIXTURE.md");
@@ -109,12 +155,12 @@ describe("closed-spec follow-through", () => {
     expect(() => closedSpecPath(project)).toThrow("one stream per worktree");
   });
 
-  test("a folded spec yields ownership to the spec it names", async () => {
+  test.each([false, true])("a folded closed spec yields ownership with quoted header %s", async (quoted) => {
     const project = closedSpecRepository("feat/shared");
     mkdirSync(join(project, "docs/v2/done"), { recursive: true });
     await Bun.write(
       join(project, "docs/v2/done/M100_001_P2_CLI_FOLDED.md"),
-      specFixture("DONE", "feat/shared", ["**Folded-into:** `M99_001`"]),
+      specFixture("DONE", "feat/shared", [quoted ? "**Folded-into:** `M99_001`" : "**Folded-into:** M99_001"]),
     );
 
     expect(closedSpecPath(project)).toEndWith("M99_001_P2_CLI_FIXTURE.md");
@@ -261,7 +307,7 @@ describe("closed-spec follow-through", () => {
 
     const acked = closedSpecRepository("feat/defer", [
       "- Dimension 1.2 was deferred to follow-up",
-      '> Indy (2026-08-11 09:00): "defer 1.2, ship the rest" — context: fixture',
+      '## Discovery\n\n> Indy (2026-08-11 09:00): "defer 1.2, ship the rest" — context: fixture',
     ]);
     const ackedModel = await modelFor(acked);
     expect(runGate(ackedModel, acked, "pr").results.find((result) => result.name === "spec.deferrals")?.ok).toBeTrue();

package/src/gates_test_support.ts

@@ -23,9 +23,11 @@ const PIPE_OUTPUT = "pipe";
 const TRUE_COMMAND = "true";
 const ACCEPTANCE_RUBRIC_HEADING = "Acceptance Rubric";
 const FIXTURE = "fixture";
-const AUDITS_DIR = "audits";
+const AUDITS_DIR = ".orly/audits";
 const SPEC_GATE_SCRIPT = `${AUDITS_DIR}/spec-template.sh`;
 const SPEC_GATE_CONTENT = `${AUDITS_DIR}/spec-template.ts`;
+const SOURCE_SPEC_GATE = "audits/spec-template.sh";
+const SOURCE_SPEC_CONTENT = "audits/spec-template.ts";
 
 export const ROOT = resolve(import.meta.dir, "..");
 export const SPEC_RELATIVE = "docs/v1/active/M99_001_P2_CLI_FIXTURE.md";
@@ -66,13 +68,13 @@ export function fixtureRegistry(project: string): string {
   return root;
 }
 
-// The gate resolves commands from `.oracle/orly.json` in the repository under
+// The gate resolves commands from `.orly/orly.json` in the repository under
 // test, so every fixture repository carries one.
 export function writeFixtureConfig(project: string, surfaces?: { user: string[]; docs: string[] }, extraCommands?: Record<string, string[][]>): void {
   const config: Record<string, unknown> = structuredClone(FIXTURE_CONFIG);
   if (surfaces) config.surfaces = surfaces;
   if (extraCommands) config.commands = { ...(config.commands as Record<string, unknown>), ...extraCommands };
-  mkdirSync(join(project, ".oracle"), { recursive: true });
+  mkdirSync(join(project, ".orly"), { recursive: true });
   writeFileSync(join(project, CONFIG_PATH), JSON.stringify(config, undefined, 2));
   // Committed, exactly as a real repository carries it: a linked worktree gets
   // its rules config from the checkout, and an uncommitted one would also make
@@ -109,8 +111,8 @@ export function closedSpecRepository(branch: string, extraLines: string[] = []):
   git(project, "checkout", QUIET, "-b", branch);
   mkdirSync(join(project, "docs/v1/done"), { recursive: true });
   mkdirSync(join(project, AUDITS_DIR), { recursive: true });
-  copyFileSync(join(ROOT, SPEC_GATE_SCRIPT), join(project, SPEC_GATE_SCRIPT));
-  copyFileSync(join(ROOT, SPEC_GATE_CONTENT), join(project, SPEC_GATE_CONTENT));
+  copyFileSync(join(ROOT, SOURCE_SPEC_GATE), join(project, SPEC_GATE_SCRIPT));
+  copyFileSync(join(ROOT, SOURCE_SPEC_CONTENT), join(project, SPEC_GATE_CONTENT));
   Bun.write(join(project, "docs/v1/done/M99_001_P2_CLI_FIXTURE.md"), specFixture("DONE", branch, [
     `**Baseline revision:** ${gitOutput(project, REV_PARSE, HEAD)}`, BASELINE_EVIDENCE, ...extraLines,
   ]));
@@ -123,8 +125,8 @@ export function newSpecRepository(): string {
   const project = newRepository();
   mkdirSync(join(project, "docs/v1/active"), { recursive: true });
   mkdirSync(join(project, AUDITS_DIR), { recursive: true });
-  copyFileSync(join(ROOT, SPEC_GATE_SCRIPT), join(project, SPEC_GATE_SCRIPT));
-  copyFileSync(join(ROOT, SPEC_GATE_CONTENT), join(project, SPEC_GATE_CONTENT));
+  copyFileSync(join(ROOT, SOURCE_SPEC_GATE), join(project, SPEC_GATE_SCRIPT));
+  copyFileSync(join(ROOT, SOURCE_SPEC_CONTENT), join(project, SPEC_GATE_CONTENT));
   Bun.write(join(project, SPEC_RELATIVE), specFixture(IN_PROGRESS, undefined, [
     `**Baseline revision:** ${gitOutput(project, REV_PARSE, HEAD)}`, BASELINE_EVIDENCE,
   ]));

package/src/install.test.ts

@@ -23,9 +23,9 @@ describe("install", () => {
     expect(result.packs).toContain("language.rust");
     expect(result.packs).not.toContain("language.zig");
     expect(existsSync(join(repo, "AGENTS.md"))).toBe(true);
-    expect(existsSync(join(repo, "dispatch/write_rust.md"))).toBe(true);
-    expect(existsSync(join(repo, ".githooks/pre-commit"))).toBe(true);
-    expect(existsSync(join(repo, ".oracle/orly.json"))).toBe(true);
+    expect(existsSync(join(repo, ".orly/dispatch/write_rust.md"))).toBe(true);
+    expect(existsSync(join(repo, ".orly/hooks/pre-commit"))).toBe(true);
+    expect(existsSync(join(repo, ".orly/orly.json"))).toBe(true);
   });
 
   test("a second install over the same target reports zero writes", async () => {
@@ -40,18 +40,18 @@ describe("install", () => {
     expect(second.skipped.length).toBeGreaterThan(0);
   });
 
-  test("replaces a file it wrote, hand-edited or not — git shows the replacement", async () => {
+  test("refuses to replace a managed file edited after installation", async () => {
     const model = await RulesModel.load(ROOT);
     const repo = newRepository();
     await Bun.write(join(repo, "src/lib.rs"), "pub fn main() {}\n");
     await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-    await Bun.write(join(repo, "dispatch/write_rust.md"), "hand-edited\n");
+    await Bun.write(join(repo, ".orly/dispatch/write_rust.md"), "hand-edited\n");
 
     const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
 
-    expect(result.ok).toBe(true);
-    expect(result.written).toContain("dispatch/write_rust.md");
-    expect(await Bun.file(join(repo, "dispatch/write_rust.md")).text()).not.toBe("hand-edited\n");
+    expect(result.ok).toBe(false);
+    expect(result.written).toEqual([]);
+    expect(await Bun.file(join(repo, ".orly/dispatch/write_rust.md")).text()).toBe("hand-edited\n");
   });
 
   // The other half of the same rule: authorship decides. A file orly never
@@ -60,13 +60,13 @@ describe("install", () => {
     const model = await RulesModel.load(ROOT);
     const repo = newRepository();
     await Bun.write(join(repo, "src/lib.rs"), "pub fn main() {}\n");
-    await Bun.write(join(repo, "dispatch/write_rust.md"), "the repository's own file\n");
+    await Bun.write(join(repo, ".orly/dispatch/write_rust.md"), "the repository's own file\n");
 
     const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
 
     expect(result.ok).toBe(false);
-    expect(result.errors.some((error) => error.path === "dispatch/write_rust.md")).toBeTrue();
-    expect(await Bun.file(join(repo, "dispatch/write_rust.md")).text()).toBe("the repository's own file\n");
+    expect(result.errors.some((error) => error.path === ".orly/dispatch/write_rust.md")).toBeTrue();
+    expect(await Bun.file(join(repo, ".orly/dispatch/write_rust.md")).text()).toBe("the repository's own file\n");
     expect(existsSync(join(repo, "AGENTS.md"))).toBe(false);
   });
 
@@ -75,19 +75,19 @@ describe("install", () => {
     const repo = newRepository();
     await Bun.write(join(repo, "src/lib.rs"), "pub fn main() {}\n");
     await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-    await Bun.write(join(repo, "dispatch/write_rust.md"), "hand-edited\n");
+    await Bun.write(join(repo, ".orly/dispatch/write_rust.md"), "hand-edited\n");
 
     const result = await install(model, { targetRoot: repo, force: true, installHooks: true, orlyVersion: "0.4.0" });
 
     expect(result.ok).toBe(true);
-    expect(await Bun.file(join(repo, "dispatch/write_rust.md")).text()).not.toBe("hand-edited\n");
+    expect(await Bun.file(join(repo, ".orly/dispatch/write_rust.md")).text()).not.toBe("hand-edited\n");
   });
 
   test("rejects a target that is not a git repository, naming the fix", async () => {
     const model = await RulesModel.load(ROOT);
     const notARepo = mkdtempSync(join(tmpdir(), "orly-install-not-a-repo-"));
     try {
-      expect(install(model, { targetRoot: notARepo, force: false, installHooks: true, orlyVersion: "0.4.0" })).rejects.toThrow("git init");
+      await expect(install(model, { targetRoot: notARepo, force: false, installHooks: true, orlyVersion: "0.4.0" })).rejects.toThrow("git init");
     } finally {
       rmSync(notARepo, { recursive: true, force: true });
     }
@@ -95,15 +95,15 @@ describe("install", () => {
 
   test("rejects a target directory that does not exist at all", async () => {
     const model = await RulesModel.load(ROOT);
-    expect(install(model, { targetRoot: join(tmpdir(), "orly-install-never-created"), force: false, installHooks: true, orlyVersion: "0.4.0" })).rejects.toThrow("does not exist");
+    await expect(install(model, { targetRoot: join(tmpdir(), "orly-install-never-created"), force: false, installHooks: true, orlyVersion: "0.4.0" })).rejects.toThrow("does not exist");
   });
 
   test("rejects an unknown pack named by the repository's own config, before writing anything", async () => {
     const model = await RulesModel.load(ROOT);
     const repo = newRepository();
-    await Bun.write(join(repo, ".oracle/orly.json"), JSON.stringify({ schema_version: 1, packs: ["language.cobol"], commands: {} }));
+    await Bun.write(join(repo, ".orly/orly.json"), JSON.stringify({ schema_version: 1, packs: ["language.cobol"], commands: {} }));
 
-    expect(install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" })).rejects.toThrow("unknown pack");
+    await expect(install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" })).rejects.toThrow("unknown pack");
     expect(existsSync(join(repo, "AGENTS.md"))).toBe(false);
   });
 
@@ -113,9 +113,9 @@ describe("install", () => {
 
     await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
 
-    expect(gitOutput(repo, "config", "--get", "core.hooksPath")).toBe(".githooks");
+    expect(gitOutput(repo, "config", "--get", "core.hooksPath")).toBe(".orly/hooks");
     for (const hook of ["pre-commit", "pre-push"]) {
-      const text = await Bun.file(join(repo, ".githooks", hook)).text();
+      const text = await Bun.file(join(repo, ".orly/hooks", hook)).text();
       expect(text).toContain("GIT_DIR");
     }
   });
@@ -126,196 +126,10 @@ describe("install", () => {
 
     await install(model, { targetRoot: repo, force: false, installHooks: false, orlyVersion: "0.4.0" });
 
-    expect(existsSync(join(repo, ".githooks"))).toBe(false);
+    expect(existsSync(join(repo, ".orly/hooks"))).toBe(false);
     expect(gitOutput(repo, "config", "--get", "core.hooksPath")).toBe("");
   });
 
-  test("an existing AGENTS.md survives byte for byte and orly lands beside it", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    const theirs = "# Our house rules\n\nAlways run `go vet`. Never touch vendor/.\n";
-    await Bun.write(join(repo, "AGENTS.md"), theirs);
-    await Bun.write(join(repo, "m.go"), "package main\n");
-
-    const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(result.ok).toBe(true);
-    expect(existsSync(join(repo, "AGENTS.orly.md"))).toBe(true);
-    const host = await Bun.file(join(repo, "AGENTS.md")).text();
-    expect(host).toStartWith(theirs.trimEnd());
-    expect(host).toContain("AGENTS.orly.md");
-    // Their file is theirs: orly owns only the block, never the whole file.
-    expect((await readConfig(repo))?.managed).not.toContain("AGENTS.md");
-  });
-
-  test("the orly pointer block is idempotent across repeated installs", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    await Bun.write(join(repo, "AGENTS.md"), "# Ours\n");
-    await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-    const afterFirst = await Bun.file(join(repo, "AGENTS.md")).text();
-
-    const second = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(second.ok).toBe(true);
-    expect(await Bun.file(join(repo, "AGENTS.md")).text()).toBe(afterFirst);
-    expect(afterFirst.split("<!-- orly:begin -->").length - 1).toBe(1);
-  });
-
-  // One layout everywhere, so `update` never asks which mode it is in and a
-  // repository that starts with no rules still has the file to put them in.
-  test("a repository with no AGENTS.md still gets both files", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-
-    await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(await Bun.file(join(repo, "AGENTS.orly.md")).text()).toStartWith("> **Generated by `orly`.**");
-    const host = await Bun.file(join(repo, "AGENTS.md")).text();
-    expect(host).toContain("AGENTS.orly.md");
-    expect(host).toContain("Write this repository's own rules below");
-    expect((await readConfig(repo))?.managed).not.toContain("AGENTS.md");
-  });
-
-  // Anything installed before the split holds orly's render under AGENTS.md.
-  // That content is generated, so replacing it with the stub loses nothing.
-  test("a single-file install migrates to the split without losing a repository line", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    await Bun.write(join(repo, "AGENTS.md"), "> **Generated by `orly`.**\nold single-file layout\n");
-
-    await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    const host = await Bun.file(join(repo, "AGENTS.md")).text();
-    expect(host).not.toContain("old single-file layout");
-    expect(host).toContain("AGENTS.orly.md");
-    expect(await Bun.file(join(repo, "AGENTS.orly.md")).text()).toStartWith("> **Generated by `orly`.**");
-  });
-
-  // Rule pages cite `AGENTS.md` meaning orly's rules — true only where they are
-  // authored. In a consumer that citation has to name the file orly wrote.
-  test("rule pages cite the file orly actually wrote, not the repository's", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    await Bun.write(join(repo, "src/lib.rs"), "pub fn main() {}\n");
-
-    const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(result.ok).toBe(true);
-    const rules = await Bun.file(join(repo, "docs/DOCUMENTATION_RULES.md")).text();
-    expect(rules).not.toContain("](../AGENTS.md)");
-  });
-
-  test("update rewrites orly's file and leaves the repository's own alone", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    await Bun.write(join(repo, "AGENTS.md"), "# Ours\n");
-    await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-    await Bun.write(join(repo, "AGENTS.orly.md"), "hand-edited\n");
-    const host = await Bun.file(join(repo, "AGENTS.md")).text();
-
-    const second = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(second.ok).toBe(true);
-    expect(second.written).toContain("AGENTS.orly.md");
-    expect(await Bun.file(join(repo, "AGENTS.orly.md")).text()).toStartWith("> **Generated by `orly`.**");
-    expect(await Bun.file(join(repo, "AGENTS.md")).text()).toBe(host);
-  });
-
-  test("a hook orly did not write is refused, not clobbered", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    const theirs = "#!/usr/bin/env bash\necho 'our precious hook'\n";
-    await Bun.write(join(repo, ".githooks/pre-commit"), theirs);
-
-    const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(result.ok).toBe(false);
-    expect(result.errors.map((error) => error.path)).toContain(".githooks/pre-commit");
-    expect(await Bun.file(join(repo, ".githooks/pre-commit")).text()).toBe(theirs);
-    // A refusal leaves no footprint: the managed files never landed either.
-    expect(existsSync(join(repo, "AGENTS.md"))).toBe(false);
-  });
-
-  test("generated_hooks_mark_telemetry_invocation", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    await Bun.write(join(repo, ".githooks/pre-commit"), "#!/usr/bin/env bash\necho 'ours'\n");
-
-    const result = await install(model, { targetRoot: repo, force: true, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(result.ok).toBe(true);
-    expect(await Bun.file(join(repo, ".githooks/pre-commit")).text()).toContain("export ORLY_INVOCATION=hook");
-    expect(await Bun.file(join(repo, ".githooks/pre-push")).text()).toContain("export ORLY_INVOCATION=hook");
-  });
-
-  test("--no-hooks installs the rules over an existing hook without touching it", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    const theirs = "#!/usr/bin/env bash\necho 'ours'\n";
-    await Bun.write(join(repo, ".githooks/pre-commit"), theirs);
-
-    const result = await install(model, { targetRoot: repo, force: false, installHooks: false, orlyVersion: "0.4.0" });
-
-    expect(result.ok).toBe(true);
-    expect(await Bun.file(join(repo, ".githooks/pre-commit")).text()).toBe(theirs);
-    expect(existsSync(join(repo, "AGENTS.md"))).toBe(true);
-  });
-
-  test("refuses to retarget a hooksPath already claimed by something else", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    git(repo, "config", "core.hooksPath", "some-other-tools-hooks");
-
-    const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(result.ok).toBe(false);
-    expect(result.errors.some((error) => error.path === "core.hooksPath")).toBe(true);
-    expect(gitOutput(repo, "config", "--get", "core.hooksPath")).toBe("some-other-tools-hooks");
-    expect(existsSync(join(repo, "AGENTS.md"))).toBe(false);
-  });
-
-  test("--no-hooks proceeds even when hooksPath is claimed by something else", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    git(repo, "config", "core.hooksPath", "some-other-tools-hooks");
-
-    const result = await install(model, { targetRoot: repo, force: false, installHooks: false, orlyVersion: "0.4.0" });
-
-    expect(result.ok).toBe(true);
-    expect(gitOutput(repo, "config", "--get", "core.hooksPath")).toBe("some-other-tools-hooks");
-  });
-
-  test("--force retargets a hooksPath claimed by something else", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    git(repo, "config", "core.hooksPath", "some-other-tools-hooks");
-
-    const result = await install(model, { targetRoot: repo, force: true, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(result.ok).toBe(true);
-    expect(gitOutput(repo, "config", "--get", "core.hooksPath")).toBe(".githooks");
-  });
-
-  test("re-running init after it already set hooksPath is not a claim by another tool", async () => {
-    const model = await RulesModel.load(ROOT);
-    const repo = newRepository();
-    await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    const second = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
-
-    expect(second.ok).toBe(true);
-  });
-
-  // Adversarial review, reproduced: a repository the user cloned can commit a
-  // symlink at a path init would otherwise write to. mkdirSync/writeFile/
-  // rename all follow an existing symlink silently — without this refusal,
-  // every managed file materialises through it into wherever the symlink
-  // points, outside the repository entirely, with `ok: true` and no warning.
-  // Adversarial review found this: every other write was guarded, the pointer
-  // host was not, and it is the one write orly aims at a file it does not own.
-  // A committed `AGENTS.md -> ../outside/victim` carried the block out of the
-  // repository and reported a normal success.
   test("refuses when the pointer host is a symlink escaping the target repository", async () => {
     const model = await RulesModel.load(ROOT);
     const repo = newRepository();
@@ -330,7 +144,7 @@ describe("install", () => {
       expect(result.ok).toBe(false);
       expect(result.errors.some((error) => error.message.includes("outside the target repository"))).toBe(true);
       expect(await Bun.file(victim).text()).toBe("PRIVATE\n");
-      expect(existsSync(join(repo, "AGENTS.orly.md"))).toBe(false);
+      expect(existsSync(join(repo, ".orly/AGENTS.md"))).toBe(false);
     } finally {
       rmSync(outside, { recursive: true, force: true });
     }
@@ -346,8 +160,8 @@ describe("install", () => {
     try {
       const victim = join(outside, "hookvictim");
       await Bun.write(victim, "VICTIM\n");
-      mkdirSync(join(repo, ".githooks"), { recursive: true });
-      symlinkSync(victim, join(repo, ".githooks/pre-commit"));
+      mkdirSync(join(repo, ".orly/hooks"), { recursive: true });
+      symlinkSync(victim, join(repo, ".orly/hooks/pre-commit"));
 
       const result = await install(model, { targetRoot: repo, force: true, installHooks: true, orlyVersion: "0.4.0" });
 
@@ -363,7 +177,8 @@ describe("install", () => {
     const repo = newRepository();
     const outside = mkdtempSync(join(tmpdir(), "orly-install-outside-"));
     try {
-      symlinkSync(outside, join(repo, "dispatch"));
+      mkdirSync(join(repo, ".orly"), { recursive: true });
+      symlinkSync(outside, join(repo, ".orly/dispatch"));
 
       const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
 
@@ -381,7 +196,8 @@ describe("install", () => {
     const repo = newRepository();
     const outside = mkdtempSync(join(tmpdir(), "orly-install-outside-hooks-"));
     try {
-      symlinkSync(outside, join(repo, ".githooks"));
+      mkdirSync(join(repo, ".orly"), { recursive: true });
+      symlinkSync(outside, join(repo, ".orly/hooks"));
 
       const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
 
@@ -393,12 +209,12 @@ describe("install", () => {
     }
   });
 
-  test("refuses when the .oracle lock directory path is a symlink escaping the target repository", async () => {
+  test("refuses when the .orly lock directory path is a symlink escaping the target repository", async () => {
     const model = await RulesModel.load(ROOT);
     const repo = newRepository();
     const outside = mkdtempSync(join(tmpdir(), "orly-install-outside-oracle-"));
     try {
-      symlinkSync(outside, join(repo, ".oracle"));
+      symlinkSync(outside, join(repo, ".orly"));
 
       const result = await install(model, { targetRoot: repo, force: false, installHooks: false, orlyVersion: "0.4.0" });
 
@@ -415,7 +231,7 @@ describe("install", () => {
   // boundary, which it cannot do — every install against a target on a
   // different filesystem than $TMPDIR (an external drive, a devcontainer's
   // bind-mounted workspace) hard-crashed with EXDEV. Staging inside the
-  // target's own .oracle/ makes that structurally impossible to reintroduce:
+  // target's own .orly/ makes that structurally impossible to reintroduce:
   // assert no stage directory or leftover ever appears outside the target.
   test("stages inside the target repository, not the OS tmp dir", async () => {
     const model = await RulesModel.load(ROOT);
@@ -430,17 +246,17 @@ describe("install", () => {
   });
 
   // The bug this milestone's own atomicity test caught while fixing the
-  // above: cleaning up an empty .oracle/ on a refused install must not also
-  // fire on the success path, where .oracle/ is legitimately empty for one
+  // above: cleaning up an empty .orly/ on a refused install must not also
+  // fire on the success path, where .orly/ is legitimately empty for one
   // instant before the caller writes orly.json into it.
-  test("a successful install leaves .oracle/ intact for the lock the caller writes next", async () => {
+  test("a successful install leaves .orly/ intact for the lock the caller writes next", async () => {
     const model = await RulesModel.load(ROOT);
     const repo = newRepository();
 
     const result = await install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" });
 
     expect(result.ok).toBe(true);
-    expect(existsSync(join(repo, ".oracle", "orly.json"))).toBe(true);
+    expect(existsSync(join(repo, ".orly", "orly.json"))).toBe(true);
   });
 
   test("the written config records the engine version and every materialised file", async () => {
@@ -453,8 +269,8 @@ describe("install", () => {
     const config = await readConfig(repo);
     expect(config).toBeDefined();
     expect(config?.orly_version).toBe("0.4.0");
-    expect(config?.managed).toContain("dispatch/write_rust.md");
-    expect(config?.managed).toContain(".githooks/pre-commit");
+    expect(config?.managed).toContain(".orly/dispatch/write_rust.md");
+    expect(config?.managed).toContain(".orly/hooks/pre-commit");
   });
 
   test("refuses atomically when a selected pack's file cites a façade no selected pack provides", async () => {
@@ -482,7 +298,7 @@ describe("install", () => {
       expect(result.errors[0]?.message).toContain("missing dispatch reference");
       expect(existsSync(join(repo, "broken.md"))).toBe(false);
       expect(existsSync(join(repo, "AGENTS.md"))).toBe(false);
-      expect(existsSync(join(repo, ".oracle"))).toBe(false);
+      expect(existsSync(join(repo, ".orly"))).toBe(false);
     } finally {
       rmSync(engineRoot, { recursive: true, force: true });
     }
@@ -507,7 +323,7 @@ describe("install", () => {
       const model = new RulesModel(engineRoot, registry);
       const repo = newRepository();
 
-      expect(install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" })).rejects.toThrow("packs disagree on shared.md");
+      await expect(install(model, { targetRoot: repo, force: false, installHooks: true, orlyVersion: "0.4.0" })).rejects.toThrow("packs disagree on shared.md");
     } finally {
       rmSync(engineRoot, { recursive: true, force: true });
     }