@cerebriline/core 4.100.240

package/dist/settings/settings-service.d.ts

@@ -0,0 +1,8 @@
+import type { CoreSettingsListInput, CoreSettingsMutationResult, CoreSettingsServiceOptions, CoreSettingsSnapshot, CoreSettingsToggleInput } from "./types";
+export declare class CoreSettingsService {
+    private readonly pluginSource;
+    constructor(options?: CoreSettingsServiceOptions);
+    list(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+    toggle(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+}
+export declare function createCoreSettingsService(options?: CoreSettingsServiceOptions): CoreSettingsService;

package/dist/settings/types.d.ts

@@ -0,0 +1,83 @@
+import type { UserInstructionConfigService } from "../extensions/config";
+import type { BuiltinToolAvailabilityContext } from "../extensions/tools";
+export type CoreSettingsType = "skills" | "workflows" | "rules" | "plugins" | "tools" | "mcp";
+export type CoreSettingsItemKind = "skill" | "workflow" | "rule" | "plugin" | "tool" | "mcp";
+export type CoreSettingsItemSource = "global" | "workspace" | "builtin" | "global-plugin" | "workspace-plugin";
+export interface CoreSettingsItem {
+    id: string;
+    name: string;
+    path: string;
+    kind: CoreSettingsItemKind;
+    source: CoreSettingsItemSource;
+    enabled?: boolean;
+    description?: string;
+    toggleable?: boolean;
+    pluginName?: string;
+    pluginPath?: string;
+    /** True when this item comes from the portable agent-plugins.org format. */
+    agentPlugin?: boolean;
+    /** Loader diagnostics associated with this item, if any. */
+    loadError?: string;
+    contributions?: CorePluginContributions;
+}
+export interface CorePluginContributions {
+    inspectionStatus: "available" | "disabled" | "failed";
+    capabilities: string[];
+    tools: string[];
+    skills: string[];
+    rules: string[];
+    hooks: string[];
+    commands: string[];
+    mcpServers: string[];
+    providers: string[];
+}
+export interface CorePluginSettingsSnapshot {
+    plugins: CoreSettingsItem[];
+    tools: CoreSettingsItem[];
+}
+export interface CorePluginSettingsSource {
+    list(input: CoreSettingsListInput): Promise<CorePluginSettingsSnapshot>;
+    /** Apply enablement and return the source's authoritative post-mutation state. */
+    setEnabled(input: {
+        path: string;
+        enabled: boolean;
+        cwd?: string;
+        workspaceRoot?: string;
+    }): Promise<CorePluginSettingsSnapshot>;
+}
+export interface CoreSettingsServiceOptions {
+    pluginSource?: CorePluginSettingsSource;
+}
+export interface CoreSettingsSnapshot {
+    workflows: CoreSettingsItem[];
+    rules: CoreSettingsItem[];
+    plugins: CoreSettingsItem[];
+    skills: CoreSettingsItem[];
+    tools: CoreSettingsItem[];
+    mcp: CoreSettingsItem[];
+}
+export interface CoreSettingsListInput {
+    cwd?: string;
+    workspaceRoot?: string;
+    /** Optional explicit portable Agent Plugin roots, resolved by the host. */
+    agentPluginPaths?: string[];
+    /** Whether inspecting Cline plugins should execute their setup for tool metadata. */
+    includePluginTools?: boolean;
+    userInstructionService?: UserInstructionConfigService;
+    availabilityContext?: BuiltinToolAvailabilityContext;
+}
+export interface CoreSettingsToggleInput extends CoreSettingsListInput {
+    type: CoreSettingsType;
+    id?: string;
+    path?: string;
+    name?: string;
+    enabled?: boolean;
+}
+export interface CoreSettingsMutationResult {
+    snapshot: CoreSettingsSnapshot;
+    changedTypes: CoreSettingsType[];
+}
+export interface ClineCoreSettingsApi {
+    list(input?: CoreSettingsListInput): Promise<CoreSettingsSnapshot>;
+    toggle(input: CoreSettingsToggleInput): Promise<CoreSettingsMutationResult>;
+}

package/dist/tasks/agenda-task-api.d.ts

@@ -0,0 +1,20 @@
+import type { AgendaAutomationPolicy, AgendaTaskActor, AgendaTaskCreateInput, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, AgendaTaskUpdateInput } from "@cerebriline/shared";
+/**
+ * The single mutation boundary for agenda tasks. File reconciliation, Hub
+ * commands, and agent tools all route through this interface so lifecycle
+ * invariants are enforced in one place.
+ */
+export interface AgendaTaskManagerApi {
+    createTask(input: AgendaTaskCreateInput): Promise<AgendaTaskRecord>;
+    listTasks(input?: AgendaTaskListInput): Promise<AgendaTaskRecord[]>;
+    getTask(taskId: string): Promise<AgendaTaskRecord | undefined>;
+    updateTask(input: AgendaTaskUpdateInput): Promise<AgendaTaskRecord>;
+    approveTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number): Promise<AgendaTaskRecord>;
+    cancelTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number, reason?: string): Promise<AgendaTaskRecord>;
+    runTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number, requestedByClientId?: string): Promise<{
+        task: AgendaTaskRecord;
+        run?: AgendaTaskRunRecord;
+    }>;
+    getAutomationPolicy(scopeKey?: string): Promise<AgendaAutomationPolicy>;
+    setAutomationPolicy(policy: Omit<AgendaAutomationPolicy, "updatedAt">, actor: AgendaTaskActor): Promise<AgendaAutomationPolicy>;
+}

