chapterhouse 0.3.20 → 0.3.22

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

package/dist/copilot/project-rule-warnings.js

@@ -0,0 +1,73 @@
+const WARNING_CAPABLE_FIELDS = [
+    "auto_pr",
+    "require_worktree",
+    "pr_draft_default",
+    "default_branch",
+    "require_clean_worktree",
+];
+const PR_CREATION_RE = /\b(?:open|create|raise|submit|start)\s+(?:a\s+|the\s+)?(?:(?:non[-\s]?draft|draft|ready[-\s]+for[-\s]+review)\s+)?(?:pull request|pr)\b/i;
+const PR_NEGATION_RE = /\b(?:do not|don't|dont|not|avoid)\s+(?:open|create|raise|submit|start)\s+(?:a\s+|the\s+)?(?:pull request|pr)\b/i;
+const NON_DRAFT_PR_RE = /\b(?:non[-\s]?draft|ready[-\s]+for[-\s]+review)\s+(?:pull request|pr)\b|\b(?:pull request|pr)\b[^.\n]{0,40}\b(?:ready[-\s]+for[-\s]+review|non[-\s]?draft)\b/i;
+const MAIN_CHECKOUT_RE = /\b(?:directly\s+in|from|using|on)\s+the\s+main\s+checkout\b|\bwithout\s+(?:a\s+)?worktree\b|\bskip\s+the\s+worktree\b/i;
+const DIRTY_WORKTREE_RE = /\bdirty\s+(?:worktree|tree)\b|\buncommitted changes\b|\bunclean\s+(?:worktree|tree)\b/i;
+const RISKY_OPERATION_RE = /\b(?:release|ship|publish|deploy|tag|version|bump version|cut a release)\b/i;
+const BRANCH_TARGET_RE = /\b(?:pull request|pr)\b[^.\n]{0,60}\b(?:against|into|onto|target(?:ing)?|base(?:d)? on)\s+([a-z0-9._/-]+)\b/gi;
+const BRANCH_SOURCE_RE = /\b(?:branch|rebase|merge)\b[^.\n]{0,60}\b(?:from|against|into|onto)\s+([a-z0-9._/-]+)\b/gi;
+export function detectProjectRuleWarnings(taskText, hardRules) {
+    const warnings = [];
+    const normalizedTask = normalize(taskText);
+    for (const field of WARNING_CAPABLE_FIELDS) {
+        if (!isRuleViolated(field, normalizedTask, hardRules)) {
+            continue;
+        }
+        warnings.push(formatProjectRuleWarning(field, hardRules[field]));
+    }
+    return warnings;
+}
+function isRuleViolated(field, normalizedTask, hardRules) {
+    switch (field) {
+        case "auto_pr":
+            return hardRules.auto_pr === false
+                && PR_CREATION_RE.test(normalizedTask)
+                && !PR_NEGATION_RE.test(normalizedTask);
+        case "require_worktree":
+            return hardRules.require_worktree === true && MAIN_CHECKOUT_RE.test(normalizedTask);
+        case "pr_draft_default":
+            return hardRules.pr_draft_default === true && NON_DRAFT_PR_RE.test(normalizedTask);
+        case "default_branch":
+            return hasNonDefaultBranchTarget(normalizedTask, hardRules.default_branch);
+        case "require_clean_worktree":
+            return hardRules.require_clean_worktree === true
+                && DIRTY_WORKTREE_RE.test(normalizedTask)
+                && RISKY_OPERATION_RE.test(normalizedTask);
+        default:
+            return false;
+    }
+}
+function hasNonDefaultBranchTarget(taskText, defaultBranch) {
+    const normalizedDefault = defaultBranch.trim().toLowerCase();
+    if (!normalizedDefault) {
+        return false;
+    }
+    return extractExplicitBranches(taskText).some((branch) => branch !== normalizedDefault);
+}
+function extractExplicitBranches(taskText) {
+    const branches = new Set();
+    for (const regex of [BRANCH_TARGET_RE, BRANCH_SOURCE_RE]) {
+        regex.lastIndex = 0;
+        for (const match of taskText.matchAll(regex)) {
+            const branch = match[1]?.trim().toLowerCase();
+            if (branch) {
+                branches.add(branch);
+            }
+        }
+    }
+    return [...branches];
+}
+function formatProjectRuleWarning(field, value) {
+    return `⚠️ Project rule warning: this task may violate \`${field}: ${String(value)}\` — proceeding anyway.`;
+}
+function normalize(taskText) {
+    return taskText.toLowerCase().replace(/\s+/g, " ").trim();
+}
+//# sourceMappingURL=project-rule-warnings.js.map

package/dist/copilot/project-rule-warnings.test.js

@@ -0,0 +1,46 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+function createHardRules(overrides = {}) {
+    return {
+        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,
+        ...overrides,
+    };
+}
+async function loadModule() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    return import(new URL(`./project-rule-warnings.js?case=${nonce}`, import.meta.url).href);
+}
+test("detectProjectRuleWarnings returns ordered warnings for explicit hard-rule conflicts", async () => {
+    const module = await loadModule();
+    assert.deepEqual(module.detectProjectRuleWarnings("Start the refactor directly in the main checkout, open a non-draft PR against develop, and release from the dirty worktree.", createHardRules()), [
+        "⚠️ 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.",
+    ]);
+});
+test("detectProjectRuleWarnings warns for an explicit non-default branch target only", async () => {
+    const module = await loadModule();
+    assert.deepEqual(module.detectProjectRuleWarnings("Create the release branch from develop and target the PR at develop.", createHardRules({
+        auto_pr: true,
+        pr_draft_default: false,
+        require_worktree: false,
+        require_clean_worktree: false,
+    })), [
+        "⚠️ Project rule warning: this task may violate `default_branch: main` — proceeding anyway.",
+    ]);
+});
+test("detectProjectRuleWarnings stays quiet for compliant or ambiguous wording", async () => {
+    const module = await loadModule();
+    assert.deepEqual(module.detectProjectRuleWarnings("Do not open a PR yet. If you change code, use a fresh worktree on main and confirm the tree is clean before any release step.", createHardRules()), []);
+});
+//# sourceMappingURL=project-rule-warnings.test.js.map

