chapterhouse 0.3.12 → 0.3.14

package/dist/copilot/hooks.test.js

@@ -1,315 +0,0 @@
-/**
- * Unit tests for src/copilot/hooks.ts
- *
- * Tests per Mal's spec §6:
- *  - One test per hook firing (block cases)
- *  - One test per hook bypass attempt (allow cases)
- *  - Integration: createSessionHooks adapter translates HookPipeline results to SDK format
- */
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert/strict";
-import { HookPipeline } from "@bradygaster/squad-sdk/hooks";
-import { initHookPipeline, getHookPipeline, createSessionHooks, DEFAULT_ALLOWED_PATHS } from "./hooks.js";
-// ---------------------------------------------------------------------------
-// HookPipeline unit tests — directly exercising the squad-sdk class
-// ---------------------------------------------------------------------------
-describe("HookPipeline — file-write guard", () => {
-    it("blocks write to path outside allowlist", async () => {
-        const pipeline = new HookPipeline({ allowedWritePaths: ["src/**"] });
-        const result = await pipeline.runPreToolHooks({
-            toolName: "edit",
-            arguments: { path: "/etc/passwd" },
-            agentName: "test-agent",
-            sessionId: "test-1",
-        });
-        assert.equal(result.action, "block");
-        assert.ok(result.reason?.includes("/etc/passwd"), `reason should mention path, got: ${result.reason}`);
-    });
-    it("allows write to path inside allowlist", async () => {
-        const pipeline = new HookPipeline({ allowedWritePaths: ["src/**"] });
-        const result = await pipeline.runPreToolHooks({
-            toolName: "edit",
-            arguments: { path: "src/copilot/hooks.ts" },
-            agentName: "test-agent",
-            sessionId: "test-1",
-        });
-        assert.equal(result.action, "allow");
-    });
-    it("allows non-write tools regardless of path", async () => {
-        const pipeline = new HookPipeline({ allowedWritePaths: ["src/**"] });
-        const result = await pipeline.runPreToolHooks({
-            toolName: "bash",
-            arguments: { command: "echo hello", path: "/etc/passwd" },
-            agentName: "test-agent",
-            sessionId: "test-1",
-        });
-        // File-write guard only fires on edit/create/write_file/create_file
-        // This will hit the shell restriction instead (echo is safe)
-        assert.ok(result.action === "allow" || result.action === "block");
-        if (result.action === "block") {
-            // Should be shell restriction, not file-write
-            assert.ok(!result.reason?.includes("/etc/passwd"));
-        }
-    });
-});
-describe("HookPipeline — shell command restriction", () => {
-    it("blocks rm -rf", async () => {
-        const pipeline = new HookPipeline({});
-        const result = await pipeline.runPreToolHooks({
-            toolName: "bash",
-            arguments: { command: "rm -rf /important" },
-            agentName: "test-agent",
-            sessionId: "test-2",
-        });
-        assert.equal(result.action, "block");
-        assert.ok(result.reason?.toLowerCase().includes("rm -rf"), `reason should mention rm -rf, got: ${result.reason}`);
-    });
-    it("blocks git push --force", async () => {
-        const pipeline = new HookPipeline({});
-        const result = await pipeline.runPreToolHooks({
-            toolName: "bash",
-            arguments: { command: "git push --force origin main" },
-            agentName: "test-agent",
-            sessionId: "test-2",
-        });
-        assert.equal(result.action, "block");
-        assert.ok(result.reason?.toLowerCase().includes("git push --force"), `reason should mention force push, got: ${result.reason}`);
-    });
-    it("allows safe shell commands", async () => {
-        const pipeline = new HookPipeline({});
-        const result = await pipeline.runPreToolHooks({
-            toolName: "bash",
-            arguments: { command: "npm test" },
-            agentName: "test-agent",
-            sessionId: "test-2",
-        });
-        assert.equal(result.action, "allow");
-    });
-    it("allows non-shell tools regardless of args", async () => {
-        const pipeline = new HookPipeline({});
-        const result = await pipeline.runPreToolHooks({
-            toolName: "read_file",
-            arguments: { command: "rm -rf /" },
-            agentName: "test-agent",
-            sessionId: "test-2",
-        });
-        // Shell restriction only fires on bash/powershell/shell/exec
-        assert.equal(result.action, "allow");
-    });
-});
-describe("HookPipeline — PII scrubber", () => {
-    it("redacts email addresses in tool output", async () => {
-        const pipeline = new HookPipeline({ scrubPii: true });
-        const result = await pipeline.runPostToolHooks({
-            toolName: "bash",
-            arguments: {},
-            result: "User email is brian@example.com and also admin@test.org",
-            agentName: "test-agent",
-            sessionId: "test-3",
-        });
-        assert.ok(typeof result.result === "string" && !result.result.includes("brian@example.com"), `Email should be redacted, got: ${result.result}`);
-        assert.ok(typeof result.result === "string" && result.result.includes("[EMAIL_REDACTED]"), `Should contain redaction marker, got: ${result.result}`);
-    });
-    it("passes through clean output unchanged", async () => {
-        const pipeline = new HookPipeline({ scrubPii: true });
-        const original = "Build succeeded. 405 tests passed.";
-        const result = await pipeline.runPostToolHooks({
-            toolName: "bash",
-            arguments: {},
-            result: original,
-            agentName: "test-agent",
-            sessionId: "test-3",
-        });
-        assert.equal(result.result, original);
-    });
-    it("does not scrub when scrubPii is false", async () => {
-        const pipeline = new HookPipeline({ scrubPii: false });
-        const original = "Email: test@example.com";
-        const result = await pipeline.runPostToolHooks({
-            toolName: "bash",
-            arguments: {},
-            result: original,
-            agentName: "test-agent",
-            sessionId: "test-3",
-        });
-        assert.equal(result.result, original);
-    });
-});
-describe("HookPipeline — reviewer lockout", () => {
-    it("blocks locked-out agent from editing artifact", async () => {
-        const pipeline = new HookPipeline({ reviewerLockout: true });
-        pipeline.getReviewerLockout().lockout("src/auth.ts", "kaylee");
-        const result = await pipeline.runPreToolHooks({
-            toolName: "edit",
-            arguments: { path: "src/auth.ts" },
-            agentName: "kaylee",
-            sessionId: "test-4",
-        });
-        assert.equal(result.action, "block");
-        assert.ok(result.reason?.includes("kaylee"), `reason should name agent, got: ${result.reason}`);
-    });
-    it("allows non-locked-out agent to edit same artifact", async () => {
-        const pipeline = new HookPipeline({ reviewerLockout: true, allowedWritePaths: ["src/**"] });
-        pipeline.getReviewerLockout().lockout("src/auth.ts", "kaylee");
-        const result = await pipeline.runPreToolHooks({
-            toolName: "edit",
-            arguments: { path: "src/auth.ts" },
-            agentName: "zoe",
-            sessionId: "test-4",
-        });
-        assert.equal(result.action, "allow");
-    });
-    it("allows locked-out agent to edit different artifact", async () => {
-        const pipeline = new HookPipeline({ reviewerLockout: true, allowedWritePaths: ["src/**"] });
-        pipeline.getReviewerLockout().lockout("src/auth.ts", "kaylee");
-        const result = await pipeline.runPreToolHooks({
-            toolName: "edit",
-            arguments: { path: "src/copilot/hooks.ts" },
-            agentName: "kaylee",
-            sessionId: "test-4",
-        });
-        assert.equal(result.action, "allow");
-    });
-});
-// ---------------------------------------------------------------------------
-// initHookPipeline / getHookPipeline — singleton lifecycle
-// ---------------------------------------------------------------------------
-describe("initHookPipeline", () => {
-    it("initializes the singleton pipeline", () => {
-        const p = initHookPipeline();
-        assert.ok(p instanceof HookPipeline);
-        assert.equal(getHookPipeline(), p);
-    });
-    it("reinitializes on second call (returns new instance)", () => {
-        const first = initHookPipeline();
-        const second = initHookPipeline();
-        assert.ok(second instanceof HookPipeline);
-        // Both are valid instances; the singleton points to the latest
-        assert.equal(getHookPipeline(), second);
-    });
-    it("respects policy overrides", async () => {
-        // Override: disable PII scrubbing
-        initHookPipeline({ scrubPii: false });
-        const p = getHookPipeline();
-        const result = await p.runPostToolHooks({
-            toolName: "bash",
-            arguments: {},
-            result: "email: test@example.com",
-            agentName: "test-agent",
-            sessionId: "test-5",
-        });
-        // With scrubPii: false, email is NOT redacted
-        assert.equal(result.result, "email: test@example.com");
-    });
-});
-// ---------------------------------------------------------------------------
-// createSessionHooks — adapter tests (SDK interface bridging)
-// ---------------------------------------------------------------------------
-describe("createSessionHooks", () => {
-    before(() => {
-        // Fresh pipeline with defaults for adapter tests
-        initHookPipeline({
-            allowedWritePaths: DEFAULT_ALLOWED_PATHS,
-            scrubPii: true,
-            reviewerLockout: true,
-        });
-    });
-    const fakeInvocation = { sessionId: "adapter-test-session" };
-    it("returns deny for blocked write (SDK adapter output)", async () => {
-        const hooks = createSessionHooks("test-agent");
-        const result = await hooks.onPreToolUse({
-            toolName: "edit",
-            toolArgs: { path: "/etc/passwd" },
-            timestamp: Date.now(),
-            cwd: process.cwd(),
-        }, fakeInvocation);
-        assert.ok(result, "Should return a result object");
-        assert.equal(result.permissionDecision, "deny");
-        assert.ok(result.permissionDecisionReason?.includes("[BLOCKED]"), `reason should start with [BLOCKED], got: ${result.permissionDecisionReason}`);
-    });
-    it("returns undefined (allow) for safe write inside default paths", async () => {
-        const hooks = createSessionHooks("test-agent");
-        const result = await hooks.onPreToolUse({
-            toolName: "edit",
-            toolArgs: { path: "src/copilot/hooks.ts" },
-            timestamp: Date.now(),
-            cwd: process.cwd(),
-        }, fakeInvocation);
-        // Allowed — should return void/undefined
-        assert.ok(result == null || result.permissionDecision !== "deny");
-    });
-    it("returns deny for blocked shell command", async () => {
-        const hooks = createSessionHooks("test-agent");
-        const result = await hooks.onPreToolUse({
-            toolName: "bash",
-            toolArgs: { command: "rm -rf /" },
-            timestamp: Date.now(),
-            cwd: process.cwd(),
-        }, fakeInvocation);
-        assert.ok(result, "Should return a result object");
-        assert.equal(result.permissionDecision, "deny");
-    });
-    it("strips CWD prefix from absolute paths before hook check", async () => {
-        const hooks = createSessionHooks("test-agent");
-        const absPath = `${process.cwd()}/src/copilot/hooks.ts`;
-        const result = await hooks.onPreToolUse({
-            toolName: "edit",
-            toolArgs: { path: absPath },
-            timestamp: Date.now(),
-            cwd: process.cwd(),
-        }, fakeInvocation);
-        // After stripping CWD, "src/copilot/hooks.ts" matches "src/**" → allow
-        assert.ok(result == null || result.permissionDecision !== "deny", "Absolute path within project should be allowed");
-    });
-    it("scrubs PII from tool output via onPostToolUse adapter", async () => {
-        const hooks = createSessionHooks("test-agent");
-        const fakeToolResult = {
-            textResultForLlm: "Contact admin@example.com for support",
-            resultType: "success",
-        };
-        const result = await hooks.onPostToolUse({
-            toolName: "bash",
-            toolArgs: {},
-            toolResult: fakeToolResult,
-            timestamp: Date.now(),
-            cwd: process.cwd(),
-        }, fakeInvocation);
-        assert.ok(result, "Should return a modified result");
-        assert.ok(result.modifiedResult?.textResultForLlm.includes("[EMAIL_REDACTED]"), `Should redact email, got: ${result.modifiedResult?.textResultForLlm}`);
-    });
-    it("returns undefined from onPostToolUse when nothing to scrub", async () => {
-        const hooks = createSessionHooks("test-agent");
-        const fakeToolResult = {
-            textResultForLlm: "All 405 tests passed.",
-            resultType: "success",
-        };
-        const result = await hooks.onPostToolUse({
-            toolName: "bash",
-            toolArgs: {},
-            toolResult: fakeToolResult,
-            timestamp: Date.now(),
-            cwd: process.cwd(),
-        }, fakeInvocation);
-        // No PII → no modification → return undefined
-        assert.ok(result == null, "Should return undefined when no scrubbing needed");
-    });
-    it("uses per-agent allowedPaths when provided", async () => {
-        // Agent restricted to .squad/** only
-        const hooks = createSessionHooks("restricted-agent", [".squad/**"]);
-        const result = await hooks.onPreToolUse({
-            toolName: "edit",
-            toolArgs: { path: "src/copilot/hooks.ts" },
-            timestamp: Date.now(),
-            cwd: process.cwd(),
-        }, fakeInvocation);
-        // src/** is in DEFAULT_ALLOWED_PATHS (global) but NOT in restricted agent's paths
-        // The per-agent check runs first and should block it
-        assert.ok(result, "Should return a result object");
-        assert.equal(result.permissionDecision, "deny");
-    });
-    after(() => {
-        // Restore default pipeline for any tests that follow
-        initHookPipeline();
-    });
-});
-//# sourceMappingURL=hooks.test.js.map