package/dist/tasks/agenda-task-manager.d.ts

@@ -0,0 +1,109 @@
+import type { AgendaAutomationPolicy, AgendaTaskActor, AgendaTaskCreateInput, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, AgendaTaskUpdateInput, BasicLogger } from "@cerebriline/shared";
+import type { AgendaTaskManagerApi } from "./agenda-task-api";
+import { SqliteAgendaTaskStore } from "./store/sqlite-task-store";
+export type AgendaTaskManagerEventName = "task.created" | "task.updated" | "task.deleted" | "task.run.started" | "task.run.completed" | "task.run.failed" | "task.automation.updated";
+export interface AgendaTaskRuntimeResult {
+    status: "completed" | "failed" | "cancelled";
+    summary?: string;
+    error?: string;
+}
+export interface AgendaTaskRuntime {
+    isInteractiveClientAvailable?(): boolean;
+    startSession(task: AgendaTaskRecord, run: AgendaTaskRunRecord, requestedByClientId?: string, options?: {
+        unattended: boolean;
+    }): Promise<{
+        sessionId: string;
+    }>;
+    runSession(sessionId: string, task: AgendaTaskRecord, run: AgendaTaskRunRecord): Promise<AgendaTaskRuntimeResult>;
+    abortSession(sessionId: string, reason: string): Promise<void>;
+}
+export interface AgendaTaskManagerOptions {
+    runtime: AgendaTaskRuntime;
+    store?: SqliteAgendaTaskStore;
+    dbPath?: string;
+    globalSpecsDir?: string;
+    watcherDebounceMs?: number;
+    watchFiles?: boolean;
+    /**
+     * Set to false to keep the automation pump idle regardless of persisted
+     * automation policies. Policies stay stored untouched and manual approve/run
+     * commands keep working; nothing is auto-approved or auto-started.
+     */
+    automationEnabled?: boolean;
+    logger?: BasicLogger;
+    publish?: (event: AgendaTaskManagerEventName, payload: Record<string, unknown>, sessionId?: string) => void;
+}
+/** Hub-owned lifecycle coordinator and the only operational task writer. */
+export declare class AgendaTaskManager implements AgendaTaskManagerApi {
+    private readonly runtime;
+    private readonly store;
+    private readonly ownsStore;
+    private readonly globalSpecsDir?;
+    private readonly watcherDebounceMs;
+    private readonly watchFiles;
+    private readonly logger;
+    private readonly publishEvent;
+    private readonly scopes;
+    private readonly activeRuns;
+    private readonly backgroundRuns;
+    private maintenanceTimer?;
+    private readonly queuedAutomationScopes;
+    private readonly automationEnabled;
+    private automationPumping;
+    private automationPolicyGeneration;
+    private started;
+    private disposed;
+    constructor(options: AgendaTaskManagerOptions);
+    start(): Promise<void>;
+    dispose(): Promise<void>;
+    createTask(input: AgendaTaskCreateInput): Promise<AgendaTaskRecord>;
+    listTasks(input?: AgendaTaskListInput): Promise<AgendaTaskRecord[]>;
+    getTask(taskId: string): Promise<AgendaTaskRecord | undefined>;
+    updateTask(input: AgendaTaskUpdateInput): Promise<AgendaTaskRecord>;
+    approveTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number): Promise<AgendaTaskRecord>;
+    cancelTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number, reason?: string): Promise<AgendaTaskRecord>;
+    runTask(taskId: string, actor: AgendaTaskActor, expectedRevision: number, requestedByClientId?: string): Promise<{
+        task: AgendaTaskRecord;
+        run?: AgendaTaskRunRecord;
+    }>;
+    getAutomationPolicy(scopeKey?: string): Promise<AgendaAutomationPolicy>;
+    setAutomationPolicy(policy: Omit<AgendaAutomationPolicy, "updatedAt">, actor: AgendaTaskActor): Promise<AgendaAutomationPolicy>;
+    /** Re-evaluate auto-start work after Hub client readiness changes. */
+    notifyAutomationReadinessChanged(): void;
+    private finishRun;
+    private finishRunFailure;
+    private ensureScope;
+    private reconcileScope;
+    private reconcileSourceForProjection;
+    private reconcileFileStore;
+    private expireTasks;
+    private expireTask;
+    private isExpired;
+    private recoverInterruptedRuns;
+    private queueAutomation;
+    private pumpAutomation;
+    private canAutomaticallyApprove;
+    private taskChainDepth;
+    private fileStoreForTask;
+    /**
+     * Approval is bound to the current user-editable Markdown intent, not just
+     * the last SQLite projection. Reconcile synchronously to close the watcher
+     * debounce window, then fail closed if the source is missing, malformed, or
+     * still differs from the projection that will be approved/executed.
+     */
+    private refreshAndVerifyTaskIntent;
+    private requireTask;
+    private assertRevision;
+    private publish;
+    /**
+     * fs.watch must be handed the fully resolved form of a path: on Windows,
+     * libuv aborts the entire process (fs-event.c assertion) when the watched
+     * path contains 8.3 short components such as C:\Users\RUNNER~1, because
+     * event filenames come back in long form and fail its prefix check. When
+     * the path cannot be resolved, going without the watcher is safer than
+     * handing libuv the unresolved path.
+     */
+    private resolveWatchRoot;
+    private logError;
+    private assertUsable;
+}

