heyio 1.12.1 → 3.0.0

package/dist/copilot/tools.js

@@ -1,402 +1,626 @@
-import { z } from "zod";
-import { defineTool } from "@github/copilot-sdk";
-import { addAuditEntry } from "../store/audit-log.js";
-export function createTools() {
+import { defineTool } from '@github/copilot-sdk';
+import { z } from 'zod';
+import { activateSkill, deactivateSkill, getActiveSkills, installSkillFromUrl, listInstalledSkills, removeSkill, } from '../skills/index.js';
+import { runInstance } from '../squad/execution/runner.js';
+import { hireSquad } from '../squad/hiring.js';
+import { bootSquad, delegateToSquad, getSquadByName, getSquadMembers, getSquadRuntime, listSquads, rethemeSquad, } from '../squad/manager.js';
+import { listInboxEntries, resolveInboxEntry } from '../store/inbox.js';
+import { createSchedule, deleteSchedule, listSchedules } from '../store/schedules.js';
+import { getOrchestratorScopes, getPageListing, listWikiPages, readWikiPage, searchWiki, writeWikiPage, } from '../wiki/index.js';
+export function createOrchestratorTools() {
     return [
-        // --- Wiki Tools ---
-        defineTool("wiki_read", {
-            description: "Read a wiki page by path (relative to ~/.io/wiki/pages/)",
-            parameters: z.object({
-                path: z.string().describe("Page path relative to pages/ (e.g., 'notes/todo.md')"),
-            }),
-            handler: async ({ path }) => {
-                const { readPage } = await import("../wiki/fs.js");
-                return await readPage(path);
-            },
-        }),
-        defineTool("wiki_write", {
-            description: "Write or update a wiki page",
-            parameters: z.object({
-                path: z.string().describe("Page path relative to pages/"),
-                content: z.string().describe("Markdown content to write"),
-            }),
-            handler: async ({ path, content }) => {
-                const { writePage } = await import("../wiki/fs.js");
-                await writePage(path, content);
-                return `Page saved: ${path}`;
-            },
-        }),
-        defineTool("wiki_list", {
-            description: "List all wiki pages",
-            parameters: z.object({}),
+        defineTool('list_squads', {
+            description: 'List all active squads and their current status. Use this when the user asks about their teams or projects.',
+            parameters: z.object({}).strict(),
             handler: async () => {
-                const { listPages } = await import("../wiki/fs.js");
-                return await listPages();
-            },
-        }),
-        defineTool("wiki_search", {
-            description: "Search wiki pages by keyword",
-            parameters: z.object({
-                query: z.string().describe("Search query"),
-            }),
-            handler: async ({ query }) => {
-                const { searchPages } = await import("../wiki/search.js");
-                return await searchPages(query);
+                const squads = await listSquads();
+                if (squads.length === 0) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            squads: [],
+                            message: 'No squads currently active.',
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                const summary = await Promise.all(squads.map(async (s) => {
+                    const members = await getSquadMembers(s.id);
+                    return {
+                        name: s.name,
+                        project: s.projectPath,
+                        universe: s.universe,
+                        autonomy: s.autonomyTier,
+                        members: members.map((m) => `${m.displayName} (${m.roleName})`),
+                        status: s.status,
+                    };
+                }));
+                return {
+                    textResultForLlm: JSON.stringify({ squads: summary }),
+                    resultType: 'success',
+                };
             },
         }),
-        defineTool("wiki_delete", {
-            description: "Delete a wiki page",
+        defineTool('get_squad_status', {
+            description: 'Get the detailed status of a specific squad including active instances, team members, and recent activity.',
             parameters: z.object({
-                path: z.string().describe("Page path relative to pages/"),
+                squadName: z.string().describe('The name of the squad to check'),
             }),
-            handler: async ({ path }) => {
-                const { deletePage } = await import("../wiki/fs.js");
-                await deletePage(path);
-                return `Page deleted: ${path}`;
+            handler: async (args) => {
+                const squad = await getSquadByName(args.squadName);
+                if (!squad) {
+                    return {
+                        textResultForLlm: JSON.stringify({ error: `Squad '${args.squadName}' not found.` }),
+                        resultType: 'success',
+                    };
+                }
+                const members = await getSquadMembers(squad.id);
+                return {
+                    textResultForLlm: JSON.stringify({
+                        squad: {
+                            name: squad.name,
+                            project: squad.projectPath,
+                            repo: squad.repoUrl,
+                            universe: squad.universe,
+                            autonomy: squad.autonomyTier,
+                            status: squad.status,
+                            createdAt: squad.createdAt.toISOString(),
+                        },
+                        members: members.map((m) => ({
+                            name: m.displayName,
+                            role: m.roleName,
+                            veto: m.isVetoMember,
+                            tools: m.toolsAllowed,
+                        })),
+                    }),
+                    resultType: 'success',
+                };
             },
         }),
-        defineTool("wiki_backlinks", {
-            description: "Find all wiki pages that link to the given page",
+        defineTool('hire_squad', {
+            description: 'Create a new squad for a project. Provide a GitHub repo URL and the project will be cloned automatically to ~/.io/source/{owner}/{repo}. Analyzes the project and recommends team composition. Each squad member gets a character name from a pop-culture universe.',
             parameters: z.object({
-                path: z.string().describe("Page path relative to pages/ (e.g., 'notes/todo.md')"),
+                repoUrl: z.string().describe('GitHub repository URL (e.g. https://github.com/owner/repo)'),
+                name: z.string().optional().describe('Name for the squad (auto-generated if omitted)'),
+                universe: z
+                    .string()
+                    .optional()
+                    .describe('Pop-culture universe for member names (a-team, marvel, star-wars, lord-of-the-rings, star-trek, firefly). Random if omitted.'),
             }),
-            handler: async ({ path }) => {
-                const { getBacklinks } = await import("../wiki/backlinks.js");
-                return await getBacklinks(path);
+            handler: async (args) => {
+                try {
+                    const { ensureCloned } = await import('../squad/source-resolver.js');
+                    const projectPath = ensureCloned(args.repoUrl);
+                    const result = await hireSquad({
+                        projectPath,
+                        repoUrl: args.repoUrl,
+                        name: args.name,
+                        universe: args.universe,
+                    });
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            message: `Squad '${args.name ?? result.analysis.name}' hired successfully!`,
+                            squadId: result.squadId,
+                            projectPath,
+                            universe: result.universe,
+                            analysis: result.analysis,
+                            members: result.members,
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to hire squad: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
             },
         }),
-        // --- Squad Tools ---
-        defineTool("squad_create", {
-            description: "Create a new project squad. Research the chosen universe to assign character names — never hardcode.",
+        defineTool('retheme_squad', {
+            description: "Change a squad's pop-culture universe. Generates new character names and personas for all members from the specified universe.",
             parameters: z.object({
-                name: z.string().describe("Squad name (e.g., 'Project Alpha')"),
+                squadName: z.string().describe('Name of the squad to retheme'),
                 universe: z
                     .string()
-                    .describe("Pop culture universe theme (e.g., 'A-Team', 'Transformers', 'ThunderCats')"),
-                repo_url: z.string().optional().describe("Git repository URL for the project"),
+                    .describe('New pop-culture universe (e.g. "The Office", "Star Wars", "Breaking Bad")'),
             }),
-            handler: async ({ name, universe, repo_url }) => {
-                const { createSquad } = await import("../store/squads.js");
-                const squad = createSquad(name, universe, repo_url);
-                let cloneMsg = "";
-                // Copy squad wiki templates into the new squad's wiki directory
-                const { copySquadTemplates } = await import("../wiki/fs.js");
-                await copySquadTemplates(squad.slug);
-                if (repo_url) {
-                    const { exec } = await import("node:child_process");
-                    const { promisify } = await import("node:util");
-                    const { existsSync, mkdirSync } = await import("node:fs");
-                    const { join } = await import("node:path");
-                    const { PATHS } = await import("../paths.js");
-                    const execAsync = promisify(exec);
-                    // Extract owner/repo from URL (supports https and git@ formats)
-                    const match = repo_url.match(/[/:]([^/]+)\/([^/.]+?)(?:\.git)?$/);
-                    if (match) {
-                        const [, owner, repo] = match;
-                        const sourceDir = join(PATHS.source, owner, repo);
-                        if (!existsSync(sourceDir)) {
-                            const parentDir = join(PATHS.source, owner);
-                            if (!existsSync(parentDir))
-                                mkdirSync(parentDir, { recursive: true });
-                            try {
-                                await execAsync(`git clone ${repo_url} ${sourceDir}`, {
-                                    timeout: 120_000,
-                                });
-                                cloneMsg = ` Repo cloned to ~/.io/source/${owner}/${repo}.`;
-                            }
-                            catch (err) {
-                                cloneMsg = ` (Clone failed: ${err.stderr?.trim() || err.message})`;
-                            }
-                        }
-                        else {
-                            cloneMsg = ` Repo already exists at ~/.io/source/${owner}/${repo}.`;
-                        }
+            handler: async (args) => {
+                try {
+                    const squad = await getSquadByName(args.squadName);
+                    if (!squad) {
+                        return {
+                            textResultForLlm: JSON.stringify({ error: `Squad '${args.squadName}' not found.` }),
+                            resultType: 'success',
+                        };
                     }
+                    const members = await getSquadMembers(squad.id);
+                    const roles = members.map((m) => m.roleName);
+                    const { generateSquadNames } = await import('../squad/name-generator.js');
+                    const generated = await generateSquadNames(roles, args.universe);
+                    await rethemeSquad(squad.id, generated.universe, generated.assignments);
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            message: `Squad '${args.squadName}' rethemed to ${generated.universe}!`,
+                            members: generated.assignments.map((a) => `${a.displayName} (${a.role})`),
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to retheme squad: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
                 }
-                const msg = `Squad "${name}" created with universe "${universe}". ID: ${squad.id}, Slug: ${squad.slug}. Wiki path: ~/.io/wiki/squads/${squad.slug}/${cloneMsg}`;
-                addAuditEntry("squad_created", `Squad "${name}" created (universe: ${universe})`, { squad_id: squad.id, name, universe, repo_url }, { squad_id: squad.id });
-                return msg;
             },
         }),
-        defineTool("squad_add_agent", {
-            description: "Add a specialist agent to a squad",
+        defineTool('delegate_to_squad', {
+            description: "Delegate a message or task to a specific squad's team lead. Use this when the user's message relates to a project that has an assigned squad.",
             parameters: z.object({
-                squad_id: z.string().describe("Squad ID"),
-                character_name: z.string().describe("Character name from the squad's universe"),
-                role_title: z.string().describe("Specialist role (e.g., 'Vue 3 Frontend Developer')"),
-                persona: z.string().optional().describe("Personality/work style description"),
-                is_lead: z.boolean().optional().describe("Is this the team lead?"),
-                is_qa: z.boolean().optional().describe("Is this a QA reviewer?"),
-                is_test: z.boolean().optional().describe("Is this a test/quality specialist?"),
+                squadName: z.string().describe('Name of the squad to delegate to'),
+                message: z.string().describe('The full message or task to delegate'),
             }),
-            handler: async ({ squad_id, character_name, role_title, persona, is_lead, is_qa, is_test }) => {
-                const { addAgent } = await import("../store/squads.js");
-                const agent = addAgent(squad_id, {
-                    character_name,
-                    role_title,
-                    persona: persona ?? "",
-                    is_lead: is_lead ?? false,
-                    is_qa: is_qa ?? false,
-                    is_test: is_test ?? false,
-                });
-                return `Agent "${character_name}" (${role_title}) added to squad. ID: ${agent.id}`;
-            },
-        }),
-        defineTool("squad_list", {
-            description: "List all squads and their agents",
-            parameters: z.object({}),
-            handler: async () => {
-                const { listSquads } = await import("../store/squads.js");
-                return listSquads();
+            handler: async (args) => {
+                const squad = await getSquadByName(args.squadName);
+                if (!squad) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Squad '${args.squadName}' not found.`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                try {
+                    // Boot squad if not already running
+                    if (!getSquadRuntime(squad.id)) {
+                        await bootSquad(squad);
+                    }
+                    const response = await delegateToSquad(squad.id, args.message);
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            delegatedTo: args.squadName,
+                            teamLeadResponse: response,
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to delegate: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
             },
         }),
-        defineTool("squad_delegate", {
-            description: "Delegate a task to a squad's team lead. The lead will break it down and route to specialists. Use this for direct execution without a planning meeting.",
+        defineTool('run_squad_instance', {
+            description: 'Start a new work instance for a squad. This kicks off the full lifecycle: meeting → task execution → PR creation. Use when the user asks a squad to work on something specific.',
             parameters: z.object({
-                squad_id: z.string().describe("Squad ID"),
-                task: z.string().describe("Detailed task description"),
-                instance_id: z.string().optional().describe("Instance ID (for parallel work)"),
+                squadName: z.string().describe('Name of the squad'),
+                objective: z.string().describe('What the squad should accomplish'),
+                issueRef: z.string().optional().describe('GitHub issue reference (e.g., #42)'),
             }),
-            handler: async ({ squad_id, task, instance_id }) => {
-                const { delegateTask } = await import("./agents.js");
-                const { getActiveMessageAttachments } = await import("./orchestrator.js");
-                const attachments = getActiveMessageAttachments();
-                addAuditEntry("task_delegated", `Task delegated to squad ${squad_id}: ${task.slice(0, 200)}`, {
-                    squad_id,
-                    task: task.slice(0, 1000),
-                    instance_id,
-                    attachments: attachments.map((attachment) => ({
-                        name: attachment.name,
-                        mimeType: attachment.mimeType,
-                        size: attachment.size,
-                    })),
-                }, { squad_id });
-                // Fire-and-forget: start delegation in background so the orchestrator can respond immediately
-                delegateTask(squad_id, task, instance_id, attachments).catch((err) => {
-                    const errMsg = err instanceof Error ? err.message : "Unknown error";
-                    addAuditEntry("task_delegation_error", `Background delegation failed: ${errMsg}`, { squad_id, error: errMsg }, { squad_id });
-                });
-                return `Task delegated to squad ${squad_id}. The squad is now working on it in the background. You will be notified via the inbox when work is complete.`;
+            handler: async (args) => {
+                const squad = await getSquadByName(args.squadName);
+                if (!squad) {
+                    return {
+                        textResultForLlm: JSON.stringify({ error: `Squad '${args.squadName}' not found.` }),
+                        resultType: 'success',
+                    };
+                }
+                try {
+                    const result = await runInstance({
+                        squad,
+                        objective: args.objective,
+                        issueRef: args.issueRef,
+                    });
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            instanceId: result.instanceId,
+                            success: result.success,
+                            pr: result.pr ? { url: result.pr.url, number: result.pr.number } : null,
+                            error: result.error,
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to run instance: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
             },
         }),
-        defineTool("squad_meeting", {
-            description: "Trigger a planning meeting for a squad. All relevant specialists provide input before work begins. Use this for complex multi-agent tasks where team input improves the plan. Set execute_after=true to start work immediately after planning, or false to post the plan to the feed for user review.",
+        defineTool('list_inbox', {
+            description: "List unread inbox entries from squads. Shows deliverables and pending questions that need the user's attention.",
             parameters: z.object({
-                squad_id: z.string().describe("Squad ID"),
-                task: z.string().describe("Detailed task description for the team to plan"),
-                execute_after: z
-                    .boolean()
-                    .describe("If true, execute the plan immediately after the meeting. If false, post plan to feed and wait for user approval."),
+                status: z
+                    .enum(['unread', 'read', 'resolved'])
+                    .optional()
+                    .describe('Filter by status (default: unread)'),
             }),
-            handler: async ({ squad_id, task, execute_after }) => {
-                const { squadMeeting } = await import("./ceremonies.js");
-                const { getActiveMessageAttachments } = await import("./orchestrator.js");
-                const attachments = getActiveMessageAttachments();
-                addAuditEntry("squad_meeting", `Planning meeting started for squad ${squad_id}: ${task.slice(0, 200)}`, {
-                    squad_id,
-                    task: task.slice(0, 1000),
-                    execute_after,
-                    attachments: attachments.map((attachment) => ({
-                        name: attachment.name,
-                        mimeType: attachment.mimeType,
-                        size: attachment.size,
-                    })),
-                }, { squad_id });
-                // Fire-and-forget: start meeting in background so the orchestrator can respond immediately
-                squadMeeting(squad_id, task, execute_after, attachments).catch((err) => {
-                    const errMsg = err instanceof Error ? err.message : "Unknown error";
-                    addAuditEntry("squad_meeting_error", `Background meeting failed: ${errMsg}`, { squad_id, error: errMsg }, { squad_id });
+            handler: async (args) => {
+                const entries = await listInboxEntries({
+                    status: args.status ?? 'unread',
+                    limit: 20,
                 });
-                return `Planning meeting started for squad ${squad_id}. The squad is discussing the task in the background.${execute_after ? " Work will begin automatically after planning." : " The plan will be posted to the feed for your review."}`;
+                if (entries.length === 0) {
+                    return {
+                        textResultForLlm: JSON.stringify({ entries: [], message: 'No inbox entries.' }),
+                        resultType: 'success',
+                    };
+                }
+                const summary = entries.map((e) => ({
+                    id: e.id,
+                    squad: e.squadId,
+                    kind: e.kind,
+                    title: e.title,
+                    content: e.content.slice(0, 500),
+                    status: e.status,
+                    createdAt: e.createdAt,
+                }));
+                return {
+                    textResultForLlm: JSON.stringify({ entries: summary }),
+                    resultType: 'success',
+                };
             },
         }),
-        defineTool("squad_task_status", {
-            description: "Check the status of tasks for a squad",
+        defineTool('respond_to_inbox', {
+            description: "Respond to an inbox question from a squad. Use this when the user provides an answer to a squad's pending question. This unblocks the squad so it can continue working.",
             parameters: z.object({
-                squad_id: z.string().describe("Squad ID"),
+                entryId: z.string().describe('The inbox entry ID to respond to'),
+                response: z.string().describe("The user's response to the squad's question"),
             }),
-            handler: async ({ squad_id }) => {
-                const { getTasksForSquad } = await import("../store/tasks.js");
-                return getTasksForSquad(squad_id);
+            handler: async (args) => {
+                try {
+                    const unblocked = await resolveInboxEntry(args.entryId, args.response);
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            resolved: true,
+                            squadUnblocked: unblocked,
+                            message: unblocked
+                                ? 'Response delivered — squad has been unblocked and will continue working.'
+                                : 'Response recorded (squad was not actively waiting).',
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to respond: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
             },
         }),
-        defineTool("squad_instance_create", {
-            description: "Create a new parallel instance (worktree) for a squad. Max 3 per squad.",
+        defineTool('create_schedule', {
+            description: 'Create a cron-based schedule that triggers a squad or the orchestrator with a predefined prompt at specified times. Use standard cron syntax (e.g., "0 9 * * 1-5" for weekdays at 9am).',
             parameters: z.object({
-                squad_id: z.string().describe("Squad ID"),
-                branch: z.string().describe("Branch name for the worktree"),
+                name: z.string().describe('Human-readable name for the schedule (e.g., "Daily Standup")'),
+                targetType: z
+                    .enum(['squad', 'orchestrator'])
+                    .describe('Whether to target a squad or the orchestrator'),
+                targetId: z.string().optional().describe('Squad name (required if targetType is "squad")'),
+                cron: z.string().describe('Cron expression (e.g., "0 9 * * 1-5" for weekdays at 9am)'),
+                prompt: z.string().describe('The prompt/message to send when the schedule fires'),
             }),
-            handler: async ({ squad_id, branch }) => {
-                const { createInstance } = await import("../store/instances.js");
-                const instance = await createInstance(squad_id, branch);
-                return `Instance created: ${instance.id} on branch ${branch}`;
+            handler: async (args) => {
+                try {
+                    // Validate squad exists if targeting a squad
+                    if (args.targetType === 'squad') {
+                        if (!args.targetId) {
+                            return {
+                                textResultForLlm: JSON.stringify({
+                                    error: 'targetId (squad name) is required for squad schedules',
+                                }),
+                                resultType: 'success',
+                            };
+                        }
+                        const squad = await getSquadByName(args.targetId);
+                        if (!squad) {
+                            return {
+                                textResultForLlm: JSON.stringify({ error: `Squad '${args.targetId}' not found` }),
+                                resultType: 'success',
+                            };
+                        }
+                        args.targetId = squad.id;
+                    }
+                    const schedule = await createSchedule({
+                        name: args.name,
+                        targetType: args.targetType,
+                        targetId: args.targetId,
+                        cron: args.cron,
+                        prompt: args.prompt,
+                    });
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            created: true,
+                            schedule: {
+                                id: schedule.id,
+                                name: schedule.name,
+                                cron: schedule.cron,
+                                nextRun: schedule.nextRun,
+                            },
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to create schedule: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
             },
         }),
-        defineTool("squad_instance_destroy", {
-            description: "Destroy a squad instance and clean up its worktree",
-            parameters: z.object({
-                instance_id: z.string().describe("Instance ID"),
-            }),
-            handler: async ({ instance_id }) => {
-                const { destroyInstance } = await import("../store/instances.js");
-                await destroyInstance(instance_id);
-                return `Instance ${instance_id} destroyed.`;
+        defineTool('list_schedules', {
+            description: 'List all configured schedules (cron-based automations).',
+            parameters: z.object({}).strict(),
+            handler: async () => {
+                const schedules = await listSchedules();
+                if (schedules.length === 0) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            schedules: [],
+                            message: 'No schedules configured.',
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                const summary = schedules.map((s) => ({
+                    id: s.id,
+                    name: s.name,
+                    targetType: s.targetType,
+                    targetId: s.targetId,
+                    cron: s.cron,
+                    prompt: s.prompt.slice(0, 100),
+                    enabled: s.enabled,
+                    nextRun: s.nextRun,
+                    lastRun: s.lastRun,
+                }));
+                return {
+                    textResultForLlm: JSON.stringify({ schedules: summary }),
+                    resultType: 'success',
+                };
             },
         }),
-        defineTool("squad_remove_agent", {
-            description: "Remove an agent from a squad",
+        defineTool('delete_schedule', {
+            description: 'Delete a schedule by ID. Use list_schedules first to find the ID.',
             parameters: z.object({
-                agent_id: z.string().describe("Agent ID to remove"),
+                scheduleId: z.string().describe('The ID of the schedule to delete'),
             }),
-            handler: async ({ agent_id }) => {
-                const { removeAgent } = await import("../store/squads.js");
-                removeAgent(agent_id);
-                return `Agent ${agent_id} removed.`;
+            handler: async (args) => {
+                try {
+                    await deleteSchedule(args.scheduleId);
+                    return {
+                        textResultForLlm: JSON.stringify({ deleted: true, scheduleId: args.scheduleId }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to delete: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
             },
         }),
-        defineTool("squad_delete", {
-            description: "Delete an entire squad and all its agents, tasks, and instances",
+        defineTool('read_wiki', {
+            description: 'Read from the wiki knowledge base. Call with no pageName to list available pages, or with a pageName to read its content. You have access to IO-level and Shared wiki scopes.',
             parameters: z.object({
-                squad_id: z.string().describe("Squad ID to delete"),
+                scope: z.enum(['io', 'shared']).describe('Which wiki scope to read from'),
+                pageName: z
+                    .string()
+                    .optional()
+                    .describe('Page name to read (omit to list all pages in scope)'),
             }),
-            handler: async ({ squad_id }) => {
-                const { deleteSquad } = await import("../store/squads.js");
-                deleteSquad(squad_id);
-                return `Squad ${squad_id} deleted.`;
+            handler: async (args) => {
+                if (!args.pageName) {
+                    const pages = listWikiPages(args.scope);
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            scope: args.scope,
+                            pages: pages.length > 0 ? pages : '(empty)',
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                const page = readWikiPage(args.scope, args.pageName);
+                if (!page) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Page '${args.pageName}' not found in ${args.scope} wiki`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                return {
+                    textResultForLlm: JSON.stringify({
+                        scope: page.scope,
+                        name: page.name,
+                        content: page.content,
+                    }),
+                    resultType: 'success',
+                };
             },
         }),
-        // --- Feed Tools ---
-        defineTool("feed_post", {
-            description: "Post a deliverable to the unified feed/inbox",
+        defineTool('write_wiki', {
+            description: 'Write a page to the wiki knowledge base. Provide the full page content (read existing first and merge if updating). You can write to IO-level and Shared scopes.',
             parameters: z.object({
-                source: z.string().describe("Source identifier (e.g., 'orchestrator', 'squad-alpha')"),
-                title: z.string().describe("Title of the deliverable"),
-                content: z.string().describe("Full content (markdown supported)"),
+                scope: z.enum(['io', 'shared']).describe('Which wiki scope to write to'),
+                pageName: z
+                    .string()
+                    .describe('Page name (no .md extension, e.g., "preferences" or "routing-conventions")'),
+                content: z.string().describe('Full markdown content for the page'),
             }),
-            handler: async ({ source, title, content }) => {
-                const { postFeedItem } = await import("../store/feed.js");
-                const item = postFeedItem(source, title, content);
-                return `Posted to feed: "${title}" (ID: ${item.id})`;
+            handler: async (args) => {
+                writeWikiPage(args.scope, args.pageName, args.content);
+                return {
+                    textResultForLlm: JSON.stringify({
+                        written: true,
+                        scope: args.scope,
+                        pageName: args.pageName,
+                    }),
+                    resultType: 'success',
+                };
             },
         }),
-        defineTool("feed_list", {
-            description: "List feed/inbox items. Can filter by unread or source.",
+        defineTool('search_wiki', {
+            description: 'Search across wiki pages by keyword. Searches IO-level and Shared scopes.',
             parameters: z.object({
-                unread_only: z.boolean().optional().describe("Only show unread items"),
-                source: z.string().optional().describe("Filter by source"),
-                limit: z.number().optional().describe("Max items to return (default 20)"),
+                keyword: z.string().describe('Keyword or phrase to search for'),
             }),
-            handler: async ({ unread_only, source, limit }) => {
-                const { getFeedItems } = await import("../store/feed.js");
-                return getFeedItems({ unreadOnly: unread_only, source, limit: limit ?? 20 });
-            },
-        }),
-        // --- MCP Tools ---
-        defineTool("mcp_list_servers", {
-            description: "List configured MCP servers and their status",
-            parameters: z.object({}),
-            handler: async () => {
-                const { listServers } = await import("../mcp/registry.js");
-                return listServers();
+            handler: async (args) => {
+                const results = searchWiki(args.keyword, getOrchestratorScopes());
+                if (results.length === 0) {
+                    return {
+                        textResultForLlm: JSON.stringify({ results: [], message: 'No matches found.' }),
+                        resultType: 'success',
+                    };
+                }
+                return {
+                    textResultForLlm: JSON.stringify({ results }),
+                    resultType: 'success',
+                };
             },
         }),
-        // --- Schedule Tools ---
-        defineTool("schedule_create", {
-            description: "Create a cron-based schedule",
+        defineTool('install_skill', {
+            description: 'Install a skill from a URL (raw GitHub URL to a SKILL.md file). Skills extend IO or squad capabilities with additional instructions and behaviors.',
             parameters: z.object({
-                type: z.enum(["squad", "io"]).describe("Schedule type"),
-                cron: z.string().describe("Cron expression (e.g., '0 9 * * 1-5')"),
-                squad_id: z.string().describe("Target squad ID"),
-                agenda: z
+                name: z
                     .string()
-                    .optional()
-                    .describe("Agenda type for squad schedules (triage, prioritize, ideation, or custom)"),
-                prompt: z.string().optional().describe("Prompt text for the schedule"),
+                    .describe('Name for the skill (kebab-case, e.g., "tdd-workflow" or "code-review")'),
+                url: z
+                    .string()
+                    .describe('URL to the raw SKILL.md content (e.g., raw.githubusercontent.com/.../SKILL.md)'),
             }),
-            handler: async ({ type, cron, squad_id, agenda, prompt }) => {
-                const { createSchedule } = await import("../store/schedules.js");
-                const schedule = createSchedule({ type, cron, squad_id, agenda, prompt });
-                return `Schedule created: ${schedule.id}`;
+            handler: async (args) => {
+                try {
+                    const skill = await installSkillFromUrl(args.name, args.url);
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            installed: true,
+                            name: skill.name,
+                            preview: skill.content.slice(0, 200),
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to install: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
             },
         }),
-        defineTool("schedule_list", {
-            description: "List all schedules, optionally filtered by type",
-            parameters: z.object({
-                type: z.enum(["squad", "io"]).optional().describe("Filter by schedule type"),
-            }),
-            handler: async ({ type }) => {
-                const { listSchedules } = await import("../store/schedules.js");
-                return listSchedules(type);
+        defineTool('list_skills', {
+            description: 'List all installed skills and their activation status.',
+            parameters: z.object({}).strict(),
+            handler: async () => {
+                const installed = listInstalledSkills();
+                const orchestratorActivations = await getActiveSkills('orchestrator');
+                const summary = installed.map((s) => ({
+                    name: s.name,
+                    activatedForOrchestrator: orchestratorActivations.some((a) => a.skillName === s.name),
+                    preview: s.content.slice(0, 100),
+                }));
+                return {
+                    textResultForLlm: JSON.stringify({
+                        skills: summary.length > 0 ? summary : '(no skills installed)',
+                    }),
+                    resultType: 'success',
+                };
             },
         }),
-        defineTool("schedule_delete", {
-            description: "Delete a schedule by ID",
+        defineTool('activate_skill', {
+            description: 'Activate an installed skill for the orchestrator or a specific squad. Active skills are injected into the system prompt.',
             parameters: z.object({
-                id: z.string().describe("Schedule ID to delete"),
+                skillName: z.string().describe('Name of the installed skill'),
+                targetType: z
+                    .enum(['orchestrator', 'squad'])
+                    .describe('Activate for orchestrator or a specific squad'),
+                targetId: z.string().optional().describe('Squad name (required if targetType is "squad")'),
             }),
-            handler: async ({ id }) => {
-                const { deleteSchedule } = await import("../store/schedules.js");
-                deleteSchedule(id);
-                return `Schedule ${id} deleted.`;
+            handler: async (args) => {
+                try {
+                    let resolvedTargetId = args.targetId ?? null;
+                    if (args.targetType === 'squad' && args.targetId) {
+                        const squad = await getSquadByName(args.targetId);
+                        if (!squad) {
+                            return {
+                                textResultForLlm: JSON.stringify({ error: `Squad '${args.targetId}' not found` }),
+                                resultType: 'success',
+                            };
+                        }
+                        resolvedTargetId = squad.id;
+                    }
+                    await activateSkill(args.skillName, args.targetType, resolvedTargetId ?? undefined);
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            activated: true,
+                            skillName: args.skillName,
+                            target: args.targetType === 'orchestrator' ? 'orchestrator' : args.targetId,
+                        }),
+                        resultType: 'success',
+                    };
+                }
+                catch (err) {
+                    return {
+                        textResultForLlm: JSON.stringify({
+                            error: `Failed to activate: ${err instanceof Error ? err.message : String(err)}`,
+                        }),
+                        resultType: 'success',
+                    };
+                }
             },
         }),
-        defineTool("schedule_update", {
-            description: "Update an existing schedule's cron, agenda, prompt, or enabled status",
+        defineTool('deactivate_skill', {
+            description: 'Deactivate a skill (stop injecting it into the system prompt).',
             parameters: z.object({
-                id: z.string().describe("Schedule ID to update"),
-                cron: z.string().optional().describe("New cron expression"),
-                agenda: z.string().optional().describe("New agenda text"),
-                prompt: z.string().optional().describe("New prompt text"),
-                enabled: z.boolean().optional().describe("Enable or disable the schedule"),
+                skillName: z.string().describe('Name of the skill to deactivate'),
+                targetType: z
+                    .enum(['orchestrator', 'squad'])
+                    .describe('Deactivate from orchestrator or a specific squad'),
+                targetId: z.string().optional().describe('Squad name (required if targetType is "squad")'),
             }),
-            handler: async ({ id, cron, agenda, prompt, enabled }) => {
-                const { updateSchedule } = await import("../store/schedules.js");
-                const schedule = updateSchedule(id, { cron, agenda, prompt, enabled });
-                return `Schedule ${id} updated. Cron: ${schedule.cron}, Enabled: ${!!schedule.enabled}`;
+            handler: async (args) => {
+                await deactivateSkill(args.skillName, args.targetType, args.targetId ?? undefined);
+                return {
+                    textResultForLlm: JSON.stringify({ deactivated: true, skillName: args.skillName }),
+                    resultType: 'success',
+                };
             },
         }),
-        // --- Shell Tool ---
-        defineTool("shell_exec", {
-            description: "Execute a shell command on the host machine. Use for git, gh CLI, file operations, etc. Commands run in the user's environment with their credentials.",
+        defineTool('remove_skill', {
+            description: 'Uninstall a skill completely (removes files and all activations).',
             parameters: z.object({
-                command: z.string().describe("Shell command to execute"),
-                cwd: z.string().optional().describe("Working directory (defaults to home directory)"),
+                skillName: z.string().describe('Name of the skill to remove'),
             }),
-            handler: async ({ command, cwd }) => {
-                const { exec } = await import("node:child_process");
-                const { promisify } = await import("node:util");
-                const { homedir } = await import("node:os");
-                const { getGhToken } = await import("./gh-token.js");
-                const execAsync = promisify(exec);
-                // Inject cached GH token for GitHub CLI operations
-                const shellEnv = { ...process.env, GH_PROMPT_DISABLED: "1" };
-                const ghToken = getGhToken();
-                if (ghToken) {
-                    shellEnv.GH_TOKEN = ghToken;
-                }
-                try {
-                    const { stdout } = await execAsync(command, {
-                        cwd: cwd ?? homedir(),
-                        timeout: 60_000,
-                        maxBuffer: 1024 * 1024,
-                        env: shellEnv,
-                    });
-                    const output = stdout.trim() || "(no output)";
-                    addAuditEntry("shell_command", `Command: ${command.slice(0, 200)}`, { command, cwd, output: output.slice(0, 500), exit_code: 0 });
-                    return output;
-                }
-                catch (err) {
-                    const stderr = err.stderr?.toString().trim() ?? "";
-                    const stdout = err.stdout?.toString().trim() ?? "";
-                    const output = `Error (exit ${err.code}): ${stderr || stdout || err.message}`;
-                    addAuditEntry("shell_command", `Command: ${command.slice(0, 200)}`, { command, cwd, output: output.slice(0, 500), exit_code: err.code ?? 1 });
-                    return output;
-                }
+            handler: async (args) => {
+                removeSkill(args.skillName);
+                return {
+                    textResultForLlm: JSON.stringify({ removed: true, skillName: args.skillName }),
+                    resultType: 'success',
+                };
             },
         }),
-        // --- Web Tools ---
-        // NOTE: web_search and web_fetch are provided by the Copilot SDK as built-in tools.
-        // Do not define them here to avoid conflicts.
     ];
 }
 //# sourceMappingURL=tools.js.map