verybot 0.1.8

package/dist/tools/schedule.js

@@ -0,0 +1,219 @@
+import { randomUUID } from "crypto";
+import { tool } from "ai";
+import { z } from "zod";
+import { Cron } from "croner";
+/**
+ * Create schedule management tools scoped to a team.
+ * These let the LLM create, list, delete, pause, resume schedules
+ * and set the team's timezone.
+ */
+export function createScheduleTools(store, teamId, availableIntegrations) {
+    const integrationsList = availableIntegrations.length > 0
+        ? `Available integrations: ${availableIntegrations.join(", ")}.`
+        : "No integrations available.";
+    const createSchedule = tool({
+        description: `Create a scheduled task. Create IMMEDIATELY when user asks — do NOT ask for confirmation. ` +
+            `One-shot: provide runAt (ISO 8601). Recurring: provide cron (e.g. "0 9 * * *"). ` +
+            `Convert relative times to absolute timestamps using current time. ` +
+            `${integrationsList}`,
+        inputSchema: z.object({
+            prompt: z.string().describe("The exact message or instruction to execute when this task fires. " +
+                "For reminders: write the actual reminder text the user should see (e.g. 'Time to call Sarah!' not 'Reminder from Assistant'). " +
+                "For data tasks: write a clear instruction (e.g. 'Check BTC price and report current value')."),
+            type: z.enum(["one_shot", "recurring"]).describe("one_shot for reminders, recurring for repeating tasks"),
+            cron: z.string().optional().describe("Cron expression for recurring tasks (e.g. '0 9 * * *')"),
+            runAt: z.string().optional().describe("ISO 8601 timestamp for one-shot tasks (e.g. '2026-02-08T15:30:00')"),
+            timezone: z.string().optional().describe("IANA timezone (e.g. 'America/New_York'). Uses saved team timezone if omitted."),
+            integrations: z.string().optional().describe("Comma-separated integration names to enable for this task"),
+            conditional: z.boolean().optional().describe("If true, the agent can skip delivery if nothing noteworthy happened"),
+        }),
+        execute: async (params) => {
+            // Resolve timezone: user param > saved setting > UTC default
+            const tz = params.timezone || store.getTimezone(teamId) || "UTC";
+            // Validate timezone
+            try {
+                Intl.DateTimeFormat(undefined, { timeZone: tz });
+            }
+            catch {
+                return `Invalid timezone "${tz}". Use IANA format like "America/New_York" or "Asia/Shanghai".`;
+            }
+            const type = params.type;
+            // Validate cron for recurring
+            if (type === "recurring") {
+                if (!params.cron) {
+                    return "Recurring schedules require a cron expression.";
+                }
+                try {
+                    new Cron(params.cron);
+                }
+                catch (err) {
+                    return `Invalid cron expression "${params.cron}": ${err instanceof Error ? err.message : err}`;
+                }
+            }
+            // Validate runAt for one-shot
+            if (type === "one_shot") {
+                if (!params.runAt) {
+                    return "One-shot schedules require a runAt timestamp.";
+                }
+                const runDate = new Date(params.runAt);
+                if (isNaN(runDate.getTime())) {
+                    return `Invalid timestamp "${params.runAt}". Use ISO 8601 format.`;
+                }
+                if (runDate.getTime() <= Date.now()) {
+                    return `The time "${params.runAt}" is in the past. Provide a future time.`;
+                }
+            }
+            // Compute nextRun
+            let nextRun = null;
+            if (type === "one_shot" && params.runAt) {
+                nextRun = new Date(params.runAt).toISOString();
+            }
+            else if (type === "recurring" && params.cron) {
+                try {
+                    const job = new Cron(params.cron, { timezone: tz });
+                    const next = job.nextRun();
+                    nextRun = next ? next.toISOString() : null;
+                }
+                catch {
+                    return "Failed to compute next run time from cron expression.";
+                }
+            }
+            const now = new Date().toISOString();
+            const id = randomUUID();
+            store.create({
+                id,
+                teamId,
+                prompt: params.prompt,
+                type,
+                cron: params.cron ?? null,
+                runAt: params.runAt ?? null,
+                timezone: tz,
+                integrations: params.integrations ?? "",
+                conditional: params.conditional ?? false,
+                status: "active",
+                nextRun,
+                lastRun: null,
+                failCount: 0,
+                createdAt: now,
+                updatedAt: now,
+            });
+            const nextRunFormatted = nextRun
+                ? new Date(nextRun).toLocaleString("en-US", { timeZone: tz })
+                : "unknown";
+            return `Schedule created (${type}). ID: ${id}\nNext run: ${nextRunFormatted} (${tz})`;
+        },
+    });
+    const listSchedules = tool({
+        description: "List all scheduled tasks for the current team.",
+        inputSchema: z.object({
+            status: z.enum(["active", "paused", "completed", "failed"]).optional()
+                .describe("Filter by status. Omit to show all."),
+        }),
+        execute: async ({ status }) => {
+            const schedules = store.listByTeam(teamId, status);
+            if (schedules.length === 0) {
+                return status ? `No ${status} schedules found.` : "No schedules found.";
+            }
+            const tz = store.getTimezone(teamId) ?? "UTC";
+            const lines = schedules.map((s) => {
+                const nextStr = s.nextRun
+                    ? new Date(s.nextRun).toLocaleString("en-US", { timeZone: tz })
+                    : "—";
+                const typeStr = s.type === "recurring" ? `recurring (${s.cron})` : "one-shot";
+                const condStr = s.conditional ? " [conditional]" : "";
+                return `- **${s.id.slice(0, 8)}** [${s.status}] ${typeStr}${condStr}\n  "${s.prompt.slice(0, 80)}"\n  Next: ${nextStr}`;
+            });
+            return lines.join("\n\n");
+        },
+    });
+    const deleteSchedule = tool({
+        description: "Delete a scheduled task by its ID.",
+        inputSchema: z.object({
+            id: z.string().describe("Schedule ID (full or first 8 chars)"),
+        }),
+        execute: async ({ id }) => {
+            const schedule = resolveScheduleId(store, teamId, id);
+            if (!schedule)
+                return `Schedule "${id}" not found or does not belong to this team.`;
+            store.delete(schedule.id);
+            return `Schedule "${schedule.id.slice(0, 8)}" deleted.`;
+        },
+    });
+    const pauseSchedule = tool({
+        description: "Pause an active scheduled task. It will not fire until resumed.",
+        inputSchema: z.object({
+            id: z.string().describe("Schedule ID (full or first 8 chars)"),
+        }),
+        execute: async ({ id }) => {
+            const schedule = resolveScheduleId(store, teamId, id);
+            if (!schedule)
+                return `Schedule "${id}" not found or does not belong to this team.`;
+            if (schedule.status !== "active")
+                return `Schedule is not active (status: ${schedule.status}).`;
+            store.update(schedule.id, { status: "paused" });
+            return `Schedule "${schedule.id.slice(0, 8)}" paused.`;
+        },
+    });
+    const resumeSchedule = tool({
+        description: "Resume a paused scheduled task.",
+        inputSchema: z.object({
+            id: z.string().describe("Schedule ID (full or first 8 chars)"),
+        }),
+        execute: async ({ id }) => {
+            const schedule = resolveScheduleId(store, teamId, id);
+            if (!schedule)
+                return `Schedule "${id}" not found or does not belong to this team.`;
+            if (schedule.status !== "paused")
+                return `Schedule is not paused (status: ${schedule.status}).`;
+            // Recompute next run
+            let nextRun = null;
+            if (schedule.type === "recurring" && schedule.cron) {
+                nextRun = store.computeNextRun(schedule);
+            }
+            else if (schedule.type === "one_shot" && schedule.runAt) {
+                // For one-shots, use original runAt if still in the future
+                const runDate = new Date(schedule.runAt);
+                nextRun = runDate.getTime() > Date.now() ? runDate.toISOString() : new Date().toISOString();
+            }
+            store.update(schedule.id, { status: "active", nextRun });
+            return `Schedule "${schedule.id.slice(0, 8)}" resumed. Next run: ${nextRun ?? "now"}`;
+        },
+    });
+    const setTimezone = tool({
+        description: `Set your timezone for scheduled tasks. Use IANA timezone names like "America/New_York", "Asia/Shanghai", "Europe/London".`,
+        inputSchema: z.object({
+            timezone: z.string().describe('IANA timezone name (e.g. "America/New_York")'),
+        }),
+        execute: async ({ timezone }) => {
+            try {
+                Intl.DateTimeFormat(undefined, { timeZone: timezone });
+            }
+            catch {
+                return `Invalid timezone "${timezone}". Use IANA format like "America/New_York" or "Asia/Shanghai".`;
+            }
+            store.setTimezone(teamId, timezone);
+            return `Timezone set to "${timezone}".`;
+        },
+    });
+    return {
+        create_schedule: createSchedule,
+        list_schedules: listSchedules,
+        delete_schedule: deleteSchedule,
+        pause_schedule: pauseSchedule,
+        resume_schedule: resumeSchedule,
+        set_timezone: setTimezone,
+    };
+}
+/** Resolve a schedule ID (full or short) that belongs to the given team. */
+function resolveScheduleId(store, teamId, id) {
+    // Try exact match first
+    const exact = store.getById(id);
+    if (exact && exact.teamId === teamId)
+        return exact;
+    // Try short ID prefix match
+    const all = store.listByTeam(teamId);
+    const matches = all.filter((s) => s.id.startsWith(id));
+    if (matches.length === 1)
+        return matches[0];
+    return null;
+}