package/dist/tasks/agenda-task-tool.d.ts

@@ -0,0 +1,94 @@
+import type { AgentTool, GatewayModelSelection, ITelemetryService } from "@cerebriline/shared";
+import { z } from "zod";
+import type { AgendaTaskManagerApi } from "./agenda-task-api";
+export declare const TodoTaskInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        list: "list";
+        update: "update";
+        create: "create";
+        get: "get";
+    }>;
+    task_id: z.ZodOptional<z.ZodString>;
+    expected_revision: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodEnum<{
+        handoff: "handoff";
+        suggestion: "suggestion";
+        "follow-up": "follow-up";
+        todo: "todo";
+        idea: "idea";
+        reminder: "reminder";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    instructions: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        workspace: "workspace";
+        global: "global";
+    }>>;
+    workspace_root: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    resource_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    priority: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    model_selection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider_id: z.ZodString;
+        model_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        plan: "plan";
+        act: "act";
+        yolo: "yolo";
+    }>>>;
+    system_prompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    max_iterations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    timeout_seconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    available_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    automation_eligible: z.ZodOptional<z.ZodBoolean>;
+    statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        in_progress: "in_progress";
+        approved: "approved";
+        pending_approval: "pending_approval";
+        expired: "expired";
+    }>>>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        handoff: "handoff";
+        suggestion: "suggestion";
+        "follow-up": "follow-up";
+        todo: "todo";
+        idea: "idea";
+        reminder: "reminder";
+    }>>>;
+    priorities: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type TodoTaskInput = z.infer<typeof TodoTaskInputSchema>;
+export interface AgendaTaskSessionDefaults {
+    workspaceRoot?: string;
+    cwd?: string;
+    modelSelection?: GatewayModelSelection;
+    originTaskId?: string;
+}
+export interface TodoTaskOperationOptions {
+    manager: AgendaTaskManagerApi;
+    telemetry?: ITelemetryService;
+    resolveSessionDefaults: (sessionId: string) => Promise<AgendaTaskSessionDefaults | undefined>;
+}
+export type TodoTaskResult = {
+    ok: true;
+    operation: TodoTaskInput["operation"];
+    task?: Awaited<ReturnType<AgendaTaskManagerApi["getTask"]>>;
+    tasks?: Awaited<ReturnType<AgendaTaskManagerApi["listTasks"]>>;
+} | {
+    ok: false;
+    operation?: TodoTaskInput["operation"];
+    error: {
+        code: string;
+        message: string;
+    };
+};
+/** Execute a Todo operation while preserving Agenda scope and authority rules. */
+export declare function executeTodoTaskOperation(options: TodoTaskOperationOptions, rawInput: unknown, context: Parameters<AgentTool<TodoTaskInput, TodoTaskResult>["execute"]>[1]): Promise<TodoTaskResult>;

