anyclaude-sdk 0.1.0

package/dist/session/types.js

@@ -0,0 +1,2 @@
+// Session persistence types.
+export {};

package/dist/settings/index.d.ts

@@ -0,0 +1,3 @@
+export type { Settings, SettingsSource } from './types.js';
+export { parseSettings, mergeSettings } from './merge.js';
+export { loadSettings, settingsToPermissionRuleSet } from './load.js';

package/dist/settings/index.js

@@ -0,0 +1,3 @@
+// Settings cascade for browser-claude-sdk (user < project < local).
+export { parseSettings, mergeSettings } from './merge.js';
+export { loadSettings, settingsToPermissionRuleSet } from './load.js';

package/dist/settings/load.d.ts

@@ -0,0 +1,20 @@
+import type { Settings } from './types.js';
+type ReadableFs = {
+    readFile(path: string): Promise<string | null>;
+};
+/**
+ * Load and cascade settings from the workspace. Reads `.claude/settings.json`
+ * (project) then `.claude/settings.local.json` (local) relative to `cwd`,
+ * merging project < local. (No home dir in the browser, so user-scope is
+ * omitted.) Never throws — missing/invalid files contribute {}.
+ */
+export declare function loadSettings(fs: ReadableFs, opts?: {
+    cwd?: string;
+}): Promise<Settings>;
+/** Extract raw permission-rule strings for the permissions module to parse. */
+export declare function settingsToPermissionRuleSet(s: Settings): {
+    allow: string[];
+    deny: string[];
+    ask: string[];
+};
+export {};

package/dist/settings/load.js

@@ -0,0 +1,36 @@
+// Load + cascade settings from the workspace filesystem.
+import { mergeSettings, parseSettings } from './merge.js';
+function join(cwd, rel) {
+    if (!cwd)
+        return rel;
+    return cwd.endsWith('/') ? cwd + rel : cwd + '/' + rel;
+}
+/**
+ * Load and cascade settings from the workspace. Reads `.claude/settings.json`
+ * (project) then `.claude/settings.local.json` (local) relative to `cwd`,
+ * merging project < local. (No home dir in the browser, so user-scope is
+ * omitted.) Never throws — missing/invalid files contribute {}.
+ */
+export async function loadSettings(fs, opts = {}) {
+    const cwd = opts.cwd ?? '';
+    const read = async (rel) => {
+        try {
+            const txt = await fs.readFile(join(cwd, rel));
+            return txt ? parseSettings(txt) : {};
+        }
+        catch {
+            return {};
+        }
+    };
+    const project = await read('.claude/settings.json');
+    const local = await read('.claude/settings.local.json');
+    return mergeSettings(project, local);
+}
+/** Extract raw permission-rule strings for the permissions module to parse. */
+export function settingsToPermissionRuleSet(s) {
+    return {
+        allow: s.allow ?? [],
+        deny: s.deny ?? [],
+        ask: s.ask ?? [],
+    };
+}

package/dist/settings/merge.d.ts

@@ -0,0 +1,13 @@
+import type { Settings } from './types.js';
+/**
+ * Parse a settings.json string. Tolerant: returns {} on invalid JSON. Accepts
+ * Claude Code's nested `permissions: { allow, deny, ask }` shape and hoists it
+ * to top-level allow/deny/ask.
+ */
+export declare function parseSettings(json: string): Settings;
+/**
+ * Merge settings sources. Later sources win for scalars; array keys are
+ * concatenated + deduped; `env` is shallow-merged. Pass lowest → highest
+ * precedence (e.g. user, project, local).
+ */
+export declare function mergeSettings(...sources: Settings[]): Settings;

package/dist/settings/merge.js

