chapterhouse 0.3.13 → 0.3.15

package/dist/squad/charter.test.js

@@ -1,89 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,268 +0,0 @@
-import { existsSync } from 'fs';
-import { join } from 'path';
-import { FSStorageProvider, SquadState, NotFoundError } from '@bradygaster/squad-sdk';
-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/ via SDK AgentsCollection.
-    // FSStorageProvider wraps the same fs calls with typed returns and ENOENT safety.
-    const agents = [];
-    const stateRoot = resolvedSquadDir.endsWith('/.squad')
-        ? resolvedSquadDir.slice(0, -'/.squad'.length)
-        : projectPath;
-    try {
-        const storage = new FSStorageProvider();
-        const state = SquadState.fromStorage(storage, stateRoot);
-        const agentNames = await state.agents.list();
-        for (const name of agentNames) {
-            const charterPath = join(resolvedSquadDir, 'agents', name, 'charter.md');
-            let charterContent;
-            try {
-                charterContent = await state.agents.get(name).charter();
-            }
-            catch (err) {
-                if (err instanceof NotFoundError)
-                    continue; // no charter.md — not a valid agent
-                continue;
-            }
-            agents.push({
-                slug: name,
-                mention: `@${name}`,
-                role: extractRoleFromCharter(charterContent),
-                description: extractDescriptionFromCharter(charterContent),
-                charterPath,
-                origin: 'project-squad',
-            });
-        }
-    }
-    catch { /* SDK unavailable — agents list stays empty */ }
-    // 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.
-                // Use SDK AgentsCollection.list() so we stay consistent with resolveProjectSquad().
-                try {
-                    const cacheStorage = new FSStorageProvider();
-                    const cacheState = SquadState.fromStorage(cacheStorage, row.project_root);
-                    const repoAgentNames = await cacheState.agents.list();
-                    const cachedSlugs = new Set(agents.map(a => a.slug));
-                    for (const slug of repoAgentNames) {
-                        if (!cachedSlugs.has(slug)) {
-                            // New agent in repo not in cache — trigger full reload
-                            return resolveProjectSquad(projectPath);
-                        }
-                    }
-                }
-                catch { /* SDK unavailable — skip new-agent check */ }
-                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

@@ -1,154 +0,0 @@
-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");
-});
-// ---------------------------------------------------------------------------
-// S5-02: agent count from filesystem is always authoritative
-// These tests guard the fix: GET /api/projects must count agents from disk,
-// not from the SQLite squad_agents cache (which is never populated on a fresh
-// registration, causing the badge to show 0).
-// ---------------------------------------------------------------------------
-test("S5-02: resolveProjectSquad counts 0 agents for an empty agents dir", async () => {
-    const m = await loadDiscovery();
-    const dir = join(repoRoot, ".test-work", `s502-empty-${process.pid}`);
-    mkdirSync(join(dir, ".squad", "agents"), { recursive: true });
-    try {
-        const result = await m.resolveProjectSquad(dir);
-        assert.ok(result !== null, "should return context even with no agents");
-        assert.equal(result.agents.length, 0, "empty agents dir → 0 agents");
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test("S5-02: resolveProjectSquad counts N agents matching charter-bearing subdirs", async () => {
-    const m = await loadDiscovery();
-    const dir = join(repoRoot, ".test-work", `s502-n-agents-${process.pid}`);
-    // Create 3 agents (with charter.md) and 1 directory without charter.md
-    for (const slug of ["alpha", "beta", "gamma"]) {
-        mkdirSync(join(dir, ".squad", "agents", slug), { recursive: true });
-        const { writeFileSync } = await import("node:fs");
-        writeFileSync(join(dir, ".squad", "agents", slug, "charter.md"), `# ${slug}\n\n**Role:** Specialist\n`);
-    }
-    mkdirSync(join(dir, ".squad", "agents", "no-charter"), { recursive: true }); // no charter.md
-    try {
-        const result = await m.resolveProjectSquad(dir);
-        assert.ok(result !== null, "should return context");
-        assert.equal(result.agents.length, 3, "only dirs with charter.md count as agents");
-        const slugs = result.agents.map((a) => a.slug).sort();
-        assert.deepEqual(slugs, ["alpha", "beta", "gamma"]);
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-test("S5-02: resolveProjectSquad re-reads filesystem after agent added (no stale count)", async () => {
-    const m = await loadDiscovery();
-    const dir = join(repoRoot, ".test-work", `s502-refresh-${process.pid}`);
-    const { writeFileSync } = await import("node:fs");
-    // Start with 1 agent
-    mkdirSync(join(dir, ".squad", "agents", "first"), { recursive: true });
-    writeFileSync(join(dir, ".squad", "agents", "first", "charter.md"), "# first\n\n**Role:** Scout\n");
-    try {
-        const before = await m.resolveProjectSquad(dir);
-        assert.equal(before.agents.length, 1, "before: 1 agent on disk");
-        // Add a second agent to disk
-        mkdirSync(join(dir, ".squad", "agents", "second"), { recursive: true });
-        writeFileSync(join(dir, ".squad", "agents", "second", "charter.md"), "# second\n\n**Role:** Recon\n");
-        // resolveProjectSquad always reads from disk (no TTL — direct filesystem read)
-        const after = await m.resolveProjectSquad(dir);
-        assert.equal(after.agents.length, 2, "after adding agent to disk: 2 agents");
-    }
-    finally {
-        rmSync(dir, { recursive: true, force: true });
-    }
-});
-//# sourceMappingURL=discovery.test.js.map

package/dist/squad/index.js

@@ -1,9 +0,0 @@
-export * from './types.js';
-export * from './discovery.js';
-export * from './registry.js';
-export * from './context.js';
-export * from './charter.js';
-export * from './mirror.js';
-export * from './worktree.js';
-export * from './init.js';
-//# sourceMappingURL=index.js.map