package/dist/copilot/squad-event-bus.js

@@ -1,27 +0,0 @@
-/**
- * Process-scoped singleton EventBus for squad agent lifecycle events.
- *
- * The SDK `EventBus` is a plain class — no hidden global state. We own
- * the singleton here so the entire daemon process shares one bus. All
- * code that emits or subscribes to squad events imports from this module.
- *
- * Cross-project reach: NOT supported with a single bus instance. Requires
- * the SDK's WS bridge (`startWSBridge`) or a shared IPC channel. Out of
- * scope for #101 — see mal-101-architecture.md §Forward Implications.
- *
- * Exported event types mirror `SquadEventPayloadMap` from the SDK:
- *   session:created      — sub-agent spawned
- *   session:idle         — sub-agent waiting / between turns
- *   session:error        — sub-agent failed
- *   session:destroyed    — sub-agent finished (reason: complete | error | abort)
- *   session:tool_call    — tool invoked (resultType undefined=start, defined=end)
- *   agent:milestone      — model fallback / exhaustion
- *   coordinator:routing  — coordinator routing decision phases
- *   pool:health          — session pool stats
- *
- * @module copilot/squad-event-bus
- */
-import { EventBus } from "@bradygaster/squad-sdk/runtime/event-bus";
-/** Process-level singleton. Import this everywhere instead of newing EventBus. */
-export const squadEventBus = new EventBus();
-//# sourceMappingURL=squad-event-bus.js.map

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

