chapterhouse 0.3.20 → 0.3.22

package/dist/copilot/orchestrator.js

@@ -19,6 +19,11 @@ import { agentEventBus } from "./agent-event-bus.js";
 import { initTaskEventLog } from "./task-event-log.js";
 import { emitTurnEvent, persistTurnEvents, scheduleClearTurnLog, } from "./turn-event-log.js";
 import { SessionManager, SessionRegistry, SESSION_IDLE_TTL_MS, SESSION_MAX_ACTIVE, } from "./session-manager.js";
+import { ActiveProjectRulesLoadError, renderActiveProjectRulesBlock, } from "./project-rules-injection.js";
+import { detectProjectRuleWarnings } from "./project-rule-warnings.js";
+import { loadRegistry } from "../wiki/project-registry.js";
+import { loadProjectRules } from "../wiki/project-rules.js";
+import { resolveProject } from "./project-resolution.js";
 const log = childLogger("orchestrator");
 const MAX_RETRIES = 3;
 const RECONNECT_DELAYS_MS = [1_000, 3_000, 10_000];
@@ -118,6 +123,9 @@ export function getCurrentChannelKey() {
 export function getCurrentActivityCallback() {
     return turnContextStorage.getStore()?.activityCallback;
 }
+export function getCurrentActiveProjectRules() {
+    return turnContextStorage.getStore()?.activeProjectRules ?? null;
+}
 export function getCurrentAuthenticatedUser() {
     return turnContextStorage.getStore()?.authUser ?? currentAuthenticatedUser;
 }
@@ -360,6 +368,14 @@ export const ORCHESTRATOR_TIMEOUT_MS = (() => {
 async function executeOnSession(manager, item) {
     const { sessionKey } = manager;
     const session = await manager.ensureSession();
+    const activeProjectRules = getActiveProjectRules(item.prompt, item.projectPath);
+    const warningLines = activeProjectRules
+        ? detectProjectRuleWarnings(item.prompt, activeProjectRules.rules.hard)
+        : [];
+    const warningBlock = warningLines.length > 0 ? `${warningLines.join("\n")}\n\n` : "";
+    const sessionPrompt = activeProjectRules
+        ? `${warningBlock}${renderActiveProjectRulesBlock(activeProjectRules.project.slug, activeProjectRules.project.path, activeProjectRules.rules.path, activeProjectRules.rules.hard, activeProjectRules.rules.soft)}\n\n${item.prompt}`
+        : item.prompt;
     // Update last-seen globals (backwards compat — for callers that inspect after a turn ends)
     currentAuthenticatedUser = item.authUser;
     currentAuthorizationHeader = item.authHeader;
@@ -370,6 +386,7 @@ async function executeOnSession(manager, item) {
         authUser: item.authUser,
         authHeader: item.authHeader,
         activityCallback: item.onActivity,
+        activeProjectRules,
     }, async () => {
         let accumulated = "";
         let toolCallExecuted = false;
@@ -386,6 +403,11 @@ async function executeOnSession(manager, item) {
                 spawnArgsMap.set(data.toolCallId, {
                     name: typeof args.name === "string" ? args.name : undefined,
                     description: typeof args.description === "string" ? args.description : undefined,
+                    prompt: typeof args.prompt === "string"
+                        ? args.prompt
+                        : typeof args.task === "string"
+                            ? args.task
+                            : undefined,
                 });
             }
         });
@@ -522,7 +544,12 @@ async function executeOnSession(manager, item) {
                 const description = (typeof spawnArgs?.description === "string"
                     ? spawnArgs.description
                     : data.agentDescription || data.agentDisplayName || `Agent dispatch: ${agentSlug}`).slice(0, 500);
-                db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key, source) VALUES (?, ?, ?, 'running', ?, ?, 'adhoc')`).run(data.toolCallId, agentSlug, description, item.sourceChannel || null, sessionKey);
+                const prompt = typeof spawnArgs?.prompt === "string" ? spawnArgs.prompt : null;
+                db.prepare(`INSERT OR IGNORE INTO agent_tasks (task_id, agent_slug, description, prompt, status, origin_channel, session_key, source)
+             VALUES (?, ?, ?, ?, 'running', ?, ?, 'adhoc')`).run(data.toolCallId, agentSlug, description, prompt, item.sourceChannel || null, sessionKey);
+                if (prompt) {
+                    db.prepare(`UPDATE agent_tasks SET prompt = COALESCE(prompt, ?) WHERE task_id = ?`).run(prompt, data.toolCallId);
+                }
                 activeSubagentTaskIds.add(data.toolCallId);
                 void agentEventBus.emit({
                     type: "session:created",
@@ -662,8 +689,22 @@ async function executeOnSession(manager, item) {
             });
         });
         try {
-            const result = await session.sendAndWait({ prompt: item.prompt, ...(item.attachments && item.attachments.length > 0 ? { attachments: item.attachments } : {}) }, ORCHESTRATOR_TIMEOUT_MS);
-            const finalContent = result?.data?.content || accumulated || "(No response)";
+            if (warningBlock) {
+                accumulated = warningBlock;
+                item.callback(accumulated, false, item.turnId);
+                emitTurnEvent(sessionKey, {
+                    type: "turn:delta",
+                    turnId: item.turnId,
+                    sessionKey,
+                    part: { type: "text", text: warningBlock },
+                });
+            }
+            const result = await session.sendAndWait({ prompt: sessionPrompt, ...(item.attachments && item.attachments.length > 0 ? { attachments: item.attachments } : {}) }, ORCHESTRATOR_TIMEOUT_MS);
+            const streamedContent = warningBlock && accumulated.startsWith(warningBlock)
+                ? accumulated.slice(warningBlock.length)
+                : accumulated;
+            const responseContent = result?.data?.content || streamedContent || "(No response)";
+            const finalContent = warningBlock ? `${warningBlock}${responseContent}` : responseContent;
             return finalContent;
         }
         catch (err) {
@@ -743,6 +784,30 @@ async function processItem(item, manager) {
     lastRouteResult = routeResult;
     return executeOnSession(manager, item);
 }
+function getActiveProjectRules(prompt, projectPath) {
+    const registry = loadRegistry();
+    const project = resolveProject(prompt, { projectPath }, registry);
+    if (!project) {
+        return null;
+    }
+    try {
+        const rules = loadProjectRules(project.slug);
+        if (!rules.found) {
+            return null;
+        }
+        return { project, rules };
+    }
+    catch (err) {
+        if (err instanceof ActiveProjectRulesLoadError || err instanceof Error) {
+            log.warn({
+                slug: err instanceof ActiveProjectRulesLoadError ? err.slug : project.slug,
+                err: err.message,
+            }, "Project rules could not be loaded; continuing without injection");
+            return null;
+        }
+        throw err;
+    }
+}
 function isRecoverableError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     if (/timeout/i.test(msg))
@@ -789,6 +854,7 @@ export async function sendToOrchestrator(prompt, source, callback, attachments,
                 const finalContent = await new Promise((resolve, reject) => {
                     manager.enqueue({
                         prompt: taggedPrompt,
+                        projectPath: source.type === "web" ? source.projectPath : undefined,
                         attachments,
                         callback,
                         // Cast: QueuedMessage.onActivity uses a wide event type to avoid circular
@@ -896,6 +962,7 @@ export async function interruptCurrentTurn(sessionKey, newPrompt, source, callba
                 const finalContent = await new Promise((resolve, reject) => {
                     manager.enqueue({
                         prompt: taggedPrompt,
+                        projectPath: source.type === "web" ? source.projectPath : undefined,
                         attachments,
                         callback,
                         onActivity: onActivity,

package/dist/copilot/orchestrator.test.js

@@ -100,6 +100,9 @@ async function loadOrchestratorModule(t, overrides = {}) {
         ],
         sendResult: "Finished successfully",
         taskEvents: new Map(),
+        projectRegistry: {},
+        resolveProjectArgs: [],
+        loadProjectRulesArgs: [],
         ...overrides,
     };
     const client = createFakeClient(state);
@@ -191,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",
@@ -246,9 +268,73 @@ 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();
@@ -330,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: {
@@ -678,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", {
@@ -695,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"));
 });
@@ -882,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