@@ -0,0 +1,65 @@
+// Parsing + cascading merge for settings sources.
+/** Array-valued keys are concatenated + deduped across sources. */
+const ARRAY_KEYS = ['allow', 'deny', 'ask', 'allowedTools', 'disallowedTools'];
+/**
+ * Parse a settings.json string. Tolerant: returns {} on invalid JSON. Accepts
+ * Claude Code's nested `permissions: { allow, deny, ask }` shape and hoists it
+ * to top-level allow/deny/ask.
+ */
+export function parseSettings(json) {
+    let raw;
+    try {
+        raw = JSON.parse(json);
+    }
+    catch {
+        return {};
+    }
+    if (!raw || typeof raw !== 'object')
+        return {};
+    const obj = raw;
+    const out = { ...obj };
+    const perms = obj.permissions;
+    if (perms && typeof perms === 'object') {
+        const p = perms;
+        for (const key of ['allow', 'deny', 'ask']) {
+            if (Array.isArray(p[key])) {
+                const existing = Array.isArray(out[key]) ? out[key] : [];
+                out[key] = dedupe([...existing, ...p[key]]);
+            }
+        }
+        if (typeof p.defaultMode === 'string') {
+            out.permissionMode = (out.permissionMode ?? p.defaultMode);
+        }
+    }
+    return out;
+}
+/**
+ * Merge settings sources. Later sources win for scalars; array keys are
+ * concatenated + deduped; `env` is shallow-merged. Pass lowest → highest
+ * precedence (e.g. user, project, local).
+ */
+export function mergeSettings(...sources) {
+    const out = {};
+    for (const src of sources) {
+        if (!src)
+            continue;
+        for (const [key, val] of Object.entries(src)) {
+            if (val === undefined)
+                continue;
+            if (ARRAY_KEYS.includes(key)) {
+                const existing = Array.isArray(out[key]) ? out[key] : [];
+                out[key] = dedupe([...existing, ...(Array.isArray(val) ? val : [val])]);
+            }
+            else if (key === 'env' && val && typeof val === 'object') {
+                out.env = { ...(out.env ?? {}), ...val };
+            }
+            else {
+                out[key] = val;
+            }
+        }
+    }
+    return out;
+}
+function dedupe(arr) {
+    return [...new Set(arr)];
+}

package/dist/settings/types.d.ts

@@ -0,0 +1,17 @@
+export type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan' | 'dontAsk';
+export type SettingsSource = 'user' | 'project' | 'local';
+export type Settings = {
+    model?: string;
+    permissionMode?: PermissionMode;
+    /** Permission rule strings (e.g. "Bash(rm *)", "Read"). */
+    allow?: string[];
+    deny?: string[];
+    ask?: string[];
+    /** Tool name allow/deny lists. */
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    appendSystemPrompt?: string;
+    maxTurns?: number;
+    env?: Record<string, string>;
+    [key: string]: unknown;
+};

package/dist/settings/types.js

@@ -0,0 +1,3 @@
+// Settings types — a browser-friendly port of Claude Code's settings.json.
+// Sources cascade user < project < local (highest precedence last).
+export {};

package/dist/skills/index.d.ts

@@ -0,0 +1,4 @@
+export type { Skill } from './types.js';
+export { parseSkill } from './parse.js';
+export { loadSkillsFromFs, skillsToCommands, applySkillArgs } from './load.js';
+export { skill } from './tool.js';

package/dist/skills/index.js

@@ -0,0 +1,5 @@
+// Skills system: load .claude/skills/*.md markdown skills and expose them as
+// slash commands and via the `skill` tool.
+export { parseSkill } from './parse.js';
+export { loadSkillsFromFs, skillsToCommands, applySkillArgs } from './load.js';
+export { skill } from './tool.js';

package/dist/skills/load.d.ts

@@ -0,0 +1,23 @@
+import type { SlashCommand } from '../commands/types.js';
+import type { Skill } from './types.js';
+interface SkillFs {
+    readFile(path: string): Promise<string | null>;
+    readdir(path: string): Promise<Array<{
+        name: string;
+        isDir: boolean;
+    }> | null>;
+}
+/** Substitute $ARGUMENTS in a skill body with the invocation args. */
+export declare function applySkillArgs(body: string, args: string): string;
+/**
+ * Load skills from `<dir>`. Supports both flat `<dir>/<name>.md` files and
+ * nested `<dir>/<name>/SKILL.md`. Never throws — returns [] on any failure.
+ */
+export declare function loadSkillsFromFs(fs: SkillFs, dir?: string): Promise<Skill[]>;
+/**
+ * Turn skills into slash commands. Invoking `/skillName args` expands the
+ * skill body (with $ARGUMENTS substituted) into a prompt. Built inline to avoid
+ * a dependency cycle with the commands module.
+ */
+export declare function skillsToCommands(skills: Skill[]): SlashCommand[];
+export {};

package/dist/skills/load.js