package/dist/tools/speak.d.ts

@@ -0,0 +1,10 @@
+import { type ToolSet } from "ai";
+export interface TTSConfig {
+    enabled: boolean;
+    voice: string;
+}
+/**
+ * Create TTS tools: speak (synthesize + play) and speech_control (pause/resume/stop).
+ * Returns null when TTS is disabled.
+ */
+export declare function createSpeakTools(config: TTSConfig): ToolSet | null;

package/dist/tools/speak.js

@@ -0,0 +1,56 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { synthesize } from "../tts/edge.js";
+import { playAudio, pauseAudio, resumeAudio, stopAudio } from "../tts/speak.js";
+import { logger } from "../logger.js";
+const PREVIEW_LENGTH = 80;
+/**
+ * Create TTS tools: speak (synthesize + play) and speech_control (pause/resume/stop).
+ * Returns null when TTS is disabled.
+ */
+export function createSpeakTools(config) {
+    if (!config.enabled)
+        return null;
+    const speak = tool({
+        description: "Speak text aloud through the computer's speakers. " +
+            "Keep spoken text concise and conversational. " +
+            "Do NOT speak code blocks, URLs, or long technical output — use text for those.",
+        inputSchema: z.object({
+            text: z.string().describe("The text to speak aloud"),
+            voice: z
+                .string()
+                .optional()
+                .describe("Edge TTS voice name (e.g. en-US-GuyNeural). Defaults to config voice."),
+        }),
+        execute: async ({ text, voice }) => {
+            try {
+                // voice param overrides; otherwise auto-detect from text content
+                const audioPath = await synthesize(text, voice);
+                playAudio(audioPath);
+                const preview = text.length > PREVIEW_LENGTH
+                    ? `${text.slice(0, PREVIEW_LENGTH)}...`
+                    : text;
+                return `Spoke: "${preview}"`;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.error(`TTS failed: ${msg}`);
+                return `TTS error: ${msg}`;
+            }
+        },
+    });
+    const speechControl = tool({
+        description: "Control ongoing speech playback. Use this to pause, resume, or stop the current TTS audio.",
+        inputSchema: z.object({
+            action: z.enum(["pause", "resume", "stop"]).describe("The playback control action"),
+        }),
+        execute: async ({ action }) => {
+            switch (action) {
+                case "pause": return pauseAudio();
+                case "resume": return resumeAudio();
+                case "stop": return stopAudio();
+            }
+        },
+    });
+    return { speak, speech_control: speechControl };
+}

