chapterhouse 0.9.2 → 0.10.0

package/dist/copilot/tools.js

@@ -1,1781 +1,2 @@
-import { z } from "zod";
-import { approveAll, defineTool } from "@github/copilot-sdk";
-import { getDb, appendTaskOutputDeltaEvent, appendTaskStatusEvent, updateTaskResult } from "../store/db.js";
-import { readdirSync, readFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-import { listSkills, createSkill, removeSkill } from "./skills.js";
-import { config, persistModel } from "../config.js";
-import { ModeContext } from "../mode-context.js";
-import { agentEventBus } from "./agent-event-bus.js";
-import { getCurrentSourceChannel, getCurrentActivityCallback, getCurrentActiveProjectRules, getCurrentAuthenticatedUser, getLastAuthenticatedUser, getCurrentAuthorizationHeader, getCurrentSessionKey, sendToAgentSession, invalidateOrchestratorSession, maybeScheduleScopeChangeCheckpoint, resetCheckpointSessionState, switchSessionModel, } from "./orchestrator.js";
-import { getRouterConfig, updateRouterConfig } from "./router.js";
-import { ensureWikiStructure, writePage, assertPagePath } from "../wiki/fs.js";
-import { searchIndex, addToIndex, buildIndexEntryForPage, reindexWikiPages, } from "../wiki/index-manager.js";
-import { traverse as wikiTraverse } from "../wiki/links.js";
-import { validateWikiFrontmatter, validateAndBackfillFrontmatter } from "../wiki/frontmatter.js";
-import { appendTimeline } from "../wiki/timeline.js";
-import { ingestSource, detectSourceType, looksLikeLocalFilePath } from "../wiki/ingest.js";
-import { appendLog } from "../wiki/log-manager.js";
-import { loadTaxonomy } from "../wiki/taxonomy.js";
-import { topicPagePath } from "../wiki/topic-structure.js";
-import { withWikiWrite } from "../wiki/lock.js";
-import { readWikiPage, teamWikiSync } from "../wiki/team-sync.js";
-import { getAgentRegistry, getAgent, createEphemeralAgentSession, getAgentSessionStatus, getTask, registerTask, completeTask, failTask, createTaskId, createAgentFile, removeAgentFile, loadAgents, } from "./agents.js";
-import * as agentsModule from "./agents.js";
-import { detectProjectRuleWarnings } from "./project-rule-warnings.js";
-import { renderDelegatedProjectRulesPreamble } from "./project-rules-injection.js";
-import { adoGetOkrs, adoOkrSummary, adoUpdateKr } from "../integrations/ado-skill.js";
-import { TeamsNotifier } from "../integrations/teams-notify.js";
-import { TeamPushClient } from "../integrations/team-push.js";
-import { OKRMapper, parseOKRPageContent } from "./okr-mapper.js";
-import { childLogger } from "../util/logger.js";
-import { getActiveScope as getMemoryActiveScope, createScope as createMemoryScope, getScope as getMemoryScope, inferScopeFromText, completeActionItem, demoteToCold, demoteToWarm, dropActionItem, queueMemoryProposal, recall as recallMemory, listActionItems, recordDecision, recordActionItem, recordObservation, runHousekeeping, reflectOnScope, reflectAllScopes, setActiveScope as setMemoryActiveScope, snoozeActionItem, promoteToHot, upsertEntity, hookDispatcher, } from "../memory/index.js";
-const log = childLogger("tools");
-const modeContext = new ModeContext(config);
-/** Escape a string for safe inclusion as a single-line YAML scalar value. */
-function yamlEscape(value) {
-    // Always quote and escape backslashes, double quotes, and newlines.
-    const escaped = value
-        .replace(/\\/g, "\\\\")
-        .replace(/"/g, '\\"')
-        .replace(/\n/g, "\\n")
-        .replace(/\r/g, "\\r");
-    return `"${escaped}"`;
-}
-/** Escape a single token for use inside a YAML inline list `[a, b]`. */
-function yamlListItem(value) {
-    // Restrict to a safe character set; replace anything else.
-    const safe = value.replace(/[^A-Za-z0-9_./-]/g, "-");
-    return safe || "untagged";
-}
-/** 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 isTimeoutError(err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    return /timeout|timed?\s*out/i.test(msg);
-}
-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})`);
-}
-function hasAdoPat() {
-    return (process.env.ADO_PAT?.trim() || config.adoPat).length > 0;
-}
-function requireOrchestratorMemoryWrite() {
-    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
-    if (agentSlug && agentSlug !== "chapterhouse") {
-        return "Memory writes are orchestrator-only. Use memory_propose instead.";
-    }
-    return null;
-}
-function resolveProposalScopeSlug(requestedScopeSlug) {
-    if (requestedScopeSlug) {
-        return requestedScopeSlug;
-    }
-    const agentSlug = agentsModule.getCurrentToolAgentSlug?.();
-    if (!agentSlug || agentSlug === "chapterhouse") {
-        return getMemoryActiveScope()?.slug;
-    }
-    const agent = getAgent(agentSlug);
-    const boundScope = agent?.scope ?? loadAgents().find((entry) => entry.slug === agentSlug)?.scope;
-    if (boundScope && getMemoryScope(boundScope)) {
-        return boundScope;
-    }
-    return getMemoryActiveScope()?.slug;
-}
-function resolveMemoryScopeForWrite(explicitScope, content) {
-    const explicit = explicitScope ? getMemoryScope(explicitScope) : undefined;
-    if (explicitScope && !explicit) {
-        throw new Error(`Unknown memory scope '${explicitScope}'.`);
-    }
-    if (explicit) {
-        return { scopeId: explicit.id, scopeSlug: explicit.slug };
-    }
-    const active = getMemoryActiveScope();
-    if (active) {
-        return { scopeId: active.id, scopeSlug: active.slug };
-    }
-    const inferred = inferScopeFromText(content);
-    if (inferred) {
-        const inferredScope = getMemoryScope(inferred.scope_id);
-        if (inferredScope) {
-            return { scopeId: inferredScope.id, scopeSlug: inferredScope.slug };
-        }
-    }
-    const validScopes = getDb().prepare(`
-    SELECT slug
-    FROM mem_scopes
-    WHERE active = 1
-    ORDER BY slug
-  `).all();
-    const activeScope = getMemoryActiveScope()?.slug ?? "none";
-    throw new Error(`No scope inferred. Active scope: ${activeScope}. Valid scopes: [${validScopes.map((row) => row.slug).join(", ")}]. `
-        + "Set active scope with memory_set_scope or pass scope explicitly.");
-}
-const observationProposalPayloadSchema = z.object({
-    content: z.string(),
-    entity_id: z.number().int().positive().optional(),
-    source: z.string().optional(),
-});
-const decisionProposalPayloadSchema = z.object({
-    title: z.string(),
-    rationale: z.string().optional(),
-    decided_at: z.string().optional(),
-});
-const entityProposalPayloadSchema = z.object({
-    name: z.string(),
-    entity_kind: z.string().optional(),
-    kind: z.string().optional(),
-    summary: z.string().optional(),
-}).superRefine((value, context) => {
-    if (!value.entity_kind && !value.kind) {
-        context.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "entity_kind is required for entity proposals.",
-            path: ["entity_kind"],
-        });
-    }
-}).transform((value) => ({
-    name: value.name,
-    entity_kind: value.entity_kind ?? value.kind,
-    summary: value.summary,
-}));
-const actionItemProposalPayloadSchema = z.object({
-    title: z.string().trim().min(1, "title is required for action_item proposals."),
-    detail: z.string().optional(),
-    due_at: z.string().optional(),
-    source: z.string().optional(),
-    entity_id: z.number().int().positive().optional(),
-    entity_name: z.string().trim().min(1, "entity_name must be non-empty when provided.").optional(),
-    entity_kind: z.string().trim().min(1, "entity_kind must be non-empty when provided.").optional(),
-}).superRefine((value, context) => {
-    if ((value.entity_name && !value.entity_kind) || (!value.entity_name && value.entity_kind)) {
-        context.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "entity_name and entity_kind must be provided together for action_item proposals.",
-            path: ["entity_name"],
-        });
-    }
-    if (value.entity_id !== undefined && value.entity_name) {
-        context.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Provide either entity_id or entity_name/entity_kind for action_item proposals, not both.",
-            path: ["entity_id"],
-        });
-    }
-});
-const memoryProposeArgsSchema = z.object({
-    kind: z.enum(["observation", "decision", "entity", "action_item"]),
-    scope_slug: z.string().optional(),
-    payload: z.record(z.string(), z.unknown()),
-    confidence: z.number().min(0).max(1).optional(),
-    reason: z.string().optional(),
-}).superRefine((value, context) => {
-    const schema = value.kind === "observation"
-        ? observationProposalPayloadSchema
-        : value.kind === "decision"
-            ? decisionProposalPayloadSchema
-            : value.kind === "entity"
-                ? entityProposalPayloadSchema
-                : actionItemProposalPayloadSchema;
-    const parsed = schema.safeParse(value.payload);
-    if (!parsed.success) {
-        for (const issue of parsed.error.issues) {
-            context.addIssue({
-                code: z.ZodIssueCode.custom,
-                message: issue.message,
-                path: ["payload", ...issue.path],
-            });
-        }
-    }
-});
-const memoryTierTableSchema = z.enum(["observation", "decision", "entity", "action_item"]);
-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)"),
-});
-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")}`;
-}
-export function createTools(deps) {
-    const getCurrentUser = deps.getCurrentUser ?? (() => getCurrentAuthenticatedUser() ?? getLastAuthenticatedUser());
-    const createTeamPushClient = deps.createTeamPushClient ?? (() => new TeamPushClient({
-        getAuthorizationHeader: getCurrentAuthorizationHeader,
-        getCurrentUser,
-    }));
-    const createOKRMapper = deps.createOKRMapper ?? (() => new OKRMapper(teamWikiSync));
-    return [
-        // ----- Agent Delegation Tools (for @chapterhouse) -----
-        defineTool("delegate_to_agent", {
-            description: "Delegate a task to a specialist agent. The task runs in the background — you'll be notified when it's done. " +
-                "Available agents: use show_agent_roster to see the roster. For @general-purpose, specify model_override based on task complexity.",
-            parameters: z.object({
-                agent_name: z.string().describe("Name or slug of the agent to delegate to (e.g. 'coder', 'designer', 'general-purpose')"),
-                task: z.string().describe("Detailed task description for the agent"),
-                summary: z.string().describe("Short human-readable summary of the task (under 80 chars, e.g. 'Fix login button styling')"),
-                model_override: z.string().optional().describe("Model override for agents with model 'auto' (e.g. 'gpt-4.1', 'claude-sonnet-4.6', 'claude-opus-4.6')"),
-            }),
-            handler: async (args) => {
-                const agent = getAgent(args.agent_name);
-                if (agent?.slug === "chapterhouse") {
-                    return "Cannot delegate to yourself. Handle this directly or pick a specialist agent.";
-                }
-                if (!agent) {
-                    const available = getAgentRegistry().map((a) => a.slug).join(", ");
-                    return `Agent '${args.agent_name}' not found. Available agents: ${available}`;
-                }
-                const delegatedSlug = agent.slug;
-                const taskId = createTaskId();
-                const task = registerTask(delegatedSlug, args.summary, getCurrentSourceChannel(), taskId);
-                const activeProjectRules = getCurrentActiveProjectRules();
-                const warningLines = activeProjectRules
-                    ? detectProjectRuleWarnings(args.task, activeProjectRules.rules.hard)
-                    : [];
-                const warningBlock = warningLines.length > 0 ? `${warningLines.join("\n")}\n\n` : "";
-                const taskPrompt = activeProjectRules
-                    ? `${warningBlock}${renderDelegatedProjectRulesPreamble(activeProjectRules.project.slug, activeProjectRules.project.path, activeProjectRules.rules.path, activeProjectRules.rules.hard, activeProjectRules.rules.soft)}\n\n${args.task}`
-                    : args.task;
-                // Persist task to DB
-                const db = getDb();
-                db.prepare(`INSERT INTO agent_tasks (task_id, agent_slug, description, prompt, status, origin_channel, session_key, source)
-           VALUES (?, ?, ?, ?, 'running', ?, ?, 'adhoc')`).run(task.taskId, delegatedSlug, args.summary, args.task, task.originChannel || null, getCurrentSessionKey());
-                if (agent.persistent) {
-                    (async () => {
-                        try {
-                            const output = await sendToAgentSession(delegatedSlug, taskPrompt, task.taskId);
-                            completeTask(task.taskId, output);
-                            updateTaskResult(task.taskId, "completed", output);
-                            const statusEvent = appendTaskStatusEvent(task.taskId, "completed");
-                            if (statusEvent) {
-                                void agentEventBus.emit({
-                                    type: "session:tool_call",
-                                    sessionId: task.taskId,
-                                    payload: {
-                                        toolName: "",
-                                        toolArgs: {},
-                                        _kind: statusEvent.kind,
-                                        _seq: statusEvent.seq,
-                                        _ts: statusEvent.ts,
-                                        _summary: statusEvent.summary,
-                                        _text: statusEvent.text,
-                                        _status: statusEvent.status,
-                                    },
-                                    timestamp: new Date(statusEvent.ts),
-                                });
-                            }
-                            deps.onAgentTaskComplete(task.taskId, delegatedSlug, output);
-                        }
-                        catch (err) {
-                            const msg = err instanceof Error ? err.message : String(err);
-                            failTask(task.taskId, msg);
-                            updateTaskResult(task.taskId, "error", msg);
-                            const statusEvent = appendTaskStatusEvent(task.taskId, "error", msg);
-                            if (statusEvent) {
-                                void agentEventBus.emit({
-                                    type: "session:tool_call",
-                                    sessionId: task.taskId,
-                                    payload: {
-                                        toolName: "",
-                                        toolArgs: {},
-                                        _kind: statusEvent.kind,
-                                        _seq: statusEvent.seq,
-                                        _ts: statusEvent.ts,
-                                        _summary: statusEvent.summary,
-                                        _text: statusEvent.text,
-                                        _status: statusEvent.status,
-                                    },
-                                    timestamp: new Date(statusEvent.ts),
-                                });
-                            }
-                            deps.onAgentTaskComplete(task.taskId, delegatedSlug, `Error: ${msg}`);
-                        }
-                    })();
-                    const model = (args.model_override && args.model_override.length > 0)
-                        ? args.model_override
-                        : (agent.model === "auto" ? "claude-sonnet-4.6" : agent.model || "claude-sonnet-4.6");
-                    return `Task delegated to @${delegatedSlug} (${model}). Task ID: ${task.taskId}. I'll notify you when it's done.`;
-                }
-                let session;
-                try {
-                    const allTools = createTools(deps);
-                    session = await createEphemeralAgentSession(agent.slug, deps.client, allTools, args.model_override, undefined, taskId);
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    return `Failed to create session for @${delegatedSlug}: ${msg}`;
-                }
-                // Capture the parent's activity callback so the child session can stream
-                // its events back to the originating SSE connection. This survives past
-                // the parent assistant turn — the child runs long after the parent's
-                // `executeOnSession` finishes.
-                const parentActivity = getCurrentActivityCallback();
-                const childUnsubs = [];
-                const emitTaskLogEvent = (taskEvent) => {
-                    void agentEventBus.emit({
-                        type: "session:tool_call",
-                        sessionId: task.taskId,
-                        payload: {
-                            toolName: "",
-                            toolArgs: {},
-                            _kind: taskEvent.kind,
-                            _seq: taskEvent.seq,
-                            _ts: taskEvent.ts,
-                            _summary: taskEvent.summary,
-                            _text: taskEvent.text,
-                            _status: taskEvent.status,
-                        },
-                        timestamp: new Date(taskEvent.ts),
-                    });
-                };
-                let workerOutput = "";
-                childUnsubs.push(session.on("assistant.message_delta", (event) => {
-                    const delta = typeof event.data.deltaContent === "string" ? event.data.deltaContent : "";
-                    if (!delta)
-                        return;
-                    workerOutput += delta;
-                    const taskEvent = appendTaskOutputDeltaEvent(task.taskId, delta);
-                    if (!taskEvent)
-                        return;
-                    emitTaskLogEvent(taskEvent);
-                }));
-                if (parentActivity) {
-                    childUnsubs.push(session.on("assistant.reasoning_delta", (event) => {
-                        parentActivity({
-                            kind: "thinking_delta",
-                            reasoningId: event.data.reasoningId,
-                            deltaContent: event.data.deltaContent,
-                            agentSlug: delegatedSlug,
-                        });
-                    }), session.on("tool.execution_start", (event) => {
-                        const data = event.data;
-                        parentActivity({
-                            kind: "tool_start",
-                            toolCallId: data.toolCallId,
-                            toolName: data.toolName,
-                            mcpServerName: data.mcpServerName,
-                            arguments: data.arguments,
-                            agentSlug: delegatedSlug,
-                        });
-                    }), session.on("tool.execution_complete", (event) => {
-                        const data = event.data;
-                        const result = data.result;
-                        const resultPreview = typeof result?.content === "string" ? result.content.slice(0, 400) : undefined;
-                        const detailedContent = typeof result?.detailedContent === "string"
-                            ? result.detailedContent
-                            : typeof result?.content === "string"
-                                ? result.content
-                                : undefined;
-                        parentActivity({
-                            kind: "tool_complete",
-                            toolCallId: data.toolCallId,
-                            success: data.success,
-                            resultPreview,
-                            detailedContent,
-                            agentSlug: delegatedSlug,
-                        });
-                    }));
-                }
-                const timeoutMs = config.workerTimeoutMs;
-                // Non-blocking: dispatch and return immediately. Session is always destroyed after.
-                (async () => {
-                    try {
-                        const result = await session.sendAndWait({ prompt: taskPrompt }, timeoutMs);
-                        const output = workerOutput || result?.data?.content || "No response";
-                        completeTask(task.taskId, output);
-                        updateTaskResult(task.taskId, "completed", output);
-                        const statusEvent = appendTaskStatusEvent(task.taskId, "completed");
-                        if (statusEvent)
-                            emitTaskLogEvent(statusEvent);
-                        deps.onAgentTaskComplete(task.taskId, delegatedSlug, output);
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        failTask(task.taskId, msg);
-                        updateTaskResult(task.taskId, "error", msg);
-                        const statusEvent = appendTaskStatusEvent(task.taskId, "error", msg);
-                        if (statusEvent)
-                            emitTaskLogEvent(statusEvent);
-                        deps.onAgentTaskComplete(task.taskId, delegatedSlug, `Error: ${msg}`);
-                    }
-                    finally {
-                        for (const unsub of childUnsubs) {
-                            try {
-                                unsub();
-                            }
-                            catch { /* best effort */ }
-                        }
-                        session.destroy().catch(() => { });
-                    }
-                })();
-                const model = (args.model_override && args.model_override.length > 0)
-                    ? args.model_override
-                    : (agent.model === "auto" ? "claude-sonnet-4.6" : agent.model || "claude-sonnet-4.6");
-                return `Task delegated to @${delegatedSlug} (${model}). Task ID: ${task.taskId}. I'll notify you when it's done.`;
-            },
-        }),
-        defineTool("check_agent_status", {
-            description: "Check the status of an agent or a specific delegated task.",
-            parameters: z.object({
-                agent_name: z.string().optional().describe("Agent name/slug to check"),
-                task_id: z.string().optional().describe("Specific task ID to check"),
-            }),
-            handler: async (args) => {
-                if (args.task_id) {
-                    const task = getTask(args.task_id);
-                    if (!task)
-                        return `Task '${args.task_id}' not found.`;
-                    const elapsed = Math.round((Date.now() - task.startedAt) / 1000);
-                    let info = `Task ${task.taskId} (@${task.agentSlug})\nStatus: ${task.status}\nDescription: ${task.description}\nElapsed: ${elapsed}s`;
-                    if (task.result)
-                        info += `\n\nResult:\n${task.result.slice(0, 2000)}`;
-                    return info;
-                }
-                if (args.agent_name) {
-                    const agent = getAgent(args.agent_name);
-                    if (!agent)
-                        return `Agent '${args.agent_name}' not found.`;
-                    const status = getAgentSessionStatus(agent.slug);
-                    let info = `@${agent.slug} (${agent.name})\nModel: ${agent.model}`;
-                    if (status.tasks.length > 0) {
-                        info += `\n\nActive tasks (${status.tasks.length}):`;
-                        for (const t of status.tasks) {
-                            info += `\n• ${t.taskId}: ${t.description} (${t.status})`;
-                        }
-                    }
-                    return info;
-                }
-                // Show all agents
-                const agents = getAgentRegistry();
-                const lines = agents.map((a) => {
-                    const status = getAgentSessionStatus(a.slug);
-                    const runningTasks = status.tasks.filter((t) => t.status === "running");
-                    const sessionBadge = runningTasks.length > 0 ? "●" : "○";
-                    const taskInfo = runningTasks.length > 0 ? ` (${runningTasks.length} task(s) running)` : "";
-                    return `${sessionBadge} @${a.slug} — ${a.description} [${a.model}]${taskInfo}`;
-                });
-                return `Agents (${agents.length}):\n${lines.join("\n")}`;
-            },
-        }),
-        defineTool("get_agent_result", {
-            description: "Get the result of a completed agent task.",
-            parameters: z.object({
-                task_id: z.string().describe("The task ID (from delegate_to_agent)"),
-            }),
-            handler: async (args) => {
-                const task = getTask(args.task_id);
-                if (!task) {
-                    // Check DB for completed tasks that may have been cleared from memory
-                    const db = getDb();
-                    const row = db.prepare(`SELECT * FROM agent_tasks WHERE task_id = ?`).get(args.task_id);
-                    if (!row)
-                        return `Task '${args.task_id}' not found.`;
-                    return `Task ${row.task_id} (@${row.agent_slug})\nStatus: ${row.status}\nDescription: ${row.description}\n\nResult:\n${row.result || "(no result)"}`;
-                }
-                if (task.status === "running") {
-                    const elapsed = Math.round((Date.now() - task.startedAt) / 1000);
-                    return `Task ${task.taskId} is still running (${elapsed}s elapsed).`;
-                }
-                return `Task ${task.taskId} (@${task.agentSlug}) — ${task.status}\n\nResult:\n${task.result || "(no result)"}`;
-            },
-        }),
-        defineTool("show_agent_roster", {
-            description: "List all registered agents with their name, model, status, and current tasks.",
-            parameters: z.object({}),
-            handler: async () => {
-                const agents = getAgentRegistry();
-                const chLines = agents.map((a) => {
-                    const status = getAgentSessionStatus(a.slug);
-                    const runningTasks = status.tasks.filter((t) => t.status === "running");
-                    const badge = runningTasks.length > 0 ? "● working" : "○ idle";
-                    const taskInfo = runningTasks.length > 0
-                        ? `\n    Tasks: ${runningTasks.map((t) => `${t.taskId}: ${t.description}`).join(", ")}`
-                        : "";
-                    return `• @${a.slug} (${a.name}) — ${a.model} — ${badge}${taskInfo}\n  ${a.description}`;
-                });
-                if (chLines.length === 0)
-                    return "No agents registered.";
-                return `Registered agents (${chLines.length}):\n${chLines.join("\n")}`;
-            },
-        }),
-        defineTool("teams_notify", {
-            description: "Send a notification to the team Microsoft Teams channel",
-            parameters: z.object({
-                title: z.string().min(1).describe("Notification title"),
-                message: z.string().min(1).describe("Notification body"),
-            }),
-            handler: async (args) => {
-                const notifier = new TeamsNotifier();
-                const sent = await notifier.sendMessage(args.title, args.message);
-                return sent
-                    ? "Sent notification to the team Microsoft Teams channel."
-                    : "Teams notifications are disabled or TEAMS_WEBHOOK_URL is not configured.";
-            },
-        }),
-        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());
-                },
-            }),
-        ] : []),
-        defineTool("hire_agent", {
-            description: "Create a new custom agent by writing an .agent.md file to ~/.chapterhouse/agents/. " +
-                "The agent will be available immediately after creation.",
-            parameters: z.object({
-                slug: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).describe("Kebab-case identifier, e.g. 'data-analyst'"),
-                name: z.string().describe("Human-readable name"),
-                description: z.string().describe("One-line description of the agent's specialty"),
-                model: z.string().describe("Model to use (e.g. 'claude-sonnet-4.6', 'gpt-5.4', or 'auto')"),
-                system_prompt: z.string().describe("The agent's system prompt (markdown)"),
-                skills: z.array(z.string()).optional().describe("Skills to attach to this agent"),
-                tools: z.array(z.string()).optional().describe("Tool allowlist (omit for all execution tools)"),
-            }),
-            handler: async (args) => {
-                const err = createAgentFile(args.slug, args.name, args.description, args.model, args.system_prompt, args.skills, args.tools);
-                if (err)
-                    return err;
-                // Reload registry
-                loadAgents();
-                return `Agent @${args.slug} created. It's ready for delegation.`;
-            },
-        }),
-        defineTool("fire_agent", {
-            description: "Remove a custom agent's .agent.md file and destroy its session. Cannot remove built-in agents.",
-            parameters: z.object({
-                slug: z.string().describe("The agent slug to remove"),
-            }),
-            handler: async (args) => {
-                const err = removeAgentFile(args.slug);
-                if (err)
-                    return err;
-                loadAgents();
-                return `Agent @${args.slug} removed.`;
-            },
-        }),
-        defineTool("list_machine_sessions", {
-            description: "List ALL Copilot CLI sessions on this machine — including sessions started from VS Code, " +
-                "the terminal, or other tools. Shows session ID, summary, working directory. " +
-                "Use this when the user asks about existing sessions running on the machine. " +
-                "By default shows the 20 most recently active sessions.",
-            parameters: z.object({
-                cwd_filter: z.string().optional().describe("Optional: only show sessions whose working directory contains this string"),
-                limit: z.number().int().min(1).max(100).optional().describe("Chapterhouse sessions to return (default 20)"),
-            }),
-            handler: async (args) => {
-                const sessionStateDir = join(homedir(), ".copilot", "session-state");
-                const limit = args.limit || 20;
-                let entries = [];
-                try {
-                    const dirs = readdirSync(sessionStateDir);
-                    for (const dir of dirs) {
-                        const yamlPath = join(sessionStateDir, dir, "workspace.yaml");
-                        try {
-                            const content = readFileSync(yamlPath, "utf-8");
-                            const parsed = parseSimpleYaml(content);
-                            if (args.cwd_filter && !parsed.cwd?.includes(args.cwd_filter))
-                                continue;
-                            entries.push({
-                                id: parsed.id || dir,
-                                cwd: parsed.cwd || "unknown",
-                                summary: parsed.summary || "",
-                                updatedAt: parsed.updated_at ? new Date(parsed.updated_at) : new Date(0),
-                            });
-                        }
-                        catch {
-                            // Skip dirs without valid workspace.yaml
-                        }
-                    }
-                }
-                catch (err) {
-                    if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-                        return "No Copilot sessions found on this machine (session state directory does not exist yet).";
-                    }
-                    return "Could not read session state directory.";
-                }
-                // Sort by most recently updated
-                entries.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-                entries = entries.slice(0, limit);
-                if (entries.length === 0) {
-                    return "No Copilot sessions found on this machine.";
-                }
-                const lines = entries.map((s) => {
-                    const age = formatAge(s.updatedAt);
-                    const summary = s.summary ? ` — ${s.summary}` : "";
-                    return `• ID: ${s.id}\n  ${s.cwd} (${age})${summary}`;
-                });
-                return `Found ${entries.length} session(s) (most recent first):\n${lines.join("\n")}`;
-            },
-        }),
-        defineTool("attach_machine_session", {
-            description: "Attach to an existing Copilot CLI session on this machine (e.g. one started from VS Code or terminal). " +
-                "Resumes the session so you can observe or interact with it.",
-            parameters: z.object({
-                session_id: z.string().describe("The session ID to attach to (from list_machine_sessions)"),
-                name: z.string().describe("A short name to reference this session by, e.g. 'vscode-main'"),
-            }),
-            handler: async (args) => {
-                try {
-                    const session = await deps.client.resumeSession(args.session_id, {
-                        model: config.copilotModel,
-                        onPermissionRequest: approveAll,
-                    });
-                    const db = getDb();
-                    db.prepare(`INSERT OR REPLACE INTO agent_sessions (slug, copilot_session_id, model, status)
-             VALUES (?, ?, ?, 'idle')`).run(args.name, args.session_id, config.copilotModel);
-                    return `Attached to session ${args.session_id.slice(0, 8)}… as '${args.name}'.`;
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    return `Failed to attach to session: ${msg}`;
-                }
-            },
-        }),
-        defineTool("list_skills", {
-            description: "List all available skills that Chapterhouse knows. Skills are instruction documents that teach Chapterhouse " +
-                "how to use external tools and services (e.g. Gmail, browser automation, YouTube transcripts). " +
-                "Shows skill name, description, and whether it's a local or global skill.",
-            parameters: z.object({}),
-            handler: async () => {
-                const skills = listSkills();
-                if (skills.length === 0) {
-                    return "No skills installed yet. Use learn_skill to teach me something new.";
-                }
-                const lines = skills.map((s) => `• ${s.name} (${s.source}) — ${s.description}`);
-                return `Available skills (${skills.length}):\n${lines.join("\n")}`;
-            },
-        }),
-        defineTool("learn_skill", {
-            description: "Teach Chapterhouse a new skill by creating a SKILL.md instruction file. Use this when the user asks Chapterhouse " +
-                "to do something it doesn't know how to do yet (e.g. 'check my email', 'search the web'). " +
-                "First, use a worker session to research what CLI tools are available on the system (run 'which', " +
-                "'--help', etc.), then create the skill with the instructions you've learned. " +
-                "The skill becomes available on the next message (no restart needed).",
-            parameters: z.object({
-                slug: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).describe("Short kebab-case identifier for the skill, e.g. 'gmail', 'web-search'"),
-                name: z.string().refine(s => !s.includes('\n'), "must be single-line").describe("Human-readable name for the skill, e.g. 'Gmail', 'Web Search'"),
-                description: z.string().refine(s => !s.includes('\n'), "must be single-line").describe("One-line description of when to use this skill"),
-                instructions: z.string().describe("Markdown instructions for how to use the skill. Include: what CLI tool to use, " +
-                    "common commands with examples, authentication steps if needed, tips and gotchas. " +
-                    "This becomes the SKILL.md content body."),
-            }),
-            handler: async (args) => {
-                return createSkill(args.slug, args.name, args.description, args.instructions);
-            },
-        }),
-        defineTool("uninstall_skill", {
-            description: "Remove a skill from Chapterhouse's local skills directory (~/.chapterhouse/skills/). " +
-                "The skill will no longer be available on the next message. " +
-                "Only works for local skills — bundled and global skills cannot be removed this way.",
-            parameters: z.object({
-                slug: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/).describe("The kebab-case slug of the skill to remove, e.g. 'gmail', 'web-search'"),
-            }),
-            handler: async (args) => {
-                const result = removeSkill(args.slug);
-                return result.message;
-            },
-        }),
-        defineTool("list_models", {
-            description: "List all available Copilot models. Shows model id, name, and billing tier. " +
-                "Marks the currently active model. Use when the user asks what models are available " +
-                "or wants to know which model is in use.",
-            parameters: z.object({}),
-            handler: async () => {
-                try {
-                    const models = await deps.client.listModels();
-                    if (models.length === 0) {
-                        return "No models available.";
-                    }
-                    const current = config.copilotModel;
-                    const lines = models.map((m) => {
-                        const active = m.id === current ? " ← active" : "";
-                        const billing = m.billing ? ` (${m.billing.multiplier}x)` : "";
-                        return `• ${m.id}${billing}${active}`;
-                    });
-                    return `Available models (${models.length}):\n${lines.join("\n")}\n\nCurrent: ${current}`;
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    return `Failed to list models: ${msg}`;
-                }
-            },
-        }),
-        defineTool("switch_model", {
-            description: "Switch the Copilot model Chapterhouse uses for conversations. Takes effect on the next message. " +
-                "The change is persisted across restarts. Use when the user asks to change or switch models.",
-            parameters: z.object({
-                model_id: z.string().describe("The model id to switch to (from list_models)"),
-            }),
-            handler: async (args) => {
-                try {
-                    const models = await deps.client.listModels();
-                    const match = models.find((m) => m.id === args.model_id);
-                    if (!match) {
-                        const suggestions = models
-                            .filter((m) => m.id.includes(args.model_id) || m.id.toLowerCase().includes(args.model_id.toLowerCase()))
-                            .map((m) => m.id);
-                        const hint = suggestions.length > 0
-                            ? ` Did you mean: ${suggestions.join(", ")}?`
-                            : " Use list_models to see available options.";
-                        return `Model '${args.model_id}' not found.${hint}`;
-                    }
-                    const previous = config.copilotModel;
-                    config.copilotModel = args.model_id;
-                    persistModel(args.model_id);
-                    // Apply model change to the live session immediately
-                    try {
-                        await switchSessionModel(args.model_id);
-                    }
-                    catch (err) {
-                        log.warn({ err: err instanceof Error ? err.message : err }, "setModel() failed during switch_model, will apply on next session");
-                    }
-                    // Disable router when manually switching — user has explicit preference
-                    if (getRouterConfig().enabled) {
-                        updateRouterConfig({ enabled: false });
-                        return `Switched model from '${previous}' to '${args.model_id}'. Auto-routing disabled (use /auto or toggle_auto to re-enable).`;
-                    }
-                    return `Switched model from '${previous}' to '${args.model_id}'.`;
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    return `Failed to switch model: ${msg}`;
-                }
-            },
-        }),
-        defineTool("toggle_auto", {
-            description: "Enable or disable automatic model routing (auto mode). When enabled, Chapterhouse automatically picks " +
-                "the best model (fast/standard/premium) for each message to save cost and optimize speed. " +
-                "Use when the user asks to turn auto-routing on or off.",
-            parameters: z.object({
-                enabled: z.boolean().describe("true to enable auto-routing, false to disable"),
-            }),
-            handler: async (args) => {
-                const updated = updateRouterConfig({ enabled: args.enabled });
-                if (args.enabled) {
-                    const tiers = updated.tierModels;
-                    return `Auto-routing enabled. Tier models:\n• fast: ${tiers.fast}\n• standard: ${tiers.standard}\n• premium: ${tiers.premium}\n\nMax will automatically pick the best model for each message.`;
-                }
-                return `Auto-routing disabled. Using fixed model: ${config.copilotModel}`;
-            },
-        }),
-        defineTool("memory_remember", {
-            description: "Write scoped agent memory (observation or decision) into the SQLite memory store. " +
-                "Use this for the new agent-memory system, not the legacy wiki-backed remember tool.",
-            parameters: z.object({
-                content: z.string().describe("Observation content or decision rationale."),
-                scope: z.string().optional().describe("Optional memory scope slug. Defaults to active scope, then keyword inference."),
-                kind: z.enum(["observation", "decision"]).optional().describe("Memory entry kind. Defaults to observation."),
-                entity_name: z.string().optional().describe("Optional entity name to attach. Auto-upserts the entity if provided."),
-                entity_kind: z.string().optional().describe("Required when entity_name is provided."),
-                title: z.string().optional().describe("Required for decision entries."),
-                decided_at: z.string().optional().describe("Decision date. Defaults to today."),
-                tier: z.enum(["hot", "warm", "cold"]).optional().describe("Storage tier. Defaults to warm."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                if (args.entity_name && !args.entity_kind) {
-                    return "entity_kind is required when entity_name is provided.";
-                }
-                try {
-                    const { scopeId, scopeSlug } = resolveMemoryScopeForWrite(args.scope, args.content);
-                    const kind = args.kind ?? "observation";
-                    const entity = args.entity_name
-                        ? upsertEntity({
-                            scope_id: scopeId,
-                            kind: args.entity_kind,
-                            name: args.entity_name,
-                            tier: args.tier ?? "warm",
-                        })
-                        : undefined;
-                    if (kind === "decision") {
-                        if (!args.title) {
-                            return "title is required when kind='decision'.";
-                        }
-                        const decision = recordDecision({
-                            scope_id: scopeId,
-                            entity_id: entity?.id,
-                            title: args.title,
-                            rationale: args.content,
-                            decided_at: args.decided_at ?? new Date().toISOString().slice(0, 10),
-                            tier: args.tier ?? "warm",
-                        });
-                        if (entity) {
-                            appendTimeline(topicPagePath(entity.kind, entity.name), `${decision.title}\n\n${decision.rationale}`);
-                        }
-                        hookDispatcher.dispatch("memory:decision", {
-                            id: decision.id,
-                            scope_id: scopeId,
-                            title: decision.title,
-                            rationale: decision.rationale,
-                        }).catch((err) => {
-                            log.error({ err }, "memory.hooks.decision.dispatch_error");
-                        });
-                        return {
-                            ok: true,
-                            id: decision.id,
-                            scope: scopeSlug,
-                            kind,
-                            entity_id: entity?.id,
-                        };
-                    }
-                    const observation = recordObservation({
-                        scope_id: scopeId,
-                        entity_id: entity?.id,
-                        content: args.content,
-                        source: `agent:${agentsModule.getCurrentToolAgentSlug?.() ?? "chapterhouse"}`,
-                        tier: args.tier ?? "warm",
-                    });
-                    return {
-                        ok: true,
-                        id: observation.id,
-                        scope: scopeSlug,
-                        kind,
-                        entity_id: entity?.id,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_propose", {
-            description: "Queue a proposed scoped memory item for orchestrator review at end-of-task. " +
-                "Available to all agents; writes land in mem_inbox as pending proposals.",
-            parameters: memoryProposeArgsSchema,
-            handler: async (args) => {
-                try {
-                    const parsedArgs = memoryProposeArgsSchema.parse(args);
-                    const payload = parsedArgs.kind === "observation"
-                        ? observationProposalPayloadSchema.parse(parsedArgs.payload)
-                        : parsedArgs.kind === "decision"
-                            ? decisionProposalPayloadSchema.parse(parsedArgs.payload)
-                            : parsedArgs.kind === "entity"
-                                ? entityProposalPayloadSchema.parse(parsedArgs.payload)
-                                : actionItemProposalPayloadSchema.parse(parsedArgs.payload);
-                    const proposal = queueMemoryProposal({
-                        kind: parsedArgs.kind,
-                        scopeSlug: resolveProposalScopeSlug(parsedArgs.scope_slug),
-                        payload,
-                        confidence: parsedArgs.confidence ?? 0.5,
-                        reason: parsedArgs.reason,
-                        sourceAgent: agentsModule.getCurrentToolAgentSlug?.() ?? "chapterhouse",
-                        sourceTaskId: agentsModule.getCurrentToolTaskId?.(),
-                    });
-                    return {
-                        proposal_id: proposal.id,
-                        status: "queued",
-                    };
-                }
-                catch (err) {
-                    if (err instanceof z.ZodError) {
-                        return err.issues.map((issue) => issue.message).join("; ");
-                    }
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_create_scope", {
-            description: "Create a new user-defined memory scope. Slugs must be unique kebab-case; baseline installs only include global and chapterhouse.",
-            parameters: z.object({
-                slug: z.string()
-                    .trim()
-                    .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be unique kebab-case"),
-                title: z.string().trim().min(1, "title is required"),
-                description: z.string().optional(),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                const parsed = z.object({
-                    slug: z.string()
-                        .trim()
-                        .regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "slug must be unique kebab-case"),
-                    title: z.string().trim().min(1, "title is required"),
-                    description: z.string().optional(),
-                }).safeParse(args);
-                if (!parsed.success) {
-                    return parsed.error.issues.map((issue) => issue.message).join("; ");
-                }
-                try {
-                    if (getMemoryScope(parsed.data.slug)) {
-                        return `Memory scope '${parsed.data.slug}' already exists.`;
-                    }
-                    const scope = createMemoryScope({
-                        slug: parsed.data.slug,
-                        title: parsed.data.title,
-                        description: parsed.data.description ?? "",
-                        keywords: [parsed.data.slug],
-                    });
-                    hookDispatcher.dispatch("scope:created", {
-                        slug: scope.slug,
-                        title: scope.title,
-                        description: scope.description,
-                    }).catch((err) => {
-                        log.error({ err }, "memory.hooks.scope_created.dispatch_error");
-                    });
-                    return {
-                        ok: true,
-                        scope: {
-                            slug: scope.slug,
-                            title: scope.title,
-                            description: scope.description,
-                            active: scope.active,
-                        },
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_add_action_item", {
-            description: "Add a scoped memory action item/reminder. Orchestrator-only write tool for follow-ups and proactive reminders.",
-            parameters: z.object({
-                scope: z.string().optional().describe("Optional memory scope slug. Defaults to active scope, then keyword inference."),
-                title: z.string().min(1).describe("Short action item title."),
-                detail: z.string().optional().describe("Longer action item detail."),
-                due_at: z.string().optional().describe("Optional ISO due timestamp."),
-                entity_name: z.string().optional().describe("Optional entity name to attach. Auto-upserts the entity if provided."),
-                entity_kind: z.string().optional().describe("Required when entity_name is provided."),
-                source: z.string().optional().describe("Action item source, e.g. manual, subagent_proposal, external."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                if (args.entity_name && !args.entity_kind) {
-                    return "entity_kind is required when entity_name is provided.";
-                }
-                try {
-                    const { scopeId, scopeSlug } = resolveMemoryScopeForWrite(args.scope, `${args.title}\n${args.detail ?? ""}`);
-                    const entity = args.entity_name
-                        ? upsertEntity({
-                            scope_id: scopeId,
-                            kind: args.entity_kind,
-                            name: args.entity_name,
-                        })
-                        : undefined;
-                    const actionItem = recordActionItem({
-                        scope_id: scopeId,
-                        entity_id: entity?.id,
-                        title: args.title,
-                        detail: args.detail,
-                        due_at: args.due_at,
-                        source: args.source ?? "manual",
-                    });
-                    return {
-                        ok: true,
-                        id: actionItem.id,
-                        scope: scopeSlug,
-                        status: actionItem.status,
-                        entity_id: entity?.id,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_complete_action_item", {
-            description: "Complete a memory action item. Orchestrator-only write tool.",
-            parameters: z.object({
-                id: z.number().int().positive(),
-                resolution_reason: z.string().optional(),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    const actionItem = completeActionItem(args.id, args.resolution_reason);
-                    return { ok: true, id: actionItem.id, status: actionItem.status, resolved_at: actionItem.resolvedAt };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_drop_action_item", {
-            description: "Drop a memory action item with a reason. Orchestrator-only write tool.",
-            parameters: z.object({
-                id: z.number().int().positive(),
-                reason: z.string().min(1),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    const actionItem = dropActionItem(args.id, args.reason);
-                    return { ok: true, id: actionItem.id, status: actionItem.status, resolved_at: actionItem.resolvedAt };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_snooze_action_item", {
-            description: "Snooze a memory action item until an ISO timestamp. Orchestrator-only write tool.",
-            parameters: z.object({
-                id: z.number().int().positive(),
-                snooze_until: z.string().min(1),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    const actionItem = snoozeActionItem(args.id, args.snooze_until);
-                    return {
-                        ok: true,
-                        id: actionItem.id,
-                        status: actionItem.status,
-                        snooze_until: actionItem.snoozeUntil,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_list_action_items", {
-            description: "List scoped memory action items/reminders. Defaults to currently actionable open items.",
-            parameters: z.object({
-                scope: z.string().optional().describe("Optional memory scope slug. Defaults to active scope when available."),
-                status: z.enum(["open", "done", "dropped", "snoozed"]).optional().describe("Optional status filter."),
-                due_before: z.string().optional().describe("Optional ISO timestamp; only include items due at or before this time."),
-                includeArchived: z.boolean().optional().describe("Include cold-tier items. Defaults to false."),
-            }),
-            handler: async (args) => {
-                const requestedScope = args.scope ? getMemoryScope(args.scope) : undefined;
-                if (args.scope && !requestedScope) {
-                    return `Unknown memory scope '${args.scope}'.`;
-                }
-                const activeScope = getMemoryActiveScope();
-                const scope = requestedScope ?? activeScope ?? undefined;
-                const actionItems = listActionItems({
-                    scope_id: scope?.id,
-                    status: args.status,
-                    due_before: args.due_before,
-                    includeArchived: args.includeArchived,
-                });
-                return {
-                    active_scope: activeScope ? { slug: activeScope.slug, title: activeScope.title } : null,
-                    scope: scope ? { slug: scope.slug, title: scope.title } : null,
-                    action_items: actionItems.map((item) => ({
-                        id: item.id,
-                        scope_id: item.scopeId,
-                        entity_id: item.entityId,
-                        title: item.title,
-                        detail: item.detail,
-                        status: item.status,
-                        due_at: item.dueAt,
-                        snooze_until: item.snoozeUntil,
-                        source: item.source,
-                        created_at: item.createdAt,
-                        updated_at: item.updatedAt,
-                        resolved_at: item.resolvedAt,
-                        resolution_reason: item.resolutionReason,
-                    })),
-                };
-            },
-        }),
-        defineTool("memory_recall", {
-            description: "Search scoped agent memory with FTS-backed recall. Use this for the new agent-memory store, not the wiki-backed recall tool.",
-            parameters: z.object({
-                query: z.string().describe("Query text to search for."),
-                scope: z.string().optional().describe("Optional scope slug. Defaults to the active scope when available."),
-                kinds: z.array(z.enum(["observation", "decision", "entity", "action_item"])).optional()
-                    .describe("Optional filter for memory entry kinds."),
-                limit: z.number().int().positive().optional().describe("Maximum number of ranked hits to return. Defaults to 10."),
-                includeSuperseded: z.boolean().optional().describe("Include superseded observations and decisions. Defaults to false."),
-                includeArchived: z.boolean().optional().describe("Include archived observations and decisions. Defaults to false."),
-                includeCold: z.boolean().optional().describe("Include cold-tier rows. Defaults to false."),
-            }),
-            handler: async (args) => {
-                const requestedScope = args.scope ? getMemoryScope(args.scope) : undefined;
-                if (args.scope && !requestedScope) {
-                    return `Unknown memory scope '${args.scope}'.`;
-                }
-                const result = recallMemory({
-                    query: args.query,
-                    scope_id: requestedScope?.id,
-                    kinds: args.kinds,
-                    limit: args.limit ?? 10,
-                    includeSuperseded: args.includeSuperseded,
-                    includeArchived: args.includeArchived,
-                    includeCold: args.includeCold,
-                });
-                return {
-                    active_scope: result.activeScope
-                        ? { slug: result.activeScope.slug, title: result.activeScope.title }
-                        : null,
-                    hot_tier: result.hotTier,
-                    hits: result.hits.map((hit) => ({
-                        kind: hit.kind,
-                        id: hit.id,
-                        scope: hit.scope,
-                        content: hit.content,
-                        decided_at: hit.decidedAt,
-                        score: hit.score,
-                        snippet: hit.snippet,
-                    })),
-                };
-            },
-        }),
-        defineTool("memory_housekeep", {
-            description: "Run the scoped agent-memory housekeeping pipeline. Orchestrator-only write-tier maintenance tool.",
-            parameters: z.object({
-                scope_slug: z.string().optional().describe("Optional scope slug. Defaults to the active scope."),
-                all_scopes: z.boolean().optional().describe("Run scoped passes for all active scopes instead of one scope."),
-                passes: z.array(z.string()).optional().describe("Optional pass names: dedup_observations, dedup_decisions, orphan_cleanup, decay, compact_inbox."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                if (args.scope_slug && args.all_scopes) {
-                    return "Pass either scope_slug or all_scopes, not both.";
-                }
-                try {
-                    const requestedScope = args.scope_slug ? getMemoryScope(args.scope_slug) : undefined;
-                    if (args.scope_slug && !requestedScope) {
-                        return `Unknown memory scope '${args.scope_slug}'.`;
-                    }
-                    const result = await runHousekeeping({
-                        scopeIds: requestedScope ? [requestedScope.id] : undefined,
-                        allScopes: args.all_scopes,
-                        passes: args.passes,
-                    });
-                    return {
-                        ok: result.summaries.every((summary) => summary.errors.length === 0),
-                        scope_ids: result.scopeIds,
-                        total_examined: result.totalExamined,
-                        total_modified: result.totalModified,
-                        duration_ms: result.durationMs,
-                        summaries: result.summaries,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_reflect", {
-            description: "Synthesize durable scoped memory patterns from repeated observations. Orchestrator-only reflect tool.",
-            parameters: z.object({
-                scope: z.string().optional(),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    if (args.scope) {
-                        const requestedScope = getMemoryScope(args.scope);
-                        if (!requestedScope) {
-                            return `Unknown memory scope '${args.scope}'.`;
-                        }
-                        const result = await reflectOnScope(args.scope, getDb());
-                        return {
-                            ok: true,
-                            scope: args.scope,
-                            patterns_created: result.patternsCreated,
-                            patterns_updated: result.patternsUpdated,
-                            contradictions_found: result.contradictionsFound,
-                        };
-                    }
-                    const results = await reflectAllScopes(getDb());
-                    const totals = Object.values(results).reduce((acc, result) => ({
-                        patterns_created: acc.patterns_created + result.patternsCreated,
-                        patterns_updated: acc.patterns_updated + result.patternsUpdated,
-                        contradictions_found: acc.contradictions_found + result.contradictionsFound,
-                    }), {
-                        patterns_created: 0,
-                        patterns_updated: 0,
-                        contradictions_found: 0,
-                    });
-                    return {
-                        ok: true,
-                        scope: "all",
-                        ...totals,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_promote", {
-            description: "Promote a memory row to the hot tier. Orchestrator-only manual override.",
-            parameters: z.object({
-                table: memoryTierTableSchema,
-                id: z.number().int().positive(),
-                reason: z.string().min(1),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    promoteToHot(args.table, args.id, args.reason);
-                    return { ok: true, table: args.table, id: args.id, tier: "hot" };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_demote", {
-            description: "Demote a memory row to warm or cold tier. Orchestrator-only manual override.",
-            parameters: z.object({
-                table: memoryTierTableSchema,
-                id: z.number().int().positive(),
-                reason: z.string().min(1),
-                tier: z.enum(["warm", "cold"]).optional().describe("Target demotion tier. Defaults to warm."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    if (args.tier === "cold") {
-                        demoteToCold(args.table, args.id, args.reason);
-                        return { ok: true, table: args.table, id: args.id, tier: "cold" };
-                    }
-                    demoteToWarm(args.table, args.id, args.reason);
-                    return { ok: true, table: args.table, id: args.id, tier: "warm" };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        defineTool("memory_set_scope", {
-            description: "Set or clear the active scope for the agent-memory system. This affects default routing for memory_remember and memory_recall.",
-            parameters: z.object({
-                slug: z.string().nullable().describe("Scope slug to activate, or null to clear the active scope."),
-            }),
-            handler: async (args) => {
-                const denied = requireOrchestratorMemoryWrite();
-                if (denied)
-                    return denied;
-                try {
-                    const previousScope = getMemoryActiveScope();
-                    const nextScope = args.slug === null ? null : (getMemoryScope(args.slug) ?? null);
-                    if (args.slug !== null && !nextScope) {
-                        return `Unknown memory scope '${args.slug}'.`;
-                    }
-                    const previousSlug = previousScope?.slug ?? null;
-                    const nextSlug = nextScope?.slug ?? null;
-                    const didChange = previousSlug !== nextSlug;
-                    const sessionKey = getCurrentSessionKey();
-                    if (didChange) {
-                        maybeScheduleScopeChangeCheckpoint(sessionKey, previousScope, nextScope);
-                    }
-                    const activeScope = setMemoryActiveScope(args.slug);
-                    if (didChange) {
-                        invalidateOrchestratorSession(sessionKey);
-                        resetCheckpointSessionState(sessionKey);
-                    }
-                    return {
-                        active_scope: activeScope
-                            ? { slug: activeScope.slug, title: activeScope.title }
-                            : null,
-                    };
-                }
-                catch (err) {
-                    return err instanceof Error ? err.message : String(err);
-                }
-            },
-        }),
-        // ----- Removed legacy wiki facades kept as compatibility stubs -----
-        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" };
-                }
-            },
-        }),
-        defineTool("restart_chapterhouse", {
-            description: "Restart the Chapterhouse daemon process. Use when the user asks Chapterhouse to restart himself, " +
-                "or when a restart is needed to pick up configuration changes. " +
-                "Spawns a new process and exits the current one.",
-            parameters: z.object({
-                reason: z.string().optional().describe("Optional reason for the restart"),
-            }),
-            handler: async (args) => {
-                const reason = args.reason ? ` (${args.reason})` : "";
-                // Dynamic import to avoid circular dependency
-                const { restartDaemon } = await import("../daemon.js");
-                // Schedule restart after returning the response
-                setTimeout(() => {
-                    restartDaemon().catch((err) => {
-                        log.error({ err: err instanceof Error ? err.message : err }, "Restart failed");
-                    });
-                }, 1000);
-                return `Restarting Chapterhouse${reason}. I'll be back in a few seconds.`;
-            },
-        }),
-    ];
-}
-function formatAge(date) {
-    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
-    if (seconds < 60)
-        return "just now";
-    if (seconds < 3600)
-        return `${Math.floor(seconds / 60)}m ago`;
-    if (seconds < 86400)
-        return `${Math.floor(seconds / 3600)}h ago`;
-    return `${Math.floor(seconds / 86400)}d ago`;
-}
-function parseSimpleYaml(content) {
-    const result = {};
-    for (const line of content.split("\n")) {
-        const idx = line.indexOf(": ");
-        if (idx > 0) {
-            const key = line.slice(0, idx).trim();
-            const value = line.slice(idx + 2).trim();
-            result[key] = value;
-        }
-    }
-    return result;
-}
-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();
-}
+export * from "./tools/index.js";
 //# sourceMappingURL=tools.js.map