@@ -0,0 +1,54 @@
+// Discover and load skills from a FileSystem, and turn them into slash commands.
+import { parseSkill } from './parse.js';
+/** Substitute $ARGUMENTS in a skill body with the invocation args. */
+export function applySkillArgs(body, args) {
+    return body.includes('$ARGUMENTS') ? body.split('$ARGUMENTS').join(args) : body;
+}
+/**
+ * Load skills from `<dir>`. Supports both flat `<dir>/<name>.md` files and
+ * nested `<dir>/<name>/SKILL.md`. Never throws — returns [] on any failure.
+ */
+export async function loadSkillsFromFs(fs, dir = '.claude/skills') {
+    const entries = await fs.readdir(dir).catch(() => null);
+    if (!entries)
+        return [];
+    const skills = [];
+    for (const entry of entries) {
+        try {
+            if (entry.isDir) {
+                // Nested form: <dir>/<name>/SKILL.md (or skill.md).
+                for (const file of ['SKILL.md', 'skill.md']) {
+                    const md = await fs.readFile(`${dir}/${entry.name}/${file}`);
+                    if (md != null) {
+                        skills.push(parseSkill(md, entry.name));
+                        break;
+                    }
+                }
+            }
+            else if (entry.name.toLowerCase().endsWith('.md')) {
+                const md = await fs.readFile(`${dir}/${entry.name}`);
+                if (md != null)
+                    skills.push(parseSkill(md, entry.name.replace(/\.md$/i, '')));
+            }
+        }
+        catch {
+            // skip unreadable entries
+        }
+    }
+    return skills;
+}
+/**
+ * Turn skills into slash commands. Invoking `/skillName args` expands the
+ * skill body (with $ARGUMENTS substituted) into a prompt. Built inline to avoid
+ * a dependency cycle with the commands module.
+ */
+export function skillsToCommands(skills) {
+    return skills.map((skill) => ({
+        name: skill.name,
+        description: skill.description,
+        argumentHint: skill.argumentHint,
+        run(args) {
+            return { expandedPrompt: applySkillArgs(skill.body, args.trim()) };
+        },
+    }));
+}

package/dist/skills/parse.d.ts

@@ -0,0 +1,7 @@
+import type { Skill } from './types.js';
+/**
+ * Parse a markdown skill. Recognizes a leading `---`-delimited frontmatter
+ * block with `name`, `description`, and `argument-hint`/`argumentHint` keys.
+ * Falls back to `fallbackName` and the first non-empty body line when absent.
+ */
+export declare function parseSkill(markdown: string, fallbackName?: string): Skill;

package/dist/skills/parse.js

@@ -0,0 +1,40 @@
+// Parse a skill markdown document into a Skill. Hand-parses a simple
+// `key: value` YAML-ish frontmatter block (no yaml dependency).
+const FRONTMATTER = /^?---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+/** Strip surrounding single/double quotes from a frontmatter value. */
+function unquote(v) {
+    const t = v.trim();
+    if (t.length >= 2 && ((t[0] === '"' && t.endsWith('"')) || (t[0] === "'" && t.endsWith("'")))) {
+        return t.slice(1, -1);
+    }
+    return t;
+}
+/**
+ * Parse a markdown skill. Recognizes a leading `---`-delimited frontmatter
+ * block with `name`, `description`, and `argument-hint`/`argumentHint` keys.
+ * Falls back to `fallbackName` and the first non-empty body line when absent.
+ */
+export function parseSkill(markdown, fallbackName = 'skill') {
+    const src = markdown ?? '';
+    const m = src.match(FRONTMATTER);
+    let meta = {};
+    let body = src;
+    if (m) {
+        body = m[2] ?? '';
+        for (const line of m[1].split(/\r?\n/)) {
+            const idx = line.indexOf(':');
+            if (idx <= 0)
+                continue;
+            const key = line.slice(0, idx).trim().toLowerCase();
+            meta[key] = unquote(line.slice(idx + 1));
+        }
+    }
+    const firstLine = body
+        .split(/\r?\n/)
+        .map((l) => l.replace(/^#+\s*/, '').trim())
+        .find((l) => l.length > 0);
+    const name = (meta['name'] || fallbackName).trim();
+    const description = (meta['description'] || firstLine || name).trim();
+    const argumentHint = (meta['argument-hint'] || meta['argumenthint'] || '').trim() || undefined;
+    return { name, description, body: body.trim(), argumentHint };
+}

package/dist/skills/tool.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from '../tools/types.js';
+export declare const skill: Tool;

package/dist/skills/tool.js

@@ -0,0 +1,39 @@
+// The `skill` tool: load a named skill's instructions so the model can follow
+// them. Skills are made available on the tool context as `ctx.skills`.
+import { applySkillArgs } from './load.js';
+const DESCRIPTION = `Loads a named skill's instructions and returns them so you can follow the skill.
+
+Use this when a task matches an available skill. Pass the skill \`name\` and optional \`arguments\`; the skill's full instructions are returned as the result.`;
+export const skill = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'skill',
+            description: DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'The skill name to invoke.' },
+                    arguments: { type: 'string', description: 'Arguments to pass to the skill (substituted for $ARGUMENTS).' },
+                },
+                required: ['name'],
+            },
+        },
+    },
+    async run(input, ctx) {
+        const skills = ctx.skills;
+        if (!skills || !skills.length) {
+            return { content: 'No skills are available in this session.', isError: true };
+        }
+        const name = String(input.name ?? '').trim();
+        const found = skills.find((s) => s.name === name) ?? skills.find((s) => s.name.toLowerCase() === name.toLowerCase());
+        if (!found) {
+            return {
+                content: `Unknown skill "${name}". Available: ${skills.map((s) => s.name).join(', ')}`,
+                isError: true,
+            };
+        }
+        const args = input.arguments != null ? String(input.arguments) : '';
+        return { content: `# Skill: ${found.name}\n\n${applySkillArgs(found.body, args)}` };
+    },
+};

