chapterhouse 0.9.1 → 0.10.0

package/dist/copilot/tools/okr.js

@@ -0,0 +1,171 @@
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { config } from "../../config.js";
+import { ModeContext } from "../../mode-context.js";
+import { adoGetOkrs, adoOkrSummary, adoUpdateKr } from "../../integrations/ado-skill.js";
+import { TeamPushClient } from "../../integrations/team-push.js";
+import { getCurrentAuthenticatedUser, getCurrentAuthorizationHeader } from "../orchestrator.js";
+import { OKRMapper, parseOKRPageContent } from "../okr-mapper.js";
+import { teamWikiSync } from "../../wiki/team-sync.js";
+const modeContext = new ModeContext(config);
+function getCurrentQuarter(now = new Date()) {
+    return `${now.getUTCFullYear()}-Q${Math.floor(now.getUTCMonth() / 3) + 1}`;
+}
+function isSharedTeamWikiPath(path) {
+    return path.startsWith("pages/shared/");
+}
+export async function getMyOkrsSummary(options) {
+    const user = options.getCurrentUser();
+    if (!user) {
+        return "I don't have the current user identity for this session, so I can't filter your OKRs.";
+    }
+    const content = await options.createTeamPushClient().fetchOKRs(options.period);
+    const owned = parseOKRPageContent(content)
+        .filter((kr) => isOwnedByCurrentUser(kr.owner, user))
+        .sort((a, b) => a.krId.localeCompare(b.krId));
+    if (owned.length === 0) {
+        return `No current OKRs found for ${user.name}.`;
+    }
+    const lines = owned.map((kr) => {
+        const progress = Number.isFinite(kr.currentValue) && Number.isFinite(kr.targetValue)
+            ? ` — ${kr.currentValue}/${kr.targetValue}${kr.unit ? ` ${kr.unit}` : ""}`
+            : "";
+        return `• ${kr.krId}: ${kr.title} (${kr.objectiveTitle})${progress}`;
+    });
+    return `Current OKRs for ${user.name}:\n${lines.join("\n")}`;
+}
+function isOwnedByCurrentUser(owner, user) {
+    const normalizedOwner = normalizeIdentity(owner);
+    return [user.id, user.name, user.email]
+        .map((value) => normalizeIdentity(value))
+        .filter(Boolean)
+        .includes(normalizedOwner);
+}
+function normalizeIdentity(value) {
+    return (value ?? "").trim().toLowerCase();
+}
+function hasAdoPat() {
+    return config.adoPat.length > 0;
+}
+export function createOkrTools(deps) {
+    const getCurrentUser = deps.getCurrentUser ?? (() => getCurrentAuthenticatedUser());
+    const createTeamPushClient = deps.createTeamPushClient ?? (() => new TeamPushClient({
+        getAuthorizationHeader: getCurrentAuthorizationHeader,
+        getCurrentUser,
+    }));
+    const createOKRMapper = deps.createOKRMapper ?? (() => new OKRMapper(teamWikiSync));
+    return [
+        defineTool("log_okr_progress", {
+            description: "Log progress on a team OKR key result. Use when the user mentions completing work, shipping features, or making progress on goals.",
+            parameters: z.object({
+                activity: z.string().min(1).describe("Human description of what was done"),
+                krId: z.string().optional().describe("Key result identifier"),
+                delta: z.number().finite().optional().describe("Progress delta in the range 0-100"),
+                notes: z.string().optional().describe("Optional notes about the work"),
+            }),
+            handler: async (args) => {
+                if (!modeContext.canLogToAdo()) {
+                    return "OKR progress logging is only available from personal Chapterhouse instances.";
+                }
+                const mapper = createOKRMapper();
+                if (!args.krId) {
+                    const matches = await mapper.findMatchingKRs(args.activity);
+                    return matches.length > 0
+                        ? mapper.formatUpdatePrompt(args.activity, matches)
+                        : `You mentioned: "${args.activity}". I couldn't confidently map that to a team key result yet. Tell me the KR id and delta (0-100), and I'll log it.`;
+                }
+                if (args.delta === undefined) {
+                    return `I can log "${args.activity}" against ${args.krId}. What's the delta (0-100)?`;
+                }
+                const result = await createTeamPushClient().pushUpdate({
+                    activity: args.activity,
+                    krId: args.krId,
+                    delta: args.delta,
+                    notes: args.notes,
+                });
+                mapper.recordConfirmedMapping(args.activity, args.krId);
+                const deltaText = typeof result.entry?.delta === "number" ? ` (${result.entry.delta}% logged)` : "";
+                return `Logged OKR progress for ${args.krId}${deltaText}.`;
+            },
+        }),
+        defineTool("get_my_okrs", {
+            description: "Show the current OKR key results owned by this user",
+            parameters: z.object({
+                period: z.string().optional().describe("Optional OKR period in YYYY-QN format"),
+            }),
+            handler: async (args) => await getMyOkrsSummary({
+                createTeamPushClient,
+                getCurrentUser,
+                period: args.period,
+            }),
+        }),
+        defineTool("write_team_wiki", {
+            description: "Write or update a page in the shared team wiki",
+            parameters: z.object({
+                path: z.string().min(1).describe("Shared team wiki page path, starting with pages/shared/"),
+                content: z.string().describe("Full markdown content to write to the shared team wiki page"),
+            }),
+            handler: async (args) => {
+                if (!isSharedTeamWikiPath(args.path)) {
+                    return 'Shared team wiki path must start with "pages/shared/".';
+                }
+                await createTeamPushClient().writePage(args.path, args.content);
+                return `Wrote shared team wiki page: ${args.path}`;
+            },
+        }),
+        defineTool("ado_get_okrs", {
+            description: "Get current OKR status from Azure DevOps for a given period (e.g. '2026-Q2')",
+            parameters: z.object({
+                period: z.string().optional().describe("Optional OKR period such as '2026-Q2'"),
+            }),
+            handler: async (args) => {
+                if (!hasAdoPat()) {
+                    return "Azure DevOps OKR integration is not configured. Set ADO_PAT in ~/.chapterhouse/.env.";
+                }
+                return await adoGetOkrs(args.period);
+            },
+        }),
+        defineTool("ado_update_kr", {
+            description: "Update the current value of a Key Result in Azure DevOps",
+            parameters: z.object({
+                workItemId: z.number().int().positive().describe("Azure DevOps work item ID for the key result"),
+                currentValue: z.number().finite().describe("New current value for the key result"),
+                notes: z.string().optional().describe("Optional progress note to add as an ADO comment"),
+            }),
+            handler: async (args) => {
+                if (!hasAdoPat()) {
+                    return "Azure DevOps OKR integration is not configured. Set ADO_PAT in ~/.chapterhouse/.env.";
+                }
+                return await adoUpdateKr(args.workItemId, args.currentValue, args.notes);
+            },
+        }),
+        defineTool("ado_okr_summary", {
+            description: "Get a full OKR summary including percent complete for all objectives",
+            parameters: z.object({
+                period: z.string().optional().describe("Optional OKR period such as '2026-Q2'"),
+            }),
+            handler: async (args) => {
+                if (!hasAdoPat()) {
+                    return { error: "Azure DevOps OKR integration is not configured. Set ADO_PAT in ~/.chapterhouse/.env." };
+                }
+                return await adoOkrSummary(args.period);
+            },
+        }),
+        ...(hasAdoPat() ? [
+            defineTool("generate_okr_report", {
+                description: "Generate a monthly OKR report narrative for the team. Queries ADO for current KR values and drafts an executive summary.",
+                parameters: z.object({
+                    period: z.string().optional().describe("Optional OKR period such as '2026-Q2'"),
+                }),
+                handler: async (args) => {
+                    const generator = deps.createReportGenerator?.() ?? await (async () => {
+                        const { ReportGenerator } = await import("../../integrations/report-generator.js");
+                        return new ReportGenerator();
+                    })();
+                    return await generator.generateMonthlyReport(args.period?.trim() || getCurrentQuarter());
+                },
+            }),
+        ] : []),
+    ];
+}
+//# sourceMappingURL=okr.js.map