package/dist/tools/tasks.d.ts

@@ -0,0 +1,67 @@
+import type { TaskStore } from "../tasks/store.js";
+import { type TaskStatusConfig } from "../tasks/types.js";
+export interface CreateTaskToolsOptions {
+    /**
+     * Whether status changes should clear task claim ownership immediately.
+     * Default true (legacy behavior).
+     */
+    clearClaimOnStatusChange?: boolean;
+    /**
+     * If set, status updates are only allowed when the task is currently
+     * claimed by this agent id. Intended for strict subscription pipelines.
+     */
+    requireClaimedByForStatusChange?: string;
+    /** Actor label used for task_create/task_update writes from this tool set. */
+    updatedBy?: string;
+}
+/**
+ * Creates AI-facing tools for task management.
+ * Non-default teams are scoped to their own tasks only.
+ * The default team has access to all tasks across all teams.
+ *
+ * @param statuses Custom task statuses for the team (undefined = defaults).
+ */
+export declare function createTaskTools(taskStore: TaskStore, teamId?: string, statuses?: TaskStatusConfig[], options?: CreateTaskToolsOptions): {
+    task_create: import("ai").Tool<{
+        title: string;
+        description?: string | undefined;
+        assignee?: string | undefined;
+        priority?: "low" | "medium" | "high" | undefined;
+        status?: string | undefined;
+        needsHumanReview?: boolean | undefined;
+    }, string>;
+    task_update: import("ai").Tool<{
+        id: string;
+        status?: string | undefined;
+        title?: string | undefined;
+        description?: string | null | undefined;
+        assignee?: string | null | undefined;
+        priority?: "low" | "medium" | "high" | undefined;
+        needsHumanReview?: boolean | undefined;
+    }, string>;
+    task_list: import("ai").Tool<{
+        status?: string | undefined;
+        team?: string | undefined;
+        needsHumanReview?: boolean | undefined;
+    }, string>;
+    task_get: import("ai").Tool<{
+        id: string;
+    }, string>;
+    task_delete: import("ai").Tool<{
+        id: string;
+    }, string>;
+    task_comment_list: import("ai").Tool<{
+        taskId: string;
+    }, string>;
+    task_comment_add: import("ai").Tool<{
+        taskId: string;
+        content: string;
+    }, string>;
+    task_comment_update: import("ai").Tool<{
+        id: string;
+        content: string;
+    }, string>;
+    task_comment_delete: import("ai").Tool<{
+        id: string;
+    }, string>;
+};