package/dist/skills/types.d.ts

@@ -0,0 +1,10 @@
+export type Skill = {
+    /** Skill name (used as the slash-command name and tool lookup key). */
+    name: string;
+    /** One-line description of what the skill does. */
+    description: string;
+    /** The skill body — instructions/prompt template ($ARGUMENTS is substituted). */
+    body: string;
+    /** Optional hint for the skill's arguments (e.g. "<file>"). */
+    argumentHint?: string;
+};

package/dist/skills/types.js

@@ -0,0 +1,4 @@
+// Skill types for browser-claude-sdk. A skill is a markdown document with
+// optional frontmatter; it becomes an invokable slash command and is reachable
+// via the `skill` tool.
+export {};

package/dist/team/dispatch.d.ts

@@ -0,0 +1,2 @@
+import type { Tool } from '../tools/types.js';
+export declare const dispatchTasks: Tool;

package/dist/team/dispatch.js

@@ -0,0 +1,41 @@
+// `dispatch_tasks` tool: the coordinator calls this to execute the board. It
+// runs the teammate idle-loop, spawning worker sub-agents for each pending,
+// unblocked task (dependencies respected, bounded parallelism). Reads
+// `ctx.board` + `ctx.runSubagent` (both injected by the agent loop).
+import { runTeamLoop } from './runner.js';
+export const dispatchTasks = {
+    def: {
+        type: 'function',
+        function: {
+            name: 'dispatch_tasks',
+            description: 'Execute the task board: spawn worker sub-agents for every pending, unblocked task (dependencies respected, run in parallel), looping until the board drains. Call this after creating tasks with task_create.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    concurrency: { type: 'number', description: 'Max workers in parallel (default 3).' },
+                },
+            },
+        },
+    },
+    async run(input, ctx) {
+        const board = ctx.board;
+        const runSubagent = ctx.runSubagent;
+        if (!board || !runSubagent) {
+            return { content: 'Teammates/sub-agents are not enabled for this session.', isError: true };
+        }
+        const spawn = (task) => runSubagent({
+            description: task.subject,
+            prompt: `Complete this task:\n# ${task.subject}\n${task.description ?? ''}\n\n` +
+                'When done, your final message should report exactly what you did.',
+        });
+        const summary = await runTeamLoop(board, spawn, {
+            concurrency: typeof input.concurrency === 'number' ? input.concurrency : undefined,
+            signal: ctx.signal,
+        });
+        const lines = board.list().map((t) => `  ${t.id} [${t.status}] — ${t.subject}`);
+        return {
+            content: `Dispatched the board — completed: ${summary.completed.length}, failed: ${summary.failed.length}, rounds: ${summary.rounds}\n` +
+                lines.join('\n'),
+        };
+    },
+};

package/dist/team/index.d.ts