package/dist/tasks/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./agenda-task-api";
+export * from "./agenda-task-manager";
+export * from "./agenda-task-tool";
+export * from "./specs/task-spec-file-store";
+export * from "./specs/task-spec-parser";
+export * from "./store/sqlite-task-store";
+export * from "./store/task-schema";
+export * from "./task-location";
+export * from "./task-tool";

package/dist/tasks/specs/task-spec-file-store.d.ts

@@ -0,0 +1,38 @@
+import type { AgendaTaskScope } from "@cerebriline/shared";
+import { type AgendaTaskSpec, type AgendaTaskSpecParseResult, type AgendaTaskSpecWriteInput } from "./task-spec-parser";
+export interface AgendaTaskSpecFileStoreOptions {
+    scope: AgendaTaskScope;
+    workspaceRoot?: string;
+    taskSpecsDir?: string;
+}
+export interface WriteAgendaTaskSpecOptions {
+    /** Existing path or a filename under this store's directory. */
+    specPath?: string;
+    /** Refuse to replace a file whose parsed content changed since it was read. */
+    expectedContentHash?: string;
+    /** Atomically fail instead of replacing an existing target. */
+    createOnly?: boolean;
+}
+export type WrittenAgendaTaskSpec = AgendaTaskSpec & {
+    taskId: string;
+};
+export declare class AgendaTaskSpecFileStore {
+    readonly specsDir: string;
+    readonly scope: AgendaTaskScope;
+    readonly workspaceRoot?: string;
+    constructor(options: AgendaTaskSpecFileStoreOptions);
+    listSpecPaths(): string[];
+    listSpecs(): AgendaTaskSpecParseResult[];
+    readSpec(specPath: string): AgendaTaskSpecParseResult;
+    writeSpec(input: AgendaTaskSpecWriteInput, options?: WriteAgendaTaskSpecOptions): WrittenAgendaTaskSpec;
+    /** Resolve the canonical target before a manager reserves it in SQLite. */
+    resolveWritePath(taskId: string, specPath?: string): string;
+    /** Validate the root both before and after creating missing directories. */
+    ensureSpecsDir(): void;
+    deleteSpec(specPath: string, options?: {
+        expectedContentHash?: string;
+    }): boolean;
+    private assertExpectedContent;
+    private assertSpecsDirSafe;
+    private resolveSpecPath;
+}

package/dist/tasks/specs/task-spec-parser.d.ts