package/dist/copilot/project-rules-injection.js

@@ -0,0 +1,71 @@
+import { loadRegistry } from "../wiki/project-registry.js";
+import { loadProjectRules, } from "../wiki/project-rules.js";
+import { resolveProject } from "./project-resolution.js";
+const PROJECT_RULE_HARD_FIELD_ORDER = [
+    "auto_pr",
+    "require_worktree",
+    "pr_draft_default",
+    "default_branch",
+    "commit_co_author",
+    "test_command",
+    "build_command",
+    "lint_command",
+    "require_clean_worktree",
+];
+export class ActiveProjectRulesLoadError extends Error {
+    slug;
+    constructor(slug, cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        super(message);
+        this.slug = slug;
+        this.name = "ActiveProjectRulesLoadError";
+    }
+}
+export function resolveActiveProjectRules(prompt, projectPath, options) {
+    const registry = (options?.loadRegistry ?? loadRegistry)();
+    const project = resolveProject(prompt, { projectPath }, registry);
+    if (!project) {
+        return null;
+    }
+    let rules;
+    try {
+        rules = (options?.loadProjectRules ?? loadProjectRules)(project.slug);
+    }
+    catch (error) {
+        throw new ActiveProjectRulesLoadError(project.slug, error);
+    }
+    if (!rules.found) {
+        return null;
+    }
+    return {
+        project,
+        rules,
+    };
+}
+export function renderActiveProjectRulesBlock(slug, registryPath, rulesPath, hardRules, softRules) {
+    return renderProjectRulesBlock("## Active Project Rules", "These rules are advisory. If a planned action may violate a hard rule, emit a visible warning and proceed unless the user says otherwise.", slug, registryPath, rulesPath, hardRules, softRules);
+}
+export function renderDelegatedProjectRulesPreamble(slug, registryPath, rulesPath, hardRules, softRules) {
+    return renderProjectRulesBlock("Project rules for this task:", "These rules are advisory. If this task may violate a hard rule, include a visible warning in your preamble and continue.", slug, registryPath, rulesPath, hardRules, softRules);
+}
+function renderProjectRulesBlock(heading, advisoryLine, slug, registryPath, rulesPath, hardRules, softRules) {
+    const lines = [
+        heading,
+        "",
+        `Project: ${slug}`,
+        `Registry path: ${registryPath}`,
+        `Rules page: ${rulesPath}`,
+        "",
+        "Hard rules:",
+        ...PROJECT_RULE_HARD_FIELD_ORDER.map((field) => `- ${field}: ${String(hardRules[field])}`),
+        "",
+        "Soft rules:",
+    ];
+    const normalizedSoftRules = softRules.replace(/\r\n/g, "\n").replace(/\n+$/, "");
+    if (normalizedSoftRules) {
+        lines.push(...normalizedSoftRules.split("\n"));
+    }
+    lines.push("", advisoryLine);
+    return lines.join("\n");
+}
+//# sourceMappingURL=project-rules-injection.js.map