@@ -0,0 +1,9 @@
+export { Mailbox, type AgentMessage } from './mailbox.js';
+export { TaskBoard, type BoardTask, type TaskStatus } from './taskBoard.js';
+export { TEAM_TOOLS, sendMessage, taskCreate, taskUpdate, taskGet, boardList, } from './tools.js';
+export { coordinatorPrompt } from './prompt.js';
+export { runTeamLoop, type SpawnWorker, type TeamLoopOptions, type TeamLoopResult, } from './runner.js';
+export { dispatchTasks } from './dispatch.js';
+import type { Tool } from '../tools/types.js';
+/** The dispatch tool, kept separate from TEAM_TOOLS so the agent can merge it in. */
+export declare const TEAM_DISPATCH_TOOLS: Tool[];

package/dist/team/index.js

@@ -0,0 +1,11 @@
+// Teammate/coordinator MVP: shared in-memory mailbox + task board, the tools
+// the coordinator uses to delegate, and the coordinator system-prompt addendum.
+export { Mailbox } from './mailbox.js';
+export { TaskBoard } from './taskBoard.js';
+export { TEAM_TOOLS, sendMessage, taskCreate, taskUpdate, taskGet, boardList, } from './tools.js';
+export { coordinatorPrompt } from './prompt.js';
+export { runTeamLoop, } from './runner.js';
+export { dispatchTasks } from './dispatch.js';
+import { dispatchTasks } from './dispatch.js';
+/** The dispatch tool, kept separate from TEAM_TOOLS so the agent can merge it in. */
+export const TEAM_DISPATCH_TOOLS = [dispatchTasks];

package/dist/team/mailbox.d.ts

@@ -0,0 +1,24 @@
+export type AgentMessage = {
+    id: string;
+    from: string;
+    to: string;
+    text: string;
+    ts: number;
+    read: boolean;
+};
+export declare class Mailbox {
+    private messages;
+    private counter;
+    /** Deliver a message; returns the message id. */
+    send(from: string, to: string, text: string): string;
+    /** Messages addressed to `agentId`, oldest first. */
+    inbox(agentId: string, opts?: {
+        unreadOnly?: boolean;
+    }): AgentMessage[];
+    /** Mark every message addressed to `agentId` as read. */
+    markRead(agentId: string): void;
+    /** Send the same text to several recipients; returns the ids. */
+    broadcast(from: string, text: string, recipients: string[]): string[];
+    /** Every message, in send order. */
+    all(): AgentMessage[];
+}

package/dist/team/mailbox.js

@@ -0,0 +1,33 @@
+// In-memory inter-agent mailbox, shared across the coordinator and the workers
+// it spawns. Each message is addressed to a teammate by name; recipients drain
+// their inbox to receive. Browser-safe: no timers/fs; ids are monotonic.
+export class Mailbox {
+    constructor() {
+        this.messages = [];
+        this.counter = 0;
+    }
+    /** Deliver a message; returns the message id. */
+    send(from, to, text) {
+        const id = `msg_${++this.counter}`;
+        this.messages.push({ id, from, to, text, ts: Date.now(), read: false });
+        return id;
+    }
+    /** Messages addressed to `agentId`, oldest first. */
+    inbox(agentId, opts) {
+        return this.messages.filter((m) => m.to === agentId && (!opts?.unreadOnly || !m.read));
+    }
+    /** Mark every message addressed to `agentId` as read. */
+    markRead(agentId) {
+        for (const m of this.messages)
+            if (m.to === agentId)
+                m.read = true;
+    }
+    /** Send the same text to several recipients; returns the ids. */
+    broadcast(from, text, recipients) {
+        return recipients.map((to) => this.send(from, to, text));
+    }
+    /** Every message, in send order. */
+    all() {
+        return [...this.messages];
+    }
+}

package/dist/team/prompt.d.ts

@@ -0,0 +1 @@
+export declare function coordinatorPrompt(): string;

package/dist/team/prompt.js

@@ -0,0 +1,12 @@
+// Coordinator system-prompt addendum, appended when teammates are enabled.
+export function coordinatorPrompt() {
+    return `# Coordinating a team
+
+You are the coordinator of a team of agents. Plan and delegate rather than doing everything yourself.
+
+- Decompose the work into discrete tasks on the shared board with \`task_create\`. When a task depends on another, set \`blocked_by\` to the prerequisite task ids so execution is correctly gated.
+- Spawn workers with the \`task\` tool to execute board tasks — give each worker a focused prompt and, when useful, run independent workers in parallel. Prefer parallelism over sequential work whenever tasks are independent.
+- Use \`send_message\` to direct workers, hand off context, or coordinate between teammates. Check the board with \`board_list\` and \`task_get\` to track progress, and keep task status current with \`task_update\` (mark in_progress when started, completed/failed when done).
+- Synthesize workers' results yourself before continuing. NEVER fabricate or assume a worker's output — rely only on what they actually returned.
+- Keep the board the source of truth: every meaningful unit of work should be a task with an owner and a status.`;
+}