@@ -0,0 +1,65 @@
+import type { AgendaTaskActor, AgendaTaskCreateInput, AgendaTaskPriority, AgendaTaskScope, AgendaTaskType, GatewayModelSelection } from "@cerebriline/shared";
+export interface AgendaTaskSpec {
+    taskId?: string;
+    type: AgendaTaskType;
+    title: string;
+    description?: string;
+    instructions: string;
+    scope: AgendaTaskScope;
+    workspaceRoot?: string;
+    cwd?: string;
+    resourcePaths: string[];
+    priority: AgendaTaskPriority;
+    assignee?: string;
+    modelSelection?: GatewayModelSelection;
+    mode?: "act" | "plan" | "yolo";
+    systemPrompt?: string;
+    maxIterations?: number;
+    timeoutSeconds?: number;
+    availableAt?: string;
+    expiresAt: string;
+    automationEligible: boolean;
+    specPath: string;
+    contentHash: string;
+}
+export interface ParseAgendaTaskSpecInput {
+    specPath: string;
+    raw: string;
+    scope: AgendaTaskScope;
+    workspaceRoot?: string;
+}
+export type AgendaTaskSpecParseResult = {
+    ok: true;
+    specPath: string;
+    contentHash: string;
+    spec: AgendaTaskSpec;
+} | {
+    ok: false;
+    specPath: string;
+    contentHash: string;
+    error: string;
+};
+export interface AgendaTaskSpecWriteInput {
+    taskId: string;
+    type: AgendaTaskType;
+    title: string;
+    description?: string;
+    instructions: string;
+    cwd?: string;
+    resourcePaths?: string[];
+    priority?: AgendaTaskPriority;
+    assignee?: string;
+    modelSelection?: GatewayModelSelection;
+    mode?: "act" | "plan" | "yolo";
+    systemPrompt?: string;
+    maxIterations?: number;
+    timeoutSeconds?: number;
+    availableAt?: string;
+    expiresAt: string;
+    automationEligible?: boolean;
+}
+/** Parse one task Markdown file without throwing for invalid user content. */
+export declare function parseAgendaTaskSpec(input: ParseAgendaTaskSpecInput): AgendaTaskSpecParseResult;
+/** Render the canonical, user-editable task spec representation. */
+export declare function serializeAgendaTaskSpec(input: AgendaTaskSpecWriteInput): string;
+export declare function agendaTaskSpecToCreateInput(spec: AgendaTaskSpec, createdBy: AgendaTaskActor): AgendaTaskCreateInput;

package/dist/tasks/store/sqlite-task-store.d.ts

@@ -0,0 +1,73 @@
+import type { AgendaAutomationPolicy, AgendaTaskActor, AgendaTaskCreateInput, AgendaTaskListInput, AgendaTaskRecord, AgendaTaskRunRecord, AgendaTaskRunStatus, AgendaTaskStatus, AgendaTaskUpdateInput } from "@cerebriline/shared";
+export interface SqliteAgendaTaskStoreOptions {
+    dbPath?: string;
+}
+export declare class AgendaTaskRevisionConflictError extends Error {
+    readonly current: AgendaTaskRecord;
+    constructor(current: AgendaTaskRecord);
+}
+export interface AgendaTaskStatePatch {
+    status?: AgendaTaskStatus;
+    approvedRevision?: number | null;
+    currentRunId?: string | null;
+    lastRunId?: string | null;
+    lastSessionId?: string | null;
+    specPath?: string | null;
+    error?: string | null;
+    completedAt?: string | null;
+    archivedAt?: string | null;
+    updatedBy?: AgendaTaskActor;
+}
+export interface CreateAgendaTaskRunInput {
+    taskId: string;
+    taskRevision: number;
+    status?: AgendaTaskRunStatus;
+    claimToken?: string;
+    claimUntilAt?: string;
+    requestedByClientId?: string;
+    sessionId?: string;
+    claimedAt?: string;
+}
+export interface UpdateAgendaTaskRunInput {
+    status?: AgendaTaskRunStatus;
+    claimToken?: string | null;
+    claimUntilAt?: string | null;
+    requestedByClientId?: string | null;
+    sessionId?: string | null;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    resultSummary?: string | null;
+    error?: string | null;
+}
+export interface ListAgendaTaskRunsInput {
+    taskId?: string;
+    status?: AgendaTaskRunStatus | AgendaTaskRunStatus[];
+    sessionId?: string;
+    limit?: number;
+}
+export declare class SqliteAgendaTaskStore {
+    private readonly db;
+    constructor(options?: SqliteAgendaTaskStoreOptions);
+    close(): void;
+    createTask(input: AgendaTaskCreateInput): AgendaTaskRecord;
+    getTask(taskId: string): AgendaTaskRecord | undefined;
+    getTaskBySpecPath(specPath: string): AgendaTaskRecord | undefined;
+    /**
+     * Return every workspace that has ever owned a task. Archived rows are
+     * intentionally included so the Hub can restore file watchers after a restart.
+     */
+    listWorkspaceRoots(): string[];
+    listTasks(input?: AgendaTaskListInput): AgendaTaskRecord[];
+    /** Apply user-editable fields, increment revision, and revoke old approval. */
+    updateTask(input: AgendaTaskUpdateInput): AgendaTaskRecord | undefined;
+    /** Mutate manager-owned lifecycle fields without changing the task revision. */
+    updateTaskState(taskId: string, patch: AgendaTaskStatePatch, expectedRevision?: number): AgendaTaskRecord | undefined;
+    deleteTask(taskId: string): boolean;
+    createRun(input: CreateAgendaTaskRunInput): AgendaTaskRunRecord;
+    getRun(runId: string): AgendaTaskRunRecord | undefined;
+    updateRun(runId: string, input: UpdateAgendaTaskRunInput): AgendaTaskRunRecord | undefined;
+    listRuns(input?: ListAgendaTaskRunsInput): AgendaTaskRunRecord[];
+    getAutomationPolicy(scopeKey?: string): AgendaAutomationPolicy;
+    listAutomationPolicies(): AgendaAutomationPolicy[];
+    setAutomationPolicy(input: Omit<AgendaAutomationPolicy, "updatedAt">): AgendaAutomationPolicy;
+}

