chapterhouse 0.1.1

package/dist/squad/charter.js

@@ -0,0 +1,108 @@
+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. 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,
+        '',
+        '## Recent Decisions',
+        '',
+        decisionsContent,
+    ].join('\n');
+}
+//# sourceMappingURL=charter.js.map

package/dist/squad/charter.test.js

@@ -0,0 +1,89 @@
+import assert from "node:assert/strict";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const fixtureRoot = join(repoRoot, "src/test/fixtures/mock-squad-repo");
+// Minimal ProjectSquadContext shape that charter functions need
+const ripleyAgent = {
+    slug: "ripley",
+    mention: "@ripley",
+    role: "Lead",
+    charterPath: join(fixtureRoot, ".squad/agents/ripley/charter.md"),
+    origin: "project-squad",
+};
+const mockContext = {
+    projectRoot: fixtureRoot,
+    squadDir: join(fixtureRoot, ".squad"),
+    teamDir: join(fixtureRoot, ".squad"),
+    personalDir: null,
+    mode: "local",
+    projectKey: null,
+    config: {},
+    agents: [
+        ripleyAgent,
+        {
+            slug: "dallas",
+            mention: "@dallas",
+            role: "Backend Dev",
+            charterPath: join(fixtureRoot, ".squad/agents/dallas/charter.md"),
+            origin: "project-squad",
+        },
+    ],
+    decisionsPath: join(fixtureRoot, ".squad/decisions.md"),
+    loadedAt: new Date().toISOString(),
+};
+async function loadCharter() {
+    return await import(new URL(`./charter.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test("buildSquadSystemPrefix includes '## Squad project context' header", async () => {
+    const m = await loadCharter();
+    assert.equal(typeof m.buildSquadSystemPrefix, "function", "buildSquadSystemPrefix should be exported");
+    const result = m.buildSquadSystemPrefix(mockContext, ripleyAgent);
+    assert.ok(typeof result === "string" && result.includes("## Squad project context"), `Expected '## Squad project context' in output, got: ${result.slice(0, 200)}`);
+});
+test("buildSquadSystemPrefix includes the charter file content", async () => {
+    const m = await loadCharter();
+    const result = m.buildSquadSystemPrefix(mockContext, ripleyAgent);
+    // ripley charter contains "Expertise: Architecture"
+    assert.ok(typeof result === "string" && result.includes("Architecture"), `Expected charter content (Expertise: Architecture) in prefix, got: ${result.slice(0, 300)}`);
+});
+test("buildSquadSystemPrefix includes '## Recent squad decisions'", async () => {
+    const m = await loadCharter();
+    const result = m.buildSquadSystemPrefix(mockContext, ripleyAgent);
+    assert.ok(typeof result === "string" && result.includes("## Recent squad decisions"), `Expected '## Recent squad decisions' in output, got: ${result.slice(0, 300)}`);
+});
+test("readRecentDecisions returns decisions.md content for valid context", async () => {
+    const m = await loadCharter();
+    assert.equal(typeof m.readRecentDecisions, "function", "readRecentDecisions should be exported");
+    const result = m.readRecentDecisions(mockContext);
+    assert.ok(typeof result === "string" && result.length > 0, "should return non-empty decisions content");
+    assert.ok(result.includes("Test Decision"), "should include fixture decision content");
+});
+test("readRecentDecisions returns empty string for non-existent decisions.md path", async () => {
+    const m = await loadCharter();
+    const ctxNoDecisions = {
+        ...mockContext,
+        decisionsPath: join(fixtureRoot, ".squad/decisions-DOES-NOT-EXIST.md"),
+    };
+    const result = m.readRecentDecisions(ctxNoDecisions);
+    assert.equal(result, "", "should return empty string when decisions file does not exist");
+});
+test("readRecentDecisions truncates to maxChars limit", async () => {
+    const m = await loadCharter();
+    const result = m.readRecentDecisions(mockContext, 10);
+    assert.ok(typeof result === "string" && result.length <= 10, `result should be at most 10 chars, got ${result.length}: "${result}"`);
+});
+test("buildSquadSystemPrefix handles missing charter file gracefully (no throw)", async () => {
+    const m = await loadCharter();
+    const ghostAgent = {
+        slug: "ghost",
+        mention: "@ghost",
+        role: "Unknown",
+        charterPath: join(fixtureRoot, ".squad/agents/ghost/charter.md"), // does not exist
+        origin: "project-squad",
+    };
+    assert.doesNotThrow(() => {
+        m.buildSquadSystemPrefix(mockContext, ghostAgent);
+    }, "buildSquadSystemPrefix should not throw when charter file is missing");
+});
+//# sourceMappingURL=charter.test.js.map

package/dist/squad/context.js

@@ -0,0 +1,48 @@
+import { homedir } from 'os';
+import { resolve } from 'path';
+// ---------------------------------------------------------------------------
+// Channel → project mapping (in-memory, not persisted)
+// ---------------------------------------------------------------------------
+const channelProjectMap = new Map();
+export function setChannelProject(channelKey, projectRoot) {
+    channelProjectMap.set(channelKey, projectRoot);
+}
+export function getChannelProject(channelKey) {
+    return channelProjectMap.get(channelKey);
+}
+export function clearChannelProject(channelKey) {
+    channelProjectMap.delete(channelKey);
+}
+// ---------------------------------------------------------------------------
+// Path extraction and normalisation
+// ---------------------------------------------------------------------------
+/**
+ * Looks for a `cwd:` prefix or an absolute path (starts with `/` or `~/`) in
+ * the prompt text. Returns the first match, or null if none found.
+ */
+export function extractProjectPathFromPrompt(prompt) {
+    // Explicit cwd: prefix — e.g. "cwd:/home/user/myproject do something"
+    const cwdMatch = prompt.match(/(?:^|\s)cwd:(\S+)/);
+    if (cwdMatch)
+        return normalizeProjectPath(cwdMatch[1]);
+    // Absolute Unix path
+    const absMatch = prompt.match(/(?:^|\s)(\/\S+)/);
+    if (absMatch)
+        return normalizeProjectPath(absMatch[1]);
+    // Home-relative path
+    const homeMatch = prompt.match(/(?:^|\s)(~\/\S+)/);
+    if (homeMatch)
+        return normalizeProjectPath(homeMatch[1]);
+    return null;
+}
+/**
+ * Resolves `~` to the home directory and then calls `path.resolve` to get an
+ * absolute, normalised path.
+ */
+export function normalizeProjectPath(projectPath) {
+    const expanded = projectPath.startsWith('~/')
+        ? projectPath.replace(/^~/, homedir())
+        : projectPath;
+    return resolve(expanded);
+}
+//# sourceMappingURL=context.js.map

package/dist/squad/context.test.js

@@ -0,0 +1,59 @@
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+async function loadContext() {
+    return await import(new URL(`./context.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test("extractProjectPathFromPrompt returns null for a plain prompt with no path", async () => {
+    const m = await loadContext();
+    assert.equal(typeof m.extractProjectPathFromPrompt, "function", "extractProjectPathFromPrompt should be exported");
+    const result = m.extractProjectPathFromPrompt("Hey, what is the status of the sprint?");
+    assert.equal(result, null);
+});
+test("extractProjectPathFromPrompt extracts path from cwd:/home/user/my-project", async () => {
+    const m = await loadContext();
+    const result = m.extractProjectPathFromPrompt("cwd:/home/user/my-project\nWhat are the recent decisions?");
+    assert.equal(result, "/home/user/my-project");
+});
+test("extractProjectPathFromPrompt extracts absolute path from prompt text", async () => {
+    const m = await loadContext();
+    const result = m.extractProjectPathFromPrompt("Looking at project /home/user/my-project — what agents are available?");
+    assert.equal(result, "/home/user/my-project");
+});
+test("normalizeProjectPath resolves ~/foo to home dir + /foo", async () => {
+    const m = await loadContext();
+    assert.equal(typeof m.normalizeProjectPath, "function", "normalizeProjectPath should be exported");
+    const result = m.normalizeProjectPath("~/foo");
+    assert.equal(result, join(homedir(), "foo"));
+});
+test("normalizeProjectPath passes through absolute paths unchanged", async () => {
+    const m = await loadContext();
+    const result = m.normalizeProjectPath("/home/user/project");
+    assert.equal(result, "/home/user/project");
+});
+test("setChannelProject + getChannelProject round-trips correctly", async () => {
+    const m = await loadContext();
+    assert.equal(typeof m.setChannelProject, "function", "setChannelProject should be exported");
+    assert.equal(typeof m.getChannelProject, "function", "getChannelProject should be exported");
+    m.setChannelProject("channel-abc", "/home/user/project-alpha");
+    const result = m.getChannelProject("channel-abc");
+    assert.equal(result, "/home/user/project-alpha");
+});
+test("clearChannelProject removes the mapping", async () => {
+    const m = await loadContext();
+    assert.equal(typeof m.clearChannelProject, "function", "clearChannelProject should be exported");
+    m.setChannelProject("channel-to-clear", "/home/user/some-project");
+    assert.equal(m.getChannelProject("channel-to-clear"), "/home/user/some-project");
+    m.clearChannelProject("channel-to-clear");
+    assert.equal(m.getChannelProject("channel-to-clear"), undefined, "cleared channel should return undefined");
+});
+test("different channel keys are independent", async () => {
+    const m = await loadContext();
+    m.setChannelProject("channel-x", "/projects/x");
+    m.setChannelProject("channel-y", "/projects/y");
+    assert.equal(m.getChannelProject("channel-x"), "/projects/x");
+    assert.equal(m.getChannelProject("channel-y"), "/projects/y");
+    assert.equal(m.getChannelProject("channel-z"), undefined, "unknown channel key should return undefined");
+});
+//# sourceMappingURL=context.test.js.map

package/dist/squad/discovery.js

@@ -0,0 +1,280 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { getDb } from '../store/db.js';
+// ---------------------------------------------------------------------------
+// DB schema — created lazily on first use
+// ---------------------------------------------------------------------------
+function ensureSquadTables() {
+    const db = getDb();
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS project_squads (
+      project_root TEXT PRIMARY KEY,
+      squad_dir TEXT NOT NULL,
+      team_dir TEXT NOT NULL,
+      personal_dir TEXT,
+      mode TEXT NOT NULL CHECK(mode IN ('local', 'remote')),
+      project_key TEXT,
+      config_source TEXT,
+      registered INTEGER NOT NULL DEFAULT 0,
+      loaded_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS squad_agents (
+      project_root TEXT NOT NULL,
+      slug TEXT NOT NULL,
+      role TEXT NOT NULL,
+      description TEXT,
+      charter_path TEXT NOT NULL,
+      model_preference TEXT,
+      tools_json TEXT,
+      capabilities_json TEXT,
+      stale INTEGER NOT NULL DEFAULT 0,
+      loaded_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+      PRIMARY KEY (project_root, slug)
+    )
+  `);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS squad_task_links (
+      task_id TEXT PRIMARY KEY,
+      project_root TEXT NOT NULL,
+      squad_agent_slug TEXT NOT NULL,
+      wiki_decision_path TEXT NOT NULL
+    )
+  `);
+}
+// ---------------------------------------------------------------------------
+// Charter parsing helpers
+// ---------------------------------------------------------------------------
+function extractRoleFromCharter(content) {
+    // Look for "**Role:**" in identity section
+    const roleMatch = content.match(/\*\*Role:\*\*\s*(.+)/);
+    if (roleMatch)
+        return roleMatch[1].trim();
+    // Fallback: first heading text after "—"
+    const headingMatch = content.match(/^#\s+.+?—\s*(.+)/m);
+    if (headingMatch)
+        return headingMatch[1].trim();
+    // Second heading as role
+    const h2Match = content.match(/^##\s+(.+)/m);
+    if (h2Match)
+        return h2Match[1].trim();
+    return 'Agent';
+}
+function extractDescriptionFromCharter(content) {
+    // Blockquote after title heading
+    const blockquoteMatch = content.match(/^#[^\n]*\n+>\s*(.+)/m);
+    if (blockquoteMatch)
+        return blockquoteMatch[1].trim();
+    // First non-empty paragraph after heading
+    const lines = content.split('\n');
+    let pastHeading = false;
+    for (const line of lines) {
+        if (!pastHeading && line.startsWith('#')) {
+            pastHeading = true;
+            continue;
+        }
+        if (pastHeading && line.trim() && !line.startsWith('#') && !line.startsWith('>')) {
+            return line.trim();
+        }
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Core discovery — reads repo filesystem, no DB required
+// ---------------------------------------------------------------------------
+export async function resolveProjectSquad(projectPath) {
+    const squadDir = join(projectPath, '.squad');
+    if (!existsSync(squadDir))
+        return null;
+    // Try SDK path resolution with graceful fallback
+    let resolvedSquadDir = squadDir;
+    let mode = 'local';
+    let projectKey = null;
+    let configSource;
+    try {
+        const { resolveSquad } = await import('@bradygaster/squad-sdk');
+        const resolved = resolveSquad(projectPath);
+        if (resolved)
+            resolvedSquadDir = resolved;
+    }
+    catch {
+        // SDK not available — use manual path resolution
+    }
+    // Enumerate agents from .squad/agents/
+    const agentsDir = join(resolvedSquadDir, 'agents');
+    const agents = [];
+    if (existsSync(agentsDir)) {
+        let entries = [];
+        try {
+            entries = readdirSync(agentsDir);
+        }
+        catch { /* ignore read errors */ }
+        for (const entry of entries) {
+            const agentDir = join(agentsDir, entry);
+            try {
+                if (!statSync(agentDir).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const charterPath = join(agentDir, 'charter.md');
+            if (!existsSync(charterPath))
+                continue;
+            let charterContent = '';
+            try {
+                charterContent = readFileSync(charterPath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const slug = entry;
+            const role = extractRoleFromCharter(charterContent);
+            const description = extractDescriptionFromCharter(charterContent);
+            agents.push({
+                slug,
+                mention: `@${slug}`,
+                role,
+                description,
+                charterPath,
+                origin: 'project-squad',
+            });
+        }
+    }
+    // Load squad config via SDK with fallback to empty config
+    let squadConfig = {};
+    try {
+        const { loadConfig } = await import('@bradygaster/squad-sdk');
+        const result = await loadConfig(resolvedSquadDir);
+        squadConfig = result.config;
+        configSource = result.source;
+    }
+    catch { /* SDK unavailable or config parse error — use empty config */ }
+    const decisionsPath = join(resolvedSquadDir, 'decisions.md');
+    const routingPath = join(resolvedSquadDir, 'routing.md');
+    const now = new Date().toISOString();
+    const context = {
+        projectRoot: projectPath,
+        squadDir: resolvedSquadDir,
+        teamDir: resolvedSquadDir,
+        personalDir: null,
+        mode,
+        projectKey,
+        configSource,
+        config: squadConfig,
+        agents,
+        decisionsPath,
+        routingPath: existsSync(routingPath) ? routingPath : undefined,
+        loadedAt: now,
+    };
+    // Persist to DB cache
+    _persistSquadToDb(context);
+    return context;
+}
+function _persistSquadToDb(context) {
+    try {
+        ensureSquadTables();
+        const db = getDb();
+        db.prepare(`
+      INSERT OR REPLACE INTO project_squads
+        (project_root, squad_dir, team_dir, personal_dir, mode, project_key, config_source, loaded_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(context.projectRoot, context.squadDir, context.teamDir, context.personalDir ?? null, context.mode, context.projectKey ?? null, context.configSource ?? null, context.loadedAt);
+        // Remove agents no longer in repo
+        const repoSlugs = context.agents.map(a => a.slug);
+        const existing = db.prepare(`SELECT slug FROM squad_agents WHERE project_root = ?`).all(context.projectRoot);
+        for (const row of existing) {
+            if (!repoSlugs.includes(row.slug)) {
+                db.prepare(`DELETE FROM squad_agents WHERE project_root = ? AND slug = ?`)
+                    .run(context.projectRoot, row.slug);
+            }
+        }
+        // Upsert each agent
+        for (const agent of context.agents) {
+            db.prepare(`
+        INSERT OR REPLACE INTO squad_agents
+          (project_root, slug, role, description, charter_path, model_preference,
+           tools_json, capabilities_json, stale, loaded_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?)
+      `).run(context.projectRoot, agent.slug, agent.role, agent.description ?? null, agent.charterPath, agent.modelPreference ?? null, agent.tools ? JSON.stringify(agent.tools) : null, agent.capabilities ? JSON.stringify(agent.capabilities) : null, context.loadedAt);
+        }
+    }
+    catch { /* DB errors are non-fatal — repo files are the source of truth */ }
+}
+export async function loadProjectSquad(projectPath) {
+    try {
+        ensureSquadTables();
+        const db = getDb();
+        const TTL_MS = 5 * 60 * 1000; // 5 minutes
+        const row = db.prepare(`SELECT * FROM project_squads WHERE project_root = ?`).get(projectPath);
+        if (row) {
+            const loadedAt = new Date(row.loaded_at).getTime();
+            const isStale = (Date.now() - loadedAt) > TTL_MS;
+            const staleAgents = db.prepare(`SELECT COUNT(*) as c FROM squad_agents WHERE project_root = ? AND stale = 1`).get(projectPath);
+            if (!isStale && staleAgents.c === 0) {
+                // Rebuild context from DB cache
+                const agentRows = db.prepare(`SELECT * FROM squad_agents WHERE project_root = ? AND stale = 0`).all(projectPath);
+                const agents = agentRows.map(a => ({
+                    slug: a.slug,
+                    mention: `@${a.slug}`,
+                    role: a.role,
+                    description: a.description ?? undefined,
+                    charterPath: a.charter_path,
+                    modelPreference: a.model_preference ?? undefined,
+                    tools: a.tools_json ? JSON.parse(a.tools_json) : undefined,
+                    capabilities: a.capabilities_json
+                        ? JSON.parse(a.capabilities_json)
+                        : undefined,
+                    origin: 'project-squad',
+                }));
+                // Repo wins: re-sync any new agents that appeared since last cache
+                const repoAgentsDir = join(row.squad_dir, 'agents');
+                if (existsSync(repoAgentsDir)) {
+                    const repoDirs = readdirSync(repoAgentsDir).filter(e => {
+                        try {
+                            return statSync(join(repoAgentsDir, e)).isDirectory();
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+                    const cachedSlugs = new Set(agents.map(a => a.slug));
+                    for (const slug of repoDirs) {
+                        if (!cachedSlugs.has(slug)) {
+                            // New agent in repo not in cache — trigger full reload
+                            return resolveProjectSquad(projectPath);
+                        }
+                    }
+                }
+                return {
+                    projectRoot: row.project_root,
+                    squadDir: row.squad_dir,
+                    teamDir: row.team_dir,
+                    personalDir: row.personal_dir,
+                    mode: row.mode,
+                    projectKey: row.project_key,
+                    configSource: row.config_source ?? undefined,
+                    config: {},
+                    agents,
+                    decisionsPath: join(row.squad_dir, 'decisions.md'),
+                    routingPath: existsSync(join(row.squad_dir, 'routing.md'))
+                        ? join(row.squad_dir, 'routing.md')
+                        : undefined,
+                    loadedAt: row.loaded_at,
+                };
+            }
+        }
+    }
+    catch { /* DB unavailable — fall through to live resolve */ }
+    return resolveProjectSquad(projectPath);
+}
+export function invalidateProjectSquad(projectRoot) {
+    try {
+        ensureSquadTables();
+        const db = getDb();
+        db.prepare(`UPDATE squad_agents SET stale = 1 WHERE project_root = ?`).run(projectRoot);
+    }
+    catch { /* non-fatal */ }
+}
+//# sourceMappingURL=discovery.js.map

package/dist/squad/discovery.test.js

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import test from "node:test";
+const repoRoot = process.cwd();
+const fixtureRoot = join(repoRoot, "src/test/fixtures/mock-squad-repo");
+// Sandbox CHAPTERHOUSE_HOME so loadProjectSquad's SQLite DB is isolated
+const sandboxRoot = join(repoRoot, ".test-work", `squad-discovery-${process.pid}`);
+process.env.CHAPTERHOUSE_HOME = sandboxRoot;
+async function loadDiscovery() {
+    return await import(new URL(`./discovery.js?v=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test.before(() => {
+    mkdirSync(join(repoRoot, ".test-work"), { recursive: true });
+    mkdirSync(join(sandboxRoot, ".chapterhouse"), { recursive: true });
+});
+test.after(() => {
+    rmSync(sandboxRoot, { recursive: true, force: true });
+});
+test("resolveProjectSquad returns null for path with no .squad/ directory", async () => {
+    const m = await loadDiscovery();
+    assert.equal(typeof m.resolveProjectSquad, "function", "resolveProjectSquad should be exported");
+    const result = await m.resolveProjectSquad(join(repoRoot, "src/test/fixtures") // directory without .squad/
+    );
+    assert.equal(result, null);
+});
+test("resolveProjectSquad returns a ProjectSquadContext for the mock fixture path", async () => {
+    const m = await loadDiscovery();
+    const result = await m.resolveProjectSquad(fixtureRoot);
+    assert.notEqual(result, null, "should return a context for a path with .squad/");
+    assert.equal(typeof result, "object");
+});
+test("returned context has agents array with 2 items", async () => {
+    const m = await loadDiscovery();
+    const result = await m.resolveProjectSquad(fixtureRoot);
+    assert.ok(result && Array.isArray(result.agents), "agents should be an array");
+    assert.equal(result.agents.length, 2, "should have 2 agents (ripley, dallas)");
+});
+test("each agent descriptor has required fields with correct shape", async () => {
+    const m = await loadDiscovery();
+    const result = await m.resolveProjectSquad(fixtureRoot);
+    assert.ok(result && result.agents, "context should have agents");
+    for (const agent of result.agents) {
+        assert.equal(typeof agent.slug, "string", `agent.slug should be a string`);
+        assert.equal(typeof agent.mention, "string", `agent.mention should be a string`);
+        assert.ok(agent.mention.startsWith("@"), `mention should start with @, got: ${agent.mention}`);
+        assert.equal(typeof agent.role, "string", `agent.role should be a string`);
+        assert.equal(typeof agent.charterPath, "string", `agent.charterPath should be a string`);
+        assert.equal(agent.origin, "project-squad", `agent.origin should be 'project-squad'`);
+    }
+});
+test("loadProjectSquad returns same result as resolveProjectSquad on first call (cache miss)", async () => {
+    const m = await loadDiscovery();
+    assert.equal(typeof m.loadProjectSquad, "function", "loadProjectSquad should be exported");
+    // Use a unique path so we're guaranteed a cache miss
+    const uniquePath = fixtureRoot + `-${Date.now()}`;
+    mkdirSync(join(uniquePath, ".squad", "agents", "ripley"), { recursive: true });
+    // Copy minimal structure
+    const { copyFileSync } = await import("node:fs");
+    copyFileSync(join(fixtureRoot, ".squad/agents/ripley/charter.md"), join(uniquePath, ".squad/agents/ripley/charter.md"));
+    const resolved = await m.resolveProjectSquad(uniquePath);
+    assert.ok(resolved !== null, "resolveProjectSquad should return non-null for valid path");
+    const loaded = await m.loadProjectSquad(uniquePath);
+    assert.ok(loaded !== null, "loadProjectSquad should return non-null for valid path");
+    assert.equal(loaded.projectRoot, resolved.projectRoot, "projectRoot should match");
+    assert.equal(loaded.agents.length, resolved.agents.length, "agent count should match");
+    rmSync(uniquePath, { recursive: true, force: true });
+});
+test("repeated loadProjectSquad call returns cached result (same loadedAt)", async () => {
+    const m = await loadDiscovery();
+    const first = await m.loadProjectSquad(fixtureRoot);
+    const second = await m.loadProjectSquad(fixtureRoot);
+    assert.ok(first && second, "both calls should return non-null");
+    // loadedAt is an ISO date string; on cache hit it should be identical
+    if (first.loadedAt !== undefined && second.loadedAt !== undefined) {
+        assert.equal(first.loadedAt, second.loadedAt, "cache hit should return same loadedAt value");
+    }
+});
+test("invalidateProjectSquad marks agents stale — next loadProjectSquad re-resolves", async () => {
+    const m = await loadDiscovery();
+    assert.equal(typeof m.invalidateProjectSquad, "function", "invalidateProjectSquad should be exported");
+    // Warm the cache
+    const before = await m.loadProjectSquad(fixtureRoot);
+    assert.ok(before, "should have a cached context");
+    // Invalidate
+    m.invalidateProjectSquad(fixtureRoot);
+    // Re-resolve — should work and return valid context
+    const after = await m.loadProjectSquad(fixtureRoot);
+    assert.ok(after, "should re-resolve after invalidation");
+    // Both should have agents (content integrity survives invalidation + re-resolve)
+    assert.ok(after && typeof after === "object" && "agents" in after, "re-resolved context should include agents");
+});
+//# sourceMappingURL=discovery.test.js.map