chapterhouse 0.1.1

package/dist/api/team.js

@@ -0,0 +1,196 @@
+import express from "express";
+import { statSync } from "node:fs";
+import { join, normalize } from "node:path";
+import { z } from "zod";
+import { config } from "../config.js";
+import { AdoClient } from "../integrations/ado-client.js";
+import { ReportGenerator } from "../integrations/report-generator.js";
+import { BadRequestError, ForbiddenError, InternalServerError, asBadRequest, parseRequest } from "./errors.js";
+import { assertPagePath, ensureWikiStructure, getWikiDir, listPages, readPage, writePage, } from "../wiki/fs.js";
+import { withWikiWrite } from "../wiki/lock.js";
+import { TeamsNotifier, TEAMS_MILESTONE_THRESHOLDS } from "../integrations/teams-notify.js";
+const wikiPageRoute = /^\/wiki\/(.+)$/;
+const updateSchema = z.object({
+    engineerId: z.string().min(1),
+    activity: z.string().min(1),
+    krId: z.union([z.string().min(1), z.number().int().positive()]),
+    delta: z.number().finite().min(-100000).max(100000),
+    notes: z.string().optional(),
+    kr: z.object({
+        id: z.string().min(1),
+        title: z.string().min(1),
+        owner: z.string().min(1),
+        currentValue: z.number().finite(),
+        targetValue: z.number().finite(),
+        unit: z.string(),
+    }).optional(),
+});
+const reportSchema = z.object({
+    quarter: z.string().trim().min(1).optional(),
+});
+const wikiWriteSchema = z.object({
+    content: z.string({ error: "Missing 'content' string in request body" }),
+}).strict();
+function requireTeamLead(user) {
+    if (user?.role !== "team-lead") {
+        throw new ForbiddenError("Forbidden");
+    }
+    return true;
+}
+function canWriteWikiPath(path, role) {
+    if (role === "team-lead") {
+        return true;
+    }
+    return path.startsWith("pages/shared/");
+}
+function resolveWikiPath(rawPath) {
+    try {
+        const path = normalize(decodeURIComponent(rawPath))
+            .replace(/\\/g, "/")
+            .replace(/^(\.\.(\/|\\|$))+/, "");
+        assertPagePath(path);
+        return path;
+    }
+    catch (error) {
+        asBadRequest(error);
+    }
+}
+function buildUpdateMarkdown(entry) {
+    return [
+        `## ${entry.timestamp} — ${entry.engineerId}`,
+        "",
+        `**Activity**: ${entry.activity}  `,
+        `**Key Result**: ${entry.krId}  `,
+        `**Delta**: ${entry.delta}  `,
+        `**Notes**: ${entry.notes ?? ""}`,
+        "",
+        "---",
+        "",
+    ].join("\n");
+}
+function readUpdatedAt(relativePath) {
+    const stats = statSync(join(getWikiDir(), relativePath));
+    return stats.mtime.toISOString();
+}
+export function currentQuarter(now = new Date()) {
+    return `${now.getUTCFullYear()}-Q${Math.floor(now.getUTCMonth() / 3) + 1}`;
+}
+function collectOkrPages() {
+    ensureWikiStructure();
+    return listPages()
+        .filter((path) => path.startsWith("pages/okrs/") && !path.startsWith("pages/okrs/updates/"))
+        .sort()
+        .map((path) => ({
+        path,
+        content: readPage(path) ?? "",
+        updatedAt: readUpdatedAt(path),
+    }));
+}
+function isConfiguredTeamWikiPath(path) {
+    return config.teamWikiPaths.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));
+}
+function collectTeamWikiPages() {
+    ensureWikiStructure();
+    return listPages()
+        .filter((path) => isConfiguredTeamWikiPath(path))
+        .sort();
+}
+function getCrossedMilestone(kr, delta) {
+    if (!Number.isFinite(delta) || !Number.isFinite(kr.currentValue) || !Number.isFinite(kr.targetValue) || kr.targetValue <= 0) {
+        return null;
+    }
+    const previousValue = kr.currentValue - delta;
+    let crossedMilestone = null;
+    for (const threshold of TEAMS_MILESTONE_THRESHOLDS) {
+        const thresholdValue = (kr.targetValue * threshold) / 100;
+        if (previousValue < thresholdValue && kr.currentValue >= thresholdValue) {
+            crossedMilestone = threshold;
+        }
+    }
+    return crossedMilestone;
+}
+export function createTeamRouter(options) {
+    const router = express.Router();
+    const now = options.now ?? (() => new Date());
+    const teamsNotifier = options.teamsNotifier ?? new TeamsNotifier();
+    const adoClient = options.adoClient ?? (config.adoPat ? new AdoClient() : undefined);
+    const warn = options.warn ?? ((message) => console.warn(message));
+    router.use(options.authMiddleware);
+    router.post("/update", async (req, res) => {
+        const input = parseRequest(updateSchema, req.body);
+        if (config.adoPat && typeof input.krId !== "number") {
+            throw new BadRequestError("krId must be a numeric ADO work item ID when ADO_PAT is configured");
+        }
+        const timestamp = now().toISOString();
+        const path = `pages/okrs/updates/${timestamp.slice(0, 10)}.md`;
+        const entry = {
+            ...input,
+            timestamp,
+            path,
+        };
+        await withWikiWrite(() => {
+            ensureWikiStructure();
+            const existing = readPage(path);
+            const content = `${existing ?? ""}${buildUpdateMarkdown(entry)}`;
+            writePage(path, content);
+        });
+        if (adoClient) {
+            if (typeof entry.krId === "number") {
+                await adoClient.updateKRProgress(entry.krId, entry.delta, entry.notes);
+            }
+            else {
+                warn(`[team] Skipping Azure DevOps KR update for non-numeric krId "${entry.krId}".`);
+            }
+        }
+        if (entry.kr && getCrossedMilestone(entry.kr, entry.delta) !== null) {
+            await teamsNotifier.notifyKRMilestone(entry.kr);
+        }
+        res.json({ ok: true, entry });
+    });
+    router.get("/okrs", (_req, res) => {
+        res.json({ pages: collectOkrPages() });
+    });
+    router.get("/wiki", (_req, res) => {
+        res.json({ pages: collectTeamWikiPages() });
+    });
+    router.get(wikiPageRoute, (req, res) => {
+        const rawPath = req.params[0];
+        if (!rawPath) {
+            throw new BadRequestError("Missing wiki page path");
+        }
+        const path = resolveWikiPath(rawPath);
+        const content = readPage(path);
+        res.json({ path, content: content ?? "", exists: content !== undefined });
+    });
+    router.put(wikiPageRoute, async (req, res) => {
+        const rawPath = req.params[0];
+        if (!rawPath) {
+            throw new BadRequestError("Missing wiki page path");
+        }
+        const { content } = parseRequest(wikiWriteSchema, req.body);
+        const normalizedPath = resolveWikiPath(rawPath);
+        if (!canWriteWikiPath(normalizedPath, req.user?.role ?? "")) {
+            throw new ForbiddenError("Forbidden");
+        }
+        await withWikiWrite(() => {
+            writePage(normalizedPath, content);
+        });
+        res.json({ ok: true, path: normalizedPath });
+    });
+    router.post("/report", async (req, res) => {
+        requireTeamLead(req.user);
+        const input = parseRequest(reportSchema, req.body ?? {});
+        const reportQuarter = input.quarter ?? currentQuarter(now());
+        const reportGenerator = options.reportGenerator ?? new ReportGenerator({ now });
+        try {
+            const report = await reportGenerator.generateMonthlyReport(reportQuarter);
+            res.json({ ok: true, report });
+        }
+        catch (error) {
+            console.error("[team] Failed to generate report:", error);
+            throw new InternalServerError();
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=team.js.map

package/dist/api/team.test.js

@@ -0,0 +1,466 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+import express from "express";
+const chapterhouseHomeRoot = mkdtempSync(join(tmpdir(), "chapterhouse-team-api-"));
+process.env.CHAPTERHOUSE_HOME = chapterhouseHomeRoot;
+function createMockAuthMiddleware(user) {
+    return (req, res, next) => {
+        if (!user) {
+            res.status(401).json({ error: "Unauthorized" });
+            return;
+        }
+        req.user = user;
+        next();
+    };
+}
+async function loadTeamModule() {
+    try {
+        return await import(new URL("./team.js", import.meta.url).href);
+    }
+    catch {
+        return null;
+    }
+}
+async function withServer(app, run) {
+    const server = createServer(app);
+    await new Promise((resolve) => {
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const address = server.address();
+    assert.ok(address && typeof address === "object", "server should expose a bound address");
+    try {
+        await run(`http://127.0.0.1:${address.port}`);
+    }
+    finally {
+        await new Promise((resolve, reject) => {
+            server.close((err) => (err ? reject(err) : resolve()));
+        });
+    }
+}
+let apiErrorHandler;
+let sharedConfig;
+let originalAdoPat;
+async function getApiErrorHandler() {
+    if (!apiErrorHandler) {
+        const errors = await import("./errors.js");
+        apiErrorHandler = errors.createApiErrorHandler();
+    }
+    return apiErrorHandler;
+}
+async function getConfig() {
+    if (!sharedConfig) {
+        const configModule = await import("../config.js");
+        sharedConfig = configModule.config;
+        originalAdoPat = configModule.config.adoPat;
+    }
+    return sharedConfig;
+}
+async function createTestApp(teamRouter) {
+    const app = express();
+    app.use(express.json());
+    app.use("/api/team", teamRouter);
+    app.use(await getApiErrorHandler());
+    return app;
+}
+function wikiRootPath(...parts) {
+    return join(chapterhouseHomeRoot, ".chapterhouse", ...parts);
+}
+test.beforeEach(async () => {
+    (await getConfig()).adoPat = "";
+});
+test.after(async () => {
+    const config = await getConfig();
+    config.adoPat = originalAdoPat ?? "";
+    rmSync(chapterhouseHomeRoot, { recursive: true, force: true });
+});
+test("unauthenticated requests return 401", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware(),
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/okrs`);
+        assert.equal(response.status, 401);
+        assert.deepEqual(await response.json(), { error: "Unauthorized" });
+    });
+});
+test("engineer can POST /api/team/update", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "eng-1",
+            name: "Ada Lovelace",
+            email: "ada@example.com",
+            role: "engineer",
+        }),
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/update`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                engineerId: "eng-1",
+                activity: "Closed migration tasks",
+                krId: "KR-2",
+                delta: 0.25,
+                notes: "Removed the final blockers",
+            }),
+        });
+        assert.equal(response.status, 200);
+        const payload = await response.json();
+        assert.equal(payload.ok, true);
+        assert.equal(payload.entry.engineerId, "eng-1");
+        assert.equal(payload.entry.krId, "KR-2");
+    });
+    const today = new Date().toISOString().slice(0, 10);
+    const updatePath = wikiRootPath("wiki", "pages", "okrs", "updates", `${today}.md`);
+    const content = readFileSync(updatePath, "utf-8");
+    assert.match(content, /## .* — eng-1/);
+    assert.match(content, /\*\*Activity\*\*: Closed migration tasks/);
+    assert.match(content, /\*\*Key Result\*\*: KR-2/);
+    assert.match(content, /\*\*Delta\*\*: 0.25/);
+});
+test("POST /api/team/update rejects deltas outside the allowed range", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "eng-delta-1",
+            name: "Ada Lovelace",
+            email: "ada@example.com",
+            role: "engineer",
+        }),
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/update`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                engineerId: "eng-delta-1",
+                activity: "Attempted an unsafe jump",
+                krId: "KR-2",
+                delta: 100001,
+            }),
+        });
+        assert.equal(response.status, 400);
+        assert.deepEqual(await response.json(), {
+            error: "Too big: expected number to be <=100000",
+        });
+    });
+});
+test("engineer cannot PUT protected team wiki paths", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "eng-2",
+            name: "Grace Hopper",
+            email: "grace@example.com",
+            role: "engineer",
+        }),
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/wiki/pages/okrs/2026-Q2.md`, {
+            method: "PUT",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ content: "# Q2\n" }),
+        });
+        assert.equal(response.status, 403);
+        assert.deepEqual(await response.json(), { error: "Forbidden" });
+    });
+});
+test("engineer cannot traverse from shared wiki paths into protected prefixes", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "eng-2b",
+            name: "Grace Hopper",
+            email: "grace@example.com",
+            role: "engineer",
+        }),
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/wiki/pages/shared/../okrs/2026-Q2.md`, {
+            method: "PUT",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ content: "# Q2\n" }),
+        });
+        assert.equal(response.status, 403);
+        assert.deepEqual(await response.json(), { error: "Forbidden" });
+    });
+});
+test("engineer can PUT /api/team/wiki/:path inside pages/shared", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "eng-shared-1",
+            name: "Grace Hopper",
+            email: "grace@example.com",
+            role: "engineer",
+        }),
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/wiki/pages/shared/runbooks/deploy.md`, {
+            method: "PUT",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ content: "# Deploy Runbook\n" }),
+        });
+        assert.equal(response.status, 200);
+        assert.deepEqual(await response.json(), { ok: true, path: "pages/shared/runbooks/deploy.md" });
+    });
+    const content = readFileSync(wikiRootPath("wiki", "pages", "shared", "runbooks", "deploy.md"), "utf-8");
+    assert.equal(content, "# Deploy Runbook\n");
+});
+test("team lead can PUT /api/team/wiki/:path", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "lead-1",
+            name: "Brian Ketelsen",
+            email: "brian@example.com",
+            role: "team-lead",
+        }),
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/wiki/pages/okrs/2026-Q2.md`, {
+            method: "PUT",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ content: "# Q2\n\nUpdated\n" }),
+        });
+        assert.equal(response.status, 200);
+        assert.deepEqual(await response.json(), { ok: true, path: "pages/okrs/2026-Q2.md" });
+    });
+    const content = readFileSync(wikiRootPath("wiki", "pages", "okrs", "2026-Q2.md"), "utf-8");
+    assert.equal(content, "# Q2\n\nUpdated\n");
+});
+test("GET /api/team/wiki lists team wiki pages under synced prefixes", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    mkdirSync(wikiRootPath("wiki", "pages", "team"), { recursive: true });
+    mkdirSync(wikiRootPath("wiki", "pages", "okrs"), { recursive: true });
+    mkdirSync(wikiRootPath("wiki", "pages", "kpis"), { recursive: true });
+    mkdirSync(wikiRootPath("wiki", "pages", "shared"), { recursive: true });
+    mkdirSync(wikiRootPath("wiki", "pages", "people"), { recursive: true });
+    writeFileSync(wikiRootPath("wiki", "pages", "team", "vision.md"), "# Team Vision\n");
+    writeFileSync(wikiRootPath("wiki", "pages", "okrs", "2026-Q2.md"), "# Q2 OKRs\n");
+    writeFileSync(wikiRootPath("wiki", "pages", "kpis", "reliability.md"), "# Reliability\n");
+    writeFileSync(wikiRootPath("wiki", "pages", "shared", "README.md"), "# Shared Team Wiki\n");
+    writeFileSync(wikiRootPath("wiki", "pages", "people", "ada.md"), "# Ada\n");
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "eng-3",
+            name: "Margaret Hamilton",
+            email: "margaret@example.com",
+            role: "engineer",
+        }),
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/wiki`);
+        assert.equal(response.status, 200);
+        const payload = await response.json();
+        assert.ok(payload.pages.includes("pages/team/vision.md"));
+        assert.ok(payload.pages.includes("pages/okrs/2026-Q2.md"));
+        assert.ok(payload.pages.includes("pages/kpis/reliability.md"));
+        assert.ok(payload.pages.includes("pages/shared/README.md"));
+        assert.equal(payload.pages.includes("pages/people/ada.md"), false);
+    });
+});
+test("POST /api/team/update notifies Teams when a KR crosses a milestone", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const milestones = [];
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "eng-4",
+            name: "Katherine Johnson",
+            email: "katherine@example.com",
+            role: "engineer",
+        }),
+        teamsNotifier: {
+            notifyKRMilestone: async (kr) => {
+                milestones.push(kr);
+                return true;
+            },
+        },
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/update`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                engineerId: "eng-4",
+                activity: "Improved SSO rollout coverage",
+                krId: "KR-9",
+                delta: 10,
+                notes: "Crossed the halfway mark",
+                kr: {
+                    id: "KR-9",
+                    title: "Ship SSO to all tenants",
+                    owner: "Katherine Johnson",
+                    currentValue: 50,
+                    targetValue: 100,
+                    unit: "%",
+                },
+            }),
+        });
+        assert.equal(response.status, 200);
+    });
+    assert.equal(milestones.length, 1);
+    assert.deepEqual(milestones[0], {
+        id: "KR-9",
+        title: "Ship SSO to all tenants",
+        owner: "Katherine Johnson",
+        currentValue: 50,
+        targetValue: 100,
+        unit: "%",
+    });
+});
+test("POST /api/team/update pushes numeric KR updates to Azure DevOps", async () => {
+    const team = await loadTeamModule();
+    assert.ok(team, "team router module should exist");
+    assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+    const adoUpdates = [];
+    const router = team.createTeamRouter({
+        authMiddleware: createMockAuthMiddleware({
+            id: "eng-5",
+            name: "Dorothy Vaughan",
+            email: "dorothy@example.com",
+            role: "engineer",
+        }),
+        adoClient: {
+            async updateKRProgress(workItemId, currentValue, notes) {
+                adoUpdates.push({ workItemId, currentValue, notes });
+            },
+        },
+    });
+    await withServer(await createTestApp(router), async (baseUrl) => {
+        const response = await fetch(`${baseUrl}/api/team/update`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                engineerId: "eng-5",
+                activity: "Advanced the SSO migration",
+                krId: 1234,
+                delta: 88,
+                notes: "Ready for wider rollout",
+            }),
+        });
+        assert.equal(response.status, 200);
+    });
+    assert.deepEqual(adoUpdates, [
+        {
+            workItemId: 1234,
+            currentValue: 88,
+            notes: "Ready for wider rollout",
+        },
+    ]);
+});
+test("POST /api/team/update rejects non-numeric krId values when ADO sync is configured", async () => {
+    const { config } = await import("../config.js");
+    const previousAdoPat = config.adoPat;
+    config.adoPat = "test-pat";
+    try {
+        const team = await loadTeamModule();
+        assert.ok(team, "team router module should exist");
+        assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+        const adoUpdates = [];
+        const router = team.createTeamRouter({
+            authMiddleware: createMockAuthMiddleware({
+                id: "eng-ado-1",
+                name: "Dorothy Vaughan",
+                email: "dorothy@example.com",
+                role: "engineer",
+            }),
+            adoClient: {
+                async updateKRProgress(workItemId, currentValue, notes) {
+                    adoUpdates.push({ workItemId, currentValue, notes });
+                },
+            },
+        });
+        await withServer(await createTestApp(router), async (baseUrl) => {
+            const response = await fetch(`${baseUrl}/api/team/update`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    engineerId: "eng-ado-1",
+                    activity: "Advanced the SSO migration",
+                    krId: "KR-1234",
+                    delta: 5,
+                    notes: "Should fail fast",
+                }),
+            });
+            assert.equal(response.status, 400);
+            assert.deepEqual(await response.json(), {
+                error: "krId must be a numeric ADO work item ID when ADO_PAT is configured",
+            });
+        });
+        assert.deepEqual(adoUpdates, []);
+    }
+    finally {
+        config.adoPat = previousAdoPat;
+    }
+});
+test("team lead can POST /api/team/report and falls back to the current quarter", async () => {
+    const realDate = Date;
+    class FixedDate extends Date {
+        constructor(value) {
+            super(value ?? "2026-05-06T10:00:00.000Z");
+        }
+        static now() {
+            return new realDate("2026-05-06T10:00:00.000Z").valueOf();
+        }
+    }
+    globalThis.Date = FixedDate;
+    try {
+        const team = await loadTeamModule();
+        assert.ok(team, "team router module should exist");
+        assert.equal(typeof team.createTeamRouter, "function", "createTeamRouter should be exported");
+        const requestedPeriods = [];
+        const router = team.createTeamRouter({
+            authMiddleware: createMockAuthMiddleware({
+                id: "lead-2",
+                name: "Brian Ketelsen",
+                email: "brian@example.com",
+                role: "team-lead",
+            }),
+            reportGenerator: {
+                async generateMonthlyReport(period) {
+                    requestedPeriods.push(period);
+                    return `Report for ${period}`;
+                },
+            },
+        });
+        await withServer(await createTestApp(router), async (baseUrl) => {
+            const response = await fetch(`${baseUrl}/api/team/report`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({}),
+            });
+            assert.equal(response.status, 200);
+            assert.deepEqual(await response.json(), { ok: true, report: "Report for 2026-Q2" });
+        });
+        assert.deepEqual(requestedPeriods, ["2026-Q2"]);
+    }
+    finally {
+        globalThis.Date = realDate;
+    }
+});
+//# sourceMappingURL=team.test.js.map