package/dist/tasks/store/task-schema.d.ts

@@ -0,0 +1,2 @@
+import type { SqliteDb } from "@cerebriline/shared/db";
+export declare function ensureAgendaTaskSchema(db: SqliteDb): void;

package/dist/tasks/task-location.d.ts

@@ -0,0 +1,14 @@
+import type { AgendaTaskScope } from "@cerebriline/shared";
+export interface AgendaTaskLocationInput {
+    scope: AgendaTaskScope;
+    workspaceRoot?: string;
+    cwd?: string;
+    resourcePaths?: readonly string[];
+}
+export interface NormalizedAgendaTaskLocation {
+    workspaceRoot?: string;
+    cwd?: string;
+    resourcePaths: string[];
+}
+/** Enforce the queue's global/chat and workspace filesystem boundaries. */
+export declare function normalizeAgendaTaskLocation(input: AgendaTaskLocationInput): NormalizedAgendaTaskLocation;

package/dist/tasks/task-tool.d.ts

@@ -0,0 +1,143 @@
+import type { AgentExtension, AgentTool } from "@cerebriline/shared";
+import { z } from "zod";
+import { type ScheduledTaskResult, type ScheduleTaskOperationOptions } from "../cron/service/schedule-tool";
+import { type TodoTaskOperationOptions, type TodoTaskResult } from "./agenda-task-tool";
+export declare const TASKS_TOOL_NAME = "tasks";
+export declare const TASKS_SYSTEM_PROMPT_RULE = "# Tasks\n\nUse the `tasks` tool to manage durable Todo items and explicitly requested scheduled agent work.\n\n- Use `kind: \"todo\"` for meaningful follow-ups, handoffs, ideas, reminders, and other work that should remain visible after this session. This includes useful work you identify and suggest proactively. Agent-created Todos require user approval; Todos created directly by the user are approved immediately. Todo `available_at` controls availability in the list; it never schedules execution.\n- Use `kind: \"scheduled\"` only when the user explicitly asks Cline to execute work once at a future time or on a recurrence. One-time schedules require an exact future ISO 8601 `run_at` with an offset or Z. Recurring schedules require a five-field `cron_pattern` and may include an IANA `timezone`.\n- \"Remind me\" is ambiguous: ask whether the user wants a reviewed Todo note or an agent to execute work at that time when intent is unclear.\n- Never create both kinds for the same request unless the user explicitly requests both. Check existing items before creating a likely duplicate.\n- Todo instructions and scheduled prompts must be self-contained. Include the goal, constraints, relevant project context, and expected output.\n- Scheduled sessions run in the user's schedules home workspace, not this conversation's folder. Include absolute paths in the scheduled `prompt` for any project files or repositories the work must touch.\n- Never approve or start a Todo yourself. Only mutate schedules from an interactive user session, and only update, pause, resume, delete, or run one immediately when the user asks.";
+/** Guidance used while the Todo kind is disabled and only schedules remain. */
+export declare const SCHEDULED_TASKS_SYSTEM_PROMPT_RULE = "# Tasks\n\nUse the `tasks` tool only when the user explicitly asks Cline to execute work once at a future time or on a recurrence. Always pass `kind: \"scheduled\"`.\n\n- One-time schedules require an exact future ISO 8601 `run_at` with an offset or Z. Recurring schedules require a five-field `cron_pattern` and may include an IANA `timezone`.\n- Never create a schedule proactively. Check existing schedules before creating a likely duplicate.\n- Make the scheduled `prompt` self-contained because it runs in a new unattended session in the user's schedules home workspace, not this conversation's folder. Include the goal, constraints, expected output, and absolute paths for any project files or repositories the work must touch.\n- Only update, pause, resume, delete, or run a schedule immediately when the user asks for that action.";
+export declare const TasksToolInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    operation: z.ZodEnum<{
+        list: "list";
+        update: "update";
+        create: "create";
+        get: "get";
+    }>;
+    task_id: z.ZodOptional<z.ZodString>;
+    expected_revision: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodEnum<{
+        handoff: "handoff";
+        suggestion: "suggestion";
+        "follow-up": "follow-up";
+        todo: "todo";
+        idea: "idea";
+        reminder: "reminder";
+    }>>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    instructions: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        workspace: "workspace";
+        global: "global";
+    }>>;
+    workspace_root: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cwd: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    resource_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    priority: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>>;
+    assignee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    model_selection: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider_id: z.ZodString;
+        model_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        plan: "plan";
+        act: "act";
+        yolo: "yolo";
+    }>>>;
+    system_prompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    max_iterations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    timeout_seconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    available_at: z.ZodOptional<z.ZodString>;
+    expires_at: z.ZodOptional<z.ZodString>;
+    automation_eligible: z.ZodOptional<z.ZodBoolean>;
+    statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        completed: "completed";
+        failed: "failed";
+        cancelled: "cancelled";
+        in_progress: "in_progress";
+        approved: "approved";
+        pending_approval: "pending_approval";
+        expired: "expired";
+    }>>>;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        handoff: "handoff";
+        suggestion: "suggestion";
+        "follow-up": "follow-up";
+        todo: "todo";
+        idea: "idea";
+        reminder: "reminder";
+    }>>>;
+    priorities: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"todo">;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodEnum<{
+        list: "list";
+        delete: "delete";
+        resume: "resume";
+        pause: "pause";
+        update: "update";
+        create: "create";
+        get: "get";
+        run_now: "run_now";
+    }>;
+    schedule_id: z.ZodOptional<z.ZodString>;
+    schedule_type: z.ZodOptional<z.ZodEnum<{
+        once: "once";
+        recurring: "recurring";
+    }>>;
+    name: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    run_at: z.ZodOptional<z.ZodString>;
+    cron_pattern: z.ZodOptional<z.ZodString>;
+    timezone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        plan: "plan";
+        act: "act";
+        yolo: "yolo";
+    }>>;
+    system_prompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    max_iterations: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    timeout_seconds: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    max_parallel: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    model_selection: z.ZodOptional<z.ZodObject<{
+        provider_id: z.ZodString;
+        model_id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    kind: z.ZodLiteral<"scheduled">;
+}, z.core.$strict>], "kind">;
+export type TasksToolInput = z.infer<typeof TasksToolInputSchema>;
+export type TasksToolResult = ({
+    kind: "todo";
+} & TodoTaskResult) | ({
+    kind: "scheduled";
+} & ScheduledTaskResult) | {
+    ok: false;
+    kind?: TasksToolInput["kind"];
+    error: {
+        code: "invalid_tasks_input";
+        message: string;
+    };
+};
+export interface CreateTasksToolOptions {
+    /**
+     * Omit to disable the Todo kind: the tool then advertises and accepts only
+     * `kind: "scheduled"` while the Agenda backend stays intact for hosts that
+     * re-enable it.
+     */
+    todo?: TodoTaskOperationOptions;
+    scheduled: ScheduleTaskOperationOptions;
+}
+/**
+ * One agent-facing task tool backed by distinct Todo and schedule domains.
+ * The discriminator selects the domain; each handler retains its own storage,
+ * authorization, scope, and execution lifecycle.
+ */
+export declare function createTasksTool(options: CreateTasksToolOptions): AgentTool<TasksToolInput, TasksToolResult>;
+/** Adds selection and safety guidance only when the unified tool is enabled. */
+export declare function createTasksPromptExtension(options?: {
+    todoEnabled?: boolean;
+}): AgentExtension;