package/dist/tools/tasks.js

@@ -0,0 +1,288 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { TASK_PRIORITIES, DEFAULT_TASK_STATUSES, MAX_TASK_COMMENT_LENGTH, } from "../tasks/types.js";
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+import { emit } from "../events.js";
+function formatClaimedAt(claimedAt) {
+    return claimedAt === null ? "none" : new Date(claimedAt).toISOString();
+}
+function formatUpdatedAt(updatedAt) {
+    return new Date(updatedAt).toISOString();
+}
+function formatTaskListLine(task) {
+    const assigned = task.assignee ? `, assigned: ${task.assignee}` : "";
+    const claimedBy = task.claimedBy ?? "none";
+    const claimedAt = formatClaimedAt(task.claimedAt);
+    const updatedBy = task.updatedBy ?? "none";
+    const updatedAt = formatUpdatedAt(task.updatedAt);
+    const needsHumanReview = task.needsHumanReview ? "yes" : "no";
+    return `[${task.id}] ${task.title} — ${task.status} (${task.priority}, team: ${task.teamId}${assigned}, needs_human_review: ${needsHumanReview}, claimed_by: ${claimedBy}, claimed_at: ${claimedAt}, updated_by: ${updatedBy}, updated_at: ${updatedAt})`;
+}
+function formatTaskCommentLine(comment) {
+    const createdAt = new Date(comment.createdAt).toISOString();
+    if (comment.updatedAt > comment.createdAt) {
+        const editedAt = new Date(comment.updatedAt).toISOString();
+        return `[${comment.id}] ${comment.createdBy} @ ${createdAt} (edited by ${comment.updatedBy} @ ${editedAt}): ${comment.content}`;
+    }
+    return `[${comment.id}] ${comment.createdBy} @ ${createdAt}: ${comment.content}`;
+}
+function formatTaskAttachmentLine(attachment) {
+    const createdAt = new Date(attachment.createdAt).toISOString();
+    return `[${attachment.id}] ${attachment.name} (${attachment.type}, ${attachment.size} bytes, created_at: ${createdAt})`;
+}
+function formatTaskDetail(task, comments) {
+    const assignee = task.assignee ?? "none";
+    const claimedBy = task.claimedBy ?? "none";
+    const claimedAt = formatClaimedAt(task.claimedAt);
+    const updatedBy = task.updatedBy ?? "none";
+    const updatedAt = formatUpdatedAt(task.updatedAt);
+    const needsHumanReview = task.needsHumanReview ? "yes" : "no";
+    const normalizedDescription = task.description?.trim()
+        ? task.description
+        : "(none)";
+    const attachmentLines = task.attachments.length > 0
+        ? task.attachments.map(formatTaskAttachmentLine)
+        : ["(none)"];
+    const commentLines = comments.length > 0
+        ? comments.map(formatTaskCommentLine)
+        : ["(none)"];
+    return [
+        `Task: [${task.id}] ${task.title}`,
+        `Team: ${task.teamId}`,
+        `Status: ${task.status}`,
+        `Priority: ${task.priority}`,
+        `Assignee: ${assignee}`,
+        `Needs human review: ${needsHumanReview}`,
+        `Claimed by: ${claimedBy}`,
+        `Claimed at: ${claimedAt}`,
+        `Updated by: ${updatedBy}`,
+        `Updated at: ${updatedAt}`,
+        "Description:",
+        normalizedDescription,
+        "Attachments:",
+        ...attachmentLines,
+        "Comments:",
+        ...commentLines,
+    ].join("\n");
+}
+/**
+ * Creates AI-facing tools for task management.
+ * Non-default teams are scoped to their own tasks only.
+ * The default team has access to all tasks across all teams.
+ *
+ * @param statuses Custom task statuses for the team (undefined = defaults).
+ */
+export function createTaskTools(taskStore, teamId, statuses, options = {}) {
+    /** Non-default teams can only access their own tasks. */
+    const scoped = !!teamId && teamId !== DEFAULT_TEAM_ID;
+    const DEFAULT_CREATE_STATUS_KEY = "todo";
+    // Build dynamic status keys from team config or fall back to global defaults.
+    // Defensive fallback: some persisted teams may still have empty status lists.
+    const configuredStatuses = statuses && statuses.length > 0 ? statuses : DEFAULT_TASK_STATUSES;
+    const createStatusKeys = configuredStatuses.map((s) => s.key);
+    const listAndUpdateStatusKeys = [...createStatusKeys, "archived"];
+    const defaultCreateStatus = createStatusKeys.includes(DEFAULT_CREATE_STATUS_KEY)
+        ? DEFAULT_CREATE_STATUS_KEY
+        : configuredStatuses[0]?.key
+            ?? DEFAULT_TASK_STATUSES[0].key;
+    const createStatusDesc = createStatusKeys.join(", ");
+    const statusDesc = listAndUpdateStatusKeys.join(", ");
+    const createStatusEnum = z.enum(createStatusKeys);
+    const statusEnum = z.enum(listAndUpdateStatusKeys);
+    const commentContentSchema = z.string().trim().min(1).max(MAX_TASK_COMMENT_LENGTH);
+    const actor = options.updatedBy ?? "assistant";
+    function getScopedTask(taskId) {
+        const task = taskStore.getById(taskId);
+        if (!task)
+            return null;
+        if (scoped && task.teamId !== teamId)
+            return null;
+        return task;
+    }
+    const createTask = tool({
+        description: "Create a new task for the team. Returns the created task with its ID.",
+        inputSchema: z.object({
+            title: z.string().describe("Short task title"),
+            description: z.string().optional().describe("Optional detailed description"),
+            assignee: z.string().optional().describe("Agent ID or 'user' to assign to"),
+            priority: z.enum(TASK_PRIORITIES).optional().describe("Task priority: low, medium, or high"),
+            status: createStatusEnum.optional().describe(`Initial status: ${createStatusDesc}`),
+            needsHumanReview: z.boolean().optional().describe("Whether this task is waiting on a human review"),
+        }),
+        execute: async ({ title, description, assignee, priority, status, needsHumanReview }) => {
+            const task = taskStore.create({
+                title,
+                description,
+                teamId,
+                assignee,
+                priority,
+                status: status ?? defaultCreateStatus,
+                needsHumanReview,
+            }, { updatedBy: actor });
+            emit("taskChange", { action: "created", task });
+            return `Task created: [${task.id}] ${task.title} (${task.priority}, ${task.status})`;
+        },
+    });
+    const updateTask = tool({
+        description: `Update an existing task. Available statuses: ${statusDesc}.`,
+        inputSchema: z.object({
+            id: z.string().describe("Task ID to update"),
+            status: statusEnum.optional().describe(`New status: ${statusDesc}`),
+            title: z.string().optional().describe("New title"),
+            description: z.string().nullable().optional().describe("New description (null to clear)"),
+            assignee: z.string().nullable().optional().describe("New assignee (agent ID, 'user', or null to unassign)"),
+            priority: z.enum(TASK_PRIORITIES).optional().describe("New priority"),
+            needsHumanReview: z.boolean().optional().describe("Set whether this task is waiting on a human review"),
+        }),
+        execute: async ({ id, status, title, description, assignee, priority, needsHumanReview }) => {
+            const existing = taskStore.getById(id);
+            if (!existing || (scoped && existing.teamId !== teamId))
+                return `Task not found: ${id}`;
+            const statusChanged = status !== undefined && status !== existing.status;
+            const requiredClaimOwner = options.requireClaimedByForStatusChange;
+            if (statusChanged && requiredClaimOwner && existing.claimedBy !== requiredClaimOwner) {
+                const claimOwner = existing.claimedBy ?? "none";
+                return `Task status update blocked: claimed by ${claimOwner}`;
+            }
+            const task = taskStore.update(id, { status, title, description, assignee, priority, needsHumanReview }, {
+                clearClaimOnStatusChange: options.clearClaimOnStatusChange,
+                updatedBy: actor,
+            });
+            if (!task)
+                return `Task not found: ${id}`;
+            emit("taskChange", { action: "updated", task });
+            return `Task updated: [${task.id}] ${task.title} — ${task.status} (${task.priority})`;
+        },
+    });
+    const listTasks = tool({
+        description: "List tasks. ALWAYS call fresh — never rely on cached results. " +
+            "Only include filters the user explicitly requests. " +
+            "Output includes human-review metadata (needs_human_review), claim metadata (claimed_by, claimed_at), and update metadata (updated_by, updated_at). " +
+            "Returns all tasks when called with no parameters.",
+        inputSchema: z.object({
+            status: statusEnum.optional().describe(`Filter by status: ${statusDesc}`),
+            team: z.string().optional().describe("Filter by team ID"),
+            needsHumanReview: z.boolean().optional().describe("Filter tasks waiting for human review"),
+        }),
+        execute: async ({ status, team, needsHumanReview }) => {
+            const effectiveTeamId = scoped ? teamId : team;
+            const tasks = taskStore.list({ teamId: effectiveTeamId, status, needsHumanReview });
+            if (tasks.length === 0)
+                return "No tasks found.";
+            return tasks.map(formatTaskListLine).join("\n");
+        },
+    });
+    const getTask = tool({
+        description: "Get full details for a task by ID, including description, attachments, and comments.",
+        inputSchema: z.object({
+            id: z.string().describe("Task ID to read"),
+        }),
+        execute: async ({ id }) => {
+            const task = getScopedTask(id);
+            if (!task)
+                return `Task not found: ${id}`;
+            const comments = taskStore.listComments(id);
+            return formatTaskDetail(task, comments);
+        },
+    });
+    const deleteTask = tool({
+        description: "Permanently delete a task by ID.",
+        inputSchema: z.object({
+            id: z.string().describe("Task ID to delete"),
+        }),
+        execute: async ({ id }) => {
+            if (scoped) {
+                const existing = taskStore.getById(id);
+                if (!existing || existing.teamId !== teamId)
+                    return `Task not found: ${id}`;
+            }
+            const deleted = taskStore.delete(id);
+            if (!deleted)
+                return `Task not found: ${id}`;
+            emit("taskChange", { action: "deleted", id });
+            return `Task deleted: ${id}`;
+        },
+    });
+    const listTaskComments = tool({
+        description: "List comments for a task by task ID.",
+        inputSchema: z.object({
+            taskId: z.string().describe("Task ID to read comments from"),
+        }),
+        execute: async ({ taskId }) => {
+            const task = getScopedTask(taskId);
+            if (!task)
+                return `Task not found: ${taskId}`;
+            const comments = taskStore.listComments(taskId);
+            if (comments.length === 0)
+                return `No comments found for task: ${taskId}`;
+            return comments.map(formatTaskCommentLine).join("\n");
+        },
+    });
+    const addTaskComment = tool({
+        description: "Add a comment to a task.",
+        inputSchema: z.object({
+            taskId: z.string().describe("Task ID to comment on"),
+            content: commentContentSchema.describe("Comment content"),
+        }),
+        execute: async ({ taskId, content }) => {
+            const task = getScopedTask(taskId);
+            if (!task)
+                return `Task not found: ${taskId}`;
+            const comment = taskStore.addComment(taskId, content, { actor });
+            if (!comment)
+                return `Task not found: ${taskId}`;
+            emit("taskChange", { action: "commentAdded", taskId, comment });
+            return `Comment added: [${comment.id}] on task ${taskId}`;
+        },
+    });
+    const updateTaskComment = tool({
+        description: "Edit an existing task comment by comment ID.",
+        inputSchema: z.object({
+            id: z.string().describe("Comment ID to edit"),
+            content: commentContentSchema.describe("Updated comment content"),
+        }),
+        execute: async ({ id, content }) => {
+            const existing = taskStore.getCommentById(id);
+            if (!existing)
+                return `Comment not found: ${id}`;
+            const task = getScopedTask(existing.taskId);
+            if (!task)
+                return `Comment not found: ${id}`;
+            const comment = taskStore.updateComment(id, content, { actor });
+            if (!comment)
+                return `Comment not found: ${id}`;
+            emit("taskChange", { action: "commentUpdated", taskId: comment.taskId, comment });
+            return `Comment updated: [${comment.id}]`;
+        },
+    });
+    const deleteTaskComment = tool({
+        description: "Delete a task comment by comment ID.",
+        inputSchema: z.object({
+            id: z.string().describe("Comment ID to delete"),
+        }),
+        execute: async ({ id }) => {
+            const existing = taskStore.getCommentById(id);
+            if (!existing)
+                return `Comment not found: ${id}`;
+            const task = getScopedTask(existing.taskId);
+            if (!task)
+                return `Comment not found: ${id}`;
+            const comment = taskStore.deleteComment(id, { actor });
+            if (!comment)
+                return `Comment not found: ${id}`;
+            emit("taskChange", { action: "commentDeleted", taskId: comment.taskId, id: comment.id });
+            return `Comment deleted: ${id}`;
+        },
+    });
+    return {
+        task_create: createTask,
+        task_update: updateTask,
+        task_list: listTasks,
+        task_get: getTask,
+        task_delete: deleteTask,
+        task_comment_list: listTaskComments,
+        task_comment_add: addTaskComment,
+        task_comment_update: updateTaskComment,
+        task_comment_delete: deleteTaskComment,
+    };
+}