package/dist/copilot/project-rules-injection.test.js

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+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: {},
+    };
+}
+async function loadModule() {
+    const nonce = `${Date.now()}-${Math.random()}`;
+    return import(new URL(`./project-rules-injection.js?case=${nonce}`, import.meta.url).href);
+}
+test("resolveActiveProjectRules prefers an explicit @project mention", async () => {
+    const module = await loadModule();
+    const activeRules = module.resolveActiveProjectRules("@project:chapterhouse inspect the worker task prompt", "/work/docs-site", {
+        loadRegistry: () => ({
+            chapterhouse: "/work/chapterhouse",
+            "docs-site": "/work/docs-site",
+        }),
+        loadProjectRules: () => createLoadedProjectRules(),
+    });
+    assert.deepEqual(activeRules, {
+        project: {
+            slug: "chapterhouse",
+            path: "/work/chapterhouse",
+            source: "mention",
+        },
+        rules: createLoadedProjectRules(),
+    });
+});
+test("resolveActiveProjectRules falls back to the current project path", async () => {
+    const module = await loadModule();
+    const activeRules = module.resolveActiveProjectRules("inspect the worker task prompt", "/work/chapterhouse/src/copilot", {
+        loadRegistry: () => ({
+            chapterhouse: "/work/chapterhouse",
+        }),
+        loadProjectRules: () => createLoadedProjectRules(),
+    });
+    assert.deepEqual(activeRules, {
+        project: {
+            slug: "chapterhouse",
+            path: "/work/chapterhouse",
+            source: "selectedProjectPath",
+        },
+        rules: createLoadedProjectRules(),
+    });
+});
+test("renderDelegatedProjectRulesPreamble matches the PRD wording and field order", async () => {
+    const module = await loadModule();
+    const rules = createLoadedProjectRules();
+    assert.equal(module.renderDelegatedProjectRulesPreamble("chapterhouse", "/home/bjk/projects/chapterhouse", rules.path, rules.hard, rules.soft), "Project rules for this task:\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 this task may violate a hard rule, include a visible warning in your preamble and continue.");
+});
+//# sourceMappingURL=project-rules-injection.test.js.map

package/dist/copilot/tools.agent.test.js

