chapterhouse 0.3.19 → 0.3.21

package/dist/copilot/orchestrator.test.js

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { clearTurnLog, subscribeSession } from "./turn-event-log.js";
 function createFakeClient(state) {
     class FakeSession {
         sessionId = "session-123";
@@ -25,6 +26,9 @@ function createFakeClient(state) {
                     state.pendingReject = reject;
                 });
             }
+            if (state.sendErrorMessage) {
+                throw new Error(state.sendErrorMessage);
+            }
             return { data: { content: state.sendResult } };
         }
         async setModel(model) {
@@ -96,6 +100,9 @@ async function loadOrchestratorModule(t, overrides = {}) {
         ],
         sendResult: "Finished successfully",
         taskEvents: new Map(),
+        projectRegistry: {},
+        resolveProjectArgs: [],
+        loadProjectRulesArgs: [],
         ...overrides,
     };
     const client = createFakeClient(state);
@@ -187,6 +194,25 @@ async function loadOrchestratorModule(t, overrides = {}) {
             getWikiSummary: () => "wiki summary",
         },
     });
+    t.mock.module("../wiki/project-registry.js", {
+        namedExports: {
+            loadRegistry: () => state.projectRegistry,
+        },
+    });
+    t.mock.module("../wiki/project-rules.js", {
+        namedExports: {
+            loadProjectRules: (slug) => {
+                state.loadProjectRulesArgs.push(slug);
+                if (state.projectRulesError) {
+                    throw new Error(state.projectRulesError);
+                }
+                return state.projectRulesResult ?? {
+                    found: false,
+                    path: `pages/projects/${slug}/rules.md`,
+                };
+            },
+        },
+    });
     t.mock.module("../paths.js", {
         namedExports: {
             SESSIONS_DIR: "/sessions",
@@ -242,9 +268,88 @@ async function loadOrchestratorModule(t, overrides = {}) {
         state.healthCheckIntervalMs = delayMs;
         return { ref() { }, unref() { } };
     });
+    t.mock.module("./project-resolution.js", {
+        namedExports: {
+            resolveProject: (message, context, registry) => {
+                state.resolveProjectArgs.push({
+                    message,
+                    context: { ...context },
+                    registry: { ...registry },
+                });
+                return state.resolvedProject ?? null;
+            },
+        },
+    });
     const orchestrator = await import(new URL(`./orchestrator.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
     return { orchestrator, state, client };
 }
+function createLoadedProjectRules() {
+    return {
+        found: true,
+        path: "pages/projects/chapterhouse/rules.md",
+        hard: {
+            auto_pr: false,
+            require_worktree: true,
+            pr_draft_default: true,
+            default_branch: "main",
+            commit_co_author: "Copilot <223556219+Copilot@users.noreply.github.com>",
+            test_command: "npm test",
+            build_command: "npm run build",
+            lint_command: "npm run lint:md",
+            require_clean_worktree: true,
+        },
+        soft: "- Keep tests green.\n- Prefer explicit names.\n",
+        warnings: [],
+        metadata: {},
+    };
+}
+function expectedWarningLines() {
+    return [
+        "⚠️ Project rule warning: this task may violate `auto_pr: false` — proceeding anyway.",
+        "⚠️ Project rule warning: this task may violate `require_worktree: true` — proceeding anyway.",
+        "⚠️ Project rule warning: this task may violate `pr_draft_default: true` — proceeding anyway.",
+        "⚠️ Project rule warning: this task may violate `default_branch: main` — proceeding anyway.",
+        "⚠️ Project rule warning: this task may violate `require_clean_worktree: true` — proceeding anyway.",
+    ];
+}
+function expectedProjectRulesPrompt(userPrompt, warningLines = []) {
+    const warningBlock = warningLines.length > 0 ? `${warningLines.join("\n")}\n\n` : "";
+    return warningBlock
+        + "## Active Project Rules\n\n"
+        + "Project: chapterhouse\n"
+        + "Registry path: /home/bjk/projects/chapterhouse\n"
+        + "Rules page: pages/projects/chapterhouse/rules.md\n\n"
+        + "Hard rules:\n"
+        + "- auto_pr: false\n"
+        + "- require_worktree: true\n"
+        + "- pr_draft_default: true\n"
+        + "- default_branch: main\n"
+        + "- commit_co_author: Copilot <223556219+Copilot@users.noreply.github.com>\n"
+        + "- test_command: npm test\n"
+        + "- build_command: npm run build\n"
+        + "- lint_command: npm run lint:md\n"
+        + "- require_clean_worktree: true\n\n"
+        + "Soft rules:\n"
+        + "- Keep tests green.\n"
+        + "- Prefer explicit names.\n\n"
+        + "These rules are advisory. If a planned action may violate a hard rule, emit a visible warning and proceed unless the user says otherwise.\n\n"
+        + userPrompt;
+}
+function captureSessionEvents(t, sessionKey) {
+    const events = [];
+    const seenTurnIds = new Set();
+    const unsubscribe = subscribeSession(sessionKey, (event) => {
+        events.push(event);
+        seenTurnIds.add(event.turnId);
+    });
+    t.after(() => {
+        unsubscribe();
+        for (const turnId of seenTurnIds) {
+            clearTurnLog(turnId);
+        }
+    });
+    return events;
+}
 test("initOrchestrator falls back to an available model and eagerly creates a session", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t);
     await orchestrator.initOrchestrator(client);
@@ -311,6 +416,222 @@ test("sendToOrchestrator logs both sides, remembers web auth context, and record
     ]);
     assert.equal(state.episodeWrites, 1);
 });
+test("sendToOrchestrator prepends active project rules when @project resolution succeeds", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        routeResults: [
+            {
+                model: "claude-sonnet-4.6",
+                tier: "standard",
+                switched: false,
+                routerMode: "auto",
+            },
+        ],
+        sendResult: "Scoped summary",
+        projectRegistry: {
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+        },
+        resolvedProject: {
+            slug: "chapterhouse",
+            path: "/home/bjk/projects/chapterhouse",
+            source: "mention",
+        },
+        projectRulesResult: createLoadedProjectRules(),
+    });
+    await orchestrator.initOrchestrator(client);
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("@project:chapterhouse summarize the deployment", { type: "web", connectionId: "conn-project" }, (text, done) => {
+            if (done) {
+                resolve(text);
+            }
+        });
+    });
+    assert.equal(final, "Scoped summary");
+    assert.deepEqual(state.routerArgs, [["[via web] @project:chapterhouse summarize the deployment", "claude-sonnet-4.6", []]]);
+    assert.deepEqual(state.resolveProjectArgs, [{
+            message: "[via web] @project:chapterhouse summarize the deployment",
+            context: {
+                projectPath: undefined,
+            },
+            registry: {
+                chapterhouse: "/home/bjk/projects/chapterhouse",
+            },
+        }]);
+    assert.deepEqual(state.loadProjectRulesArgs, ["chapterhouse"]);
+    assert.deepEqual(state.sessionPrompts, [{
+            prompt: expectedProjectRulesPrompt("[via web] @project:chapterhouse summarize the deployment"),
+        }]);
+});
+test("sendToOrchestrator prepends active project rules when the web project path resolves a project", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        routeResults: [
+            {
+                model: "claude-sonnet-4.6",
+                tier: "standard",
+                switched: false,
+                routerMode: "auto",
+            },
+        ],
+        sendResult: "Path summary",
+        projectRegistry: {
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+        },
+        resolvedProject: {
+            slug: "chapterhouse",
+            path: "/home/bjk/projects/chapterhouse",
+            source: "selectedProjectPath",
+        },
+        projectRulesResult: createLoadedProjectRules(),
+    });
+    await orchestrator.initOrchestrator(client);
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("summarize the deployment", { type: "web", connectionId: "conn-path", projectPath: "/home/bjk/projects/chapterhouse/src/copilot" }, (text, done) => {
+            if (done) {
+                resolve(text);
+            }
+        });
+    });
+    assert.equal(final, "Path summary");
+    assert.deepEqual(state.resolveProjectArgs, [{
+            message: "[via web] summarize the deployment",
+            context: {
+                projectPath: "/home/bjk/projects/chapterhouse/src/copilot",
+            },
+            registry: {
+                chapterhouse: "/home/bjk/projects/chapterhouse",
+            },
+        }]);
+    assert.deepEqual(state.loadProjectRulesArgs, ["chapterhouse"]);
+    assert.deepEqual(state.sessionPrompts, [{
+            prompt: expectedProjectRulesPrompt("[via web] summarize the deployment"),
+        }]);
+});
+test("sendToOrchestrator surfaces project rule warnings before the orchestrator response", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        routeResults: [
+            {
+                model: "claude-sonnet-4.6",
+                tier: "standard",
+                switched: false,
+                routerMode: "auto",
+            },
+        ],
+        sendResult: "Working on it",
+        projectRegistry: {
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+        },
+        resolvedProject: {
+            slug: "chapterhouse",
+            path: "/home/bjk/projects/chapterhouse",
+            source: "mention",
+        },
+        projectRulesResult: createLoadedProjectRules(),
+    });
+    await orchestrator.initOrchestrator(client);
+    const callbackStates = [];
+    const prompt = "@project:chapterhouse start the refactor directly in the main checkout, open a non-draft PR against develop, and release from the dirty worktree";
+    const warningBlock = `${expectedWarningLines().join("\n")}\n\n`;
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator(prompt, { type: "web", connectionId: "conn-warning" }, (text, done) => {
+            callbackStates.push({ text, done });
+            if (done) {
+                resolve(text);
+            }
+        });
+    });
+    assert.equal(final, `${warningBlock}Working on it`);
+    assert.deepEqual(callbackStates, [
+        { text: warningBlock, done: false },
+        { text: `${warningBlock}Working on it`, done: true },
+    ]);
+    assert.deepEqual(state.sessionPrompts, [{
+            prompt: expectedProjectRulesPrompt(`[via web] ${prompt}`, expectedWarningLines()),
+        }]);
+});
+test("sendToOrchestrator leaves the prompt unchanged when no project resolves", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        routeResults: [
+            {
+                model: "claude-sonnet-4.6",
+                tier: "standard",
+                switched: false,
+                routerMode: "auto",
+            },
+        ],
+        sendResult: "No rules",
+        projectRegistry: {
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+        },
+        resolvedProject: null,
+    });
+    await orchestrator.initOrchestrator(client);
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("summarize the deployment", { type: "web", connectionId: "conn-no-project" }, (text, done) => {
+            if (done) {
+                resolve(text);
+            }
+        });
+    });
+    assert.equal(final, "No rules");
+    assert.deepEqual(state.loadProjectRulesArgs, []);
+    assert.deepEqual(state.sessionPrompts, [{
+            prompt: "[via web] summarize the deployment",
+        }]);
+});
+test("sendToOrchestrator leaves the prompt unchanged when loading project rules fails", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        routeResults: [
+            {
+                model: "claude-sonnet-4.6",
+                tier: "standard",
+                switched: false,
+                routerMode: "auto",
+            },
+        ],
+        sendResult: "No rules",
+        projectRegistry: {
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+        },
+        resolvedProject: {
+            slug: "chapterhouse",
+            path: "/home/bjk/projects/chapterhouse",
+            source: "mention",
+        },
+        projectRulesError: "invalid frontmatter",
+    });
+    await orchestrator.initOrchestrator(client);
+    const final = await new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("@project:chapterhouse summarize the deployment", { type: "web", connectionId: "conn-project" }, (text, done) => {
+            if (done) {
+                resolve(text);
+            }
+        });
+    });
+    assert.equal(final, "No rules");
+    assert.deepEqual(state.loadProjectRulesArgs, ["chapterhouse"]);
+    assert.deepEqual(state.sessionPrompts, [{
+            prompt: "[via web] @project:chapterhouse summarize the deployment",
+        }]);
+});
 test("@mentions route through the orchestrator session without invoking the model router", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         config: {
@@ -340,8 +661,10 @@ test("feedAgentResult injects a background completion turn and proactively notif
             selfEditEnabled: true,
         },
         sendResult: "Agent complete",
+        taskSessionKeys: new Map([["task-9", "chat:bg-lifecycle"]]),
     });
     await orchestrator.initOrchestrator(client);
+    const events = captureSessionEvents(t, "chat:bg-lifecycle");
     const notified = new Promise((resolve) => {
         orchestrator.setProactiveNotify(resolve);
     });
@@ -362,6 +685,57 @@ test("feedAgentResult injects a background completion turn and proactively notif
             source: "background",
         },
     ]);
+    const started = events.filter((event) => event.type === "turn:started");
+    const completed = events.filter((event) => event.type === "turn:complete");
+    assert.equal(started.length, 1, "background turn should emit one turn:started event");
+    assert.equal(completed.length, 1, "background turn should emit one turn:complete event");
+    assert.equal(started[0]?.turnId, completed[0]?.turnId, "background lifecycle events must share the same turnId");
+});
+test("enqueueForSse emits exactly one turn lifecycle pair for sse-web turns", async (t) => {
+    const { orchestrator, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        sendResult: "SSE complete",
+    });
+    await orchestrator.initOrchestrator(client);
+    const sessionKey = `chat:sse-lifecycle-${Date.now()}`;
+    const events = captureSessionEvents(t, sessionKey);
+    const turnId = orchestrator.enqueueForSse({ sessionKey, prompt: "hello from sse" });
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    const turnEvents = events.filter((event) => event.turnId === turnId);
+    const started = turnEvents.filter((event) => event.type === "turn:started");
+    const completed = turnEvents.filter((event) => event.type === "turn:complete");
+    assert.equal(started.length, 1, "sse-web turn should emit turn:started exactly once");
+    assert.equal(completed.length, 1, "sse-web turn should emit turn:complete exactly once");
+});
+test("sendToOrchestrator emits turn:error instead of turn:complete on failures", async (t) => {
+    const { orchestrator, client } = await loadOrchestratorModule(t, {
+        config: {
+            copilotModel: "claude-sonnet-4.6",
+            selfEditEnabled: true,
+        },
+        sendErrorMessage: "session exploded",
+        sendResult: "unreachable",
+    });
+    await orchestrator.initOrchestrator(client);
+    const sessionKey = `chat:error-lifecycle-${Date.now()}`;
+    const events = captureSessionEvents(t, sessionKey);
+    const received = new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("trigger an error", { type: "background", sessionKey }, (text, done, turnId) => {
+            if (done) {
+                resolve({ text, done, turnId });
+            }
+        });
+    });
+    const result = await received;
+    assert.match(result.text, /^Error:/);
+    const turnEvents = events.filter((event) => event.turnId === result.turnId);
+    const errors = turnEvents.filter((event) => event.type === "turn:error");
+    const completed = turnEvents.filter((event) => event.type === "turn:complete");
+    assert.equal(errors.length, 1, "failed turn should emit one turn:error event");
+    assert.equal(completed.length, 0, "failed turn must not emit turn:complete");
 });
 test("cancelCurrentMessage aborts the active request and agent helpers expose running work", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
@@ -606,10 +980,18 @@ test("#81: tool.execution_start stash + subagent.started → agent_tasks uses sp
     await new Promise((resolve) => setTimeout(resolve, 10));
     assert.ok(state.lastSession, "FakeSession must have been created");
     // Step 1: emit tool.execution_start for a "task" call with spawn parameters
+    const promptText = [
+        "Investigate why /workers omits the dispatched prompt.",
+        "Return the exact DB column and API response change needed.",
+    ].join("\n");
     state.lastSession.emit("tool.execution_start", {
         toolName: "task",
         toolCallId: "tc-spawn-1",
-        arguments: { name: "kaylee", description: "🔧 Kaylee: test spawn" },
+        arguments: {
+            name: "kaylee",
+            description: "🔧 Kaylee: test spawn",
+            prompt: promptText,
+        },
     });
     // Step 2: emit subagent.started with the same toolCallId — SDK only knows agent_type details
     state.lastSession.emit("subagent.started", {
@@ -623,6 +1005,7 @@ test("#81: tool.execution_start stash + subagent.started → agent_tasks uses sp
     const argsJson = JSON.stringify(insertWrite.args);
     assert.ok(argsJson.includes("kaylee"), `agent_slug must be "kaylee" but got: ${argsJson}`);
     assert.ok(argsJson.includes("🔧 Kaylee: test spawn"), `description must be spawn description but got: ${argsJson}`);
+    assert.ok(insertWrite.args.some((arg) => arg === promptText), `prompt must be persisted from task spawn args but got: ${argsJson}`);
     assert.ok(!argsJson.includes("general-purpose"), `agent_slug must NOT fall back to "general-purpose" when spawn name is available`);
     state.pendingReject?.(new Error("test teardown"));
 });
@@ -810,6 +1193,31 @@ test("#98: interruptCurrentTurn aborts active turn and starts replacement turn",
     state.pendingReject?.(new Error("aborted"));
     await new Promise((resolve) => setTimeout(resolve, 50));
 });
+test("interruptCurrentTurn prepends active project rules to the replacement turn", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+        projectRegistry: {
+            chapterhouse: "/home/bjk/projects/chapterhouse",
+        },
+        projectRulesResult: createLoadedProjectRules(),
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("first long request", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    state.resolvedProject = {
+        slug: "chapterhouse",
+        path: "/home/bjk/projects/chapterhouse",
+        source: "mention",
+    };
+    await orchestrator.interruptCurrentTurn("default", "@project:chapterhouse replacement request", { type: "background" }, () => { });
+    state.sendResult = "replacement complete";
+    state.pendingReject?.(new Error("aborted"));
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    assert.deepEqual(state.sessionPrompts, [
+        { prompt: "first long request" },
+        { prompt: expectedProjectRulesPrompt("@project:chapterhouse replacement request") },
+    ]);
+});
 test("#98: interruptCurrentTurn falls back to normal send when no session is active", async (t) => {
     const { orchestrator, state, client } = await loadOrchestratorModule(t, {
         sendResult: "fallback response",

package/dist/copilot/project-resolution.js

@@ -0,0 +1,73 @@
+import { isAbsolute, normalize, relative, sep } from "node:path";
+const PROJECT_MENTION_RE = /(^|[^@\w-])@project:([a-z0-9][a-z0-9-]*)(?=$|[^A-Za-z0-9_-])/;
+export function extractProjectMention(message) {
+    const match = message.match(PROJECT_MENTION_RE);
+    return match?.[2] ?? null;
+}
+export function resolveProject(message, context, registry) {
+    const explicitSlug = extractProjectMention(message);
+    if (explicitSlug) {
+        const explicitPath = registry[explicitSlug];
+        if (explicitPath) {
+            return {
+                slug: explicitSlug,
+                path: normalizeProjectPath(explicitPath),
+                source: "mention",
+            };
+        }
+    }
+    const selectedProjectPath = context.selectedProjectPath ?? context.projectPath;
+    if (selectedProjectPath) {
+        const selectedMatch = matchProjectPath(selectedProjectPath, registry);
+        if (selectedMatch) {
+            return {
+                ...selectedMatch,
+                source: "selectedProjectPath",
+            };
+        }
+    }
+    if (context.cwd) {
+        const cwdMatch = matchProjectPath(context.cwd, registry);
+        if (cwdMatch) {
+            return {
+                ...cwdMatch,
+                source: "cwd",
+            };
+        }
+    }
+    return null;
+}
+function matchProjectPath(candidatePath, registry) {
+    const normalizedCandidate = normalizeCandidatePath(candidatePath);
+    if (!normalizedCandidate)
+        return null;
+    const entries = Object.entries(registry)
+        .map(([slug, registeredPath]) => ({
+        slug,
+        path: normalizeProjectPath(registeredPath),
+    }))
+        .sort((left, right) => right.path.length - left.path.length || left.slug.localeCompare(right.slug));
+    for (const entry of entries) {
+        if (pathMatches(entry.path, normalizedCandidate)) {
+            return entry;
+        }
+    }
+    return null;
+}
+function pathMatches(projectPath, candidatePath) {
+    const rel = relative(projectPath, candidatePath);
+    return rel === "" || (!rel.startsWith("..") && rel !== ".." && !rel.startsWith(`..${sep}`));
+}
+function normalizeCandidatePath(path) {
+    if (!isAbsolute(path))
+        return null;
+    return normalizeProjectPath(path);
+}
+function normalizeProjectPath(path) {
+    let normalized = normalize(path);
+    while (normalized.length > 1 && normalized.endsWith(sep)) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+//# sourceMappingURL=project-resolution.js.map

package/dist/copilot/project-resolution.test.js

@@ -0,0 +1,124 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadModule() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    return import(new URL(`./project-resolution.js?case=${nonce}`, import.meta.url).href);
+}
+test("extractProjectMention returns the first exact slug mention", async () => {
+    const { extractProjectMention } = await loadModule();
+    assert.equal(extractProjectMention("Please fix this for (@project:docs-site), then circle back to @project:chapterhouse."), "docs-site");
+});
+test("extractProjectMention ignores partial, cased, and embedded mentions", async () => {
+    const { extractProjectMention } = await loadModule();
+    assert.equal(extractProjectMention("email foo@project:docs-site later"), null);
+    assert.equal(extractProjectMention("@project:Docs-Site fix this"), null);
+    assert.equal(extractProjectMention("@project:docs_site fix this"), null);
+});
+test("resolveProject prefers an explicit project mention over path-based matches", async () => {
+    const { resolveProject } = await loadModule();
+    const registry = {
+        chapterhouse: "/work/chapterhouse",
+        "docs-site": "/work/docs-site",
+    };
+    assert.deepEqual(resolveProject("@project:chapterhouse fix the spinner", {
+        selectedProjectPath: "/work/docs-site",
+        cwd: "/work/docs-site",
+    }, registry), {
+        slug: "chapterhouse",
+        path: "/work/chapterhouse",
+        source: "mention",
+    });
+});
+test("resolveProject falls back to the selected project path when an explicit mention is not registered", async () => {
+    const { resolveProject } = await loadModule();
+    const registry = {
+        chapterhouse: "/work/chapterhouse",
+        "docs-site": "/work/docs-site",
+    };
+    assert.deepEqual(resolveProject("@project:missing update the landing page", {
+        selectedProjectPath: "/work/docs-site",
+        cwd: "/work/chapterhouse",
+    }, registry), {
+        slug: "docs-site",
+        path: "/work/docs-site",
+        source: "selectedProjectPath",
+    });
+});
+test("resolveProject treats projectPath as the selected project path signal", async () => {
+    const { resolveProject } = await loadModule();
+    const registry = {
+        chapterhouse: "/work/chapterhouse",
+        "docs-site": "/work/docs-site",
+    };
+    assert.deepEqual(resolveProject("Update the landing page", {
+        projectPath: "/work/docs-site",
+        cwd: "/work/chapterhouse",
+    }, registry), {
+        slug: "docs-site",
+        path: "/work/docs-site",
+        source: "selectedProjectPath",
+    });
+});
+test("resolveProject matches an exact selected project path before cwd", async () => {
+    const { resolveProject } = await loadModule();
+    const registry = {
+        chapterhouse: "/work/chapterhouse",
+        "docs-site": "/work/docs-site",
+    };
+    assert.deepEqual(resolveProject("Update the landing page", {
+        selectedProjectPath: "/work/docs-site",
+        cwd: "/work/chapterhouse",
+    }, registry), {
+        slug: "docs-site",
+        path: "/work/docs-site",
+        source: "selectedProjectPath",
+    });
+});
+test("resolveProject matches descendant paths and picks the longest registered prefix", async () => {
+    const { resolveProject } = await loadModule();
+    const registry = {
+        monorepo: "/work/chapterhouse",
+        web: "/work/chapterhouse/web",
+        docs: "/work/docs",
+    };
+    assert.deepEqual(resolveProject("Fix the UI build", {
+        cwd: "/work/chapterhouse/web/src/routes",
+    }, registry), {
+        slug: "web",
+        path: "/work/chapterhouse/web",
+        source: "cwd",
+    });
+});
+test("resolveProject does not treat sibling prefixes as descendant matches", async () => {
+    const { resolveProject } = await loadModule();
+    const registry = {
+        app: "/work/app",
+    };
+    assert.equal(resolveProject("Fix it", {
+        cwd: "/work/app2/src",
+    }, registry), null);
+});
+test("resolveProject trims trailing slashes before path matching", async () => {
+    const { resolveProject } = await loadModule();
+    const registry = {
+        chapterhouse: "/work/chapterhouse/",
+    };
+    assert.deepEqual(resolveProject("Fix it", {
+        cwd: "/work/chapterhouse/web/",
+    }, registry), {
+        slug: "chapterhouse",
+        path: "/work/chapterhouse",
+        source: "cwd",
+    });
+});
+test("resolveProject returns null when neither message text nor paths resolve to a registered project", async () => {
+    const { resolveProject } = await loadModule();
+    const registry = {
+        chapterhouse: "/work/chapterhouse",
+    };
+    assert.equal(resolveProject("Fix it", {
+        selectedProjectPath: "/work/docs-site",
+        cwd: "/tmp/other",
+    }, registry), null);
+});
+//# sourceMappingURL=project-resolution.test.js.map