@@ -1,168 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-const fixtureProjectRoot = `${process.cwd()}/src/test/fixtures/mock-squad-repo`;
-async function loadToolsModule(t, state) {
-    const fakeSession = {
-        on() {
-            return () => { };
-        },
-        async sendAndWait() {
-            return { data: { content: "Squad result" } };
-        },
-        async destroy() { },
-    };
-    t.mock.module("../config.js", {
-        namedExports: {
-            config: {
-                workerTimeoutMs: 1_000,
-                chapterhouseMode: "personal",
-                adoPat: "",
-                squadEnabled: true,
-                copilotModel: "claude-sonnet-4.6",
-            },
-            persistModel: () => { },
-        },
-    });
-    t.mock.module("./orchestrator.js", {
-        namedExports: {
-            getCurrentSourceChannel: () => "web",
-            getCurrentActivityCallback: () => undefined,
-            getCurrentAuthenticatedUser: () => undefined,
-            getLastAuthenticatedUser: () => undefined,
-            getCurrentAuthorizationHeader: () => undefined,
-            getCurrentChannelKey: () => "conn-squad",
-            getCurrentSessionKey: () => "default",
-            switchSessionModel: async () => { },
-        },
-    });
-    t.mock.module("./agents.js", {
-        namedExports: {
-            getAgentRegistry: () => [{ slug: "coder" }, { slug: "designer" }],
-            getAgent: () => undefined,
-            createEphemeralAgentSession: async () => {
-                throw new Error("should not create a Chapterhouse registry agent session");
-            },
-            createSquadAgentSession: async (slug, _client, allTools, systemMessagePrefix, modelOverride) => {
-                state.createSquadSessionCalls.push({
-                    slug,
-                    toolNames: allTools.map((tool) => tool.name),
-                    systemMessagePrefix,
-                    modelOverride,
-                });
-                return fakeSession;
-            },
-            getAgentSessionStatus: () => ({ taskCount: 0, tasks: [] }),
-            getActiveTasks: () => [],
-            getTask: () => undefined,
-            registerTask: (agentSlug, description, originChannel) => ({
-                taskId: "task-squad-1",
-                agentSlug,
-                description,
-                status: "running",
-                startedAt: Date.now(),
-                originChannel,
-            }),
-            completeTask: () => { },
-            failTask: () => { },
-            createAgentFile: () => null,
-            removeAgentFile: () => null,
-            loadAgents: () => [],
-        },
-    });
-    t.mock.module("../squad/context.js", {
-        namedExports: {
-            getChannelProject: () => fixtureProjectRoot,
-        },
-    });
-    t.mock.module("../squad/registry.js", {
-        namedExports: {
-            findSquadAgent: (_projectRoot, mention) => mention === "ripley"
-                ? {
-                    slug: "ripley",
-                    mention: "@ripley",
-                    role: "Lead",
-                    charterPath: `${fixtureProjectRoot}/.squad/agents/ripley/charter.md`,
-                    origin: "project-squad",
-                }
-                : null,
-        },
-    });
-    t.mock.module("../squad/charter.js", {
-        namedExports: {
-            buildSquadSystemPrefix: (context, descriptor) => {
-                state.charterCalls.push({ projectRoot: context.projectRoot, slug: descriptor.slug });
-                return "SQUAD SYSTEM PREFIX";
-            },
-        },
-    });
-    t.mock.module("../squad/mirror.js", {
-        namedExports: {
-            mirrorDecisionToWiki: async (link, taskSummary, resultSummary) => {
-                state.mirrorCalls.push({ link, taskSummary, resultSummary });
-                return "pages/projects/mock-squad-repo/decisions.md";
-            },
-            syncDecisionsFileToWiki: async (_projectRoot) => null,
-        },
-    });
-    t.mock.module("../store/db.js", {
-        namedExports: {
-            getDb: () => ({
-                prepare: (sql) => ({
-                    run: (...args) => {
-                        state.dbWrites.push({ sql, args });
-                        return {};
-                    },
-                    get: () => undefined,
-                    all: () => [],
-                }),
-            }),
-            getState: () => undefined,
-            setState: () => { },
-            logConversation: () => { },
-        },
-    });
-    t.mock.module("../wiki/team-sync.js", {
-        namedExports: {
-            readWikiPage: async () => undefined,
-            teamWikiSync: {
-                isEnabled: () => false,
-                syncAll: async () => { },
-            },
-        },
-    });
-    return await import(new URL(`./tools.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
-}
-test("delegate_to_agent routes squad virtual agents with charter injection and mirrors results", async (t) => {
-    const state = {
-        taskCompleteCalls: [],
-        createSquadSessionCalls: [],
-        charterCalls: [],
-        mirrorCalls: [],
-        dbWrites: [],
-    };
-    const toolsModule = await loadToolsModule(t, state);
-    const tools = toolsModule.createTools({
-        client: {},
-        onAgentTaskComplete: (taskId, agentSlug, result) => {
-            state.taskCompleteCalls.push({ taskId, agentSlug, result });
-        },
-    });
-    const delegateTool = tools.find((tool) => tool.name === "delegate_to_agent");
-    assert.ok(delegateTool, "delegate_to_agent should exist");
-    const result = await delegateTool.handler({
-        agent_name: "ripley",
-        task: "Audit the squad routing",
-        summary: "Audit squad routing",
-    }, {});
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    assert.match(String(result), /@ripley/);
-    assert.equal(state.createSquadSessionCalls.length, 1);
-    assert.deepEqual(state.charterCalls, [{ projectRoot: fixtureProjectRoot, slug: "ripley" }]);
-    assert.equal(state.taskCompleteCalls[0]?.result, "Squad result");
-    assert.equal(state.mirrorCalls.length, 1);
-    assert.equal(state.mirrorCalls[0]?.taskSummary, "Audit squad routing");
-    assert.equal(state.mirrorCalls[0]?.resultSummary, "Squad result");
-    assert.ok(state.dbWrites.some((write) => write.sql.includes("INSERT INTO agent_tasks")));
-    assert.ok(state.dbWrites.some((write) => write.sql.includes("squad_task_links")));
-});
-//# sourceMappingURL=tools.squad.test.js.map

package/dist/squad/charter.js

@@ -1,125 +0,0 @@
-import { readFileSync, existsSync } from 'fs';
-/**
- * Read `context.decisionsPath`, return the last `maxChars` characters.
- * Returns an empty string if the file doesn't exist or cannot be read.
- */
-export function readRecentDecisions(context, maxChars = 4000) {
-    try {
-        if (!existsSync(context.decisionsPath))
-            return '';
-        const content = readFileSync(context.decisionsPath, 'utf-8');
-        if (content.length <= maxChars)
-            return content;
-        return content.slice(content.length - maxChars);
-    }
-    catch {
-        return '';
-    }
-}
-/**
- * Build the system prefix that is prepended to a squad agent's system prompt.
- * Includes the project context, the agent's charter, and recent decisions.
- */
-export function buildSquadSystemPrefix(context, agent) {
-    let charter = '';
-    try {
-        charter = readFileSync(agent.charterPath, 'utf-8');
-    }
-    catch { /* non-fatal */ }
-    const decisions = readRecentDecisions(context) || '(none)';
-    return [
-        '## Squad project context',
-        `Project root: ${context.projectRoot}`,
-        `Squad dir: ${context.squadDir}`,
-        '',
-        '## Agent charter',
-        charter,
-        '',
-        '## Recent squad decisions',
-        decisions,
-    ].join('\n');
-}
-/**
- * Build the delegation task prompt that is sent to a squad agent when Chapterhouse
- * delegates work on behalf of the user.
- */
-export function buildSquadDelegationTask(context, agent, task) {
-    return [
-        `You are ${agent.mention} (${agent.role}) working on project: ${context.projectRoot}`,
-        '',
-        task,
-    ].join('\n');
-}
-/**
- * Build the system message for a Squad Coordinator session attached to a specific project.
- *
- * Resolution order for coordinator instructions:
- *   1. ${projectRoot}/.github/agents/squad.agent.md
- *   2. ${projectRoot}/squad.agent.md
- * Throws if neither is found.
- */
-export async function getSquadCoordinatorSystemMessage(projectRoot) {
-    // 1. Coordinator instructions
-    const candidatePaths = [
-        `${projectRoot}/.github/agents/squad.agent.md`,
-        `${projectRoot}/squad.agent.md`,
-    ];
-    let agentInstructions;
-    for (const p of candidatePaths) {
-        if (existsSync(p)) {
-            agentInstructions = readFileSync(p, 'utf-8');
-            break;
-        }
-    }
-    if (!agentInstructions) {
-        throw new Error(`Squad coordinator instructions not found in ${projectRoot}. ` +
-            `Expected .github/agents/squad.agent.md or squad.agent.md.`);
-    }
-    // 2. Project charter
-    const teamMdPath = `${projectRoot}/.squad/team.md`;
-    const teamContent = existsSync(teamMdPath)
-        ? readFileSync(teamMdPath, 'utf-8')
-        : '(not found — create .squad/team.md to provide project charter context)';
-    // 3. Identity files — what the team is focused on and what patterns we use
-    const nowMdPath = `${projectRoot}/.squad/identity/now.md`;
-    const nowContent = existsSync(nowMdPath)
-        ? readFileSync(nowMdPath, 'utf-8')
-        : '(not found — create .squad/identity/now.md to share current focus)';
-    const wisdomMdPath = `${projectRoot}/.squad/identity/wisdom.md`;
-    const wisdomContent = existsSync(wisdomMdPath)
-        ? readFileSync(wisdomMdPath, 'utf-8')
-        : '(not found — create .squad/identity/wisdom.md to capture team patterns)';
-    // 4. Recent decisions — last ~4000 chars
-    const decisionsMdPath = `${projectRoot}/.squad/decisions.md`;
-    let decisionsContent = '(no decisions recorded yet)';
-    if (existsSync(decisionsMdPath)) {
-        const raw = readFileSync(decisionsMdPath, 'utf-8');
-        decisionsContent = raw.length > 4000 ? raw.slice(raw.length - 4000) : raw;
-    }
-    return [
-        agentInstructions,
-        '',
-        '## Chapterhouse Project Session Context',
-        '',
-        `- **Project Root:** ${projectRoot}`,
-        `- **Squad Dir:** ${projectRoot}/.squad`,
-        `- **Session Mode:** project (Squad Coordinator)`,
-        '',
-        '## Project Charter',
-        '',
-        teamContent,
-        '',
-        '## Team Current Focus (What We\'re Doing Now)',
-        '',
-        nowContent,
-        '',
-        '## Team Wisdom (Patterns & Lessons)',
-        '',
-        wisdomContent,
-        '',
-        '## Recent Decisions',
-        '',
-        decisionsContent,
-    ].join('\n');
-}
-//# sourceMappingURL=charter.js.map