package/dist/team/runner.d.ts

@@ -0,0 +1,20 @@
+import type { BoardTask, TaskBoard } from './taskBoard.js';
+export type SpawnWorker = (task: BoardTask) => Promise<{
+    text: string;
+    isError?: boolean;
+}>;
+export interface TeamLoopOptions {
+    /** Max tasks executed in parallel per round. Default 3. */
+    concurrency?: number;
+    /** Safety cap on rounds (each round runs one parallel batch). Default 25. */
+    maxIterations?: number;
+    /** Owner label recorded when claiming. Default 'worker'. */
+    worker?: string;
+    signal?: AbortSignal;
+}
+export interface TeamLoopResult {
+    completed: string[];
+    failed: string[];
+    rounds: number;
+}
+export declare function runTeamLoop(board: TaskBoard, spawn: SpawnWorker, opts?: TeamLoopOptions): Promise<TeamLoopResult>;

package/dist/team/runner.js

@@ -0,0 +1,45 @@
+// Teammate idle-loop: auto-claim pending, unblocked tasks from the shared board
+// and execute them via worker sub-agents, respecting dependencies. Loops until
+// nothing is claimable (all done, or remaining tasks blocked by failed
+// prerequisites), a max-iteration cap, or an abort.
+export async function runTeamLoop(board, spawn, opts = {}) {
+    const concurrency = Math.max(1, opts.concurrency ?? 3);
+    const maxIterations = opts.maxIterations ?? 25;
+    const worker = opts.worker || 'worker';
+    const signal = opts.signal;
+    const completed = [];
+    const failed = [];
+    let rounds = 0;
+    while (rounds < maxIterations) {
+        if (signal?.aborted)
+            break;
+        // Claimable = pending and not blocked by an incomplete prerequisite.
+        const claimable = board.list({ status: 'pending' }).filter((t) => !board.isBlocked(t.id));
+        if (!claimable.length)
+            break;
+        // Atomically claim up to `concurrency` of them for this round.
+        const batch = [];
+        for (const t of claimable) {
+            if (batch.length >= concurrency)
+                break;
+            const claimed = board.claim(t.id, worker);
+            if (claimed)
+                batch.push(claimed);
+        }
+        if (!batch.length)
+            break;
+        rounds++;
+        await Promise.all(batch.map(async (task) => {
+            try {
+                const res = await spawn(task);
+                board.update(task.id, { status: res.isError ? 'failed' : 'completed' });
+                (res.isError ? failed : completed).push(task.id);
+            }
+            catch {
+                board.update(task.id, { status: 'failed' });
+                failed.push(task.id);
+            }
+        }));
+    }
+    return { completed, failed, rounds };
+}

package/dist/team/taskBoard.d.ts

@@ -0,0 +1,41 @@
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed';
+export type BoardTask = {
+    id: string;
+    subject: string;
+    description?: string;
+    owner?: string;
+    status: TaskStatus;
+    /** Tasks that depend on this one. */
+    blocks: string[];
+    /** Tasks that must complete before this one can start. */
+    blockedBy: string[];
+    createdAt: number;
+    updatedAt: number;
+};
+export declare class TaskBoard {
+    private tasks;
+    private counter;
+    create(input: {
+        subject: string;
+        description?: string;
+        owner?: string;
+        blockedBy?: string[];
+    }): BoardTask;
+    update(id: string, patch: Partial<{
+        subject: string;
+        description: string;
+        owner: string;
+        status: TaskStatus;
+        blocks: string[];
+        blockedBy: string[];
+    }>): BoardTask | null;
+    get(id: string): BoardTask | null;
+    list(filter?: {
+        status?: TaskStatus;
+        owner?: string;
+    }): BoardTask[];
+    /** Atomically claim an unowned/pending task. Null if already claimed. */
+    claim(id: string, owner: string): BoardTask | null;
+    /** True if any prerequisite is not yet completed. */
+    isBlocked(id: string): boolean;
+}