package/dist/tools/teams.d.ts

@@ -0,0 +1,22 @@
+import { type ToolSet } from "ai";
+import type { TeamStore } from "../teams/store.js";
+import type { PromptTemplateStore } from "../prompt-templates/store.js";
+type TeamManagementToolName = "team_list" | "team_create" | "team_update" | "team_status_list" | "team_status_get" | "team_status_add" | "team_status_update" | "team_status_delete" | "orchestrator_update" | "worker_create" | "worker_update" | "worker_delete";
+interface TeamManagementToolOptions {
+    /** Optional hard scope: all team-aware operations are constrained to this team. */
+    scopeTeamId?: string;
+    /** Optional subset to expose from the full team management toolset. */
+    enabledTools?: TeamManagementToolName[];
+}
+/**
+ * Creates AI-facing tools for team and worker management.
+ * Available to the default team orchestrator.
+ * All mutating tools accept an optional teamId (defaults to the default team).
+ */
+export declare function createTeamManagementTools(teamStore: TeamStore, defaultTeamId: string, promptTemplateStore?: PromptTemplateStore, options?: TeamManagementToolOptions): ToolSet;
+/**
+ * Worker CRUD-only toolset for a single team orchestrator.
+ * Exposes worker_create/update/delete and hard-scopes all operations to `teamId`.
+ */
+export declare function createScopedWorkerManagementTools(teamStore: TeamStore, teamId: string, promptTemplateStore?: PromptTemplateStore): ToolSet;
+export {};