verybot 0.1.8

package/dist/tasks/store.js

@@ -0,0 +1,519 @@
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import { randomUUID } from "node:crypto";
+import Database from "better-sqlite3";
+import { logger } from "../logger.js";
+import { DEFAULT_TEAM_ID } from "../config/agent-config.js";
+const DEFAULT_TASK_ACTOR = "system";
+const HUMAN_TASK_ACTOR = "user";
+const EMPTY_STATUS_POSITION = 0;
+/**
+ * SQLite-backed persistence for team tasks.
+ * Shares the same DB file as MemoryStore, ScheduleStore, etc.
+ */
+export class TaskStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    static async create(dbPath) {
+        mkdirSync(dirname(dbPath), { recursive: true });
+        const db = new Database(dbPath);
+        db.pragma("journal_mode = WAL");
+        const store = new TaskStore(db);
+        store.createSchema();
+        store.migrate();
+        return store;
+    }
+    createSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        team_id TEXT,
+        title TEXT NOT NULL,
+        description TEXT,
+        status TEXT NOT NULL DEFAULT 'todo',
+        assignee TEXT,
+        priority TEXT NOT NULL DEFAULT 'medium',
+        position INTEGER NOT NULL DEFAULT 0,
+        needs_human_review INTEGER NOT NULL DEFAULT 0,
+        last_processed_by TEXT,
+        last_processed_for_updated_at INTEGER,
+        updated_by TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_tasks_team ON tasks(team_id);
+      CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+      CREATE INDEX IF NOT EXISTS idx_tasks_assignee ON tasks(assignee);
+
+      CREATE TABLE IF NOT EXISTS task_comments (
+        id TEXT PRIMARY KEY,
+        task_id TEXT NOT NULL,
+        content TEXT NOT NULL,
+        created_by TEXT NOT NULL,
+        updated_by TEXT NOT NULL,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_task_comments_task ON task_comments(task_id);
+      CREATE INDEX IF NOT EXISTS idx_task_comments_created_at ON task_comments(created_at);
+
+      CREATE TABLE IF NOT EXISTS task_counters (
+        key TEXT PRIMARY KEY,
+        value INTEGER NOT NULL
+      );
+    `);
+    }
+    /** Add position column for existing databases that lack it. */
+    migrate() {
+        const columns = this.db.pragma("table_info(tasks)");
+        const hasPosition = columns.some((c) => c.name === "position");
+        if (!hasPosition) {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN position INTEGER NOT NULL DEFAULT 0");
+            // Backfill: assign positions based on created_at DESC per status
+            for (const status of ["backlog", "todo", "plan", "in_progress", "done", "archived"]) {
+                const rows = this.db
+                    .prepare("SELECT id FROM tasks WHERE status = ? ORDER BY created_at DESC")
+                    .all(status);
+                const stmt = this.db.prepare("UPDATE tasks SET position = ? WHERE id = ?");
+                rows.forEach((row, i) => stmt.run(i, row.id));
+            }
+            logger.info("Migrated tasks table: added position column");
+        }
+        const hasAttachments = columns.some((c) => c.name === "attachments");
+        if (!hasAttachments) {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN attachments TEXT DEFAULT '[]'");
+            logger.info("Migrated tasks table: added attachments column");
+        }
+        const hasNeedsHumanReview = columns.some((c) => c.name === "needs_human_review");
+        if (!hasNeedsHumanReview) {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN needs_human_review INTEGER NOT NULL DEFAULT 0");
+            logger.info("Migrated tasks table: added needs_human_review column");
+        }
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_human_review ON tasks(needs_human_review)");
+        // Backfill NULL team_id → "default"
+        const nullCount = this.db
+            .prepare(`SELECT COUNT(*) AS n FROM tasks WHERE team_id IS NULL`)
+            .get();
+        if (nullCount.n > 0) {
+            this.db.prepare(`UPDATE tasks SET team_id = ? WHERE team_id IS NULL`).run(DEFAULT_TEAM_ID);
+            logger.info(`Migrated ${nullCount.n} tasks: set NULL team_id to '${DEFAULT_TEAM_ID}'`);
+        }
+        // Add claimed_by / claimed_at columns for pull-based task subscriptions
+        const hasClaimedBy = columns.some((c) => c.name === "claimed_by");
+        if (!hasClaimedBy) {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN claimed_by TEXT");
+            this.db.exec("ALTER TABLE tasks ADD COLUMN claimed_at INTEGER");
+            this.db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_claimed ON tasks(claimed_by)");
+            logger.info("Migrated tasks table: added claimed_by, claimed_at columns");
+        }
+        // Add actor audit field for task updates.
+        const hasUpdatedBy = columns.some((c) => c.name === "updated_by");
+        if (!hasUpdatedBy) {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN updated_by TEXT");
+            this.db.prepare("UPDATE tasks SET updated_by = ? WHERE updated_by IS NULL").run("legacy");
+            logger.info("Migrated tasks table: added updated_by column");
+        }
+        // Add processed-marker fields for subscription dedupe.
+        const hasLastProcessedBy = columns.some((c) => c.name === "last_processed_by");
+        if (!hasLastProcessedBy) {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN last_processed_by TEXT");
+            logger.info("Migrated tasks table: added last_processed_by column");
+        }
+        const hasLastProcessedForUpdatedAt = columns.some((c) => c.name === "last_processed_for_updated_at");
+        if (!hasLastProcessedForUpdatedAt) {
+            this.db.exec("ALTER TABLE tasks ADD COLUMN last_processed_for_updated_at INTEGER");
+            logger.info("Migrated tasks table: added last_processed_for_updated_at column");
+        }
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_last_processed ON tasks(last_processed_by, last_processed_for_updated_at)");
+        this.ensureTaskIdCounter();
+    }
+    /** Initialize or bump task ID counter based on highest numeric task id in DB. */
+    ensureTaskIdCounter() {
+        const row = this.db
+            .prepare(`SELECT COALESCE(MAX(CAST(id AS INTEGER)), 0) AS max_id
+         FROM tasks
+         WHERE id <> '' AND id NOT GLOB '*[^0-9]*'`)
+            .get();
+        const nextId = Number(row.max_id) + 1;
+        const current = this.db
+            .prepare("SELECT value FROM task_counters WHERE key = 'task_id'")
+            .get();
+        if (!current) {
+            this.db
+                .prepare("INSERT INTO task_counters (key, value) VALUES ('task_id', ?)")
+                .run(nextId);
+            return;
+        }
+        if (current.value < nextId) {
+            this.db
+                .prepare("UPDATE task_counters SET value = ? WHERE key = 'task_id'")
+                .run(nextId);
+        }
+    }
+    /** Allocate next task ID as an incrementing number persisted in SQLite. */
+    nextTaskId() {
+        const next = this.db.transaction(() => {
+            const current = this.db
+                .prepare("SELECT value FROM task_counters WHERE key = 'task_id'")
+                .get();
+            const value = current?.value ?? 1;
+            if (!current) {
+                this.db
+                    .prepare("INSERT INTO task_counters (key, value) VALUES ('task_id', ?)")
+                    .run(value + 1);
+            }
+            else {
+                this.db
+                    .prepare("UPDATE task_counters SET value = ? WHERE key = 'task_id'")
+                    .run(value + 1);
+            }
+            return value;
+        })();
+        return String(next);
+    }
+    /** Get the next position value for a given status (appends to end). */
+    nextPosition(status) {
+        const row = this.db
+            .prepare("SELECT COALESCE(MAX(position), -1) + 1 AS next FROM tasks WHERE status = ?")
+            .get(status);
+        return row.next;
+    }
+    /** Get the next position value for a given status (prepends to top). */
+    topPosition(status) {
+        const row = this.db
+            .prepare("SELECT COALESCE(MIN(position), ?) - 1 AS next FROM tasks WHERE status = ?")
+            .get(EMPTY_STATUS_POSITION + 1, status);
+        return row.next;
+    }
+    create(input, options = {}) {
+        const now = Date.now();
+        const status = input.status ?? "todo";
+        const updatedBy = options.updatedBy ?? DEFAULT_TASK_ACTOR;
+        const task = {
+            id: this.nextTaskId(),
+            teamId: input.teamId || DEFAULT_TEAM_ID,
+            title: input.title,
+            description: input.description ?? null,
+            status,
+            assignee: input.assignee ?? null,
+            priority: input.priority ?? "medium",
+            position: this.nextPosition(status),
+            needsHumanReview: input.needsHumanReview ?? false,
+            attachments: input.attachments ?? [],
+            claimedBy: null,
+            claimedAt: null,
+            updatedBy,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.db
+            .prepare(`INSERT INTO tasks (id, team_id, title, description, status, assignee, priority, position, needs_human_review, attachments, claimed_by, claimed_at, updated_by, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(task.id, task.teamId, task.title, task.description, task.status, task.assignee, task.priority, task.position, task.needsHumanReview ? 1 : 0, JSON.stringify(task.attachments), null, null, task.updatedBy, task.createdAt, task.updatedAt);
+        return task;
+    }
+    update(id, input, options = {}) {
+        const existing = this.getById(id);
+        if (!existing)
+            return null;
+        // When status changes, assign position at top of destination column
+        const statusChanged = input.status !== undefined && input.status !== existing.status;
+        const newPosition = statusChanged ? this.topPosition(input.status) : existing.position;
+        // Default behavior: clear claim on status changes so a new subscriber can pick it up.
+        // Strict subscription flows can opt out and release claim explicitly after run completion.
+        const clearClaimOnStatusChange = options.clearClaimOnStatusChange ?? true;
+        const clearClaim = statusChanged && clearClaimOnStatusChange;
+        const updatedBy = options.updatedBy ?? DEFAULT_TASK_ACTOR;
+        const isHumanUpdate = updatedBy === HUMAN_TASK_ACTOR;
+        const needsHumanReview = input.needsHumanReview !== undefined
+            ? input.needsHumanReview
+            : isHumanUpdate
+                ? false
+                : existing.needsHumanReview;
+        const updated = {
+            ...existing,
+            ...(input.title !== undefined && { title: input.title }),
+            ...(input.description !== undefined && { description: input.description }),
+            ...(input.status !== undefined && { status: input.status }),
+            ...(input.assignee !== undefined && { assignee: input.assignee }),
+            ...(input.priority !== undefined && { priority: input.priority }),
+            ...(input.teamId !== undefined && { teamId: input.teamId || DEFAULT_TEAM_ID }),
+            ...(input.attachments !== undefined && { attachments: input.attachments }),
+            needsHumanReview,
+            ...(clearClaim && { claimedBy: null, claimedAt: null }),
+            updatedBy,
+            position: newPosition,
+            updatedAt: Date.now(),
+        };
+        this.db
+            .prepare(`UPDATE tasks SET team_id = ?, title = ?, description = ?, status = ?, assignee = ?, priority = ?, position = ?, needs_human_review = ?, attachments = ?, claimed_by = ?, claimed_at = ?, updated_by = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(updated.teamId, updated.title, updated.description, updated.status, updated.assignee, updated.priority, updated.position, updated.needsHumanReview ? 1 : 0, JSON.stringify(updated.attachments), updated.claimedBy, updated.claimedAt, updated.updatedBy, updated.updatedAt, id);
+        return updated;
+    }
+    /**
+     * Bulk-reorder tasks within a status column. Sets positions 0, 1, 2, ...
+     * Reordering is a board-layout concern and must not mutate task freshness fields
+     * (for example updated_at), otherwise subscription workers re-run unchanged tasks.
+     */
+    reorder(status, orderedIds) {
+        const stmt = this.db.prepare("UPDATE tasks SET position = ? WHERE id = ? AND status = ?");
+        const tx = this.db.transaction(() => {
+            orderedIds.forEach((id, i) => stmt.run(i, id, status));
+        });
+        tx();
+    }
+    delete(id) {
+        const info = this.db.transaction(() => {
+            this.db.prepare("DELETE FROM task_comments WHERE task_id = ?").run(id);
+            return this.db.prepare("DELETE FROM tasks WHERE id = ?").run(id);
+        })();
+        return info.changes > 0;
+    }
+    getById(id) {
+        const row = this.db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+        return row ? toTask(row) : null;
+    }
+    list(filter = {}) {
+        const conditions = [];
+        const params = [];
+        if (filter.teamId) {
+            conditions.push("team_id = ?");
+            params.push(filter.teamId);
+        }
+        if (filter.status) {
+            conditions.push("status = ?");
+            params.push(filter.status);
+        }
+        else if (!filter.includeArchived) {
+            conditions.push("status != 'archived'");
+        }
+        if (filter.assignee) {
+            conditions.push("assignee = ?");
+            params.push(filter.assignee);
+        }
+        if (filter.needsHumanReview !== undefined) {
+            conditions.push("needs_human_review = ?");
+            params.push(filter.needsHumanReview ? 1 : 0);
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const rows = this.db
+            .prepare(`SELECT * FROM tasks ${where} ORDER BY position ASC`)
+            .all(...params);
+        return rows.map(toTask);
+    }
+    listComments(taskId) {
+        const rows = this.db
+            .prepare("SELECT * FROM task_comments WHERE task_id = ? ORDER BY created_at ASC, id ASC")
+            .all(taskId);
+        return rows.map(toTaskComment);
+    }
+    addComment(taskId, content, options = {}) {
+        const task = this.getById(taskId);
+        if (!task)
+            return null;
+        const now = Date.now();
+        const actor = options.actor ?? DEFAULT_TASK_ACTOR;
+        const normalizedContent = content.trim();
+        const comment = {
+            id: randomUUID(),
+            taskId,
+            content: normalizedContent,
+            createdBy: actor,
+            updatedBy: actor,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.db.transaction(() => {
+            this.db
+                .prepare(`INSERT INTO task_comments (id, task_id, content, created_by, updated_by, created_at, updated_at)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`)
+                .run(comment.id, comment.taskId, comment.content, comment.createdBy, comment.updatedBy, comment.createdAt, comment.updatedAt);
+            this.touchTaskAudit(taskId, actor, now);
+        })();
+        return comment;
+    }
+    updateComment(id, content, options = {}) {
+        const existing = this.getCommentById(id);
+        if (!existing)
+            return null;
+        const now = Date.now();
+        const actor = options.actor ?? DEFAULT_TASK_ACTOR;
+        const normalizedContent = content.trim();
+        const updated = {
+            ...existing,
+            content: normalizedContent,
+            updatedBy: actor,
+            updatedAt: now,
+        };
+        this.db.transaction(() => {
+            this.db
+                .prepare("UPDATE task_comments SET content = ?, updated_by = ?, updated_at = ? WHERE id = ?")
+                .run(updated.content, updated.updatedBy, updated.updatedAt, id);
+            this.touchTaskAudit(existing.taskId, actor, now);
+        })();
+        return updated;
+    }
+    deleteComment(id, options = {}) {
+        const existing = this.getCommentById(id);
+        if (!existing)
+            return null;
+        const now = Date.now();
+        const actor = options.actor ?? DEFAULT_TASK_ACTOR;
+        const info = this.db.transaction(() => {
+            const deleteInfo = this.db.prepare("DELETE FROM task_comments WHERE id = ?").run(id);
+            if (deleteInfo.changes > 0) {
+                this.touchTaskAudit(existing.taskId, actor, now);
+            }
+            return deleteInfo;
+        })();
+        return info.changes > 0 ? existing : null;
+    }
+    /** Bulk-archive all tasks currently in the provided completion status, optionally scoped to a team. */
+    archiveDone(teamId, doneStatus = "done", updatedBy = DEFAULT_TASK_ACTOR) {
+        const STATUS_KEY_RE = /^\w+$/;
+        if (!STATUS_KEY_RE.test(doneStatus)) {
+            throw new Error(`Invalid status key: ${doneStatus}`);
+        }
+        const now = Date.now();
+        if (teamId) {
+            const info = this.db
+                .prepare("UPDATE tasks SET status = 'archived', updated_by = ?, updated_at = ? WHERE status = ? AND team_id = ?")
+                .run(updatedBy, now, doneStatus, teamId);
+            return info.changes;
+        }
+        const info = this.db
+            .prepare("UPDATE tasks SET status = 'archived', updated_by = ?, updated_at = ? WHERE status = ?")
+            .run(updatedBy, now, doneStatus);
+        return info.changes;
+    }
+    /**
+     * Atomically claim the oldest unclaimed task matching the given status for an agent.
+     * Respects assignee: assigned tasks only go to that agent, unassigned to any subscriber.
+     */
+    claimTask(agentId, status) {
+        return this.db.transaction(() => {
+            const row = this.db.prepare(`SELECT * FROM tasks
+         WHERE status = ? AND claimed_by IS NULL AND needs_human_review = 0
+           AND (assignee IS NULL OR assignee = ?)
+           AND (
+             last_processed_by IS NULL
+             OR last_processed_for_updated_at IS NULL
+             OR last_processed_by != ?
+             OR last_processed_for_updated_at != updated_at
+           )
+         ORDER BY
+           CASE WHEN assignee = ? THEN 0 ELSE 1 END,
+           created_at ASC
+         LIMIT 1`).get(status, agentId, agentId, agentId);
+            if (!row)
+                return null;
+            const now = Date.now();
+            this.db.prepare("UPDATE tasks SET claimed_by = ?, claimed_at = ? WHERE id = ?").run(agentId, now, row.id);
+            const task = toTask(row);
+            task.claimedBy = agentId;
+            task.claimedAt = now;
+            return task;
+        })();
+    }
+    /** Atomically claim a specific task by ID for an agent. Returns the task if claimed, null if already taken. */
+    claimTaskById(taskId, agentId) {
+        const now = Date.now();
+        const info = this.db.prepare("UPDATE tasks SET claimed_by = ?, claimed_at = ? WHERE id = ? AND claimed_by IS NULL AND needs_human_review = 0").run(agentId, now, taskId);
+        if (info.changes === 0)
+            return null;
+        return this.getById(taskId);
+    }
+    /** Release a claimed task so it can be retried. */
+    releaseTask(taskId) {
+        this.db.prepare("UPDATE tasks SET claimed_by = NULL, claimed_at = NULL WHERE id = ?").run(taskId);
+    }
+    /**
+     * Release claim only when held by the provided agent id.
+     * Returns true when a claim was released.
+     */
+    releaseTaskIfClaimedBy(taskId, agentId) {
+        const info = this.db.prepare("UPDATE tasks SET claimed_by = NULL, claimed_at = NULL WHERE id = ? AND claimed_by = ?").run(taskId, agentId);
+        return info.changes > 0;
+    }
+    /**
+     * Mark a claimed task as processed by the given agent for the current task version,
+     * then release the claim atomically.
+     * Returns true when the task was finalized by the expected claim owner.
+     */
+    finalizeClaimedTaskRun(taskId, agentId) {
+        const info = this.db.prepare(`UPDATE tasks
+       SET last_processed_by = ?,
+           last_processed_for_updated_at = updated_at,
+           claimed_by = NULL,
+           claimed_at = NULL
+       WHERE id = ? AND claimed_by = ?`).run(agentId, taskId, agentId);
+        return info.changes > 0;
+    }
+    /** Release claims older than the given cutoff timestamp. Returns count of released claims. */
+    cleanupStaleClaims(cutoffTimestamp) {
+        const info = this.db.prepare("UPDATE tasks SET claimed_by = NULL, claimed_at = NULL WHERE claimed_by IS NOT NULL AND claimed_at < ?").run(cutoffTimestamp);
+        return info.changes;
+    }
+    close() {
+        this.db.close();
+        logger.info("Task store closed");
+    }
+    getCommentById(id) {
+        const row = this.db.prepare("SELECT * FROM task_comments WHERE id = ?").get(id);
+        return row ? toTaskComment(row) : null;
+    }
+    touchTaskAudit(taskId, updatedBy, updatedAt) {
+        if (updatedBy === HUMAN_TASK_ACTOR) {
+            this.db
+                .prepare("UPDATE tasks SET updated_by = ?, updated_at = ?, needs_human_review = 0 WHERE id = ?")
+                .run(updatedBy, updatedAt, taskId);
+            return;
+        }
+        this.db
+            .prepare("UPDATE tasks SET updated_by = ?, updated_at = ? WHERE id = ?")
+            .run(updatedBy, updatedAt, taskId);
+    }
+}
+function parseAttachments(raw) {
+    if (typeof raw !== "string" || !raw)
+        return [];
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+function toTask(row) {
+    return {
+        id: row.id,
+        teamId: row.team_id || DEFAULT_TEAM_ID,
+        title: row.title,
+        description: row.description ?? null,
+        status: row.status,
+        assignee: row.assignee ?? null,
+        priority: row.priority,
+        position: row.position ?? 0,
+        attachments: parseAttachments(row.attachments),
+        needsHumanReview: Number(row.needs_human_review ?? 0) === 1,
+        claimedBy: row.claimed_by ?? null,
+        claimedAt: row.claimed_at ?? null,
+        updatedBy: row.updated_by ?? null,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function toTaskComment(row) {
+    return {
+        id: row.id,
+        taskId: row.task_id,
+        content: row.content,
+        createdBy: row.created_by,
+        updatedBy: row.updated_by,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}

package/dist/tasks/types.d.ts

@@ -0,0 +1,129 @@
+import { z } from "zod";
+/** Max upload file size: 10 MB */
+export declare const MAX_FILE_SIZE: number;
+export declare const ALLOWED_IMAGE_TYPES: Set<string>;
+export declare const EXT_FOR_MIME: Record<string, string>;
+/** Legacy list of default status keys — used only for migration backfills. */
+export declare const LEGACY_STATUS_KEYS: readonly ["backlog", "todo", "plan", "in_progress", "done", "archived"];
+/** Status is now a free-form string to support per-team custom statuses. */
+export type TaskStatus = string;
+export declare const TASK_PRIORITIES: readonly ["low", "medium", "high"];
+export type TaskPriority = (typeof TASK_PRIORITIES)[number];
+import type { TaskStatusConfig } from "../config/agent-config.js";
+export type { TaskStatusConfig } from "../config/agent-config.js";
+/** Default statuses used when a team has no custom config. */
+export declare const DEFAULT_TASK_STATUSES: TaskStatusConfig[];
+export interface TaskAttachment {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    createdAt: number;
+}
+export interface TaskComment {
+    id: string;
+    taskId: string;
+    content: string;
+    createdBy: string;
+    updatedBy: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export interface Task {
+    id: string;
+    teamId: string;
+    title: string;
+    description: string | null;
+    status: TaskStatus;
+    assignee: string | null;
+    priority: TaskPriority;
+    position: number;
+    attachments: TaskAttachment[];
+    /** True when the task is waiting on a human to review or act. */
+    needsHumanReview: boolean;
+    /** Agent ID that claimed this task for pull-based execution. */
+    claimedBy: string | null;
+    /** Timestamp when the task was claimed. */
+    claimedAt: number | null;
+    /** Last actor that updated this task (user, orchestrator, worker, system). */
+    updatedBy: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare const MAX_TASK_COMMENT_LENGTH = 4000;
+export declare const CreateTaskSchema: z.ZodObject<{
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodString>;
+    priority: z.ZodDefault<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    status: z.ZodDefault<z.ZodString>;
+    needsHumanReview: z.ZodDefault<z.ZodBoolean>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            "image/png": "image/png";
+            "image/jpeg": "image/jpeg";
+            "image/gif": "image/gif";
+            "image/webp": "image/webp";
+        }>;
+        size: z.ZodNumber;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const UpdateTaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    priority: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>>;
+    teamId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    needsHumanReview: z.ZodOptional<z.ZodBoolean>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            "image/png": "image/png";
+            "image/jpeg": "image/jpeg";
+            "image/gif": "image/gif";
+            "image/webp": "image/webp";
+        }>;
+        size: z.ZodNumber;
+        createdAt: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const ListTasksSchema: z.ZodObject<{
+    teamId: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodString>;
+    needsHumanReview: z.ZodOptional<z.ZodBoolean>;
+    includeArchived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const ReorderTasksSchema: z.ZodObject<{
+    status: z.ZodString;
+    orderedIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const ListTaskCommentsSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, z.core.$strip>;
+export declare const AddTaskCommentSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const UpdateTaskCommentSchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+}, z.core.$strip>;
+export declare const DeleteTaskCommentSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;