@@ -0,0 +1,214 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+function createActiveProjectRules() {
+    return {
+        project: {
+            slug: "chapterhouse",
+            path: "/home/bjk/projects/chapterhouse",
+            source: "mention",
+        },
+        rules: {
+            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 expectedDelegatedPrompt(task, warningLines = []) {
+    const warningBlock = warningLines.length > 0 ? `${warningLines.join("\n")}\n\n` : "";
+    return warningBlock
+        + "Project rules for this task:\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 this task may violate a hard rule, include a visible warning in your preamble and continue.\n\n"
+        + task;
+}
+async function loadToolsModule(t, options) {
+    const sentPrompts = [];
+    const taskId = options?.taskId ?? `delegated-task-${Date.now()}-${Math.random()}`;
+    const fakeSession = {
+        on: () => () => { },
+        async sendAndWait(request) {
+            sentPrompts.push(request.prompt);
+            return { data: { content: `handled: ${request.prompt}` } };
+        },
+        async destroy() { },
+    };
+    t.mock.module("./orchestrator.js", {
+        namedExports: {
+            getCurrentSourceChannel: () => options?.sourceChannel ?? "web",
+            getCurrentActivityCallback: () => undefined,
+            getCurrentAuthenticatedUser: () => undefined,
+            getLastAuthenticatedUser: () => undefined,
+            getCurrentAuthorizationHeader: () => undefined,
+            getCurrentSessionKey: () => "session-test",
+            getCurrentActiveProjectRules: () => options?.activeProjectRules ?? null,
+            switchSessionModel: async () => { },
+        },
+    });
+    t.mock.module("./agents.js", {
+        namedExports: {
+            getAgentRegistry: () => [{ slug: "coder", name: "Coder", model: "claude-sonnet-4.6" }],
+            getAgent: (name) => name === "coder"
+                ? { slug: "coder", name: "Coder", model: "claude-sonnet-4.6" }
+                : undefined,
+            createEphemeralAgentSession: async () => fakeSession,
+            getAgentSessionStatus: () => ({ tasks: [] }),
+            getActiveTasks: () => [],
+            getTask: () => undefined,
+            registerTask: () => ({
+                taskId,
+                agentSlug: "coder",
+                description: "Show dispatched prompt",
+                status: "running",
+                startedAt: Date.now(),
+                originChannel: options?.sourceChannel ?? "web",
+            }),
+            completeTask: () => { },
+            failTask: () => { },
+            createAgentFile: () => "",
+            removeAgentFile: () => { },
+            loadAgents: () => [],
+        },
+    });
+    const module = await import(new URL(`./tools.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+    return { module, sentPrompts, taskId };
+}
+test.beforeEach(() => {
+    process.env.CHAPTERHOUSE_HOME = mkdtempSync(join(tmpdir(), "chapterhouse-tools-agent-"));
+});
+test.afterEach(async () => {
+    const home = process.env.CHAPTERHOUSE_HOME;
+    if (home) {
+        const dbModule = await import("../store/db.js");
+        dbModule.closeDb();
+        rmSync(home, { recursive: true, force: true });
+    }
+});
+test("delegate_to_agent persists the full dispatched task prompt", async (t) => {
+    const promptText = [
+        "Inspect the /workers route detail pane.",
+        "Return the exact prompt sent to the worker.",
+    ].join("\n");
+    const { module, taskId } = await loadToolsModule(t, {
+        sourceChannel: "chat",
+        taskId: "delegated-task-001",
+    });
+    const tools = module.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "delegate_to_agent");
+    assert.ok(tool, "delegate_to_agent tool should be registered");
+    await tool.handler({
+        agent_name: "coder",
+        summary: "Show dispatched prompt",
+        task: promptText,
+    }, {});
+    const dbModule = await import("../store/db.js");
+    const db = dbModule.getDb();
+    const row = db.prepare(`SELECT description, prompt, session_key, source FROM agent_tasks WHERE task_id = ?`).get(taskId);
+    assert.deepEqual(row, {
+        description: "Show dispatched prompt",
+        prompt: promptText,
+        session_key: "session-test",
+        source: "adhoc",
+    });
+});
+test("delegate_to_agent prepends active project rules to the dispatched task prompt", async (t) => {
+    const { module, sentPrompts } = await loadToolsModule(t, {
+        activeProjectRules: createActiveProjectRules(),
+    });
+    const tools = module.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "delegate_to_agent");
+    assert.ok(tool, "delegate_to_agent tool should be registered");
+    const task = "Inspect the worker task prompt.\nDo not re-resolve @project:docs-site from this text.";
+    await tool.handler({
+        agent_name: "coder",
+        summary: "Show dispatched prompt",
+        task,
+    }, {});
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.deepEqual(sentPrompts, [expectedDelegatedPrompt(task)]);
+});
+test("delegate_to_agent prepends project rule warnings above the dispatched task prompt", async (t) => {
+    const { module, sentPrompts } = await loadToolsModule(t, {
+        activeProjectRules: createActiveProjectRules(),
+    });
+    const tools = module.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "delegate_to_agent");
+    assert.ok(tool, "delegate_to_agent tool should be registered");
+    const task = "Start the refactor directly in the main checkout, open a non-draft PR against develop, and release from the dirty worktree.";
+    await tool.handler({
+        agent_name: "coder",
+        summary: "Show warning preamble",
+        task,
+    }, {});
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.deepEqual(sentPrompts, [expectedDelegatedPrompt(task, expectedWarningLines())]);
+});
+test("delegate_to_agent leaves the prompt unchanged when no active project is resolved", async (t) => {
+    const { module, sentPrompts } = await loadToolsModule(t, {
+        activeProjectRules: null,
+    });
+    const tools = module.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+    });
+    const tool = tools.find((entry) => entry.name === "delegate_to_agent");
+    assert.ok(tool, "delegate_to_agent tool should be registered");
+    const task = "Inspect the worker task prompt without project context.";
+    await tool.handler({
+        agent_name: "coder",
+        summary: "Show dispatched prompt",
+        task,
+    }, {});
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    assert.deepEqual(sentPrompts, [task]);
+});
+//# sourceMappingURL=tools.agent.test.js.map

package/dist/copilot/tools.js

@@ -6,7 +6,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { listSkills, createSkill, removeSkill } from "./skills.js";
 import { config, persistModel } from "../config.js";
-import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, switchSessionModel, } from "./orchestrator.js";
+import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, switchSessionModel, } from "./orchestrator.js";
 import { getRouterConfig, updateRouterConfig } from "./router.js";
 import { ensureWikiStructure, readPage, writePage, deletePage, writeRawSource, assertPagePath } from "../wiki/fs.js";
 import { searchIndex, addToIndex, removeFromIndex, buildIndexEntryForPage } from "../wiki/index-manager.js";
@@ -20,6 +20,8 @@ import { getCategoryDir, topicPagePath, slugify, entityCategories, FLAT_CATEGORI
 import { withWikiWrite } from "../wiki/lock.js";
 import { readWikiPage, teamWikiSync } from "../wiki/team-sync.js";
 import { getAgentRegistry, getAgent, createEphemeralAgentSession, getAgentSessionStatus, getTask, registerTask, completeTask, failTask, createAgentFile, removeAgentFile, loadAgents, } from "./agents.js";
+import { detectProjectRuleWarnings } from "./project-rule-warnings.js";
+import { renderDelegatedProjectRulesPreamble } from "./project-rules-injection.js";
 import { adoGetOkrs, adoOkrSummary, adoUpdateKr } from "../integrations/ado-skill.js";
 import { TeamsNotifier } from "../integrations/teams-notify.js";
 import { TeamPushClient } from "../integrations/team-push.js";
@@ -117,9 +119,18 @@ export function createTools(deps) {
                     return `Failed to create session for @${delegatedSlug}: ${msg}`;
                 }
                 const task = registerTask(delegatedSlug, args.summary, getCurrentSourceChannel());
+                const activeProjectRules = getCurrentActiveProjectRules();
+                const warningLines = activeProjectRules
+                    ? detectProjectRuleWarnings(args.task, activeProjectRules.rules.hard)
+                    : [];
+                const warningBlock = warningLines.length > 0 ? `${warningLines.join("\n")}\n\n` : "";
+                const taskPrompt = activeProjectRules
+                    ? `${warningBlock}${renderDelegatedProjectRulesPreamble(activeProjectRules.project.slug, activeProjectRules.project.path, activeProjectRules.rules.path, activeProjectRules.rules.hard, activeProjectRules.rules.soft)}\n\n${args.task}`
+                    : args.task;
                 // Persist task to DB
                 const db = getDb();
-                db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, status, origin_channel, session_key, source) VALUES (?, ?, ?, 'running', ?, ?, 'adhoc')`).run(task.taskId, delegatedSlug, args.summary, task.originChannel || null, getCurrentSessionKey());
+                db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, prompt, status, origin_channel, session_key, source)
+           VALUES (?, ?, ?, ?, 'running', ?, ?, 'adhoc')`).run(task.taskId, delegatedSlug, args.summary, args.task, task.originChannel || null, getCurrentSessionKey());
                 // Capture the parent's activity callback so the child session can stream
                 // its events back to the originating SSE connection. This survives past
                 // the parent assistant turn — the child runs long after the parent's
@@ -167,7 +178,7 @@ export function createTools(deps) {
                 // Non-blocking: dispatch and return immediately. Session is always destroyed after.
                 (async () => {
                     try {
-                        const result = await session.sendAndWait({ prompt: args.task }, timeoutMs);
+                        const result = await session.sendAndWait({ prompt: taskPrompt }, timeoutMs);
                         const output = result?.data?.content || "No response";
                         completeTask(task.taskId, output);
                         db.prepare(`UPDATE agent_tasks SET status = 'completed', result = ?, completed_at = CURRENT_TIMESTAMP WHERE task_id = ?`).run(output.slice(0, 10000), task.taskId);