package/dist/copilot/tools/wiki.js

@@ -0,0 +1,333 @@
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+import { appendLog } from "../../wiki/log-manager.js";
+import { appendTimeline } from "../../wiki/timeline.js";
+import { assertPagePath, ensureWikiStructure, writePage } from "../../wiki/fs.js";
+import { addToIndex, buildIndexEntryForPage, reindexWikiPages, searchIndex, } from "../../wiki/index-manager.js";
+import { ingestSource, detectSourceType, looksLikeLocalFilePath } from "../../wiki/ingest.js";
+import { traverse as wikiTraverse } from "../../wiki/links.js";
+import { withWikiWrite } from "../../wiki/lock.js";
+import { loadTaxonomy } from "../../wiki/taxonomy.js";
+import { readWikiPage } from "../../wiki/team-sync.js";
+import { validateWikiFrontmatter, validateAndBackfillFrontmatter } from "../../wiki/frontmatter.js";
+import { childLogger } from "../../util/logger.js";
+const log = childLogger("tools");
+/** Sanitize a single line for safe inclusion as an index/log table entry. */
+function indexSafe(text) {
+    return text.replace(/[\r\n|]/g, " ").trim();
+}
+function sanitizeWikiUpdateError(err) {
+    if (err instanceof z.ZodError) {
+        return err.issues.map((issue) => issue.message).join("; ") || "Invalid wiki_update arguments.";
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    if (message.startsWith("Wiki page frontmatter violates the required shape:")
+        || message.startsWith("Wiki path")
+        || message.startsWith("Wiki page paths must end in .md:")
+        || message.startsWith("Refused unsafe wiki path:")
+        || message.startsWith("Refused: only pages under pages/")
+        || message === "Wiki path is required") {
+        return message;
+    }
+    return "Wiki update failed. Check the page path and frontmatter, then try again.";
+}
+function validateWikiPageInput(path, content, allowedTags = loadTaxonomy()) {
+    assertPagePath(path);
+    const backfilled = validateAndBackfillFrontmatter(path, content);
+    const nextContent = backfilled.changed ? backfilled.content : content;
+    const validation = validateWikiFrontmatter(nextContent, { allowedTags });
+    if (!validation.valid) {
+        throw new Error(validation.errors.map((error) => error.message).join("\n\n"));
+    }
+    return nextContent;
+}
+function writeWikiPageAndRefreshIndex(page, logSource) {
+    writePage(page.path, page.content);
+    const today = new Date().toISOString().slice(0, 10);
+    const rebuilt = buildIndexEntryForPage(page.path, {
+        section: page.section || "Knowledge",
+        updated: today,
+    });
+    if (rebuilt) {
+        rebuilt.section = page.section || "Knowledge";
+        addToIndex(rebuilt);
+    }
+    else {
+        addToIndex({
+            path: page.path,
+            title: page.title,
+            summary: indexSafe(page.summary),
+            section: page.section || "Knowledge",
+            updated: today,
+        });
+    }
+    appendLog("update", `${logSource}: ${indexSafe(page.title)} (${page.path})`);
+}
+const wikiPageArgsSchema = z.object({
+    path: z.string().describe("Page path relative to wiki root (e.g. 'pages/projects/chapterhouse/index.md', 'pages/projects/chapterhouse/decisions.md', 'pages/people/brian/index.md')"),
+    title: z.string().describe("Page title for the index"),
+    summary: z.string().max(160, "Summary must be 160 characters or fewer").describe("One-line summary for the index"),
+    section: z.string().optional().describe("Index section (default: 'Knowledge')"),
+    content: z.string().describe("Full page content (markdown)"),
+});
+const wikiUpdateArgsSchema = wikiPageArgsSchema;
+const wikiBatchUpdateArgsSchema = z.object({
+    pages: z.array(wikiPageArgsSchema)
+        .min(1)
+        .max(50)
+        .describe("Array of pages to create or update (1–50 items)"),
+});
+export function createWikiTools(_deps) {
+    return [
+        defineTool("remember", {
+            description: "REMOVED: Use wiki_update or memory_remember instead.",
+            parameters: z.object({}).passthrough(),
+            handler: async () => "This tool has been removed. Use wiki_update to write to wiki pages, or memory_remember for agent memory.",
+        }),
+        defineTool("recall", {
+            description: "REMOVED: Use wiki_search or memory_recall instead.",
+            parameters: z.object({}).passthrough(),
+            handler: async () => "This tool has been removed. Use wiki_search to search wiki pages, or memory_recall for agent memory.",
+        }),
+        defineTool("forget", {
+            description: "REMOVED: Use wiki_update instead.",
+            parameters: z.object({}).passthrough(),
+            handler: async () => "This tool has been removed. Use wiki_update to modify wiki pages.",
+        }),
+        // ----- New wiki tools -----
+        defineTool("wiki_search", {
+            description: "Search Chapterhouse's wiki knowledge base. Returns matching page titles, paths, and summaries " +
+                "from the wiki index. Use this to find relevant knowledge before answering questions.",
+            parameters: z.object({
+                query: z.string().describe("What to search for in the wiki"),
+            }),
+            handler: async (args) => {
+                ensureWikiStructure();
+                const matches = searchIndex(args.query, 10);
+                if (matches.length === 0)
+                    return "No matching wiki pages found.";
+                const lines = matches.map((m) => `• [${m.title}](${m.path}) — ${m.summary}`);
+                return `Found ${matches.length} page(s):\n${lines.join("\n")}`;
+            },
+        }),
+        defineTool("wiki_read", {
+            description: "Read a specific wiki page by path. Use after wiki_search to read full page content. " +
+                "Paths are relative to the wiki root. Layout: entity categories (projects, people, orgs, tools, " +
+                "topics, areas) live at 'pages/<category>/<topic>/index.md' (the topic overview) plus optional " +
+                "'pages/<category>/<topic>/<facet>.md' sub-pages; flat categories at 'pages/<category>.md' " +
+                "(preferences, facts, routines, decisions); daily summaries at 'pages/conversations/YYYY-MM-DD.md'.",
+            parameters: z.object({
+                path: z.string().describe("Path to the wiki page (e.g. 'pages/people/brian/index.md', 'pages/projects/chapterhouse/decisions.md', 'index.md')"),
+            }),
+            handler: async (args) => {
+                ensureWikiStructure();
+                const content = await readWikiPage(args.path);
+                if (!content)
+                    return `Page not found: ${args.path}`;
+                return content;
+            },
+        }),
+        defineTool("wiki_update", {
+            description: "Create or update a wiki page. You provide the full page content (markdown with optional " +
+                "YAML frontmatter). The page will be written to disk and the index updated. Use this for " +
+                "rich knowledge pages, entity pages, synthesis documents — anything more structured than " +
+                "a quick 'remember' call. After creating/updating a page, the index is automatically updated. " +
+                "PATH RULES: entity-category pages MUST be 'pages/<category>/<topic-slug>/<page>.md' where " +
+                "category is one of projects, people, orgs, tools, topics, areas, '<page>' is 'index' for the " +
+                "topic overview or a facet name (e.g. 'decisions', 'feature-ideas') — exactly one topic level, " +
+                "lowercase slugs only. Flat-category pages MUST be 'pages/<category>.md' (preferences, facts, " +
+                "routines, decisions). Bad paths are rejected with a suggested correction.",
+            parameters: wikiUpdateArgsSchema,
+            handler: async (args) => {
+                try {
+                    const parsedArgs = wikiUpdateArgsSchema.parse(args);
+                    ensureWikiStructure();
+                    return await withWikiWrite(async () => {
+                        const content = validateWikiPageInput(parsedArgs.path, parsedArgs.content);
+                        const page = { ...parsedArgs, content };
+                        writeWikiPageAndRefreshIndex(page, "wiki_update");
+                        return `Wiki page updated: ${page.title} (${page.path})`;
+                    });
+                }
+                catch (err) {
+                    const error = sanitizeWikiUpdateError(err);
+                    log.error({ err: err instanceof Error ? err.message : err, path: typeof args?.path === "string" ? args.path : undefined }, "wiki_update failed");
+                    return { error };
+                }
+            },
+        }),
+        defineTool("wiki_batch_update", {
+            description: "Create or update multiple wiki pages in a single operation. " +
+                "Each page follows the same path rules as wiki_update. " +
+                "Up to 50 pages per call. Returns a per-page success/error summary.",
+            parameters: wikiBatchUpdateArgsSchema,
+            handler: async (args) => {
+                try {
+                    const parsedArgs = wikiBatchUpdateArgsSchema.parse(args);
+                    ensureWikiStructure();
+                    return await withWikiWrite(async () => {
+                        const allowedTags = loadTaxonomy();
+                        const results = [];
+                        for (const pageArgs of parsedArgs.pages) {
+                            try {
+                                const content = validateWikiPageInput(pageArgs.path, pageArgs.content, allowedTags);
+                                writeWikiPageAndRefreshIndex({ ...pageArgs, content }, "wiki_batch_update");
+                                results.push({ path: pageArgs.path, status: "ok" });
+                            }
+                            catch (err) {
+                                results.push({
+                                    path: pageArgs.path,
+                                    status: "error",
+                                    error: sanitizeWikiUpdateError(err),
+                                });
+                            }
+                        }
+                        const createdCount = results.filter((result) => result.status === "ok").length;
+                        const errors = results.filter((result) => result.status === "error");
+                        if (errors.length === 0) {
+                            return `Created ${createdCount} pages successfully.`;
+                        }
+                        return `Created ${createdCount} pages successfully.\nErrors (${errors.length}):\n${errors.map((result) => `  • ${result.path} — ${result.error}`).join("\n")}`;
+                    });
+                }
+                catch (err) {
+                    const error = sanitizeWikiUpdateError(err);
+                    log.error({ err: err instanceof Error ? err.message : err }, "wiki_batch_update failed");
+                    return { error };
+                }
+            },
+        }),
+        defineTool("wiki_ingest", {
+            description: "REMOVED: Use wiki_ingest_source instead.",
+            parameters: z.object({}).passthrough(),
+            handler: async () => "This tool has been removed. Use wiki_ingest_source instead.",
+        }),
+        defineTool("wiki_lint", {
+            description: "REMOVED: Wiki health checks are no longer needed.",
+            parameters: z.object({}).passthrough(),
+            handler: async () => "This tool has been removed. Wiki health checks are no longer needed with SQLite-backed storage.",
+        }),
+        defineTool("wiki_rebuild_index", {
+            description: "REMOVED: The wiki index is maintained automatically.",
+            parameters: z.object({}).passthrough(),
+            handler: async () => "This tool has been removed. The wiki index is now maintained automatically via SQLite FTS5.",
+        }),
+        defineTool("wiki_reindex", {
+            description: "Force a full wiki filesystem-to-SQLite reindex pass.",
+            parameters: z.object({}),
+            handler: async () => {
+                ensureWikiStructure();
+                const result = reindexWikiPages();
+                appendLog("update", `wiki_reindex: rebuilt ${result.indexedPageCount} page(s)`);
+                return `Reindexed ${result.indexedPageCount} wiki page(s) from disk.`;
+            },
+        }),
+        defineTool("wiki_traverse", {
+            description: "Walk the wiki entity graph from a starting page. Returns pages connected by typed links. " +
+                "Use to discover related knowledge, trace dependencies, find who works on a project, etc. " +
+                "Depth 1 returns direct neighbors; depth 2-3 expands further (max 3). " +
+                "Optionally filter by link_type: references, implements, supersedes, member_of, works_on, decided_by, depends_on, attended, follow_up.",
+            parameters: z.object({
+                page: z.string().describe("Wiki page path to traverse from (e.g. 'pages/topics/rust/index.md')"),
+                link_type: z.string().optional().describe("Filter by link type (e.g. 'references', 'implements')"),
+                depth: z.number().int().min(1).max(3).optional().describe("Traversal depth (1–3, default 1)"),
+            }),
+            handler: async (args) => {
+                ensureWikiStructure();
+                const results = wikiTraverse(args.page, args.link_type, args.depth ?? 1);
+                if (results.length === 0)
+                    return `No linked pages found for: ${args.page}`;
+                const lines = results.map((r) => `• [depth ${r.depth}] ${r.direction === "outbound" ? "→" : "←"} ${r.page} (${r.link_type})`);
+                return `Found ${results.length} linked page(s):\n${lines.join("\n")}`;
+            },
+        }),
+        defineTool("wiki_fix", {
+            description: "REMOVED: Use wiki_update instead.",
+            parameters: z.object({}).passthrough(),
+            handler: async () => "This tool has been removed. Use wiki_update to correct wiki pages.",
+        }),
+        defineTool("wiki_append_timeline", {
+            description: "Append an entry to the '## Timeline' section of a wiki page. " +
+                "Creates the section (and the page itself) if absent. " +
+                "Timeline is append-only — existing entries are never modified. " +
+                "Use for recording events, source ingestion, and interaction history.",
+            parameters: z.object({
+                page: z.string().describe("Relative path from wiki root (e.g. 'pages/people/alice/index.md')"),
+                entry: z.string().describe("Markdown text for the timeline entry"),
+                source_id: z.string().optional().describe("Optional reference to a wiki_sources id"),
+            }),
+            handler: async (args) => {
+                ensureWikiStructure();
+                try {
+                    const entry = args.source_id
+                        ? `${args.entry}\n\n_Source: ${args.source_id}_`
+                        : args.entry;
+                    return await withWikiWrite(async () => {
+                        appendTimeline(args.page, entry);
+                        return `Timeline entry appended to ${args.page}`;
+                    });
+                }
+                catch (err) {
+                    log.error({ err: err instanceof Error ? err.message : err, page: args.page }, "wiki_append_timeline failed");
+                    return { error: err instanceof Error ? err.message : "wiki_append_timeline failed" };
+                }
+            },
+        }),
+        defineTool("wiki_ingest_source", {
+            description: "Ingest an external source (URL, PDF, Git repo, or raw text) into the PKB. " +
+                "Fetches and parses the content, extracts entities with LLM, creates/updates wiki pages, " +
+                "and writes timeline entries. Idempotent: re-ingesting the same source returns the existing result. " +
+                "Type is auto-detected if omitted.",
+            parameters: z.object({
+                source: z.string().describe("URL, file path, git repo URL, or raw text content to ingest"),
+                type: z.enum(["url", "pdf", "repo", "text"]).optional().describe("Source type. Auto-detected if omitted: http(s) URL → url/repo, .pdf path → pdf, else text"),
+                topic: z.string().optional().describe("Optional hint for entity extraction focus"),
+                session_id: z.string().optional().describe("Optional research session id to persist in wiki_sources"),
+                session_name: z.string().optional().describe("Optional human-readable research session name"),
+            }),
+            handler: async (args) => {
+                ensureWikiStructure();
+                try {
+                    if (looksLikeLocalFilePath(args.source)) {
+                        return {
+                            error: "wiki_ingest_source does not support local file paths. Provide a URL, git repo URL, or raw text content.",
+                        };
+                    }
+                    const sourceType = args.type ?? detectSourceType(args.source);
+                    const result = await ingestSource(args.source, sourceType, args.topic, {
+                        sessionId: args.session_id,
+                        sessionName: args.session_name,
+                    });
+                    if (result.already_existed) {
+                        return (`Source already ingested (id: ${result.source_id}).\n` +
+                            `Pages previously updated: ${result.pages_updated.length > 0 ? result.pages_updated.join(", ") : "none"}`);
+                    }
+                    const lines = [
+                        `✅ Ingested source (id: ${result.source_id})`,
+                    ];
+                    if (result.pages_created.length > 0) {
+                        lines.push(`📄 Pages created (${result.pages_created.length}): ${result.pages_created.join(", ")}`);
+                    }
+                    if (result.pages_updated.length > 0) {
+                        lines.push(`✏️ Pages updated (${result.pages_updated.length}): ${result.pages_updated.join(", ")}`);
+                    }
+                    if (result.entities.length > 0) {
+                        lines.push(`🔍 Entities extracted (${result.entities.length}):`);
+                        for (const e of result.entities) {
+                            lines.push(`  • ${e.name} (${e.type}) → ${e.path}`);
+                        }
+                    }
+                    else {
+                        lines.push("🔍 No entities extracted.");
+                    }
+                    return lines.join("\n");
+                }
+                catch (err) {
+                    log.error({ err: err instanceof Error ? err.message : err }, "wiki_ingest_source failed");
+                    return { error: err instanceof Error ? err.message : "Ingestion failed" };
+                }
+            },
+        }),
+    ];
+}
+//# sourceMappingURL=wiki.js.map

package/dist/copilot/tools-deps.js

@@ -0,0 +1,4 @@
+export * from "./agents.js";
+export * as agentsModule from "./agents.js";
+export { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentSessionKey, sendToAgentSession, switchSessionModel, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, } from "./orchestrator.js";
+//# sourceMappingURL=tools-deps.js.map

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

@@ -3,6 +3,7 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
+let activeMockState;
 function createActiveProjectRules() {
     return {
         project: {
@@ -66,29 +67,30 @@ async function loadToolsModule(t, options) {
     const sentPrompts = [];
     const persistentSends = [];
     const taskId = options?.taskId ?? `delegated-task-${Date.now()}-${Math.random()}`;
+    activeMockState = { options, sentPrompts, persistentSends, taskId };
     const fakeSession = {
         on: () => () => { },
         async sendAndWait(request) {
-            sentPrompts.push(request.prompt);
+            activeMockState.sentPrompts.push(request.prompt);
             return { data: { content: `handled: ${request.prompt}` } };
         },
         async destroy() { },
     };
     t.mock.module("./orchestrator.js", {
         namedExports: {
-            getCurrentSourceChannel: () => options?.sourceChannel ?? "web",
+            getCurrentSourceChannel: () => activeMockState.options?.sourceChannel ?? "web",
             getCurrentActivityCallback: () => undefined,
             getCurrentAuthenticatedUser: () => undefined,
             getLastAuthenticatedUser: () => undefined,
             getCurrentAuthorizationHeader: () => undefined,
             getCurrentSessionKey: () => "session-test",
-            getCurrentActiveProjectRules: () => options?.activeProjectRules ?? null,
+            getCurrentActiveProjectRules: () => activeMockState.options?.activeProjectRules ?? null,
             maybeScheduleScopeChangeCheckpoint: () => { },
             invalidateOrchestratorSession: () => { },
             resetCheckpointSessionState: () => { },
             switchSessionModel: async () => { },
             sendToAgentSession: async (slug, prompt, delegatedTaskId) => {
-                persistentSends.push({ slug, prompt, taskId: delegatedTaskId });
+                activeMockState.persistentSends.push({ slug, prompt, taskId: delegatedTaskId });
                 return `persistent handled: ${prompt}`;
             },
         },
@@ -105,7 +107,7 @@ async function loadToolsModule(t, options) {
                     ? { slug: "bellonda", name: "Bellonda", model: "claude-sonnet-4.6", persistent: true, scope: "infra" }
                     : undefined,
             createEphemeralAgentSession: async () => {
-                if (options?.persistentAgent) {
+                if (activeMockState.options?.persistentAgent) {
                     throw new Error("persistent agent should not use ephemeral session");
                 }
                 return fakeSession;
@@ -113,14 +115,14 @@ async function loadToolsModule(t, options) {
             getAgentSessionStatus: () => ({ tasks: [] }),
             getActiveTasks: () => [],
             getTask: () => undefined,
-            createTaskId: () => taskId,
+            createTaskId: () => activeMockState.taskId,
             registerTask: () => ({
-                taskId,
+                taskId: activeMockState.taskId,
                 agentSlug: "coder",
                 description: "Show dispatched prompt",
                 status: "running",
                 startedAt: Date.now(),
-                originChannel: options?.sourceChannel ?? "web",
+                originChannel: activeMockState.options?.sourceChannel ?? "web",
             }),
             completeTask: () => { },
             failTask: () => { },

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

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+async function loadToolsIndex() {
+    process.env.ADO_PAT = "inventory-test-pat";
+    return await import(new URL(`./tools/index.js?case=${Date.now()}-${Math.random()}`, import.meta.url).href);
+}
+test("createTools returns the full expected tool set without duplicate names", async () => {
+    const toolsModule = await loadToolsIndex();
+    const tools = toolsModule.createTools({
+        client: { async listModels() { return []; } },
+        onAgentTaskComplete: () => { },
+        createReportGenerator: () => ({
+            async generateMonthlyReport() {
+                return "inventory test report";
+            },
+        }),
+    });
+    const names = tools.map((tool) => tool.name);
+    const expectedNames = [
+        "delegate_to_agent",
+        "check_agent_status",
+        "get_agent_result",
+        "show_agent_roster",
+        "teams_notify",
+        "log_okr_progress",
+        "get_my_okrs",
+        "write_team_wiki",
+        "ado_get_okrs",
+        "ado_update_kr",
+        "ado_okr_summary",
+        "generate_okr_report",
+        "hire_agent",
+        "fire_agent",
+        "list_machine_sessions",
+        "attach_machine_session",
+        "list_skills",
+        "learn_skill",
+        "uninstall_skill",
+        "list_models",
+        "switch_model",
+        "toggle_auto",
+        "memory_remember",
+        "memory_propose",
+        "memory_create_scope",
+        "memory_add_action_item",
+        "memory_complete_action_item",
+        "memory_drop_action_item",
+        "memory_snooze_action_item",
+        "memory_list_action_items",
+        "memory_recall",
+        "memory_housekeep",
+        "memory_reflect",
+        "memory_promote",
+        "memory_demote",
+        "memory_set_scope",
+        "remember",
+        "recall",
+        "forget",
+        "wiki_search",
+        "wiki_read",
+        "wiki_update",
+        "wiki_batch_update",
+        "wiki_ingest",
+        "wiki_lint",
+        "wiki_rebuild_index",
+        "wiki_reindex",
+        "wiki_traverse",
+        "wiki_fix",
+        "wiki_append_timeline",
+        "wiki_ingest_source",
+        "restart_chapterhouse",
+    ];
+    assert.deepEqual([...names].sort(), [...expectedNames].sort());
+    assert.equal(new Set(names).size, names.length);
+});
+//# sourceMappingURL=tools.inventory.test.js.map