diff --git a/apps/cli/src/commands/schedule.test.ts b/apps/cli/src/commands/schedule.test.ts
index 3a1db71525..db1fed0804 100644
--- a/apps/cli/src/commands/schedule.test.ts
+++ b/apps/cli/src/commands/schedule.test.ts
@@ -4,7 +4,8 @@ import { join } from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { createScheduleCommand } from "./schedule";
 
-const mockSendHubCommand = vi.hoisted(() => vi.fn());
+const mockHubClientCommand = vi.hoisted(() => vi.fn());
+const mockNodeHubClientCtor = vi.hoisted(() => vi.fn());
 const mockEnsureCliHubServer = vi.hoisted(() => vi.fn());
 const mockProviderSettings = vi.hoisted(() => ({
 	lastUsed: undefined as { provider?: string; model?: string } | undefined,
@@ -16,7 +17,17 @@ vi.mock("@cline/core", async () => {
 		await vi.importActual<typeof import("@cline/core")>("@cline/core");
 	return {
 		...actual,
-		sendHubCommand: mockSendHubCommand,
+		NodeHubClient: class {
+			command = mockHubClientCommand;
+
+			constructor(options: Record<string, unknown>) {
+				mockNodeHubClientCtor(options);
+			}
+
+			async connect(): Promise<void> {}
+
+			close(): void {}
+		},
 		ProviderSettingsManager: class {
 			getLastUsedProviderSettings() {
 				return mockProviderSettings.lastUsed;
@@ -74,7 +85,7 @@ describe("runScheduleCommand list output", () => {
 			url: "ws://127.0.0.1:25463/hub",
 			authToken: "test-token",
 		});
-		mockSendHubCommand.mockResolvedValue({
+		mockHubClientCommand.mockResolvedValue({
 			ok: true,
 			payload: { schedules: [] },
 		});
@@ -96,18 +107,21 @@ describe("runScheduleCommand list output", () => {
 		expect(code).toBe(0);
 		expect(errors).toEqual([]);
 		expect(output).toEqual(["No schedules found."]);
-		expect(mockSendHubCommand).toHaveBeenCalledWith(
-			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
-			{
-				clientId: "cline-schedule",
-				command: "schedule.list",
-				payload: {
-					limit: 100,
-					enabled: undefined,
-					tags: undefined,
-				},
-			},
+		// Schedule commands are workspace-scoped: the hub client must register
+		// with a workspace context (and the hub auth token) before commanding.
+		expect(mockNodeHubClientCtor).toHaveBeenCalledWith(
+			expect.objectContaining({
+				url: "ws://127.0.0.1:25463/hub",
+				workspaceRoot: process.cwd(),
+				cwd: process.cwd(),
+				authToken: "test-token",
+			}),
 		);
+		expect(mockHubClientCommand).toHaveBeenCalledWith("schedule.list", {
+			limit: 100,
+			enabled: undefined,
+			tags: undefined,
+		});
 	});
 
 	it("keeps JSON list output unchanged when --json is provided", async () => {
@@ -115,7 +129,7 @@ describe("runScheduleCommand list output", () => {
 			url: "ws://127.0.0.1:25463/hub",
 			authToken: "test-token",
 		});
-		mockSendHubCommand.mockResolvedValue({
+		mockHubClientCommand.mockResolvedValue({
 			ok: true,
 			payload: { schedules: [] },
 		});
@@ -137,7 +151,7 @@ describe("runScheduleCommand list output", () => {
 		expect(code).toBe(0);
 		expect(errors).toEqual([]);
 		expect(output).toEqual(["[]"]);
-		expect(mockSendHubCommand).toHaveBeenCalled();
+		expect(mockHubClientCommand).toHaveBeenCalled();
 	});
 });
 
@@ -157,7 +171,7 @@ describe("runScheduleCommand create", () => {
 			url: "ws://127.0.0.1:25463/hub",
 			authToken: "test-token",
 		});
-		mockSendHubCommand.mockResolvedValue({
+		mockHubClientCommand.mockResolvedValue({
 			ok: true,
 			payload: { schedule: { scheduleId: "sched_123" } },
 		});
@@ -189,15 +203,19 @@ describe("runScheduleCommand create", () => {
 
 		expect(code).toBe(0);
 		expect(errors).toEqual([]);
-		expect(mockSendHubCommand).toHaveBeenCalledWith(
-			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
+		expect(mockNodeHubClientCtor).toHaveBeenCalledWith(
 			expect.objectContaining({
-				clientId: "cline-schedule",
-				command: "schedule.create",
-				payload: expect.objectContaining({
-					provider: "anthropic",
-					model: "claude-sonnet-4-6",
-				}),
+				url: "ws://127.0.0.1:25463/hub",
+				workspaceRoot: "/tmp/workspace",
+				cwd: "/tmp/workspace",
+				authToken: "test-token",
+			}),
+		);
+		expect(mockHubClientCommand).toHaveBeenCalledWith(
+			"schedule.create",
+			expect.objectContaining({
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
 			}),
 		);
 	});
@@ -215,7 +233,7 @@ describe("runScheduleCommand create", () => {
 			url: "ws://127.0.0.1:25463/hub",
 			authToken: "test-token",
 		});
-		mockSendHubCommand.mockResolvedValue({
+		mockHubClientCommand.mockResolvedValue({
 			ok: true,
 			payload: { schedule: { scheduleId: "sched_123" } },
 		});
@@ -246,14 +264,11 @@ describe("runScheduleCommand create", () => {
 
 		expect(code).toBe(0);
 		expect(errors).toEqual([]);
-		expect(mockSendHubCommand).toHaveBeenCalledWith(
-			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
+		expect(mockHubClientCommand).toHaveBeenCalledWith(
+			"schedule.create",
 			expect.objectContaining({
-				command: "schedule.create",
-				payload: expect.objectContaining({
-					provider: "anthropic",
-					model: "claude-sonnet-4-6",
-				}),
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
 			}),
 		);
 	});
@@ -292,7 +307,7 @@ describe("runScheduleCommand create", () => {
 		expect(errors).toEqual([
 			'No model is configured for provider "anthropic". Pass --model or save a model for that provider before creating the schedule.',
 		]);
-		expect(mockSendHubCommand).not.toHaveBeenCalled();
+		expect(mockHubClientCommand).not.toHaveBeenCalled();
 	});
 
 	it("maps --delivery-bot to delivery.userName", async () => {
@@ -300,7 +315,7 @@ describe("runScheduleCommand create", () => {
 			url: "ws://127.0.0.1:25463/hub",
 			authToken: "test-token",
 		});
-		mockSendHubCommand.mockResolvedValue({
+		mockHubClientCommand.mockResolvedValue({
 			ok: true,
 			payload: { schedule: { scheduleId: "sched_delivery" } },
 		});
@@ -339,21 +354,17 @@ describe("runScheduleCommand create", () => {
 		expect(code).toBe(0);
 		expect(errors).toEqual([]);
 		expect(output).toEqual(['{\n  "scheduleId": "sched_delivery"\n}']);
-		expect(mockSendHubCommand).toHaveBeenCalledWith(
-			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
-			{
-				clientId: "cline-schedule",
-				command: "schedule.create",
-				payload: expect.objectContaining({
-					metadata: {
-						delivery: {
-							adapter: "telegram",
-							threadId: "telegram:123456789",
-							userName: "my_bot",
-						},
+		expect(mockHubClientCommand).toHaveBeenCalledWith(
+			"schedule.create",
+			expect.objectContaining({
+				metadata: {
+					delivery: {
+						adapter: "telegram",
+						threadId: "telegram:123456789",
+						userName: "my_bot",
 					},
-				}),
-			},
+				},
+			}),
 		);
 	});
 });
@@ -370,7 +381,7 @@ describe("runScheduleCommand import", () => {
 			url: "ws://127.0.0.1:25463/hub",
 			authToken: "test-token",
 		});
-		mockSendHubCommand.mockResolvedValue({
+		mockHubClientCommand.mockResolvedValue({
 			ok: true,
 			payload: { schedule: { scheduleId: "sched_123" } },
 		});
@@ -411,16 +422,12 @@ describe("runScheduleCommand import", () => {
 		expect(code).toBe(0);
 		expect(errors).toEqual([]);
 		expect(output).toEqual(['{\n  "scheduleId": "sched_123"\n}']);
-		expect(mockSendHubCommand).toHaveBeenCalledWith(
-			{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
-			{
-				clientId: "cline-schedule",
-				command: "schedule.create",
-				payload: expect.objectContaining({
-					provider: "anthropic",
-					model: "claude-sonnet-4-6",
-				}),
-			},
+		expect(mockHubClientCommand).toHaveBeenCalledWith(
+			"schedule.create",
+			expect.objectContaining({
+				provider: "anthropic",
+				model: "claude-sonnet-4-6",
+			}),
 		);
 	});
 });
@@ -444,7 +451,7 @@ describe("runScheduleCommand export", () => {
 			prompt: "review status",
 			workspaceRoot: "/tmp/workspace",
 		};
-		mockSendHubCommand.mockResolvedValue({
+		mockHubClientCommand.mockResolvedValue({
 			ok: true,
 			payload: { schedule: scheduleRecord },
 		});
@@ -484,14 +491,9 @@ describe("runScheduleCommand export", () => {
 
 			const written = await readFile(targetPath, "utf8");
 			expect(written).toBe(JSON.stringify(scheduleRecord, null, 2));
-			expect(mockSendHubCommand).toHaveBeenCalledWith(
-				{ host: "127.0.0.1", port: 25463, pathname: "/hub" },
-				{
-					clientId: "cline-schedule",
-					command: "schedule.get",
-					payload: { scheduleId: "sched_abc" },
-				},
-			);
+			expect(mockHubClientCommand).toHaveBeenCalledWith("schedule.get", {
+				scheduleId: "sched_abc",
+			});
 		} finally {
 			await rm(targetPath, { force: true });
 		}
@@ -507,7 +509,7 @@ describe("runScheduleCommand export", () => {
 			name: "Weekly Sync",
 			cronPattern: "0 9 * * 1",
 		};
-		mockSendHubCommand.mockResolvedValue({
+		mockHubClientCommand.mockResolvedValue({
 			ok: true,
 			payload: { schedule: scheduleRecord },
 		});
diff --git a/apps/cli/src/commands/schedule/client.ts b/apps/cli/src/commands/schedule/client.ts
index 23da54e897..b45e857981 100644
--- a/apps/cli/src/commands/schedule/client.ts
+++ b/apps/cli/src/commands/schedule/client.ts
@@ -2,7 +2,7 @@ import {
 	createLocalHubScheduleRuntimeHandlers,
 	HubScheduleCommandService,
 	HubScheduleService,
-	sendHubCommand,
+	NodeHubClient,
 } from "@cline/core";
 import {
 	ensureCliHubServer,
@@ -11,28 +11,51 @@ import {
 import type { CommandIo } from "./types";
 
 export class HubScheduleClient {
+	private hub: Promise<NodeHubClient> | undefined;
+
 	constructor(
-		private readonly endpoint: {
-			host?: string;
-			port?: number;
-			pathname?: string;
-		},
+		private readonly url: string,
+		private readonly workspaceRoot: string,
+		private readonly authToken?: string,
 	) {}
 
-	close(): void {}
+	close(): void {
+		const hub = this.hub;
+		this.hub = undefined;
+		void hub?.then((client) => client.close()).catch(() => undefined);
+	}
+
+	// Schedule commands are authorized against the workspace bound to the
+	// connection's client registration, so all commands must share one
+	// registered connection instead of fire-and-forget envelopes.
+	private connectedHub(): Promise<NodeHubClient> {
+		this.hub ??= (async () => {
+			const client = new NodeHubClient({
+				url: this.url,
+				clientType: "cli-schedule",
+				displayName: "Cline CLI scheduler",
+				workspaceRoot: this.workspaceRoot,
+				cwd: this.workspaceRoot,
+				authToken: this.authToken,
+			});
+			try {
+				await client.connect();
+			} catch (error) {
+				client.close();
+				this.hub = undefined;
+				throw error;
+			}
+			return client;
+		})();
+		return this.hub;
+	}
 
 	private async command(
 		command: string,
 		payload?: Record<string, unknown>,
 	): Promise<Record<string, unknown>> {
-		const reply = await sendHubCommand(this.endpoint, {
-			clientId: "cline-schedule",
-			command: command as never,
-			payload,
-		});
-		if (!reply.ok) {
-			throw new Error(reply.error?.message ?? `hub command failed: ${command}`);
-		}
+		const client = await this.connectedHub();
+		const reply = await client.command(command as never, payload);
 		return (reply.payload ?? {}) as Record<string, unknown>;
 	}
 
@@ -97,6 +120,7 @@ export class LocalScheduleClient {
 		runtimeHandlers: createLocalHubScheduleRuntimeHandlers(),
 	});
 	private readonly commands = new HubScheduleCommandService(this.service);
+	constructor(private readonly workspaceRoot: string) {}
 
 	close(): void {
 		void this.service.dispose();
@@ -106,12 +130,21 @@ export class LocalScheduleClient {
 		command: string,
 		payload?: Record<string, unknown>,
 	): Promise<Record<string, unknown>> {
-		const reply = await this.commands.handleCommand({
-			version: "v1",
-			clientId: "cline-schedule-local",
-			command: command as never,
-			payload,
-		});
+		const reply = await this.commands.handleCommand(
+			{
+				version: "v1",
+				clientId: "cline-schedule-local",
+				command: command as never,
+				payload,
+			},
+			{
+				clientId: "cline-schedule-local",
+				workspaceContext: {
+					workspaceRoot: this.workspaceRoot,
+					cwd: this.workspaceRoot,
+				},
+			},
+		);
 		if (!reply.ok) {
 			throw new Error(reply.error?.message ?? `hub command failed: ${command}`);
 		}
@@ -185,24 +218,27 @@ export async function ensureSchedulerHub(
 	if (!address?.trim()) {
 		return {
 			ok: true,
-			client: new LocalScheduleClient() as unknown as HubScheduleClient,
+			client: new LocalScheduleClient(
+				workspaceRoot,
+			) as unknown as HubScheduleClient,
 		};
 	}
 	try {
 		const requestedEndpoint = parseHubEndpointOverride(address);
-		const { url: hubUrl } = await ensureCliHubServer(
+		const { url: hubUrl, authToken } = await ensureCliHubServer(
 			workspaceRoot,
 			requestedEndpoint,
 		);
-		const endpoint = parseHubEndpointOverride(hubUrl);
 		return {
 			ok: true,
-			client: new HubScheduleClient(endpoint),
+			client: new HubScheduleClient(hubUrl, workspaceRoot, authToken),
 		};
 	} catch (_error) {
 		return {
 			ok: true,
-			client: new LocalScheduleClient() as unknown as HubScheduleClient,
+			client: new LocalScheduleClient(
+				workspaceRoot,
+			) as unknown as HubScheduleClient,
 		};
 	}
 }
diff --git a/apps/cline-hub/src/server/desktop-commands.ts b/apps/cline-hub/src/server/desktop-commands.ts
index b5573df821..7354f94bbf 100644
--- a/apps/cline-hub/src/server/desktop-commands.ts
+++ b/apps/cline-hub/src/server/desktop-commands.ts
@@ -253,7 +253,7 @@ export async function handleDesktopCommand(
 		return path;
 	}
 	if (ROUTINE_SCHEDULE_COMMANDS.has(command)) {
-		return await handleRoutineScheduleCommand(command, args);
+		return await handleRoutineScheduleCommand(command, args, workspaceRoot);
 	}
 	if (command === "get_process_context") {
 		return { workspaceRoot, cwd: workspaceRoot };
diff --git a/apps/cline-hub/src/server/schedules.ts b/apps/cline-hub/src/server/schedules.ts
index b32ec1bec9..03c4d9ca7b 100644
--- a/apps/cline-hub/src/server/schedules.ts
+++ b/apps/cline-hub/src/server/schedules.ts
@@ -27,13 +27,20 @@ function getCommands(): HubScheduleCommandService {
 async function clientCommand(
 	hubCommand: string,
 	payload?: Record<string, unknown>,
+	workspaceRoot = process.cwd(),
 ): Promise<Record<string, unknown>> {
-	const reply = await getCommands().handleCommand({
-		version: "v1",
-		clientId: "cline-hub-schedules",
-		command: hubCommand as never,
-		payload,
-	});
+	const reply = await getCommands().handleCommand(
+		{
+			version: "v1",
+			clientId: "cline-hub-schedules",
+			command: hubCommand as never,
+			payload,
+		},
+		{
+			clientId: "cline-hub-schedules",
+			workspaceContext: { workspaceRoot, cwd: workspaceRoot },
+		},
+	);
 	if (!reply.ok) {
 		throw new Error(
 			reply.error?.message ?? `hub command failed: ${hubCommand}`,
@@ -70,14 +77,17 @@ function asTrimmedStringArray(value: unknown): string[] | undefined {
 export async function handleRoutineScheduleCommand(
 	command: string,
 	args?: Record<string, unknown>,
+	workspaceRoot = process.cwd(),
 ): Promise<unknown> {
+	const commandHub = (hubCommand: string, payload?: Record<string, unknown>) =>
+		clientCommand(hubCommand, payload, workspaceRoot);
 	if (command === "list_routine_schedules") {
 		const [schedules, activeExecutions, upcomingRuns] = await Promise.all([
-			clientCommand("schedule.list", {
+			commandHub("schedule.list", {
 				limit: toPositiveInt(args?.limit) ?? 200,
 			}),
-			clientCommand("schedule.active"),
-			clientCommand("schedule.upcoming", { limit: 30 }),
+			commandHub("schedule.active"),
+			commandHub("schedule.upcoming", { limit: 30 }),
 		]);
 		const scheduleRows = Array.isArray(schedules.schedules)
 			? schedules.schedules
@@ -88,7 +98,7 @@ export async function handleRoutineScheduleCommand(
 					(schedule as Record<string, unknown>).scheduleId,
 				);
 				if (!scheduleId) return undefined;
-				const reply = await clientCommand("schedule.list_executions", {
+				const reply = await commandHub("schedule.list_executions", {
 					scheduleId,
 					limit: 1,
 				});
@@ -115,7 +125,7 @@ export async function handleRoutineScheduleCommand(
 				"createSchedule requires name, timing, prompt, and workspace_root",
 			);
 		}
-		const created = await clientCommand("schedule.create", {
+		const created = await commandHub("schedule.create", {
 			name,
 			...timing,
 			prompt,
@@ -149,7 +159,7 @@ export async function handleRoutineScheduleCommand(
 				"updateSchedule requires schedule_id, name, timing, prompt, and workspace_root",
 			);
 		}
-		const reply = await clientCommand("schedule.update", {
+		const reply = await commandHub("schedule.update", {
 			scheduleId,
 			name,
 			...timing,
@@ -180,25 +190,25 @@ export async function handleRoutineScheduleCommand(
 		return { schedule: reply.schedule ?? null };
 	}
 	if (command === "pause_routine_schedule") {
-		const reply = await clientCommand("schedule.disable", { scheduleId });
+		const reply = await commandHub("schedule.disable", { scheduleId });
 		return { schedule: reply.schedule ?? null };
 	}
 	if (command === "resume_routine_schedule") {
-		const reply = await clientCommand("schedule.enable", { scheduleId });
+		const reply = await commandHub("schedule.enable", { scheduleId });
 		return { schedule: reply.schedule ?? null };
 	}
 	if (command === "trigger_routine_schedule") {
-		const existing = await clientCommand("schedule.get", { scheduleId });
+		const existing = await commandHub("schedule.get", { scheduleId });
 		if (!existing.schedule)
 			throw new Error(`schedule not found: ${scheduleId}`);
-		const reply = await clientCommand("schedule.trigger", {
+		const reply = await commandHub("schedule.trigger", {
 			scheduleId,
 			wait: false,
 		});
 		return { execution: reply.execution ?? null };
 	}
 	if (command === "delete_routine_schedule") {
-		const reply = await clientCommand("schedule.delete", { scheduleId });
+		const reply = await commandHub("schedule.delete", { scheduleId });
 		return { deleted: reply.deleted === true };
 	}
 	throw new Error(`unsupported routine schedule command: ${command}`);
diff --git a/apps/examples/desktop-app/README.md b/apps/examples/desktop-app/README.md
index b6eeadd218..0673714bee 100644
--- a/apps/examples/desktop-app/README.md
+++ b/apps/examples/desktop-app/README.md
@@ -6,8 +6,9 @@ Tauri desktop shell + Bun sidecar backend + Next.js UI for running and inspectin
 
 From `apps/examples/desktop-app/`:
 
-- `bun run dev:web` - Next.js UI only (`http://localhost:3125`)
-- `bun run dev:sidecar` - sidecar backend only
+- `bun run dev:headless` - Next.js UI (`http://localhost:3125`) and sidecar backend with a fresh shared approval credential
+- `bun run dev:web` - Next.js UI only (approval-gated tools require `dev:headless` or the native app)
+- `bun run dev:sidecar` - sidecar backend only (approval-gated tools require `dev:headless` or the native app)
 - `bun run dev` - Tauri desktop dev
 - `bun run build` - build web assets
 - `bun run build:sidecar` - build the Bun sidecar bundle
diff --git a/apps/examples/desktop-app/package.json b/apps/examples/desktop-app/package.json
index 9e0878eeb5..1279705da6 100644
--- a/apps/examples/desktop-app/package.json
+++ b/apps/examples/desktop-app/package.json
@@ -7,6 +7,8 @@
 		"predev:web": "bun run build:ui",
 		"dev:web": "next dev webview -p 3125 --turbo",
 		"dev:sidecar": "bun run sidecar/index.ts",
+		"predev:headless": "bun run build:ui",
+		"dev:headless": "bun run scripts/dev-headless.ts",
 		"dev": "tauri dev --config src-tauri/tauri.dev.conf.json",
 		"prebuild": "bun run build:ui",
 		"build": "bun run bun.mts",
diff --git a/apps/examples/desktop-app/scripts/dev-headless.ts b/apps/examples/desktop-app/scripts/dev-headless.ts
new file mode 100644
index 0000000000..3598798bf2
--- /dev/null
+++ b/apps/examples/desktop-app/scripts/dev-headless.ts
@@ -0,0 +1,64 @@
+import { randomUUID } from "node:crypto";
+import { createServer } from "node:net";
+
+const approvalToken = randomUUID();
+const children: ReturnType<typeof Bun.spawn>[] = [];
+
+async function reserveAvailablePort(): Promise<number> {
+	return await new Promise((resolve, reject) => {
+		const server = createServer();
+		server.once("error", reject);
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			if (!address || typeof address === "string") {
+				server.close();
+				reject(new Error("Failed to reserve a sidecar port"));
+				return;
+			}
+			server.close((error) =>
+				error ? reject(error) : resolve(address.port),
+			);
+		});
+	});
+}
+
+function spawn(command: string[], env: Record<string, string>) {
+	const child = Bun.spawn(command, {
+		cwd: import.meta.dir + "/..",
+		env: { ...process.env, ...env },
+		stdin: "inherit",
+		stdout: "inherit",
+		stderr: "inherit",
+	});
+	children.push(child);
+	return child;
+}
+
+function stopChildren(): void {
+	for (const child of children) {
+		if (!child.killed) child.kill();
+	}
+}
+
+process.on("SIGINT", stopChildren);
+process.on("SIGTERM", stopChildren);
+
+async function main(): Promise<void> {
+	const sidecarPort = await reserveAvailablePort();
+	const endpoint = `ws://127.0.0.1:${sidecarPort}/transport?approval_token=${approvalToken}`;
+	const sidecar = spawn(["bun", "run", "sidecar/index.ts"], {
+		CLINE_SIDECAR_APPROVAL_TOKEN: approvalToken,
+		CLINE_SIDECAR_PORT: String(sidecarPort),
+	});
+	const web = spawn(
+		["bun", "run", "next", "dev", "webview", "-p", "3125", "--turbo"],
+		{ NEXT_PUBLIC_SIDECAR_WS_ENDPOINT: endpoint },
+	);
+
+	const exitCode = await Promise.race([sidecar.exited, web.exited]);
+	stopChildren();
+	await Promise.allSettled(children.map((child) => child.exited));
+	process.exit(exitCode);
+}
+
+void main();
diff --git a/apps/examples/desktop-app/sidecar/ARCHITECTURE.md b/apps/examples/desktop-app/sidecar/ARCHITECTURE.md
index 45099d4d0e..d59bfe622e 100644
--- a/apps/examples/desktop-app/sidecar/ARCHITECTURE.md
+++ b/apps/examples/desktop-app/sidecar/ARCHITECTURE.md
@@ -175,7 +175,8 @@ Supported commands:
 ## Dev Workflow
 
 ```bash
-bun run dev:sidecar   # Start sidecar on port 3126
-bun run dev:web       # Start Next.js on port 3125
+bun run dev:headless  # Start sidecar and Next.js with a fresh shared approval credential
+bun run dev:sidecar   # Start only the sidecar (no browser approval surface)
+bun run dev:web       # Start only Next.js (no authenticated approval connection)
 bun run dev           # Both concurrently
 ```
diff --git a/apps/examples/desktop-app/sidecar/commands.ts b/apps/examples/desktop-app/sidecar/commands.ts
index 1df7e4c775..ba20e49bd9 100644
--- a/apps/examples/desktop-app/sidecar/commands.ts
+++ b/apps/examples/desktop-app/sidecar/commands.ts
@@ -67,6 +67,7 @@ import {
 	broadcastEvent,
 	ensureSharedHubClient,
 	resolveSidecarAskQuestion,
+	sendEventToClient,
 } from "./context";
 import {
 	installMarketplaceEntryForDesktopCommand,
@@ -107,6 +108,7 @@ import type {
 	ChatSessionCommandRequest,
 	JsonRecord,
 	SidecarContext,
+	SidecarWebSocketClient,
 } from "./types";
 import { pickWorkspaceDirectory } from "./workspace-picker";
 
@@ -741,6 +743,43 @@ async function handleRoutineScheduleCommand(
 	throw new Error(`unsupported routine schedule command: ${command}`);
 }
 
+// ---------------------------------------------------------------------------
+// Agenda task queue helpers (in-process via shared hub server)
+// ---------------------------------------------------------------------------
+
+const AGENDA_TASK_COMMANDS = new Set([
+	"task.create",
+	"task.list",
+	"task.get",
+	"task.update",
+	"task.approve",
+	"task.cancel",
+	"task.run",
+	"task.automation.get",
+	"task.automation.set",
+]);
+
+const AGENDA_TASK_EXECUTION_COMMANDS = new Set([
+	"task.create",
+	"task.approve",
+	"task.cancel",
+	"task.run",
+	"task.automation.set",
+]);
+
+async function handleAgendaTaskCommand(
+	ctx: SidecarContext,
+	command: string,
+	args?: Record<string, unknown>,
+): Promise<unknown> {
+	const hubClient = await ensureSharedHubClient(ctx);
+	const reply = await hubClient.command(command as never, args);
+	if (!reply.ok) {
+		throw new Error(reply.error?.message ?? `hub command failed: ${command}`);
+	}
+	return reply.payload ?? {};
+}
+
 // ---------------------------------------------------------------------------
 // User instruction config listing through the core config service.
 // ---------------------------------------------------------------------------
@@ -1149,7 +1188,7 @@ export async function handleCommand(
 	ctx: SidecarContext,
 	command: string,
 	args?: Record<string, unknown>,
-	options?: { connection?: object },
+	options?: { connection?: SidecarWebSocketClient },
 ): Promise<unknown> {
 	// ── Chat session commands ──────────────────────────────────────────
 	if (command === "chat_session_command") {
@@ -1239,8 +1278,12 @@ export async function handleCommand(
 	// ── Tool approvals (in-memory) ────────────────────────────────────
 	if (command === "poll_tool_approvals") {
 		const sessionId = String(args?.sessionId ?? "").trim();
+		const connection = options?.connection;
+		if (!connection?.data?.canApproveTools) {
+			throw new Error("tool approvals require a trusted desktop connection");
+		}
 		return Array.from(ctx.pendingApprovals.values())
-			.filter((a) => a.item.sessionId === sessionId)
+			.filter((a) => a.owner === connection && a.item.sessionId === sessionId)
 			.map((a) => a.item);
 	}
 	if (command === "respond_tool_approval") {
@@ -1249,20 +1292,28 @@ export async function handleCommand(
 		if (!sessionId || !requestId) {
 			throw new Error("sessionId and requestId are required");
 		}
-		const pending = ctx.pendingApprovals.get(requestId);
-		if (pending) {
-			pending.resolve({
-				approved: Boolean(args?.approved),
-				...(typeof args?.reason === "string" && args.reason.trim().length > 0
-					? { reason: args.reason.trim() }
-					: {}),
-			});
+		const connection = options?.connection;
+		if (!connection?.data?.canApproveTools) {
+			throw new Error("tool approvals require a trusted desktop connection");
 		}
+		const pending = ctx.pendingApprovals.get(requestId);
+		if (!pending || pending.owner !== connection) {
+			throw new Error("tool approval does not belong to this connection");
+		}
+		if (pending.item.sessionId !== sessionId) {
+			throw new Error("tool approval does not belong to this session");
+		}
+		pending.resolve({
+			approved: Boolean(args?.approved),
+			...(typeof args?.reason === "string" && args.reason.trim().length > 0
+				? { reason: args.reason.trim() }
+				: {}),
+		});
 		ctx.pendingApprovals.delete(requestId);
 		const remaining = Array.from(ctx.pendingApprovals.values())
-			.filter((a) => a.item.sessionId === sessionId)
+			.filter((a) => a.owner === connection && a.item.sessionId === sessionId)
 			.map((a) => a.item);
-		broadcastEvent(ctx, "tool_approval_state", {
+		sendEventToClient(ctx, connection, "tool_approval_state", {
 			sessionId,
 			items: remaining,
 		});
@@ -2025,6 +2076,17 @@ export async function handleCommand(
 		return await handleRoutineScheduleCommand(ctx, command, args);
 	}
 
+	// ── Agenda task queue ─────────────────────────────────────────────
+	if (AGENDA_TASK_COMMANDS.has(command)) {
+		if (
+			AGENDA_TASK_EXECUTION_COMMANDS.has(command) &&
+			!options?.connection?.data?.canApproveTools
+		) {
+			throw new Error("task execution requires a trusted desktop connection");
+		}
+		return await handleAgendaTaskCommand(ctx, command, args);
+	}
+
 	// ── User instruction configs ──────────────────────────────────────
 	if (command === "list_user_instruction_configs") {
 		return await listUserInstructionConfigs(ctx);
diff --git a/apps/examples/desktop-app/sidecar/context.test.ts b/apps/examples/desktop-app/sidecar/context.test.ts
index fd3ddb71e1..7f3e220e7c 100644
--- a/apps/examples/desktop-app/sidecar/context.test.ts
+++ b/apps/examples/desktop-app/sidecar/context.test.ts
@@ -15,6 +15,11 @@ const hubGetUrlMock = vi.hoisted(() => vi.fn());
 const hubIsConnectedMock = vi.hoisted(() => vi.fn());
 const nodeHubClientCtorMock = vi.hoisted(() => vi.fn());
 const subscribeMock = vi.hoisted(() => vi.fn());
+const updateCapabilitiesMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@ai-sdk/provider-utils", () => ({
+	createProviderDefinedToolFactory: vi.fn(() => vi.fn()),
+}));
 
 vi.mock("@cline/core", async () => {
 	const actual =
@@ -35,6 +40,7 @@ vi.mock("@cline/core", async () => {
 			getUrl = hubGetUrlMock;
 			isConnected = hubIsConnectedMock;
 			subscribe = subscribeMock;
+			updateCapabilities = updateCapabilitiesMock;
 			dispose = vi.fn();
 		},
 	};
@@ -64,6 +70,7 @@ describe("Code sidecar runtime capabilities", () => {
 		hubIsConnectedMock.mockReset();
 		nodeHubClientCtorMock.mockReset();
 		subscribeMock.mockReset();
+		updateCapabilitiesMock.mockReset();
 		connectMock.mockResolvedValue(undefined);
 		ensureCompatibleLocalHubUrlMock.mockResolvedValue(
 			"ws://127.0.0.1:25463/hub",
@@ -73,6 +80,7 @@ describe("Code sidecar runtime capabilities", () => {
 		hubGetUrlMock.mockReturnValue("ws://127.0.0.1:25463/hub");
 		hubIsConnectedMock.mockReturnValue(true);
 		subscribeMock.mockReturnValue(() => {});
+		updateCapabilitiesMock.mockResolvedValue(undefined);
 		createCoreMock.mockResolvedValue({
 			runtimeAddress: "ws://127.0.0.1:25463/hub",
 			subscribe: vi.fn(() => () => {}),
@@ -459,7 +467,11 @@ describe("Code sidecar runtime capabilities", () => {
 		const { handleCommand } = await import("./commands");
 
 		const ctx = createSidecarContext("/workspace/project");
-		ctx.wsClients.add({ send: vi.fn() });
+		const approvalClient = {
+			data: { canApproveTools: true },
+			send: vi.fn(),
+		};
+		ctx.wsClients.add(approvalClient);
 
 		await initializeSessionManager(ctx);
 
@@ -565,7 +577,11 @@ describe("Code sidecar runtime capabilities", () => {
 		const { handleCommand } = await import("./commands");
 
 		const ctx = createSidecarContext("/workspace/project");
-		ctx.wsClients.add({ send: vi.fn() });
+		const approvalClient = {
+			data: { canApproveTools: true },
+			send: vi.fn(),
+		};
+		ctx.wsClients.add(approvalClient);
 
 		await initializeSessionManager(ctx);
 
@@ -597,9 +613,12 @@ describe("Code sidecar runtime capabilities", () => {
 		});
 
 		expect(approval).toBeInstanceOf(Promise);
-		const pending = await handleCommand(ctx, "poll_tool_approvals", {
-			sessionId: "sess-1",
-		});
+		const pending = await handleCommand(
+			ctx,
+			"poll_tool_approvals",
+			{ sessionId: "sess-1" },
+			{ connection: approvalClient },
+		);
 		expect(pending).toEqual([
 			expect.objectContaining({
 				sessionId: "sess-1",
@@ -625,18 +644,270 @@ describe("Code sidecar runtime capabilities", () => {
 		);
 
 		const [{ requestId }] = pending as Array<{ requestId: string }>;
-		await handleCommand(ctx, "respond_tool_approval", {
-			sessionId: "sess-1",
-			requestId,
-			approved: true,
-		});
+		const untrustedClient = { send: vi.fn() };
+		ctx.wsClients.add(untrustedClient);
+		await expect(
+			handleCommand(
+				ctx,
+				"respond_tool_approval",
+				{ sessionId: "sess-1", requestId, approved: true },
+				{ connection: untrustedClient },
+			),
+		).rejects.toThrow("trusted desktop connection");
+		expect(ctx.pendingApprovals.size).toBe(1);
+		await handleCommand(
+			ctx,
+			"respond_tool_approval",
+			{ sessionId: "sess-1", requestId, approved: true },
+			{ connection: approvalClient },
+		);
 
 		await expect(approval).resolves.toEqual({ approved: true });
 		expect(
-			await handleCommand(ctx, "poll_tool_approvals", { sessionId: "sess-1" }),
+			await handleCommand(
+				ctx,
+				"poll_tool_approvals",
+				{ sessionId: "sess-1" },
+				{ connection: approvalClient },
+			),
 		).toEqual([]);
 	});
 
+	it("rejects and removes an approval when initial delivery fails", async () => {
+		const { createSidecarContext, createSidecarRuntimeCapabilities } =
+			await import("./context");
+		const ctx = createSidecarContext("/workspace/project");
+		const failedClient = {
+			data: { canApproveTools: true },
+			send: vi.fn(() => {
+				throw new Error("socket closed");
+			}),
+		};
+		ctx.wsClients.add(failedClient);
+
+		const approval = createSidecarRuntimeCapabilities(
+			ctx,
+		).requestToolApproval?.({
+			sessionId: "sess-1",
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+			iteration: 1,
+			toolCallId: "tool-call-1",
+			toolName: "run_commands",
+			input: { commands: ["echo hi"] },
+			policy: { autoApprove: false },
+		});
+
+		await expect(approval).resolves.toEqual({
+			approved: false,
+			reason: "Desktop approval surface disconnected",
+		});
+		expect(ctx.pendingApprovals.size).toBe(0);
+		expect(ctx.wsClients.has(failedClient)).toBe(false);
+	});
+
+	it("rejects an owned approval when a later broadcast fails", async () => {
+		const {
+			broadcastEvent,
+			createSidecarContext,
+			createSidecarRuntimeCapabilities,
+		} = await import("./context");
+		const ctx = createSidecarContext("/workspace/project");
+		const approvalClient = {
+			data: { canApproveTools: true },
+			send: vi
+				.fn()
+				.mockImplementationOnce(() => undefined)
+				.mockImplementationOnce(() => {
+					throw new Error("socket closed");
+				}),
+		};
+		ctx.wsClients.add(approvalClient);
+
+		const approval = createSidecarRuntimeCapabilities(
+			ctx,
+		).requestToolApproval?.({
+			sessionId: "sess-1",
+			agentId: "agent-1",
+			conversationId: "conversation-1",
+			iteration: 1,
+			toolCallId: "tool-call-1",
+			toolName: "run_commands",
+			input: { commands: ["echo hi"] },
+			policy: { autoApprove: false },
+		});
+		expect(ctx.pendingApprovals.size).toBe(1);
+
+		broadcastEvent(ctx, "task.updated", { taskId: "task-1" });
+
+		await expect(approval).resolves.toEqual({
+			approved: false,
+			reason: "Desktop approval surface disconnected",
+		});
+		expect(ctx.pendingApprovals.size).toBe(0);
+		expect(ctx.wsClients.has(approvalClient)).toBe(false);
+	});
+
+	it("rejects sibling approvals when a targeted state update fails", async () => {
+		const { createSidecarContext, createSidecarRuntimeCapabilities } =
+			await import("./context");
+		const { handleCommand } = await import("./commands");
+		const ctx = createSidecarContext("/workspace/project");
+		const approvalClient = {
+			data: { canApproveTools: true },
+			send: vi
+				.fn()
+				.mockImplementationOnce(() => undefined)
+				.mockImplementationOnce(() => undefined)
+				.mockImplementationOnce(() => {
+					throw new Error("socket closed");
+				}),
+		};
+		ctx.wsClients.add(approvalClient);
+		const capabilities = createSidecarRuntimeCapabilities(ctx);
+		const request = (toolCallId: string) =>
+			capabilities.requestToolApproval?.({
+				sessionId: "sess-1",
+				agentId: "agent-1",
+				conversationId: "conversation-1",
+				iteration: 1,
+				toolCallId,
+				toolName: "run_commands",
+				input: { commands: ["echo hi"] },
+				policy: { autoApprove: false },
+			});
+		const firstApproval = request("tool-call-1");
+		const siblingApproval = request("tool-call-2");
+		const [{ requestId }] = (await handleCommand(
+			ctx,
+			"poll_tool_approvals",
+			{ sessionId: "sess-1" },
+			{ connection: approvalClient },
+		)) as Array<{ requestId: string }>;
+
+		await handleCommand(
+			ctx,
+			"respond_tool_approval",
+			{ sessionId: "sess-1", requestId, approved: true },
+			{ connection: approvalClient },
+		);
+
+		await expect(firstApproval).resolves.toEqual({ approved: true });
+		await expect(siblingApproval).resolves.toEqual({
+			approved: false,
+			reason: "Desktop approval surface disconnected",
+		});
+		expect(ctx.pendingApprovals.size).toBe(0);
+		expect(ctx.wsClients.has(approvalClient)).toBe(false);
+	});
+
+	it("serializes approval readiness updates and publishes the latest state", async () => {
+		const {
+			createSidecarContext,
+			initializeSessionManager,
+			syncSidecarApprovalReadiness,
+		} = await import("./context");
+		const ctx = createSidecarContext("/workspace/project");
+		await initializeSessionManager(ctx);
+		updateCapabilitiesMock.mockReset();
+
+		let finishDisconnectedUpdate: (() => void) | undefined;
+		updateCapabilitiesMock
+			.mockImplementationOnce(
+				() =>
+					new Promise<void>((resolve) => {
+						finishDisconnectedUpdate = resolve;
+					}),
+			)
+			.mockResolvedValue(undefined);
+
+		const disconnected = syncSidecarApprovalReadiness(ctx);
+		await vi.waitFor(() =>
+			expect(updateCapabilitiesMock).toHaveBeenCalledWith([]),
+		);
+		ctx.wsClients.add({
+			data: { canApproveTools: true },
+			send: vi.fn(),
+		});
+		const connected = syncSidecarApprovalReadiness(ctx);
+		expect(updateCapabilitiesMock).toHaveBeenCalledTimes(1);
+
+		finishDisconnectedUpdate?.();
+		await Promise.all([disconnected, connected]);
+		expect(updateCapabilitiesMock).toHaveBeenLastCalledWith([
+			expect.objectContaining({ name: "approval.respond" }),
+		]);
+	});
+
+	it("forwards Hub-owned task session approvals to the live desktop", async () => {
+		const { createSidecarContext, initializeSessionManager } = await import(
+			"./context"
+		);
+		const { handleCommand } = await import("./commands");
+		let onHubEvent: ((event: Record<string, unknown>) => void) | undefined;
+		subscribeMock.mockImplementation((handler) => {
+			onHubEvent = handler;
+			return () => {};
+		});
+		const ctx = createSidecarContext("/workspace/project");
+		const approvalClient = {
+			data: { canApproveTools: true },
+			send: vi.fn(),
+		};
+		ctx.wsClients.add(approvalClient);
+		await initializeSessionManager(ctx);
+
+		expect(updateCapabilitiesMock).toHaveBeenCalledWith([
+			expect.objectContaining({ name: "approval.respond" }),
+		]);
+		onHubEvent?.({
+			event: "approval.requested",
+			sessionId: "task-session-1",
+			payload: {
+				approvalId: "hub-approval-1",
+				agendaTaskId: "task-1",
+				agentId: "task-agent-1",
+				conversationId: "task-conversation-1",
+				iteration: 2,
+				toolCallId: "tool-call-1",
+				toolName: "write_to_file",
+				inputJson: JSON.stringify({ path: "src/a.ts" }),
+				policy: { autoApprove: false },
+			},
+		});
+		await vi.waitFor(() => expect(ctx.pendingApprovals.size).toBe(1));
+		const pendingItems = (await handleCommand(
+			ctx,
+			"poll_tool_approvals",
+			{ sessionId: "task-session-1" },
+			{ connection: approvalClient },
+		)) as Array<{ requestId: string }>;
+		const pending = pendingItems[0];
+		if (!pending) throw new Error("expected a pending task approval");
+		await handleCommand(
+			ctx,
+			"respond_tool_approval",
+			{
+				sessionId: "task-session-1",
+				requestId: pending.requestId,
+				approved: true,
+			},
+			{ connection: approvalClient },
+		);
+
+		await vi.waitFor(() =>
+			expect(hubCommandMock).toHaveBeenCalledWith(
+				"approval.respond",
+				{
+					approvalId: "hub-approval-1",
+					approved: true,
+					reason: undefined,
+				},
+				"task-session-1",
+			),
+		);
+	});
+
 	it("routes routine commands through the connected shared Hub client", async () => {
 		const { createSidecarContext, initializeSessionManager } = await import(
 			"./context"
@@ -661,6 +932,115 @@ describe("Code sidecar runtime capabilities", () => {
 			scheduleId: "schedule-1",
 		});
 	});
+
+	it("proxies Agenda task commands through the connected shared Hub", async () => {
+		const { createSidecarContext, initializeSessionManager } = await import(
+			"./context"
+		);
+		const { handleCommand } = await import("./commands");
+		const task = {
+			taskId: "task-1",
+			title: "Review the PR",
+			status: "pending_approval",
+		};
+		hubCommandMock.mockResolvedValue({
+			ok: true,
+			payload: { tasks: [task] },
+		});
+
+		const ctx = createSidecarContext("/workspace/project");
+		await initializeSessionManager(ctx);
+		const approvalClient = {
+			data: { canApproveTools: true },
+			send: vi.fn(),
+		};
+
+		await expect(
+			handleCommand(ctx, "task.list", {
+				workspaceRoot: "/workspace/project",
+				statuses: ["pending_approval"],
+			}),
+		).resolves.toEqual({ tasks: [task] });
+		expect(hubCommandMock).toHaveBeenCalledWith("task.list", {
+			workspaceRoot: "/workspace/project",
+			statuses: ["pending_approval"],
+		});
+
+		hubCommandMock.mockResolvedValueOnce({
+			ok: true,
+			payload: { task: { ...task, status: "in_progress", revision: 4 } },
+		});
+		await expect(
+			handleCommand(
+				ctx,
+				"task.run",
+				{
+					taskId: "task-1",
+					expectedRevision: 4,
+				},
+				{ connection: approvalClient },
+			),
+		).resolves.toEqual({
+			task: { ...task, status: "in_progress", revision: 4 },
+		});
+		expect(hubCommandMock).toHaveBeenCalledWith("task.run", {
+			taskId: "task-1",
+			expectedRevision: 4,
+		});
+	});
+
+	it.each([
+		"task.create",
+		"task.approve",
+		"task.cancel",
+		"task.run",
+		"task.automation.set",
+	])("rejects untrusted %s commands before they reach the shared Hub", async (command) => {
+		const { createSidecarContext, initializeSessionManager } = await import(
+			"./context"
+		);
+		const { handleCommand } = await import("./commands");
+		const ctx = createSidecarContext("/workspace/project");
+		await initializeSessionManager(ctx);
+		const untrustedClient = {
+			data: { canApproveTools: false },
+			send: vi.fn(),
+		};
+
+		await expect(
+			handleCommand(ctx, command, {}, { connection: untrustedClient }),
+		).rejects.toThrow("task execution requires a trusted desktop connection");
+		expect(hubCommandMock).not.toHaveBeenCalled();
+	});
+
+	it("forwards Hub task events that do not have a session", async () => {
+		const { createSidecarContext, handleHubLiveEvent } = await import(
+			"./context"
+		);
+		const ctx = createSidecarContext("/workspace/project");
+		ctx.wsClients.add({ send: vi.fn() } as never);
+
+		handleHubLiveEvent(ctx, {
+			event: "task.created",
+			payload: {
+				taskId: "task-1",
+				status: "pending_approval",
+			},
+		});
+
+		expect(readEvents(ctx)).toEqual([
+			{
+				type: "event",
+				event: {
+					name: "task.created",
+					payload: {
+						taskId: "task-1",
+						status: "pending_approval",
+					},
+				},
+			},
+		]);
+	});
 });
 
 describe("disposeSidecarContext attachment cleanup", () => {
diff --git a/apps/examples/desktop-app/sidecar/context.ts b/apps/examples/desktop-app/sidecar/context.ts
index 74540c9a52..20697402d7 100644
--- a/apps/examples/desktop-app/sidecar/context.ts
+++ b/apps/examples/desktop-app/sidecar/context.ts
@@ -15,7 +15,11 @@ import {
 	type ToolApprovalRequest,
 	type ToolApprovalResult,
 } from "@cline/core";
-import { type AgentEvent, isGeneratedMedia } from "@cline/shared";
+import {
+	type AgentEvent,
+	HUB_CLIENT_TOOL_APPROVAL_CAPABILITY,
+	isGeneratedMedia,
+} from "@cline/shared";
 import {
 	discardAllTrackedAttachments,
 	flushConsumedAttachments,
@@ -29,6 +33,7 @@ import type {
 	PendingToolApproval,
 	PromptInQueue,
 	SidecarContext,
+	SidecarWebSocketClient,
 } from "./types";
 
 const ASK_QUESTION_TIMEOUT_MS = 5 * 60_000;
@@ -36,6 +41,7 @@ const hubClientInitialization = new WeakMap<
 	SidecarContext,
 	Promise<NodeHubClient>
 >();
+const approvalReadinessUpdates = new WeakMap<SidecarContext, Promise<void>>();
 
 // ---------------------------------------------------------------------------
 // Helpers — WebSocket broadcast
@@ -59,10 +65,76 @@ function sendEvent(ctx: SidecarContext, name: string, payload: unknown): void {
 			client.send(encoded);
 		} catch {
 			ctx.wsClients.delete(client);
+			cancelSidecarToolApprovalsForOwner(ctx, client);
+			void syncSidecarApprovalReadiness(ctx).catch((error) =>
+				ctx.logger?.error?.("Hub approval readiness update failed", { error }),
+			);
 		}
 	}
 }
 
+export function sendEventToClient(
+	ctx: SidecarContext,
+	client: SidecarWebSocketClient,
+	name: string,
+	payload: unknown,
+): boolean {
+	try {
+		client.send(encodeSidecarEvent(name, payload));
+		return true;
+	} catch {
+		ctx.wsClients.delete(client);
+		cancelSidecarToolApprovalsForOwner(ctx, client);
+		void syncSidecarApprovalReadiness(ctx).catch((error) =>
+			ctx.logger?.error?.("Hub approval readiness update failed", { error }),
+		);
+		return false;
+	}
+}
+
+export function cancelSidecarToolApprovalsForOwner(
+	ctx: SidecarContext,
+	owner: SidecarWebSocketClient,
+): void {
+	for (const [requestId, pending] of ctx.pendingApprovals) {
+		if (pending.owner !== owner) continue;
+		ctx.pendingApprovals.delete(requestId);
+		pending.resolve({
+			approved: false,
+			reason: "Desktop approval surface disconnected",
+		});
+	}
+}
+
+export function syncSidecarApprovalReadiness(
+	ctx: SidecarContext,
+): Promise<void> {
+	const previous = approvalReadinessUpdates.get(ctx) ?? Promise.resolve();
+	const update = previous.catch(() => undefined).then(async () => {
+		const hubClient = ctx.hubClient;
+		if (!hubClient) return;
+		await hubClient.updateCapabilities(
+			[...ctx.wsClients].some(
+				(client) => client.data?.canApproveTools === true,
+			)
+				? [
+						{
+							name: HUB_CLIENT_TOOL_APPROVAL_CAPABILITY,
+							description:
+								"Cline Code has a live user surface for tool review.",
+						},
+					]
+				: [],
+		);
+	});
+	approvalReadinessUpdates.set(ctx, update);
+	return update.finally(() => {
+		if (approvalReadinessUpdates.get(ctx) === update) {
+			approvalReadinessUpdates.delete(ctx);
+		}
+	});
+}
+
 // Session log appends are chained per session so writes stay ordered, but
 // they run asynchronously: a synchronous write per streamed token would stall
 // the sidecar event loop (and therefore every pending UI command) under load.
@@ -658,6 +730,15 @@ function requestSidecarToolApproval(
 	ctx: SidecarContext,
 	request: ToolApprovalRequest,
 ): Promise<ToolApprovalResult> {
+	const owner = [...ctx.wsClients].find(
+		(client) => client.data?.canApproveTools === true,
+	);
+	if (!owner) {
+		return Promise.resolve({
+			approved: false,
+			reason: "No trusted desktop approval surface is connected",
+		});
+	}
 	return new Promise<ToolApprovalResult>((resolve) => {
 		const requestId = randomUUID();
 		const pending: PendingToolApproval = {
@@ -672,16 +753,25 @@ function requestSidecarToolApproval(
 				agentId: request.agentId,
 				conversationId: request.conversationId,
 			},
+			owner,
 			resolve,
 		};
 		ctx.pendingApprovals.set(requestId, pending);
 		const sessionApprovals = Array.from(ctx.pendingApprovals.values())
-			.filter((approval) => approval.item.sessionId === request.sessionId)
+			.filter(
+				(approval) =>
+					approval.owner === owner &&
+					approval.item.sessionId === request.sessionId,
+			)
 			.map((approval) => approval.item);
-		sendEvent(ctx, "tool_approval_state", {
-			sessionId: request.sessionId,
-			items: sessionApprovals,
-		});
+		if (
+			!sendEventToClient(ctx, owner, "tool_approval_state", {
+				sessionId: request.sessionId,
+				items: sessionApprovals,
+			})
+		) {
+			cancelSidecarToolApprovalsForOwner(ctx, owner);
+		}
 	});
 }
 
@@ -693,6 +783,25 @@ export function handleHubLiveEvent(
 		payload?: Record<string, unknown>;
 	},
 ): void {
+	if (event.event === "approval.requested") {
+		if (typeof event.payload?.agendaTaskId !== "string") return;
+		void handleHubApprovalRequest(ctx, event).catch((error) => {
+			ctx.logger?.error?.("Hub task approval forwarding failed", { error });
+		});
+		return;
+	}
+	// Task lifecycle events are Hub-wide invalidations and usually do not have a
+	// session yet (pending and approved tasks explicitly predate their session).
+	// Forward them before the session-only live-chat projection below so Agenda
+	// surfaces stay current without polling.
+	if (event.event.startsWith("task.")) {
+		sendEvent(ctx, event.event, {
+			...(event.payload ?? {}),
+			...(event.sessionId ? { sessionId: event.sessionId } : {}),
+		});
+		return;
+	}
+
 	const sessionId = typeof event.sessionId === "string" ? event.sessionId : "";
 	if (!sessionId) {
 		return;
@@ -836,6 +945,72 @@ export function handleHubLiveEvent(
 	}
 }
 
+async function handleHubApprovalRequest(
+	ctx: SidecarContext,
+	event: {
+		sessionId?: string;
+		payload?: Record<string, unknown>;
+	},
+): Promise<void> {
+	const sessionId = event.sessionId?.trim() || "";
+	const approvalId =
+		typeof event.payload?.approvalId === "string"
+			? event.payload.approvalId.trim()
+			: "";
+	const toolCallId =
+		typeof event.payload?.toolCallId === "string"
+			? event.payload.toolCallId.trim()
+			: "";
+	const toolName =
+		typeof event.payload?.toolName === "string"
+			? event.payload.toolName.trim()
+			: "";
+	if (!sessionId || !approvalId || !toolCallId || !toolName) return;
+	let input: unknown;
+	try {
+		input =
+			typeof event.payload?.inputJson === "string"
+				? JSON.parse(event.payload.inputJson)
+				: undefined;
+	} catch {
+		input = undefined;
+	}
+	const result = await requestSidecarToolApproval(ctx, {
+		sessionId,
+		agentId:
+			typeof event.payload?.agentId === "string" ? event.payload.agentId : "",
+		conversationId:
+			typeof event.payload?.conversationId === "string"
+				? event.payload.conversationId
+				: sessionId,
+		iteration:
+			typeof event.payload?.iteration === "number"
+				? event.payload.iteration
+				: 0,
+		toolCallId,
+		toolName,
+		input,
+		policy:
+			event.payload?.policy &&
+			typeof event.payload.policy === "object" &&
+			!Array.isArray(event.payload.policy)
+				? (event.payload.policy as ToolApprovalRequest["policy"])
+				: { autoApprove: false },
+	});
+	const client = ctx.hubClient;
+	if (!client)
+		throw new Error("Hub client disconnected before approval response");
+	await client.command(
+		"approval.respond",
+		{
+			approvalId,
+			approved: result.approved,
+			reason: result.reason,
+		},
+		sessionId,
+	);
+}
+
 export async function initializeSessionManager(
 	ctx: SidecarContext,
 ): Promise<void> {
@@ -909,6 +1084,7 @@ export async function ensureSharedHubClient(
 				handleHubLiveEvent(ctx, event);
 			});
 			ctx.hubClient = client;
+			await syncSidecarApprovalReadiness(ctx);
 			return client;
 		} catch (error) {
 			await client.dispose().catch(() => undefined);
diff --git a/apps/examples/desktop-app/sidecar/index.ts b/apps/examples/desktop-app/sidecar/index.ts
index 5ae3017a24..24270f62be 100644
--- a/apps/examples/desktop-app/sidecar/index.ts
+++ b/apps/examples/desktop-app/sidecar/index.ts
@@ -128,7 +128,7 @@ async function main() {
 		void shutdown("code_sidecar_before_exit");
 	});
 
-	const { port } = startServer(ctx, SIDECAR_PORT, shutdown);
+	const { port, approvalToken } = startServer(ctx, SIDECAR_PORT, shutdown);
 	observability.logger.log("Desktop sidecar ready", {
 		port,
 		mode: SIDECAR_MODE,
@@ -152,12 +152,13 @@ async function main() {
 	// A wildcard bind isn't a dialable address; advertise loopback instead.
 	const dialHost = SIDECAR_HOST === "0.0.0.0" ? "127.0.0.1" : SIDECAR_HOST;
 	const endpoint = `http://${dialHost}:${port}`;
-	const wsEndpoint = `ws://${dialHost}:${port}/transport`;
+	const wsEndpoint = new URL(`ws://${dialHost}:${port}/transport`);
+	wsEndpoint.searchParams.set("approval_token", approvalToken);
 	process.stdout.write(
 		`${JSON.stringify({
 			type: "ready",
 			endpoint,
-			wsEndpoint,
+			wsEndpoint: wsEndpoint.toString(),
 			pid: process.pid,
 			mode: SIDECAR_MODE,
 		})}\n`,
diff --git a/apps/examples/desktop-app/sidecar/server.test.ts b/apps/examples/desktop-app/sidecar/server.test.ts
index bd28db8b87..1bff4a8a23 100644
--- a/apps/examples/desktop-app/sidecar/server.test.ts
+++ b/apps/examples/desktop-app/sidecar/server.test.ts
@@ -6,6 +6,8 @@ import {
 import { createFetchHandler, createWebSocketHandler } from "./server";
 import type { SidecarContext } from "./types";
 
+const TEST_APPROVAL_TOKEN = "test-approval-token";
+
 function createTestServer() {
 	return {
 		port: 3126,
@@ -14,7 +16,11 @@ function createTestServer() {
 }
 
 function createHandler(onShutdown = vi.fn()) {
-	return createFetchHandler({} as SidecarContext, onShutdown);
+	return createFetchHandler(
+		{} as SidecarContext,
+		onShutdown,
+		TEST_APPROVAL_TOKEN,
+	);
 }
 
 function createTelemetryHandler(capture = vi.fn()) {
@@ -85,6 +91,37 @@ describe("sidecar HTTP origin checks", () => {
 		expect(server.upgrade).not.toHaveBeenCalled();
 	});
 
+	it("does not grant approval authority to originless local clients", async () => {
+		const server = createTestServer();
+		await createHandler()(
+			new Request(
+				`http://127.0.0.1:3126/transport?approval_token=${TEST_APPROVAL_TOKEN}`,
+			),
+			server,
+		);
+
+		expect(server.upgrade).toHaveBeenCalledWith(expect.any(Request), {
+			data: { canApproveTools: false },
+		});
+	});
+
+	it("grants approval authority to the trusted desktop webview", async () => {
+		const server = createTestServer();
+		await createHandler()(
+			new Request(
+				`http://127.0.0.1:3126/transport?approval_token=${TEST_APPROVAL_TOKEN}`,
+				{
+					headers: { origin: "tauri://localhost" },
+				},
+			),
+			server,
+		);
+
+		expect(server.upgrade).toHaveBeenCalledWith(expect.any(Request), {
+			data: { canApproveTools: true },
+		});
+	});
+
 	it("allows desktop webview origins in preflight responses", async () => {
 		const server = createTestServer();
 		const response = await createHandler()(
@@ -103,6 +140,20 @@ describe("sidecar HTTP origin checks", () => {
 			"tauri://localhost",
 		);
 	});
+
+	it("does not grant approval authority to a spoofed trusted origin", async () => {
+		const server = createTestServer();
+		await createHandler()(
+			new Request("http://127.0.0.1:3126/transport", {
+				headers: { origin: "tauri://localhost" },
+			}),
+			server,
+		);
+
+		expect(server.upgrade).toHaveBeenCalledWith(expect.any(Request), {
+			data: { canApproveTools: false },
+		});
+	});
 });
 
 describe("desktop error telemetry", () => {
diff --git a/apps/examples/desktop-app/sidecar/server.ts b/apps/examples/desktop-app/sidecar/server.ts
index 71c0c9a12a..f98f3631da 100644
--- a/apps/examples/desktop-app/sidecar/server.ts
+++ b/apps/examples/desktop-app/sidecar/server.ts
@@ -1,8 +1,14 @@
+import { randomUUID, timingSafeEqual } from "node:crypto";
 import { captureSdkError } from "@cline/shared";
 import type { DesktopTransportRequest } from "../webview/lib/desktop-transport";
 import { MAX_DESKTOP_TRANSPORT_PAYLOAD_BYTES } from "../webview/lib/voice-input-limits";
 import { handleCommand } from "./commands";
-import { encodeSidecarEvent, sendEvent } from "./context";
+import {
+	cancelSidecarToolApprovalsForOwner,
+	encodeSidecarEvent,
+	sendEvent,
+	syncSidecarApprovalReadiness,
+} from "./context";
 import { fetchMarketplaceCatalog } from "./marketplace";
 import { cancelMcpOAuthAuthorizationsForOwner } from "./mcp-oauth";
 import { cancelProviderOAuthLoginsForOwner } from "./oauth-login";
@@ -17,7 +23,10 @@ import {
 
 type SidecarServer = {
 	port: number;
-	upgrade(req: Request): boolean;
+	upgrade(
+		req: Request,
+		options?: { data?: { canApproveTools?: boolean } },
+	): boolean;
 };
 
 // Comma-separated extra origins (e.g. a dev server on a nonstandard port when
@@ -40,6 +49,19 @@ const JSON_HEADERS = {
 	"content-type": "application/json",
 };
 
+const APPROVAL_TOKEN_QUERY_PARAM = "approval_token";
+
+function hasValidApprovalToken(url: URL, expectedToken: string): boolean {
+	const candidate = url.searchParams.get(APPROVAL_TOKEN_QUERY_PARAM);
+	if (!candidate) return false;
+	const candidateBytes = Buffer.from(candidate);
+	const expectedBytes = Buffer.from(expectedToken);
+	return (
+		candidateBytes.length === expectedBytes.length &&
+		timingSafeEqual(candidateBytes, expectedBytes)
+	);
+}
+
 function readOrigin(req: Request): string | undefined {
 	const origin = req.headers.get("origin")?.trim();
 	return origin ? origin : undefined;
@@ -149,7 +171,9 @@ export function startServer(
 	ctx: SidecarContext,
 	preferredPort: number = SIDECAR_PORT,
 	onShutdown?: (reason?: string) => Promise<void>,
-): { port: number } {
+	approvalToken = process.env.CLINE_SIDECAR_APPROVAL_TOKEN?.trim() ||
+		randomUUID(),
+): { port: number; approvalToken: string } {
 	if (!BunRuntime) {
 		throw new Error("sidecar must be run with Bun");
 	}
@@ -164,7 +188,7 @@ export function startServer(
 			server = BunRuntime.serve({
 				hostname: SIDECAR_HOST,
 				port: candidate,
-				fetch: createFetchHandler(ctx, onShutdown),
+				fetch: createFetchHandler(ctx, onShutdown, approvalToken),
 				websocket: createWebSocketHandler(ctx),
 			}) as SidecarServer;
 			break;
@@ -177,12 +201,13 @@ export function startServer(
 		throw lastError ?? new Error("Failed to start sidecar server");
 	}
 
-	return { port: server.port };
+	return { port: server.port, approvalToken };
 }
 
 export function createFetchHandler(
 	ctx: SidecarContext,
 	onShutdown?: (reason?: string) => Promise<void>,
+	approvalToken = "",
 ) {
 	return async (req: Request, server: SidecarServer) => {
 		const url = new URL(req.url);
@@ -208,7 +233,15 @@ export function createFetchHandler(
 		if (
 			url.pathname === "/transport" &&
 			isTrustedRequestOrigin(req) &&
-			server.upgrade(req)
+			server.upgrade(req, {
+				data: {
+					// Originless clients remain supported for local integrations, but only
+					// the browser-hosted desktop UI may receive or resolve approvals.
+					canApproveTools:
+						Boolean(readOrigin(req)) &&
+						hasValidApprovalToken(url, approvalToken),
+				},
+			})
 		) {
 			return undefined;
 		}
@@ -325,6 +358,7 @@ export function createWebSocketHandler(ctx: SidecarContext) {
 		maxPayloadLength: MAX_DESKTOP_TRANSPORT_PAYLOAD_BYTES,
 		open(ws: SidecarWebSocketClient) {
 			ctx.wsClients.add(ws);
+			void syncSidecarApprovalReadiness(ctx).catch(() => {});
 			sendEvent(ctx, "host_ready", {
 				pid: process.pid,
 				mode: SIDECAR_MODE,
@@ -365,6 +399,8 @@ export function createWebSocketHandler(ctx: SidecarContext) {
 		},
 		close(ws: SidecarWebSocketClient) {
 			ctx.wsClients.delete(ws);
+			cancelSidecarToolApprovalsForOwner(ctx, ws);
+			void syncSidecarApprovalReadiness(ctx).catch(() => {});
 			// Browser OAuth flows are interactive: if the connection that started
 			// one goes away (webview reload, transport drop), cancel its callback
 			// wait so the sidecar cannot retain an abandoned authorization attempt.
diff --git a/apps/examples/desktop-app/sidecar/types.ts b/apps/examples/desktop-app/sidecar/types.ts
index 7eeb369c58..3fde004081 100644
--- a/apps/examples/desktop-app/sidecar/types.ts
+++ b/apps/examples/desktop-app/sidecar/types.ts
@@ -82,6 +82,7 @@ export type ToolApprovalRequestItem = {
 
 export type PendingToolApproval = {
 	item: ToolApprovalRequestItem;
+	owner: SidecarWebSocketClient;
 	resolve: (result: ToolApprovalResult) => void;
 };
 
@@ -105,6 +106,7 @@ export type PendingAskQuestion = {
 };
 
 export type SidecarWebSocketClient = {
+	data?: { canApproveTools?: boolean };
 	send: (message: string) => void;
 	close?: () => void;
 };
diff --git a/apps/examples/desktop-app/webview/app/page.tsx b/apps/examples/desktop-app/webview/app/page.tsx
index 723df455ad..62b9cec21c 100644
--- a/apps/examples/desktop-app/webview/app/page.tsx
+++ b/apps/examples/desktop-app/webview/app/page.tsx
@@ -432,11 +432,17 @@ export default function Home() {
 							onNavigateBack={handleNavigateBack}
 							onNavigateForward={handleNavigateForward}
 							onNewThread={handleNewThread}
+							onOpenSessionById={handleOpenSessionById}
 							onSettingsSectionChange={handleSettingsSectionChange}
 							sessionHistory={sessionHistory}
 							setView={handleViewChange}
 							settingsSection={settingsSection}
 							view={view}
+							workspaceRoot={
+								activeThread?.historySession?.workspaceRoot ||
+								activeThread?.historySession?.cwd ||
+								historyWorkspacePaths[0]
+							}
 							canNavigateBack={navigation.back.length > 0}
 							canNavigateForward={navigation.forward.length > 0}
 						/>
@@ -1642,6 +1648,7 @@ function ChatThreadPane({
 						) : undefined
 					}
 					onListGitBranches={listGitBranches}
+					onOpenSession={onOpenSessionById}
 					onSwitchGitBranch={switchGitBranch}
 				/>
 			</div>
diff --git a/apps/examples/desktop-app/webview/components/agenda-task-review-dialog.tsx b/apps/examples/desktop-app/webview/components/agenda-task-review-dialog.tsx
new file mode 100644
index 0000000000..23b65a112b
--- /dev/null
+++ b/apps/examples/desktop-app/webview/components/agenda-task-review-dialog.tsx
@@ -0,0 +1,170 @@
+"use client";
+
+import type { AgendaTaskRecord } from "@cline/shared";
+import { Loader2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import {
+	Dialog,
+	DialogContent,
+	DialogDescription,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+} from "@/components/ui/dialog";
+
+export function AgendaTaskReviewDialog({
+	task,
+	open,
+	pending,
+	confirmLabel = "Approve",
+	rejectLabel = "Reject",
+	onOpenChange,
+	onConfirm,
+	onReject,
+}: {
+	task: AgendaTaskRecord | null;
+	open: boolean;
+	pending: boolean;
+	confirmLabel?: string;
+	rejectLabel?: string;
+	onOpenChange: (open: boolean) => void;
+	onConfirm: (task: AgendaTaskRecord) => void | Promise<void>;
+	onReject?: (task: AgendaTaskRecord) => void | Promise<void>;
+}) {
+	return (
+		<Dialog onOpenChange={onOpenChange} open={open}>
+			<DialogContent className="h-[min(720px,calc(100dvh-2rem))] w-[min(640px,calc(100vw-2rem))] max-w-none grid-rows-[auto_minmax(0,1fr)_auto] overflow-hidden">
+				{task ? (
+					<>
+						<DialogHeader>
+							<DialogTitle>{task.title}</DialogTitle>
+							<DialogDescription>
+								Review the exact revision before it can start a new agent
+								session.
+							</DialogDescription>
+						</DialogHeader>
+						<div className="min-h-0 space-y-4 overflow-y-auto pr-1">
+							<div className="grid grid-cols-2 gap-x-4 gap-y-2 rounded-md border bg-muted/20 p-3 text-xs">
+								<ReviewField label="Revision" value={String(task.revision)} />
+								<ReviewField label="Priority" value={`P${task.priority}`} />
+								<ReviewField label="Type" value={task.type} />
+								<ReviewField label="Mode" value={task.mode ?? "act"} />
+								<ReviewField
+									label="Scope"
+									value={
+										task.scope === "workspace"
+											? (task.workspaceRoot ?? "workspace")
+											: "General / chat workspace"
+									}
+								/>
+								<ReviewField
+									label="Expires"
+									value={new Date(task.expiresAt).toLocaleString()}
+								/>
+								<ReviewField
+									label="Available"
+									value={new Date(task.availableAt).toLocaleString()}
+								/>
+								<ReviewField
+									label="Assignee"
+									value={task.assignee ?? "Default agent"}
+								/>
+								<ReviewField
+									label="Model"
+									value={
+										task.modelSelection
+											? `${task.modelSelection.providerId}/${task.modelSelection.modelId ?? "default"}`
+											: "Cline default"
+									}
+								/>
+								{task.cwd ? (
+									<ReviewField label="Working directory" value={task.cwd} />
+								) : null}
+								<ReviewField
+									label="Run limits"
+									value={
+										[
+											task.maxIterations
+												? `${task.maxIterations} iterations`
+												: undefined,
+											task.timeoutSeconds
+												? `${task.timeoutSeconds}s timeout`
+												: undefined,
+										]
+											.filter(Boolean)
+											.join(" · ") || "Hub defaults"
+									}
+								/>
+							</div>
+							{task.description ? (
+								<ReviewText label="Description" value={task.description} />
+							) : null}
+							<ReviewText label="Instructions" value={task.instructions} />
+							{task.systemPrompt ? (
+								<ReviewText
+									label="System prompt override"
+									value={task.systemPrompt}
+								/>
+							) : null}
+							{task.resourcePaths.length > 0 ? (
+								<div className="space-y-1.5">
+									<h4 className="text-xs font-medium">Files</h4>
+									<ul className="space-y-1 rounded-md border bg-muted/20 p-3 font-mono text-[11px]">
+										{task.resourcePaths.map((path) => (
+											<li className="break-all" key={path}>
+												{path}
+											</li>
+										))}
+									</ul>
+								</div>
+							) : null}
+						</div>
+						<DialogFooter>
+							<Button
+								disabled={pending}
+								onClick={() => {
+									if (onReject) void onReject(task);
+									else onOpenChange(false);
+								}}
+								type="button"
+								variant={onReject ? "destructive" : "outline"}
+							>
+								{onReject ? rejectLabel : "Not now"}
+							</Button>
+							<Button
+								disabled={pending}
+								onClick={() => void onConfirm(task)}
+								type="button"
+							>
+								{pending ? <Loader2 className="size-4 animate-spin" /> : null}
+								{confirmLabel}
+							</Button>
+						</DialogFooter>
+					</>
+				) : null}
+			</DialogContent>
+		</Dialog>
+	);
+}
+
+function ReviewField({ label, value }: { label: string; value: string }) {
+	return (
+		<div className="min-w-0">
+			<div className="text-muted-foreground">{label}</div>
+			<div className="truncate font-medium capitalize" title={value}>
+				{value}
+			</div>
+		</div>
+	);
+}
+
+function ReviewText({ label, value }: { label: string; value: string }) {
+	return (
+		<div className="space-y-1.5">
+			<h4 className="text-xs font-medium">{label}</h4>
+			<div className="whitespace-pre-wrap rounded-md border bg-muted/20 p-3 text-xs leading-relaxed">
+				{value}
+			</div>
+		</div>
+	);
+}
diff --git a/apps/examples/desktop-app/webview/components/agent-sidebar.test.tsx b/apps/examples/desktop-app/webview/components/agent-sidebar.test.tsx
index 5adde4b0c9..c2caa9a838 100644
--- a/apps/examples/desktop-app/webview/components/agent-sidebar.test.tsx
+++ b/apps/examples/desktop-app/webview/components/agent-sidebar.test.tsx
@@ -1,5 +1,6 @@
 // @vitest-environment jsdom
 
+import type { AgendaTaskRecord } from "@cline/shared";
 import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -15,8 +16,20 @@ import type {
 	UseSessionHistoryResult,
 } from "@/hooks/use-session-history";
 
-const { invoke } = vi.hoisted(() => ({ invoke: vi.fn() }));
-vi.mock("@/lib/desktop-client", () => ({ desktopClient: { invoke } }));
+const desktopMocks = vi.hoisted(() => ({
+	invoke: vi.fn(),
+	createAgendaTask: vi.fn(),
+	listAgendaTasks: vi.fn(),
+	approveAgendaTask: vi.fn(),
+	cancelAgendaTask: vi.fn(),
+	runAgendaTask: vi.fn(),
+	getAgendaAutomationPolicy: vi.fn(),
+	setAgendaAutomationPolicy: vi.fn(),
+	subscribe: vi.fn(() => () => undefined),
+	subscribeTransportState: vi.fn(() => () => undefined),
+}));
+const { invoke } = desktopMocks;
+vi.mock("@/lib/desktop-client", () => ({ desktopClient: desktopMocks }));
 
 let container: HTMLDivElement;
 let root: Root;
@@ -80,6 +93,20 @@ async function hover(element: Element): Promise<void> {
 	});
 }
 
+async function changeField(
+	element: HTMLInputElement | HTMLTextAreaElement,
+	value: string,
+): Promise<void> {
+	await act(async () => {
+		const prototype = Object.getPrototypeOf(element) as object;
+		const setter = Object.getOwnPropertyDescriptor(prototype, "value")?.set;
+		setter?.call(element, value);
+		element.dispatchEvent(new Event("input", { bubbles: true }));
+		element.dispatchEvent(new Event("change", { bubbles: true }));
+		await Promise.resolve();
+	});
+}
+
 function buttonWithText(text: string, rootNode: ParentNode = container) {
 	const button = [
 		...rootNode.querySelectorAll<HTMLButtonElement>("button"),
@@ -117,6 +144,29 @@ beforeEach(() => {
 	window.localStorage.clear();
 	invoke.mockReset();
 	invoke.mockRejectedValue(new Error("No Cline account auth token found"));
+	desktopMocks.createAgendaTask.mockReset();
+	desktopMocks.listAgendaTasks.mockReset();
+	desktopMocks.listAgendaTasks.mockResolvedValue([]);
+	desktopMocks.approveAgendaTask.mockReset();
+	desktopMocks.cancelAgendaTask.mockReset();
+	desktopMocks.runAgendaTask.mockReset();
+	desktopMocks.getAgendaAutomationPolicy.mockReset();
+	desktopMocks.getAgendaAutomationPolicy.mockResolvedValue({
+		scopeKey: "global",
+		mode: "manual",
+		applyToAgentCreated: true,
+		maxConcurrentRuns: 1,
+		maxChainDepth: 3,
+		maxStartsPerHour: 20,
+		updatedAt: "2026-08-13T00:00:00.000Z",
+	});
+	desktopMocks.setAgendaAutomationPolicy.mockReset();
+	desktopMocks.subscribe.mockReset();
+	desktopMocks.subscribe.mockImplementation(() => () => undefined);
+	desktopMocks.subscribeTransportState.mockReset();
+	desktopMocks.subscribeTransportState.mockImplementation(
+		() => () => undefined,
+	);
 	Object.defineProperty(window, "matchMedia", {
 		configurable: true,
 		value: vi.fn(() => ({
@@ -140,6 +190,251 @@ afterEach(async () => {
 });
 
 describe("AgentSidebar session organization", () => {
+	it("shows an unread dot when a new Todo item arrives and clears it on open", async () => {
+		const eventHandlers = new Map<string, () => void>();
+		desktopMocks.subscribe.mockImplementation(
+			(eventName: string, handler: () => void) => {
+				eventHandlers.set(eventName, handler);
+				return () => eventHandlers.delete(eventName);
+			},
+		);
+
+		await act(async () => {
+			root.render(
+				<SidebarProvider>
+					<AgentSidebar
+						onHome={vi.fn()}
+						onSettingsSectionChange={vi.fn()}
+						sessionHistory={makeSessionHistory([], vi.fn())}
+						setView={vi.fn()}
+						settingsSection="General"
+						view="chat"
+					/>
+				</SidebarProvider>,
+			);
+		});
+		await vi.waitFor(() =>
+			expect(desktopMocks.listAgendaTasks).toHaveBeenCalled(),
+		);
+		expect(
+			container.querySelector('[data-testid="new-todo-indicator"]'),
+		).toBeNull();
+
+		desktopMocks.listAgendaTasks.mockResolvedValue([makeAgendaTask()]);
+		await act(async () => {
+			eventHandlers.get("task.created")?.();
+		});
+		await vi.waitFor(() =>
+			expect(
+				container.querySelector('[data-testid="new-todo-indicator"]'),
+			).not.toBeNull(),
+		);
+
+		await click(
+			container.querySelector('[aria-label="Show Agenda"]') as Element,
+		);
+		expect(
+			container.querySelector('[data-testid="new-todo-indicator"]'),
+		).toBeNull();
+	});
+
+	it("shows pending Agenda work and requires approval before run", async () => {
+		const task = makeAgendaTask();
+		desktopMocks.listAgendaTasks.mockResolvedValue([task]);
+		desktopMocks.approveAgendaTask.mockResolvedValue({
+			...task,
+			status: "approved",
+			revision: 2,
+		});
+
+		await act(async () => {
+			root.render(
+				<SidebarProvider>
+					<AgentSidebar
+						onHome={vi.fn()}
+						onSettingsSectionChange={vi.fn()}
+						sessionHistory={makeSessionHistory([], vi.fn())}
+						setView={vi.fn()}
+						settingsSection="General"
+						view="chat"
+						workspaceRoot="/projects/current"
+					/>
+				</SidebarProvider>,
+			);
+			await Promise.resolve();
+		});
+		await click(
+			container.querySelector('[aria-label="Show Agenda"]') as Element,
+		);
+
+		expect(container.textContent).toContain("Review PR checks");
+		expect(container.textContent).toContain("cline");
+		expect(container.textContent).not.toContain("P1 · pending approval");
+		expect(desktopMocks.listAgendaTasks).toHaveBeenCalledWith({
+			statuses: ["pending_approval", "approved", "in_progress", "failed"],
+			workspaceRoot: "/projects/current",
+			limit: 200,
+		});
+		const approve = container.querySelector(
+			'[aria-label="Approve Review PR checks"]',
+		);
+		expect(approve).not.toBeNull();
+		expect(approve?.className).toContain("text-emerald-500!");
+		expect(
+			container.querySelector('[aria-label="Cancel Review PR checks"]')
+				?.className,
+		).toContain("text-destructive!");
+		expect(approve?.closest(".group")?.className).toContain("max-w-full");
+		expect(
+			buttonWithText("Review PR checks").querySelector(".truncate"),
+		).not.toBeNull();
+		expect(
+			container.querySelector('[aria-label="Run Review PR checks"]'),
+		).toBeNull();
+
+		await click(buttonWithText("Review PR checks"));
+		expect(desktopMocks.approveAgendaTask).not.toHaveBeenCalled();
+		expect(document.body.textContent).toContain(
+			"Review CI and report failures.",
+		);
+		expect(buttonWithText("Reject", document)).toBeDefined();
+		await click(buttonWithText("Approve", document));
+		expect(desktopMocks.approveAgendaTask).toHaveBeenCalledWith({
+			taskId: "task-1",
+			expectedRevision: 1,
+		});
+	});
+
+	it("uses each displayed Agenda revision when running or cancelling", async () => {
+		const runnable = makeAgendaTask({
+			taskId: "task-run",
+			title: "Run task",
+			status: "approved",
+			revision: 4,
+		});
+		const cancellable = makeAgendaTask({
+			taskId: "task-cancel",
+			title: "Cancel task",
+			status: "approved",
+			revision: 9,
+		});
+		desktopMocks.listAgendaTasks.mockResolvedValue([runnable, cancellable]);
+		desktopMocks.runAgendaTask.mockResolvedValue({
+			task: { ...runnable, status: "in_progress" },
+		});
+		desktopMocks.cancelAgendaTask.mockResolvedValue({
+			...cancellable,
+			status: "cancelled",
+		});
+
+		await act(async () => {
+			root.render(
+				<SidebarProvider>
+					<AgentSidebar
+						onHome={vi.fn()}
+						onSettingsSectionChange={vi.fn()}
+						sessionHistory={makeSessionHistory([], vi.fn())}
+						setView={vi.fn()}
+						settingsSection="General"
+						view="chat"
+					/>
+				</SidebarProvider>,
+			);
+			await Promise.resolve();
+		});
+		await click(
+			container.querySelector('[aria-label="Show Agenda"]') as Element,
+		);
+
+		await click(
+			container.querySelector('[aria-label="Run Run task"]') as Element,
+		);
+		expect(desktopMocks.runAgendaTask).toHaveBeenCalledWith({
+			taskId: "task-run",
+			expectedRevision: 4,
+		});
+
+		await click(
+			container.querySelector('[aria-label="Cancel Cancel task"]') as Element,
+		);
+		expect(desktopMocks.cancelAgendaTask).toHaveBeenCalledWith({
+			taskId: "task-cancel",
+			expectedRevision: 9,
+		});
+	});
+
+	it("creates a workspace task with the selected priority, expiry, and model", async () => {
+		const created = makeAgendaTask({
+			taskId: "task-created",
+			title: "Investigate the regression",
+		});
+		desktopMocks.createAgendaTask.mockResolvedValue(created);
+		window.localStorage.setItem(
+			"cline.code.model-selection.v1",
+			JSON.stringify({
+				lastProvider: "openrouter",
+				lastModelByProvider: { openrouter: "anthropic/claude-sonnet-4.6" },
+			}),
+		);
+
+		await act(async () => {
+			root.render(
+				<SidebarProvider>
+					<AgentSidebar
+						onHome={vi.fn()}
+						onSettingsSectionChange={vi.fn()}
+						sessionHistory={makeSessionHistory([], vi.fn())}
+						setView={vi.fn()}
+						settingsSection="General"
+						view="chat"
+						workspaceRoot="/projects/current"
+					/>
+				</SidebarProvider>,
+			);
+			await Promise.resolve();
+		});
+
+		expect(container.querySelector('[aria-label="Agenda"]')).toBeNull();
+		await click(
+			container.querySelector('[aria-label="Show Agenda"]') as Element,
+		);
+		await click(
+			container.querySelector('[aria-label="Create Todo item"]') as Element,
+		);
+		const title =
+			document.querySelector<HTMLInputElement>("#agenda-task-title");
+		const instructions = document.querySelector<HTMLTextAreaElement>(
+			"#agenda-task-instructions",
+		);
+		expect(title).not.toBeNull();
+		expect(instructions).not.toBeNull();
+		await changeField(title as HTMLInputElement, "Investigate the regression");
+		await changeField(
+			instructions as HTMLTextAreaElement,
+			"Inspect the failing build and implement a fix.",
+		);
+		await click(buttonWithText("Add to Agenda", document));
+
+		await vi.waitFor(() =>
+			expect(desktopMocks.createAgendaTask).toHaveBeenCalledOnce(),
+		);
+		const input = desktopMocks.createAgendaTask.mock.calls[0]?.[0];
+		expect(input).toMatchObject({
+			type: "todo",
+			title: "Investigate the regression",
+			instructions: "Inspect the failing build and implement a fix.",
+			scope: "workspace",
+			workspaceRoot: "/projects/current",
+			priority: 3,
+			modelSelection: {
+				providerId: "openrouter",
+				modelId: "anthropic/claude-sonnet-4.6",
+			},
+			automationEligible: true,
+		});
+		expect(Date.parse(input.expiresAt)).toBeGreaterThan(Date.now());
+	});
+
 	it("filters scheduled sessions without changing their titles", async () => {
 		const scheduled = {
 			...makeThread("scheduled", 1),
@@ -568,8 +863,10 @@ describe("AgentSidebar session organization", () => {
 		});
 
 		const logo = container.querySelector('[aria-label="Cline home"]');
+		const showAgenda = container.querySelector('[aria-label="Show Agenda"]');
 		const newSession = container.querySelector('[aria-label="New Session"]');
 		expect(logo).not.toBeNull();
+		expect(showAgenda).not.toBeNull();
 		expect(newSession).not.toBeNull();
 		expect(newSession?.textContent).toBe("");
 		await click(newSession as Element);
@@ -683,3 +980,29 @@ describe("AgentSidebar session organization", () => {
 		).toContain("Settings");
 	});
 });
+
+function makeAgendaTask(
+	overrides: Partial<AgendaTaskRecord> = {},
+): AgendaTaskRecord {
+	return {
+		taskId: "task-1",
+		type: "follow-up",
+		status: "pending_approval",
+		title: "Review PR checks",
+		description: "Confirm that CI passed.",
+		instructions: "Review CI and report failures.",
+		scope: "workspace",
+		workspaceRoot: "/projects/cline",
+		resourcePaths: [],
+		priority: 1,
+		availableAt: "2026-08-13T00:00:00.000Z",
+		expiresAt: "2099-08-20T00:00:00.000Z",
+		automationEligible: true,
+		revision: 1,
+		createdBy: { kind: "agent" },
+		updatedBy: { kind: "agent" },
+		createdAt: "2026-08-13T00:00:00.000Z",
+		updatedAt: "2026-08-13T00:00:00.000Z",
+		...overrides,
+	};
+}
diff --git a/apps/examples/desktop-app/webview/components/agent-sidebar.tsx b/apps/examples/desktop-app/webview/components/agent-sidebar.tsx
index 222f7b645e..574ef10e45 100644
--- a/apps/examples/desktop-app/webview/components/agent-sidebar.tsx
+++ b/apps/examples/desktop-app/webview/components/agent-sidebar.tsx
@@ -1,13 +1,22 @@
 "use client";
 
+import type {
+	AgendaTaskPriority,
+	AgendaTaskRecord,
+	AgendaTaskType,
+	HubTaskCreateInput,
+} from "@cline/shared";
+import { isChatWorkspacePath } from "@cline/shared/browser";
 import {
 	Activity,
 	ArrowDownUp,
 	Bot,
+	Check,
 	ChevronDown,
 	ChevronLeft,
 	ChevronRight,
 	CircleUserRound,
+	ClipboardList,
 	Clock3,
 	Code,
 	FileText,
@@ -15,8 +24,10 @@ import {
 	FolderTree,
 	GitFork,
 	Loader2,
+	MessageSquarePlus,
 	PanelLeftOpen,
 	Pencil,
+	Play,
 	Plug,
 	Plus,
 	Radio,
@@ -27,6 +38,8 @@ import {
 	Star,
 	Trash2,
 	Wrench,
+	X,
+	Zap,
 } from "lucide-react";
 import {
 	type ReactNode,
@@ -36,6 +49,7 @@ import {
 	useRef,
 	useState,
 } from "react";
+import { AgendaTaskReviewDialog } from "@/components/agenda-task-review-dialog";
 import { AppUpdateIndicator } from "@/components/app-update-indicator";
 import { ClineLogo } from "@/components/cline-logo";
 import {
@@ -56,6 +70,14 @@ import {
 	ContextMenuItem,
 	ContextMenuTrigger,
 } from "@/components/ui/context-menu";
+import {
+	Dialog,
+	DialogContent,
+	DialogFooter,
+	DialogHeader,
+	DialogTitle,
+	DialogTrigger,
+} from "@/components/ui/dialog";
 import {
 	DropdownMenu,
 	DropdownMenuContent,
@@ -73,6 +95,7 @@ import {
 import { Input } from "@/components/ui/input";
 import { ScrollArea } from "@/components/ui/scroll-area";
 import { useSidebar } from "@/components/ui/sidebar";
+import { Textarea } from "@/components/ui/textarea";
 import { normalizeTitle } from "@/components/utils";
 import {
 	CUSTOMIZATION_SECTIONS,
@@ -80,6 +103,7 @@ import {
 	type SettingsSection,
 } from "@/components/views/settings/sections";
 import { useAccount } from "@/contexts/account-context";
+import { useAgendaAutomation, useAgendaTasks } from "@/hooks/use-agenda-tasks";
 import type {
 	SessionThread,
 	UseSessionHistoryResult,
@@ -91,6 +115,7 @@ import {
 	productNameForVersion,
 } from "@/lib/app-channel";
 import { desktopClient } from "@/lib/desktop-client";
+import { readModelSelectionStorageFromWindow } from "@/lib/model-selection";
 import {
 	ALL_SESSION_SOURCES,
 	filterSessionsBySource,
@@ -110,6 +135,7 @@ type AppView = "chat" | "sessions" | "settings";
 const filterOptions = ["All", "Running", "Schedules", "Favorites"] as const;
 type FilterOption = (typeof filterOptions)[number];
 type SidebarSortMode = "time" | "project";
+type SidebarContent = "sessions" | "agenda";
 type DesktopProcessContext = {
 	appVersion?: unknown;
 	hub?: {
@@ -216,12 +242,14 @@ export function AgentSidebar({
 	onNavigateBack,
 	onNavigateForward,
 	onNewThread,
+	onOpenSessionById,
 	onSettingsSectionChange,
 	setView,
 	settingsSection,
 	view,
 	activeSessionId,
 	sessionHistory,
+	workspaceRoot,
 }: {
 	canNavigateBack?: boolean;
 	canNavigateForward?: boolean;
@@ -229,12 +257,14 @@ export function AgentSidebar({
 	onNavigateBack?: () => void;
 	onNavigateForward?: () => void;
 	onNewThread?: () => void;
+	onOpenSessionById?: (sessionId: string) => void | Promise<void>;
 	onSettingsSectionChange: (section: SettingsSection) => void;
 	setView: (view: AppView) => void;
 	settingsSection: SettingsSection;
 	view: AppView;
 	activeSessionId?: string | null;
 	sessionHistory: UseSessionHistoryResult;
+	workspaceRoot?: string;
 }) {
 	const { isMobile, setOpen, setOpenMobile, state } = useSidebar();
 	const isCollapsed = !isMobile && state === "collapsed";
@@ -265,6 +295,10 @@ export function AgentSidebar({
 	const [filter, setFilter] = useState<FilterOption>("All");
 	const [sourceFilter, setSourceFilter] = useState(ALL_SESSION_SOURCES);
 	const [sortMode, setSortMode] = useState<SidebarSortMode>("time");
+	const [sidebarContent, setSidebarContent] =
+		useState<SidebarContent>("sessions");
+	const [hasNewTodoTasks, setHasNewTodoTasks] = useState(false);
+	const knownAgendaTaskIdsRef = useRef<Set<string> | null>(null);
 	const [searchOpen, setSearchOpen] = useState(false);
 	const [searchQuery, setSearchQuery] = useState("");
 	const [showMoreCount, setShowMoreCount] = useState(
@@ -283,6 +317,38 @@ export function AgentSidebar({
 	>({});
 	const [appVersion, setAppVersion] = useState<string | null>(null);
 	const [hubStatus, setHubStatus] = useState<HubStatus | null>(null);
+	const normalizedWorkspaceRoot = workspaceRoot?.trim() ?? "";
+	const agendaWorkspaceRoot =
+		normalizedWorkspaceRoot && !isChatWorkspacePath(normalizedWorkspaceRoot)
+			? normalizedWorkspaceRoot
+			: undefined;
+	const agenda = useAgendaTasks(
+		{
+			statuses: ["pending_approval", "approved", "in_progress", "failed"],
+			workspaceRoot: agendaWorkspaceRoot,
+			limit: 200,
+		},
+		view !== "settings",
+	);
+	const agendaAutomation = useAgendaAutomation(view !== "settings");
+
+	useEffect(() => {
+		if (view === "settings") {
+			knownAgendaTaskIdsRef.current = null;
+			return;
+		}
+		if (agenda.isLoading) return;
+		const currentTaskIds = new Set(agenda.tasks.map((task) => task.taskId));
+		const knownTaskIds = knownAgendaTaskIdsRef.current;
+		if (
+			knownTaskIds !== null &&
+			sidebarContent !== "agenda" &&
+			agenda.tasks.some((task) => !knownTaskIds.has(task.taskId))
+		) {
+			setHasNewTodoTasks(true);
+		}
+		knownAgendaTaskIdsRef.current = currentTaskIds;
+	}, [agenda.isLoading, agenda.tasks, sidebarContent, view]);
 
 	const loadProcessContext = useCallback(async () => {
 		try {
@@ -354,6 +420,25 @@ export function AgentSidebar({
 	const closeMobileSidebar = useCallback(() => {
 		if (isMobile) setOpenMobile(false);
 	}, [isMobile, setOpenMobile]);
+	const openAgendaSession = useCallback(
+		(task: AgendaTaskRecord) => {
+			if (!task.lastSessionId) return;
+			void onOpenSessionById?.(task.lastSessionId);
+			closeMobileSidebar();
+		},
+		[closeMobileSidebar, onOpenSessionById],
+	);
+	const runAgendaTask = useCallback(
+		async (task: AgendaTaskRecord) => {
+			try {
+				const started = await agenda.runTask(task);
+				if (started.lastSessionId) openAgendaSession(started);
+			} catch {
+				// The queue hook exposes the error inline and refreshes after recovery.
+			}
+		},
+		[agenda.runTask, openAgendaSession],
+	);
 
 	const openThread = useCallback(
 		(threadId: string) => {
@@ -392,6 +477,12 @@ export function AgentSidebar({
 	const navigateForward = useCallback(() => {
 		onNavigateForward?.();
 	}, [onNavigateForward]);
+	const toggleSidebarContent = useCallback(() => {
+		const next = sidebarContent === "agenda" ? "sessions" : "agenda";
+		setSidebarContent(next);
+		if (next === "agenda") setHasNewTodoTasks(false);
+		if (next === "agenda" && view === "settings") setView("chat");
+	}, [setView, sidebarContent, view]);
 
 	const startRenameThread = useCallback((thread: Thread) => {
 		setEditingSessionId(thread.id);
@@ -705,16 +796,43 @@ export function AgentSidebar({
 						{!isCollapsed ? <AppUpdateIndicator /> : null}
 					</div>
 					{!isCollapsed ? (
-						<Button
-							aria-label="New Session"
-							className="size-8 shrink-0 justify-center px-0"
-							onClick={openNewThread}
-							title="New Session"
-							type="button"
-							variant="sidebarItem"
-						>
-							<Plus className="size-4" />
-						</Button>
+						<div className="flex items-center gap-1">
+							<Button
+								aria-label={
+									sidebarContent === "agenda" ? "Show Sessions" : "Show Agenda"
+								}
+								aria-pressed={sidebarContent === "agenda"}
+								className={cn(
+									"relative size-8 shrink-0 justify-center px-0",
+									sidebarContent === "agenda" &&
+										"bg-surface-hover text-sidebar-foreground",
+								)}
+								onClick={toggleSidebarContent}
+								title={
+									sidebarContent === "agenda" ? "Show Sessions" : "Show Agenda"
+								}
+								type="button"
+								variant="sidebarItem"
+							>
+								<ClipboardList className="size-4" />
+								{hasNewTodoTasks ? (
+									<span
+										className="absolute right-1 top-1 size-1.5 rounded-full bg-primary"
+										data-testid="new-todo-indicator"
+									/>
+								) : null}
+							</Button>
+							<Button
+								aria-label="New Session"
+								className="size-8 shrink-0 justify-center px-0"
+								onClick={openNewThread}
+								title="New Session"
+								type="button"
+								variant="sidebarItem"
+							>
+								<MessageSquarePlus className="size-4" />
+							</Button>
+						</div>
 					) : null}
 				</div>
 
@@ -747,6 +865,36 @@ export function AgentSidebar({
 							onSelect={openSettingsSection}
 						/>
 					</div>
+				) : sidebarContent === "agenda" ? (
+					<AgendaSection
+						automatic={
+							agendaAutomation.policy !== null &&
+							agendaAutomation.policy.mode !== "manual"
+						}
+						automationDisabled={
+							agendaAutomation.isLoading || agendaAutomation.isUpdating
+						}
+						error={agenda.error ?? agendaAutomation.error}
+						isLoading={agenda.isLoading}
+						onCreate={agenda.createTask}
+						onApprove={agenda.approveTask}
+						onCancel={(task) => {
+							return agenda.cancelTask(task).catch(() => undefined);
+						}}
+						onOpen={openAgendaSession}
+						onRun={(task) => void runAgendaTask(task)}
+						onToggleAutomation={() => {
+							void agendaAutomation
+								.setAutomatic(
+									agendaAutomation.policy?.mode !== "auto_start" &&
+										agendaAutomation.policy?.mode !== "unattended",
+								)
+								.catch(() => undefined);
+						}}
+						pendingTaskIds={agenda.pendingTaskIds}
+						tasks={agenda.tasks}
+						workspaceRoot={agendaWorkspaceRoot}
+					/>
 				) : (
 					<>
 						<div className="mt-5 shrink-0 pl-4 pr-2">
@@ -1023,6 +1171,421 @@ export function AgentSidebar({
 	);
 }
 
+function AgendaSection({
+	tasks,
+	workspaceRoot,
+	isLoading,
+	error,
+	pendingTaskIds,
+	automatic,
+	automationDisabled,
+	onApprove,
+	onRun,
+	onOpen,
+	onCancel,
+	onToggleAutomation,
+	onCreate,
+}: {
+	tasks: AgendaTaskRecord[];
+	workspaceRoot?: string;
+	isLoading: boolean;
+	error: string | null;
+	pendingTaskIds: ReadonlySet<string>;
+	automatic: boolean;
+	automationDisabled: boolean;
+	onApprove: (task: AgendaTaskRecord) => Promise<AgendaTaskRecord>;
+	onRun: (task: AgendaTaskRecord) => void;
+	onOpen: (task: AgendaTaskRecord) => void;
+	onCancel: (task: AgendaTaskRecord) => void | Promise<void>;
+	onToggleAutomation: () => void;
+	onCreate: (input: HubTaskCreateInput) => Promise<AgendaTaskRecord>;
+}) {
+	const [createOpen, setCreateOpen] = useState(false);
+	const [reviewTask, setReviewTask] = useState<AgendaTaskRecord | null>(null);
+	const [creating, setCreating] = useState(false);
+	const [title, setTitle] = useState("");
+	const [instructions, setInstructions] = useState("");
+	const [type, setType] = useState<AgendaTaskType>("todo");
+	const [priority, setPriority] = useState<AgendaTaskPriority>(3);
+	const [scope, setScope] = useState<"workspace" | "global">(
+		workspaceRoot ? "workspace" : "global",
+	);
+	const [expiresAt, setExpiresAt] = useState(() =>
+		new Date(Date.now() + 7 * 86_400_000).toISOString().slice(0, 16),
+	);
+	const resetCreateForm = () => {
+		setTitle("");
+		setInstructions("");
+		setType("todo");
+		setPriority(3);
+		setScope(workspaceRoot ? "workspace" : "global");
+		setExpiresAt(
+			new Date(Date.now() + 7 * 86_400_000).toISOString().slice(0, 16),
+		);
+	};
+	const submitCreate = async () => {
+		const normalizedTitle = title.trim();
+		const normalizedInstructions = instructions.trim();
+		if (!normalizedTitle || !normalizedInstructions || !expiresAt) return;
+		const expiration = new Date(expiresAt);
+		if (Number.isNaN(expiration.getTime())) return;
+		setCreating(true);
+		try {
+			const rememberedModel = readModelSelectionStorageFromWindow();
+			const providerId = rememberedModel.lastProvider.trim();
+			const modelId = providerId
+				? rememberedModel.lastModelByProvider[providerId]?.trim()
+				: undefined;
+			await onCreate({
+				type,
+				title: normalizedTitle,
+				instructions: normalizedInstructions,
+				scope: scope === "workspace" && workspaceRoot ? "workspace" : "global",
+				workspaceRoot:
+					scope === "workspace" && workspaceRoot ? workspaceRoot : undefined,
+				priority,
+				modelSelection: providerId
+					? { providerId, ...(modelId ? { modelId } : {}) }
+					: undefined,
+				expiresAt: expiration.toISOString(),
+				automationEligible: true,
+			});
+			setCreateOpen(false);
+			resetCreateForm();
+		} catch {
+			// The Agenda hook surfaces the manager's structured error inline.
+		} finally {
+			setCreating(false);
+		}
+	};
+	return (
+		<section
+			aria-label="Agenda"
+			className="mt-4 flex min-h-0 flex-1 flex-col px-2"
+		>
+			<div className="flex h-8 items-center justify-between px-2">
+				<span className="text-sm font-medium text-muted-foreground">Todo</span>
+				<div className="flex items-center">
+					<Button
+						aria-label={
+							automatic ? "Pause Agenda automation" : "Automate Agenda"
+						}
+						aria-pressed={automatic}
+						className={cn(
+							"size-7 p-0 text-muted-foreground",
+							automatic && "text-emerald-500",
+						)}
+						disabled={automationDisabled}
+						onClick={onToggleAutomation}
+						title={
+							automatic
+								? "Auto mode: click to switch to manual"
+								: "Manual mode: click to automate eligible trusted work"
+						}
+						type="button"
+						variant="ghost"
+					>
+						{automationDisabled ? (
+							<Loader2 className="size-3.5 animate-spin" />
+						) : (
+							<Zap className={cn("size-3.5", automatic && "fill-current")} />
+						)}
+					</Button>
+					<Dialog
+						onOpenChange={(open) => {
+							setCreateOpen(open);
+							if (open) setScope(workspaceRoot ? "workspace" : "global");
+						}}
+						open={createOpen}
+					>
+						<DialogTrigger asChild>
+							<Button
+								aria-label="Create Todo item"
+								className="size-7 p-0 text-muted-foreground"
+								title="Create task"
+								type="button"
+								variant="ghost"
+							>
+								<Plus className="size-3.5" />
+							</Button>
+						</DialogTrigger>
+						<DialogContent className="sm:max-w-md">
+							<DialogHeader>
+								<DialogTitle>Create Todo Item</DialogTitle>
+							</DialogHeader>
+							<div className="space-y-3">
+								<label
+									className="block space-y-1 text-xs"
+									htmlFor="agenda-task-title"
+								>
+									<span className="text-muted-foreground">Title</span>
+									<Input
+										autoFocus
+										id="agenda-task-title"
+										onChange={(event) => setTitle(event.target.value)}
+										placeholder="What needs attention?"
+										value={title}
+									/>
+								</label>
+								<label
+									className="block space-y-1 text-xs"
+									htmlFor="agenda-task-instructions"
+								>
+									<span className="text-muted-foreground">Instructions</span>
+									<Textarea
+										id="agenda-task-instructions"
+										onChange={(event) => setInstructions(event.target.value)}
+										placeholder="Describe the outcome and any relevant files."
+										rows={4}
+										value={instructions}
+									/>
+								</label>
+								<div className="grid grid-cols-3 gap-2">
+									<label className="space-y-1 text-xs">
+										<span className="text-muted-foreground">Type</span>
+										<select
+											className="h-9 w-full rounded-md border border-input bg-background px-2"
+											onChange={(event) =>
+												setType(event.target.value as AgendaTaskType)
+											}
+											value={type}
+										>
+											{[
+												"todo",
+												"follow-up",
+												"suggestion",
+												"handoff",
+												"idea",
+												"reminder",
+											].map((value) => (
+												<option key={value} value={value}>
+													{value}
+												</option>
+											))}
+										</select>
+									</label>
+									<label className="space-y-1 text-xs">
+										<span className="text-muted-foreground">Priority</span>
+										<select
+											className="h-9 w-full rounded-md border border-input bg-background px-2"
+											onChange={(event) =>
+												setPriority(
+													Number(event.target.value) as AgendaTaskPriority,
+												)
+											}
+											value={priority}
+										>
+											{[0, 1, 2, 3, 4, 5].map((value) => (
+												<option key={value} value={value}>
+													P{value}
+												</option>
+											))}
+										</select>
+									</label>
+									<label className="space-y-1 text-xs">
+										<span className="text-muted-foreground">Scope</span>
+										<select
+											className="h-9 w-full rounded-md border border-input bg-background px-2"
+											onChange={(event) =>
+												setScope(event.target.value as "workspace" | "global")
+											}
+											value={scope}
+										>
+											{workspaceRoot ? (
+												<option value="workspace">Project</option>
+											) : null}
+											<option value="global">General</option>
+										</select>
+									</label>
+								</div>
+								<label
+									className="block space-y-1 text-xs"
+									htmlFor="agenda-task-expires-at"
+								>
+									<span className="text-muted-foreground">Expires</span>
+									<Input
+										id="agenda-task-expires-at"
+										onChange={(event) => setExpiresAt(event.target.value)}
+										type="datetime-local"
+										value={expiresAt}
+									/>
+								</label>
+							</div>
+							<DialogFooter>
+								<Button
+									disabled={
+										creating ||
+										!title.trim() ||
+										!instructions.trim() ||
+										!expiresAt
+									}
+									onClick={() => void submitCreate()}
+									type="button"
+								>
+									{creating ? (
+										<Loader2 className="size-4 animate-spin" />
+									) : null}
+									Add to Agenda
+								</Button>
+							</DialogFooter>
+						</DialogContent>
+					</Dialog>
+				</div>
+			</div>
+			{/* Radix ScrollArea wraps its children in a display:table element. A long
+			    task title can therefore widen the table beyond the sidebar and push the
+			    action buttons off-screen, so this fixed-width list uses native scrolling. */}
+			<div className="min-h-0 w-full min-w-0 flex-1 overflow-x-hidden overflow-y-auto overscroll-contain">
+				<div className="w-full min-w-0 max-w-full space-y-1">
+					{isLoading && tasks.length === 0 ? (
+						<div className="flex items-center gap-2 px-2 py-2 text-xs text-muted-foreground">
+							<Loader2 className="size-3 animate-spin" />
+							Loading Agenda…
+						</div>
+					) : null}
+					{tasks.map((task) => {
+						const pending = pendingTaskIds.has(task.taskId);
+						const requiresFileReview =
+							task.updatedBy.kind === "system" &&
+							task.updatedBy.id === "file_reconciler" &&
+							task.status === "pending_approval";
+						const canOpen = Boolean(task.lastSessionId);
+						const canRun =
+							task.status === "approved" || task.status === "failed";
+						const taskWorkspaceName =
+							task.scope === "workspace"
+								? workspaceDisplayName(task.workspaceRoot ?? task.cwd ?? "") ||
+									"Workspace"
+								: "General";
+						return (
+							<div
+								className="group flex w-full min-w-0 max-w-full flex-col items-stretch overflow-hidden rounded-md px-2 py-1.5 hover:bg-surface-hover"
+								key={task.taskId}
+								title={
+									requiresFileReview
+										? "File-created or edited tasks always require manual review."
+										: task.description || task.instructions
+								}
+							>
+								<button
+									className="w-full min-w-0 overflow-hidden text-left focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-sidebar-ring"
+									onClick={() => setReviewTask(task)}
+									type="button"
+								>
+									<span className="block truncate text-xs text-sidebar-foreground">
+										{task.title}
+									</span>
+								</button>
+								<div className="flex min-w-0 items-center justify-between">
+									<span className="min-w-0 truncate text-[10px] capitalize text-muted-foreground">
+										{taskWorkspaceName}
+										{task.status !== "pending_approval"
+											? ` · ${task.status.replace("_", " ")}`
+											: ""}
+										{requiresFileReview ? " · file review" : ""}
+									</span>
+									<div className="flex shrink-0 items-center">
+										{pending ? (
+											<Loader2 className="mx-1 size-3 animate-spin text-muted-foreground" />
+										) : task.status === "pending_approval" ? (
+											<AgendaIconButton
+												className="text-emerald-500! hover:text-emerald-400!"
+												icon={<Check className="size-3" />}
+												label={`Approve ${task.title}`}
+												onClick={() => setReviewTask(task)}
+											/>
+										) : canRun ? (
+											<AgendaIconButton
+												icon={<Play className="size-3 fill-current" />}
+												label={`Run ${task.title}`}
+												onClick={() => onRun(task)}
+											/>
+										) : canOpen ? (
+											<AgendaIconButton
+												icon={<ChevronRight className="size-3" />}
+												label={`Open session for ${task.title}`}
+												onClick={() => onOpen(task)}
+											/>
+										) : null}
+										{!pending ? (
+											<AgendaIconButton
+												className="text-destructive! hover:text-destructive!"
+												icon={<X className="size-3" />}
+												label={`Cancel ${task.title}`}
+												onClick={() => onCancel(task)}
+											/>
+										) : null}
+									</div>
+								</div>
+							</div>
+						);
+					})}
+					{!isLoading && tasks.length === 0 && !error ? (
+						<p className="px-2 py-1 text-[11px] text-muted-foreground">
+							Nothing waiting for review.
+						</p>
+					) : null}
+					{error ? (
+						<p
+							className="truncate px-2 py-1 text-[11px] text-destructive"
+							title={error}
+						>
+							{error}
+						</p>
+					) : null}
+				</div>
+			</div>
+			<AgendaTaskReviewDialog
+				onConfirm={async (task) => {
+					try {
+						await onApprove(task);
+						setReviewTask(null);
+					} catch {
+						// The Agenda hook keeps the manager error visible in this section.
+					}
+				}}
+				onOpenChange={(open) => {
+					if (!open) setReviewTask(null);
+				}}
+				onReject={async (task) => {
+					await onCancel(task);
+					setReviewTask(null);
+				}}
+				open={reviewTask !== null}
+				pending={reviewTask ? pendingTaskIds.has(reviewTask.taskId) : false}
+				task={reviewTask}
+			/>
+		</section>
+	);
+}
+
+function AgendaIconButton({
+	className,
+	icon,
+	label,
+	onClick,
+}: {
+	className?: string;
+	icon: ReactNode;
+	label: string;
+	onClick: () => void;
+}) {
+	return (
+		<button
+			aria-label={label}
+			className={cn(
+				"flex size-6 items-center justify-center rounded text-muted-foreground hover:bg-background/70 hover:text-sidebar-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-sidebar-ring",
+				className,
+			)}
+			onClick={onClick}
+			title={label}
+			type="button"
+		>
+			{icon}
+		</button>
+	);
+}
+
 function ProjectSection({
 	label,
 	collapsed,
diff --git a/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.test.tsx b/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.test.tsx
index 8a74478d1f..5f73e00d10 100644
--- a/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.test.tsx
+++ b/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.test.tsx
@@ -1,11 +1,27 @@
 // @vitest-environment jsdom
 
+import type { AgendaTaskRecord } from "@cline/shared";
 import { act } from "react";
 import { createRoot, type Root } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { WorkspaceProvider } from "@/contexts/workspace-context";
 import { WelcomeScreen } from "./welcome-chat";
 
+const listAgendaTasksMock = vi.hoisted(() => vi.fn());
+const approveAgendaTaskMock = vi.hoisted(() => vi.fn());
+const runAgendaTaskMock = vi.hoisted(() => vi.fn());
+
+vi.mock("@/lib/desktop-client", () => ({
+	desktopClient: {
+		listAgendaTasks: listAgendaTasksMock,
+		approveAgendaTask: approveAgendaTaskMock,
+		cancelAgendaTask: vi.fn(),
+		runAgendaTask: runAgendaTaskMock,
+		subscribe: vi.fn(() => () => undefined),
+		subscribeTransportState: vi.fn(() => () => undefined),
+	},
+}));
+
 let container: HTMLDivElement;
 let root: Root;
 
@@ -19,6 +35,10 @@ beforeEach(() => {
 	container = document.createElement("div");
 	document.body.appendChild(container);
 	root = createRoot(container);
+	listAgendaTasksMock.mockReset();
+	listAgendaTasksMock.mockResolvedValue([]);
+	approveAgendaTaskMock.mockReset();
+	runAgendaTaskMock.mockReset();
 });
 
 afterEach(async () => {
@@ -36,6 +56,7 @@ async function renderWelcomeScreen({
 		current: "main",
 		branches: ["main"],
 	})),
+	onOpenSession = vi.fn(),
 }: {
 	workspaceRoot: string;
 	workspaces: string[];
@@ -45,6 +66,7 @@ async function renderWelcomeScreen({
 		current: string;
 		branches: string[];
 	}>;
+	onOpenSession?: (sessionId: string) => void | Promise<void>;
 }): Promise<void> {
 	await act(async () => {
 		root.render(
@@ -65,6 +87,7 @@ async function renderWelcomeScreen({
 					composer={null}
 					gitBranch={gitBranch}
 					onListGitBranches={onListGitBranches}
+					onOpenSession={onOpenSession}
 					onSwitchGitBranch={vi.fn(async () => true)}
 				/>
 			</WorkspaceProvider>,
@@ -73,9 +96,13 @@ async function renderWelcomeScreen({
 	});
 }
 
-async function clickButton(text: string, last = false): Promise<void> {
+async function clickButton(
+	text: string,
+	last = false,
+	rootNode: ParentNode = container,
+): Promise<void> {
 	const buttons = [
-		...container.querySelectorAll<HTMLButtonElement>("button"),
+		...rootNode.querySelectorAll<HTMLButtonElement>("button"),
 	].filter((candidate) => candidate.textContent?.includes(text));
 	const button = last ? buttons.at(-1) : buttons[0];
 	expect(button).toBeDefined();
@@ -86,120 +113,7 @@ async function clickButton(text: string, last = false): Promise<void> {
 }
 
 describe("WelcomeScreen", () => {
-	// Prompt suggestions (quick-action cards, including "Review changes") are
-	// temporarily disabled while we improve them; see welcome-chat.tsx.
-	// Re-enable these tests when the suggestions come back.
-	//
-	// it("starts chat with the selected quick-action prompt", async () => {
-	// 	const onStartChat = vi.fn();
-	// 	await renderWelcomeScreen({
-	// 		onStartChat,
-	// 		workspaceRoot: "/projects/project-1",
-	// 		workspaces: ["/projects/project-1"],
-	// 	});
-	//
-	// 	await clickButton("Check for build errors");
-	//
-	// 	expect(onStartChat).toHaveBeenCalledWith(
-	// 		"Check this project for build errors and help me fix any failures.",
-	// 	);
-	// });
-	//
-	// it("shows code-centric suggestions only inside a git repository", async () => {
-	// 	await renderWelcomeScreen({
-	// 		gitBranch: "main",
-	// 		workspaceRoot: "/projects/project-1",
-	// 		workspaces: ["/projects/project-1"],
-	// 	});
-	//
-	// 	expect(container.textContent).toContain("Review changes");
-	// 	expect(container.textContent).toContain("Check for build errors");
-	// 	expect(container.textContent).not.toContain("Summarize this folder");
-	// });
-	//
-	// it("offers general-purpose suggestions for a plain (non-git) folder", async () => {
-	// 	const onStartChat = vi.fn();
-	// 	await renderWelcomeScreen({
-	// 		gitBranch: "no-git",
-	// 		onStartChat,
-	// 		workspaceRoot: "/home/beatrix/recipes",
-	// 		workspaces: ["/home/beatrix/recipes"],
-	// 	});
-	//
-	// 	// No developer vocabulary for a documents folder.
-	// 	expect(container.textContent).not.toContain("Review changes");
-	// 	expect(container.textContent).not.toContain("build errors");
-	// 	expect(container.textContent).toContain("Summarize this folder");
-	// 	expect(container.textContent).toContain("Organize these files");
-	// 	expect(container.textContent).toContain("Draft a document");
-	//
-	// 	await clickButton("Summarize this folder");
-	// 	expect(onStartChat).toHaveBeenCalledWith(
-	// 		"Look through the files in this folder and give me a plain-language summary of what's here.",
-	// 	);
-	// });
-	//
-	// it("shows no suggestions for a folder while branch discovery is pending", async () => {
-	// 	// Initial load and workspace switches report null until the folder is
-	// 	// classified; guessing a card set here would misclassify git repos.
-	// 	await renderWelcomeScreen({
-	// 		gitBranch: null,
-	// 		workspaceRoot: "/projects/project-1",
-	// 		workspaces: ["/projects/project-1"],
-	// 	});
-	//
-	// 	expect(container.textContent).not.toContain("Review changes");
-	// 	expect(container.textContent).not.toContain("Check for build errors");
-	// 	expect(container.textContent).not.toContain("Summarize this folder");
-	// 	expect(container.textContent).not.toContain("Draft a document");
-	// });
-	//
-	// it("resolves pending branch discovery to the matching card set", async () => {
-	// 	await renderWelcomeScreen({
-	// 		gitBranch: null,
-	// 		workspaceRoot: "/projects/project-1",
-	// 		workspaces: ["/projects/project-1"],
-	// 	});
-	// 	await renderWelcomeScreen({
-	// 		gitBranch: "main",
-	// 		workspaceRoot: "/projects/project-1",
-	// 		workspaces: ["/projects/project-1"],
-	// 	});
-	//
-	// 	expect(container.textContent).toContain("Review changes");
-	// 	expect(container.textContent).toContain("Check for build errors");
-	// 	expect(container.textContent).not.toContain("Summarize this folder");
-	// });
-	//
-	// it("offers folderless suggestions even while branch state is pending", async () => {
-	// 	// Switching to "Just chat" resets branch discovery to pending; the
-	// 	// chat cards never depend on git state, so they show immediately.
-	// 	await renderWelcomeScreen({
-	// 		gitBranch: null,
-	// 		workspaceRoot: "",
-	// 		workspaces: [],
-	// 	});
-	//
-	// 	expect(container.textContent).toContain("Draft a document");
-	// 	expect(container.textContent).toContain("Research a topic");
-	// 	expect(container.textContent).toContain("Plan something");
-	// });
-	//
-	// it("offers folderless suggestions when no workspace is selected", async () => {
-	// 	await renderWelcomeScreen({
-	// 		gitBranch: "no-git",
-	// 		workspaceRoot: "",
-	// 		workspaces: [],
-	// 	});
-	//
-	// 	expect(container.textContent).not.toContain("Review changes");
-	// 	expect(container.textContent).not.toContain("Summarize this folder");
-	// 	expect(container.textContent).toContain("Draft a document");
-	// 	expect(container.textContent).toContain("Research a topic");
-	// 	expect(container.textContent).toContain("Plan something");
-	// });
-
-	it("does not render prompt suggestions while they are disabled", async () => {
+	it("does not render static prompt suggestions", async () => {
 		await renderWelcomeScreen({
 			gitBranch: "main",
 			workspaceRoot: "/projects/project-1",
@@ -212,6 +126,78 @@ describe("WelcomeScreen", () => {
 		expect(container.textContent).not.toContain("Draft a document");
 	});
 
+	it("shows live workspace suggestions and approves them before starting", async () => {
+		const task = agendaTask({ status: "pending_approval" });
+		const approved = { ...task, status: "approved" as const, revision: 2 };
+		const running = {
+			...approved,
+			status: "in_progress" as const,
+			lastSessionId: "task-session-1",
+		};
+		const onOpenSession = vi.fn();
+		listAgendaTasksMock.mockResolvedValue([task]);
+		approveAgendaTaskMock.mockResolvedValue(approved);
+		runAgendaTaskMock.mockResolvedValue({ task: running });
+
+		await renderWelcomeScreen({
+			workspaceRoot: "/projects/project-1",
+			workspaces: ["/projects/project-1"],
+			onOpenSession,
+		});
+		expect(listAgendaTasksMock).toHaveBeenCalledWith(
+			expect.objectContaining({
+				scope: "workspace",
+				workspaceRoot: "/projects/project-1",
+				types: ["suggestion", "reminder", "follow-up"],
+			}),
+		);
+		await clickButton("Review PR checks");
+		expect(approveAgendaTaskMock).not.toHaveBeenCalled();
+		expect(document.body.textContent).toContain(task.instructions);
+		await clickButton("Approve and start", false, document);
+
+		expect(approveAgendaTaskMock).toHaveBeenCalledWith({
+			taskId: "task-1",
+			expectedRevision: 1,
+		});
+		expect(runAgendaTaskMock).toHaveBeenCalledWith({
+			taskId: "task-1",
+			expectedRevision: 2,
+		});
+		expect(onOpenSession).toHaveBeenCalledWith("task-session-1");
+	});
+
+	it("shows workspace follow-up items", async () => {
+		listAgendaTasksMock.mockResolvedValue([
+			agendaTask({
+				type: "follow-up",
+				title: "Finish accessibility review",
+				description: undefined,
+			}),
+		]);
+
+		await renderWelcomeScreen({
+			workspaceRoot: "/projects/project-1",
+			workspaces: ["/projects/project-1"],
+		});
+
+		expect(container.textContent).toContain("Finish accessibility review");
+		expect(container.textContent).toContain("Follow-up · P1");
+	});
+
+	it("hides expired workspace suggestions", async () => {
+		listAgendaTasksMock.mockResolvedValue([
+			agendaTask({ expiresAt: "2020-01-01T00:00:00.000Z" }),
+		]);
+
+		await renderWelcomeScreen({
+			workspaceRoot: "/projects/project-1",
+			workspaces: ["/projects/project-1"],
+		});
+
+		expect(container.textContent).not.toContain("Review PR checks");
+	});
+
 	it("renders every known project in the opened workspace menu", async () => {
 		const workspaces = Array.from(
 			{ length: 6 },
@@ -257,3 +243,29 @@ describe("WelcomeScreen", () => {
 		expect(selectChat).toHaveBeenCalledOnce();
 	});
 });
+
+function agendaTask(
+	overrides: Partial<AgendaTaskRecord> = {},
+): AgendaTaskRecord {
+	return {
+		taskId: "task-1",
+		type: "suggestion",
+		status: "pending_approval",
+		title: "Review PR checks",
+		description: "Check whether CI is green.",
+		instructions: "Review the pull request checks.",
+		scope: "workspace",
+		workspaceRoot: "/projects/project-1",
+		resourcePaths: [],
+		priority: 1,
+		availableAt: "2026-08-13T00:00:00.000Z",
+		expiresAt: "2099-08-20T00:00:00.000Z",
+		automationEligible: true,
+		revision: 1,
+		createdBy: { kind: "agent" },
+		updatedBy: { kind: "agent" },
+		createdAt: "2026-08-13T00:00:00.000Z",
+		updatedAt: "2026-08-13T00:00:00.000Z",
+		...overrides,
+	};
+}
diff --git a/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.tsx b/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.tsx
index ee9560df98..9761593188 100644
--- a/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.tsx
+++ b/apps/examples/desktop-app/webview/components/views/chat/welcome-chat.tsx
@@ -1,123 +1,21 @@
 "use client";
 
-import { AgentAurora, AgentHeroHeading } from "@cline/ui";
+import type { AgendaTaskRecord } from "@cline/shared";
+import {
+	AgentAurora,
+	AgentHeroHeading,
+	type AgentQuickAction,
+	AgentQuickActions,
+} from "@cline/ui";
 import type { ReactNode } from "react";
-import { useEffect } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { AgendaTaskReviewDialog } from "@/components/agenda-task-review-dialog";
 import { useWorkspace } from "@/contexts/workspace-context";
+import { isAgendaTaskExpired, useAgendaTasks } from "@/hooks/use-agenda-tasks";
 import { cn } from "@/lib/utils";
 import { SessionContent } from "./session-content";
 import { WelcomeWorkspaceControls } from "./welcome-workspace-controls";
 
-// Prompt suggestions (including "Review changes") are temporarily disabled
-// while we improve them. To re-enable, uncomment the block below plus the
-// `AgentQuickActions` render in `WelcomeScreen`, restore the commented-out
-// imports (`isChatWorkspacePath`, `AgentQuickAction`, `AgentQuickActions`,
-// `useMemo`) and the `onStartChat`/`quickActions` props, and re-enable the
-// suggestion tests in `welcome-chat.test.tsx`.
-//
-// import { isChatWorkspacePath } from "@cline/shared/browser";
-// import { type AgentQuickAction, AgentQuickActions } from "@cline/ui";
-// import { useMemo } from "react";
-//
-// /** Code-centric starters, shown only when the folder is a git repository. */
-// const DEVELOPER_QUICK_ACTIONS: AgentQuickAction[] = [
-// 	{
-// 		id: "review-changes",
-// 		label: "Review changes",
-// 		description: "Review the current changes and call out anything risky.",
-// 		value: "Review the current changes and call out anything risky.",
-// 	},
-// 	{
-// 		id: "check-build",
-// 		label: "Check for build errors",
-// 		description: "Run the relevant checks and help me fix any failures.",
-// 		value: "Check this project for build errors and help me fix any failures.",
-// 	},
-// ];
-//
-// /**
-//  * General-purpose starters for a plain (non-git) folder — phrased around the
-//  * files the agent can see, with no developer vocabulary.
-//  */
-// const FOLDER_QUICK_ACTIONS: AgentQuickAction[] = [
-// 	{
-// 		id: "summarize-folder",
-// 		label: "Summarize this folder",
-// 		description: "Get a plain-language overview of the files here.",
-// 		value:
-// 			"Look through the files in this folder and give me a plain-language summary of what's here.",
-// 	},
-// 	{
-// 		id: "organize-files",
-// 		label: "Organize these files",
-// 		description: "Tidy up names and structure, with your approval.",
-// 		value:
-// 			"Help me organize this folder: suggest a tidy structure and clearer file names, and check with me before moving anything.",
-// 	},
-// 	{
-// 		id: "draft-document",
-// 		label: "Draft a document",
-// 		description: "Start a new doc with a first draft you can edit.",
-// 		value:
-// 			"Help me draft a new document in this folder. Ask me a few questions about what it should cover, then write a first draft.",
-// 	},
-// ];
-//
-// /** Starters for chat with no folder selected at all. */
-// const CHAT_QUICK_ACTIONS: AgentQuickAction[] = [
-// 	{
-// 		id: "draft-document",
-// 		label: "Draft a document",
-// 		description: "Start a new doc with a first draft you can edit.",
-// 		value:
-// 			"Help me draft a document. Ask me a few questions about what it should cover, then write a first draft.",
-// 	},
-// 	{
-// 		id: "research-topic",
-// 		label: "Research a topic",
-// 		description: "Gather the key facts and sum them up.",
-// 		value:
-// 			"Research a topic for me: ask me what I want to learn about, then summarize the key points in plain language.",
-// 	},
-// 	{
-// 		id: "plan-something",
-// 		label: "Plan something",
-// 		description: "Break a goal into clear, doable steps.",
-// 		value:
-// 			"Help me plan something. Ask me what I'm trying to get done, then break it into clear steps.",
-// 	},
-// ];
-//
-// /**
-//  * Picks starter suggestions that match what the user actually opened: code
-//  * cards only make sense inside a git repo; a plain folder gets file-oriented
-//  * cards; no folder at all gets folderless general-purpose cards.
-//  *
-//  * `gitBranch` is `null` while branch discovery for the selected folder is
-//  * still pending; no cards are suggested until the folder is classified so a
-//  * git repo never flashes the plain-folder set (or vice versa).
-//  */
-// export function defaultQuickActionsForContext({
-// 	workspaceRoot,
-// 	gitBranch,
-// }: {
-// 	workspaceRoot: string;
-// 	gitBranch: string | null;
-// }): AgentQuickAction[] {
-// 	const isChatWorkspace =
-// 		!workspaceRoot.trim() || isChatWorkspacePath(workspaceRoot);
-// 	if (isChatWorkspace) {
-// 		return CHAT_QUICK_ACTIONS;
-// 	}
-// 	if (gitBranch === null) {
-// 		return [];
-// 	}
-// 	if (gitBranch !== "no-git") {
-// 		return DEVELOPER_QUICK_ACTIONS;
-// 	}
-// 	return FOLDER_QUICK_ACTIONS;
-// }
-
 export function WelcomeScreen({
 	active,
 	body,
@@ -126,6 +24,7 @@ export function WelcomeScreen({
 	gitBranch,
 	onListGitBranches,
 	onSwitchGitBranch,
+	onOpenSession,
 }: {
 	active: boolean;
 	body: ReactNode;
@@ -136,6 +35,7 @@ export function WelcomeScreen({
 	gitBranch: string | null;
 	onListGitBranches: () => Promise<{ current: string; branches: string[] }>;
 	onSwitchGitBranch: (branch: string) => Promise<boolean>;
+	onOpenSession?: (sessionId: string) => void | Promise<void>;
 }) {
 	const {
 		workspaceRoot,
@@ -145,12 +45,65 @@ export function WelcomeScreen({
 		pickWorkspaceDirectory,
 		selectChat,
 	} = useWorkspace();
-	// Suggestions are disabled for now; see the note above.
-	// const defaultActions = useMemo(
-	// 	() => defaultQuickActionsForContext({ workspaceRoot, gitBranch }),
-	// 	[workspaceRoot, gitBranch],
-	// );
-	// const actions = quickActions.length > 0 ? quickActions : defaultActions;
+	const agenda = useAgendaTasks(
+		{
+			scope: "workspace",
+			workspaceRoot,
+			types: ["suggestion", "reminder", "follow-up"],
+			statuses: ["pending_approval", "approved", "in_progress", "failed"],
+			limit: 8,
+		},
+		active && workspaceRoot.trim().length > 0,
+	);
+	const [runningTaskId, setRunningTaskId] = useState<string | null>(null);
+	const [reviewTask, setReviewTask] = useState<AgendaTaskRecord | null>(null);
+	const quickActionTasks = useMemo(
+		() => agenda.tasks.filter((task) => !isAgendaTaskExpired(task)).slice(0, 4),
+		[agenda.tasks],
+	);
+	const actions = useMemo<AgentQuickAction[]>(
+		() =>
+			quickActionTasks.map((task) => ({
+				id: task.taskId,
+				label: task.title,
+				description:
+					task.description ||
+					`${task.type === "follow-up" ? "Follow-up" : task.type === "reminder" ? "Reminder" : "Suggestion"} · P${task.priority}`,
+				value: task.instructions,
+			})),
+		[quickActionTasks],
+	);
+
+	const handleTaskAction = useCallback(
+		async (task: AgendaTaskRecord) => {
+			setRunningTaskId(task.taskId);
+			try {
+				if (task.status === "in_progress" && task.lastSessionId) {
+					await onOpenSession?.(task.lastSessionId);
+					return;
+				}
+				let runnable = task;
+				if (runnable.status === "pending_approval") {
+					runnable = await agenda.approveTask(runnable);
+				}
+				if (runnable.status === "in_progress" && runnable.lastSessionId) {
+					await onOpenSession?.(runnable.lastSessionId);
+					return;
+				}
+				if (runnable.status === "approved" || runnable.status === "failed") {
+					const started = await agenda.runTask(runnable);
+					if (started.lastSessionId) {
+						await onOpenSession?.(started.lastSessionId);
+					}
+				}
+			} catch {
+				// useAgendaTasks renders the command failure with the quick actions.
+			} finally {
+				setRunningTaskId(null);
+			}
+		},
+		[agenda.approveTask, agenda.runTask, onOpenSession],
+	);
 
 	useEffect(() => {
 		if (active) void refreshWorkspaces();
@@ -219,14 +172,44 @@ export function WelcomeScreen({
 						{active ? composer : <SessionContent>{composer}</SessionContent>}
 					</div>
 
-					{/* Prompt suggestions are disabled for now; see the note above.
 					{active ? (
-						<AgentQuickActions
-							actions={actions}
-							className="cline-view-enter mt-11"
-							onSelect={(action) => onStartChat(action.value)}
-						/>
-					) : null} */}
+						<>
+							<AgentQuickActions
+								actions={actions}
+								className="cline-view-enter mt-11"
+								disabled={runningTaskId !== null}
+								onSelect={(action) => {
+									const task = quickActionTasks.find(
+										(candidate) => candidate.taskId === action.id,
+									);
+									if (!task) return;
+									if (task.status === "pending_approval") {
+										setReviewTask(task);
+									} else {
+										void handleTaskAction(task);
+									}
+								}}
+							/>
+							<AgendaTaskReviewDialog
+								confirmLabel="Approve and start"
+								onConfirm={async (task) => {
+									await handleTaskAction(task);
+									setReviewTask(null);
+								}}
+								onOpenChange={(open) => {
+									if (!open) setReviewTask(null);
+								}}
+								open={reviewTask !== null}
+								pending={runningTaskId === reviewTask?.taskId}
+								task={reviewTask}
+							/>
+							{agenda.error ? (
+								<p className="mt-2 text-xs text-destructive" role="alert">
+									{agenda.error}
+								</p>
+							) : null}
+						</>
+					) : null}
 				</div>
 			</div>
 		</div>
diff --git a/apps/examples/desktop-app/webview/components/views/settings/routine-view.tsx b/apps/examples/desktop-app/webview/components/views/settings/routine-view.tsx
index 5784e61b54..3af95ac646 100644
--- a/apps/examples/desktop-app/webview/components/views/settings/routine-view.tsx
+++ b/apps/examples/desktop-app/webview/components/views/settings/routine-view.tsx
@@ -93,6 +93,7 @@ interface RoutineSchedule {
 	scheduleId: string;
 	name: string;
 	cronPattern: string;
+	timezone?: string;
 	metadata?: Record<string, unknown>;
 	prompt: string;
 	provider?: string;
@@ -375,9 +376,11 @@ function formatScheduleTrigger(schedule: RoutineSchedule): string {
 		return `Once · ${formatDateTime(getOneTimeScheduleRunAt(schedule))}`;
 	}
 	const parsed = parseCronPattern(schedule.cronPattern);
-	return parsed.scheduleType === "daily"
-		? `Daily · ${formatScheduleTime(parsed.scheduleHour, parsed.scheduleMinute)}`
-		: `${formatScheduleDays(parsed.scheduleDays)} · ${formatScheduleTime(parsed.scheduleHour, parsed.scheduleMinute)}`;
+	const label =
+		parsed.scheduleType === "daily"
+			? `Daily · ${formatScheduleTime(parsed.scheduleHour, parsed.scheduleMinute)}`
+			: `${formatScheduleDays(parsed.scheduleDays)} · ${formatScheduleTime(parsed.scheduleHour, parsed.scheduleMinute)}`;
+	return schedule.timezone ? `${label} · ${schedule.timezone}` : label;
 }
 
 function getOneTimeScheduleRunAt(
diff --git a/apps/examples/desktop-app/webview/hooks/use-agenda-tasks.test.ts b/apps/examples/desktop-app/webview/hooks/use-agenda-tasks.test.ts
new file mode 100644
index 0000000000..2b6c7bc72e
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/use-agenda-tasks.test.ts
@@ -0,0 +1,59 @@
+import type { AgendaTaskRecord } from "@cline/shared";
+import { describe, expect, it } from "vitest";
+import { isAgendaTaskExpired, sortAgendaTasks } from "./use-agenda-tasks";
+
+describe("Agenda task presentation", () => {
+	it("groups actionable status before ordering by priority", () => {
+		const tasks = [
+			task({ taskId: "approved-p0", status: "approved", priority: 0 }),
+			task({ taskId: "pending-p3", status: "pending_approval", priority: 3 }),
+			task({ taskId: "running-p5", status: "in_progress", priority: 5 }),
+			task({ taskId: "pending-p1", status: "pending_approval", priority: 1 }),
+		];
+
+		expect(sortAgendaTasks(tasks).map((item) => item.taskId)).toEqual([
+			"running-p5",
+			"pending-p1",
+			"pending-p3",
+			"approved-p0",
+		]);
+	});
+
+	it("treats both an expired status and a past deadline as expired", () => {
+		const now = Date.parse("2026-08-13T12:00:00.000Z");
+		expect(
+			isAgendaTaskExpired(
+				task({ status: "expired", expiresAt: "2099-01-01T00:00:00.000Z" }),
+				now,
+			),
+		).toBe(true);
+		expect(
+			isAgendaTaskExpired(task({ expiresAt: "2026-08-13T11:59:59.000Z" }), now),
+		).toBe(true);
+		expect(
+			isAgendaTaskExpired(task({ expiresAt: "2026-08-13T12:00:01.000Z" }), now),
+		).toBe(false);
+	});
+});
+
+function task(overrides: Partial<AgendaTaskRecord> = {}): AgendaTaskRecord {
+	return {
+		taskId: "task-1",
+		type: "todo",
+		status: "pending_approval",
+		title: "Task",
+		instructions: "Do the task.",
+		scope: "global",
+		resourcePaths: [],
+		priority: 3,
+		availableAt: "2026-08-13T00:00:00.000Z",
+		expiresAt: "2099-08-20T00:00:00.000Z",
+		automationEligible: true,
+		revision: 1,
+		createdBy: { kind: "user" },
+		updatedBy: { kind: "user" },
+		createdAt: "2026-08-13T00:00:00.000Z",
+		updatedAt: "2026-08-13T00:00:00.000Z",
+		...overrides,
+	};
+}
diff --git a/apps/examples/desktop-app/webview/hooks/use-agenda-tasks.ts b/apps/examples/desktop-app/webview/hooks/use-agenda-tasks.ts
new file mode 100644
index 0000000000..1c7713b2b4
--- /dev/null
+++ b/apps/examples/desktop-app/webview/hooks/use-agenda-tasks.ts
@@ -0,0 +1,344 @@
+"use client";
+
+import type {
+	AgendaAutomationPolicy,
+	AgendaTaskListInput,
+	AgendaTaskRecord,
+	AgendaTaskStatus,
+	HubTaskCreateInput,
+} from "@cline/shared";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { desktopClient } from "@/lib/desktop-client";
+
+const TASK_EVENTS = [
+	"task.created",
+	"task.updated",
+	"task.deleted",
+	"task.run.started",
+	"task.run.completed",
+	"task.run.failed",
+	"task.automation.updated",
+] as const;
+
+const STATUS_ORDER: Record<AgendaTaskStatus, number> = {
+	in_progress: 0,
+	pending_approval: 1,
+	approved: 2,
+	failed: 3,
+	completed: 4,
+	expired: 5,
+	cancelled: 6,
+};
+
+export function sortAgendaTasks(tasks: AgendaTaskRecord[]): AgendaTaskRecord[] {
+	return [...tasks].sort((left, right) => {
+		const statusDifference =
+			STATUS_ORDER[left.status] - STATUS_ORDER[right.status];
+		if (statusDifference !== 0) return statusDifference;
+		const priorityDifference = left.priority - right.priority;
+		if (priorityDifference !== 0) return priorityDifference;
+		const availabilityDifference =
+			Date.parse(left.availableAt) - Date.parse(right.availableAt);
+		if (
+			Number.isFinite(availabilityDifference) &&
+			availabilityDifference !== 0
+		) {
+			return availabilityDifference;
+		}
+		return Date.parse(left.createdAt) - Date.parse(right.createdAt);
+	});
+}
+
+export function isAgendaTaskExpired(
+	task: AgendaTaskRecord,
+	now = Date.now(),
+): boolean {
+	const expiresAt = Date.parse(task.expiresAt);
+	return (
+		task.status === "expired" ||
+		(Number.isFinite(expiresAt) && expiresAt <= now)
+	);
+}
+
+export type UseAgendaTasksResult = {
+	tasks: AgendaTaskRecord[];
+	isLoading: boolean;
+	error: string | null;
+	pendingTaskIds: ReadonlySet<string>;
+	refresh: () => Promise<void>;
+	createTask: (input: HubTaskCreateInput) => Promise<AgendaTaskRecord>;
+	approveTask: (task: AgendaTaskRecord) => Promise<AgendaTaskRecord>;
+	cancelTask: (task: AgendaTaskRecord) => Promise<AgendaTaskRecord>;
+	runTask: (task: AgendaTaskRecord) => Promise<AgendaTaskRecord>;
+};
+
+export type UseAgendaAutomationResult = {
+	policy: AgendaAutomationPolicy | null;
+	isLoading: boolean;
+	isUpdating: boolean;
+	error: string | null;
+	setAutomatic: (automatic: boolean) => Promise<AgendaAutomationPolicy>;
+};
+
+const DEFAULT_AUTOMATION_POLICY: Omit<AgendaAutomationPolicy, "updatedAt"> = {
+	scopeKey: "global",
+	mode: "manual",
+	applyToAgentCreated: true,
+	maxConcurrentRuns: 1,
+	maxChainDepth: 3,
+	maxStartsPerHour: 20,
+};
+
+function editableAutomationPolicy(
+	policy: AgendaAutomationPolicy,
+): Omit<AgendaAutomationPolicy, "updatedAt"> {
+	return {
+		scopeKey: policy.scopeKey,
+		mode: policy.mode,
+		applyToAgentCreated: policy.applyToAgentCreated,
+		maxConcurrentRuns: policy.maxConcurrentRuns,
+		maxChainDepth: policy.maxChainDepth,
+		maxStartsPerHour: policy.maxStartsPerHour,
+		enabledBy: policy.enabledBy,
+		enabledAt: policy.enabledAt,
+	};
+}
+
+export function useAgendaAutomation(enabled = true): UseAgendaAutomationResult {
+	const [policy, setPolicy] = useState<AgendaAutomationPolicy | null>(null);
+	const [isLoading, setIsLoading] = useState(enabled);
+	const [isUpdating, setIsUpdating] = useState(false);
+	const [error, setError] = useState<string | null>(null);
+
+	const refresh = useCallback(async () => {
+		if (!enabled) {
+			setIsLoading(false);
+			return;
+		}
+		setIsLoading(true);
+		try {
+			setPolicy(await desktopClient.getAgendaAutomationPolicy());
+			setError(null);
+		} catch (cause) {
+			setError(
+				cause instanceof Error
+					? cause.message
+					: "Unable to load Agenda automation.",
+			);
+		} finally {
+			setIsLoading(false);
+		}
+	}, [enabled]);
+
+	useEffect(() => {
+		void refresh();
+		if (!enabled) return;
+		const unsubscribeEvent = desktopClient.subscribe(
+			"task.automation.updated",
+			() => void refresh(),
+		);
+		const unsubscribeTransport = desktopClient.subscribeTransportState(
+			(state) => {
+				if (state === "connected") void refresh();
+			},
+		);
+		return () => {
+			unsubscribeEvent();
+			unsubscribeTransport();
+		};
+	}, [enabled, refresh]);
+
+	const setAutomatic = useCallback(
+		async (automatic: boolean) => {
+			setIsUpdating(true);
+			setError(null);
+			try {
+				const current = policy
+					? editableAutomationPolicy(policy)
+					: DEFAULT_AUTOMATION_POLICY;
+				const next = await desktopClient.setAgendaAutomationPolicy({
+					policy: {
+						...current,
+						mode: automatic ? "auto_start" : "manual",
+					},
+				});
+				setPolicy(next);
+				return next;
+			} catch (cause) {
+				setError(
+					cause instanceof Error
+						? cause.message
+						: "Unable to update Agenda automation.",
+				);
+				throw cause;
+			} finally {
+				setIsUpdating(false);
+			}
+		},
+		[policy],
+	);
+
+	return { policy, isLoading, isUpdating, error, setAutomatic };
+}
+
+/**
+ * Live task queue state backed by Hub commands. Task events are invalidation
+ * signals rather than an event-sourced cache, so every mutation/event re-lists
+ * the current projection and reconnects cannot leave stale Agenda state.
+ */
+export function useAgendaTasks(
+	filters: AgendaTaskListInput = {},
+	enabled = true,
+): UseAgendaTasksResult {
+	const filtersKey = JSON.stringify(filters);
+	const parsedFilters = useMemo(
+		() => JSON.parse(filtersKey) as AgendaTaskListInput,
+		[filtersKey],
+	);
+	const [tasks, setTasks] = useState<AgendaTaskRecord[]>([]);
+	const [isLoading, setIsLoading] = useState(enabled);
+	const [error, setError] = useState<string | null>(null);
+	const [pendingTaskIds, setPendingTaskIds] = useState<Set<string>>(
+		() => new Set(),
+	);
+	const requestSequence = useRef(0);
+
+	const refresh = useCallback(async () => {
+		if (!enabled) {
+			setTasks([]);
+			setIsLoading(false);
+			setError(null);
+			return;
+		}
+		const requestId = ++requestSequence.current;
+		setIsLoading(true);
+		try {
+			const nextTasks = await desktopClient.listAgendaTasks(parsedFilters);
+			if (requestId !== requestSequence.current) return;
+			setTasks(sortAgendaTasks(nextTasks));
+			setError(null);
+		} catch (cause) {
+			if (requestId !== requestSequence.current) return;
+			setError(
+				cause instanceof Error ? cause.message : "Unable to load the Agenda.",
+			);
+		} finally {
+			if (requestId === requestSequence.current) setIsLoading(false);
+		}
+	}, [enabled, parsedFilters]);
+
+	useEffect(() => {
+		void refresh();
+		if (!enabled) return;
+
+		const invalidate = () => void refresh();
+		const unsubscribeEvents = TASK_EVENTS.map((eventName) =>
+			desktopClient.subscribe(eventName, invalidate),
+		);
+		const unsubscribeTransport = desktopClient.subscribeTransportState(
+			(state) => {
+				if (state === "connected") void refresh();
+			},
+		);
+		return () => {
+			requestSequence.current += 1;
+			for (const unsubscribe of unsubscribeEvents) unsubscribe();
+			unsubscribeTransport();
+		};
+	}, [enabled, refresh]);
+
+	const mutateTask = useCallback(
+		async (
+			task: AgendaTaskRecord,
+			operation: (task: AgendaTaskRecord) => Promise<AgendaTaskRecord>,
+		) => {
+			setPendingTaskIds((current) => new Set(current).add(task.taskId));
+			setError(null);
+			try {
+				const next = await operation(task);
+				setTasks((current) =>
+					sortAgendaTasks(
+						current.map((item) => (item.taskId === next.taskId ? next : item)),
+					),
+				);
+				void refresh();
+				return next;
+			} catch (cause) {
+				const message =
+					cause instanceof Error ? cause.message : "Unable to update the task.";
+				setError(message);
+				throw cause;
+			} finally {
+				setPendingTaskIds((current) => {
+					const next = new Set(current);
+					next.delete(task.taskId);
+					return next;
+				});
+			}
+		},
+		[refresh],
+	);
+	const createTask = useCallback(
+		async (input: HubTaskCreateInput) => {
+			setError(null);
+			try {
+				const created = await desktopClient.createAgendaTask(input);
+				setTasks((current) => sortAgendaTasks([created, ...current]));
+				void refresh();
+				return created;
+			} catch (cause) {
+				const message =
+					cause instanceof Error ? cause.message : "Unable to create the task.";
+				setError(message);
+				throw cause;
+			}
+		},
+		[refresh],
+	);
+
+	const approveTask = useCallback(
+		(task: AgendaTaskRecord) =>
+			mutateTask(task, (current) =>
+				desktopClient.approveAgendaTask({
+					taskId: current.taskId,
+					expectedRevision: current.revision,
+				}),
+			),
+		[mutateTask],
+	);
+	const cancelTask = useCallback(
+		(task: AgendaTaskRecord) =>
+			mutateTask(task, (current) =>
+				desktopClient.cancelAgendaTask({
+					taskId: current.taskId,
+					expectedRevision: current.revision,
+				}),
+			),
+		[mutateTask],
+	);
+	const runTask = useCallback(
+		(task: AgendaTaskRecord) =>
+			mutateTask(task, async (current) => {
+				const result = await desktopClient.runAgendaTask({
+					taskId: current.taskId,
+					expectedRevision: current.revision,
+				});
+				return result.run?.sessionId && !result.task.lastSessionId
+					? { ...result.task, lastSessionId: result.run.sessionId }
+					: result.task;
+			}),
+		[mutateTask],
+	);
+
+	return {
+		tasks,
+		isLoading,
+		error,
+		pendingTaskIds,
+		refresh,
+		createTask,
+		approveTask,
+		cancelTask,
+		runTask,
+	};
+}
diff --git a/apps/examples/desktop-app/webview/lib/desktop-client.test.ts b/apps/examples/desktop-app/webview/lib/desktop-client.test.ts
index 15e67b197c..56f072c39e 100644
--- a/apps/examples/desktop-app/webview/lib/desktop-client.test.ts
+++ b/apps/examples/desktop-app/webview/lib/desktop-client.test.ts
@@ -6,6 +6,7 @@ import { writeDesktopDebugLog } from "./desktop-client";
 type SentDesktopRequest = {
 	id: string;
 	command: string;
+	args?: Record<string, unknown>;
 };
 
 class FakeWebSocket {
@@ -107,6 +108,50 @@ afterEach(() => {
 });
 
 describe("DesktopClient command deadlines", () => {
+	it("sends the displayed revision for Agenda approval, cancellation, and run", async () => {
+		const { desktopClient } = await import("./desktop-client");
+		const approval = desktopClient.approveAgendaTask({
+			taskId: "task-7",
+			expectedRevision: 7,
+		});
+		const socket = await connectLatestSocket();
+		expect(socket.lastRequest()).toMatchObject({
+			command: "task.approve",
+			args: { taskId: "task-7", expectedRevision: 7 },
+		});
+		socket.respond({ task: {} });
+		await approval;
+
+		const cancellation = desktopClient.cancelAgendaTask({
+			taskId: "task-7",
+			expectedRevision: 7,
+			reason: "Superseded",
+		});
+		await vi.waitFor(() => expect(socket.sent).toHaveLength(2));
+		expect(socket.lastRequest()).toMatchObject({
+			command: "task.cancel",
+			args: {
+				taskId: "task-7",
+				expectedRevision: 7,
+				reason: "Superseded",
+			},
+		});
+		socket.respond({ task: {} });
+		await cancellation;
+
+		const run = desktopClient.runAgendaTask({
+			taskId: "task-7",
+			expectedRevision: 7,
+		});
+		await vi.waitFor(() => expect(socket.sent).toHaveLength(3));
+		expect(socket.lastRequest()).toMatchObject({
+			command: "task.run",
+			args: { taskId: "task-7", expectedRevision: 7 },
+		});
+		socket.respond({ task: {} });
+		await run;
+	});
+
 	it("reports the same error object only once across local and global handlers", async () => {
 		const { desktopClient } = await import("./desktop-client");
 		const error = new Error("native command failed");
diff --git a/apps/examples/desktop-app/webview/lib/desktop-client.ts b/apps/examples/desktop-app/webview/lib/desktop-client.ts
index e6bac66340..92e07f823d 100644
--- a/apps/examples/desktop-app/webview/lib/desktop-client.ts
+++ b/apps/examples/desktop-app/webview/lib/desktop-client.ts
@@ -1,7 +1,15 @@
 "use client";
 
 import type {
+	AgendaAutomationPolicy,
+	AgendaTaskListInput,
+	AgendaTaskRecord,
+	AgendaTaskRunRecord,
 	DesktopDebugLogPayload,
+	HubTaskCreateInput,
+	HubTaskUpdateInput,
+} from "@cline/shared";
+import type {
 	DesktopTransportEvent,
 	DesktopTransportMessage,
 	DesktopTransportRequest,
@@ -102,6 +110,22 @@ export type DesktopInvokeOptions = {
 	timeoutMs?: number | null;
 };
 
+export type AgendaTaskIdInput = {
+	taskId: string;
+};
+
+export type AgendaTaskRevisionInput = AgendaTaskIdInput & {
+	expectedRevision: number;
+};
+
+export type AgendaTaskCancelInput = AgendaTaskRevisionInput & {
+	reason?: string;
+};
+
+export type AgendaAutomationSetInput = {
+	policy: Omit<AgendaAutomationPolicy, "updatedAt">;
+};
+
 export type DesktopErrorReport = {
 	operation: string;
 	error: unknown;
@@ -591,6 +615,89 @@ class DesktopClient {
 	getTransportError(): string | null {
 		return this.transportError;
 	}
+
+	async createAgendaTask(input: HubTaskCreateInput): Promise<AgendaTaskRecord> {
+		const response = await this.invoke<{ task: AgendaTaskRecord }>(
+			"task.create",
+			{ ...input },
+		);
+		return response.task;
+	}
+
+	async listAgendaTasks(
+		input: AgendaTaskListInput = {},
+	): Promise<AgendaTaskRecord[]> {
+		const response = await this.invoke<{ tasks: AgendaTaskRecord[] }>(
+			"task.list",
+			{ ...input },
+		);
+		return response.tasks ?? [];
+	}
+
+	async getAgendaTask(taskId: string): Promise<AgendaTaskRecord | undefined> {
+		const response = await this.invoke<{ task?: AgendaTaskRecord }>(
+			"task.get",
+			{
+				taskId,
+			},
+		);
+		return response.task;
+	}
+
+	async updateAgendaTask(input: HubTaskUpdateInput): Promise<AgendaTaskRecord> {
+		const response = await this.invoke<{ task: AgendaTaskRecord }>(
+			"task.update",
+			{ ...input },
+		);
+		return response.task;
+	}
+
+	async approveAgendaTask(
+		input: AgendaTaskRevisionInput,
+	): Promise<AgendaTaskRecord> {
+		const response = await this.invoke<{ task: AgendaTaskRecord }>(
+			"task.approve",
+			{ ...input },
+		);
+		return response.task;
+	}
+
+	async cancelAgendaTask(
+		input: AgendaTaskCancelInput,
+	): Promise<AgendaTaskRecord> {
+		const response = await this.invoke<{ task: AgendaTaskRecord }>(
+			"task.cancel",
+			{ ...input },
+		);
+		return response.task;
+	}
+
+	async runAgendaTask(input: AgendaTaskRevisionInput): Promise<{
+		task: AgendaTaskRecord;
+		run?: AgendaTaskRunRecord;
+	}> {
+		return await this.invoke<{
+			task: AgendaTaskRecord;
+			run?: AgendaTaskRunRecord;
+		}>("task.run", { ...input });
+	}
+
+	async getAgendaAutomationPolicy(): Promise<AgendaAutomationPolicy> {
+		const response = await this.invoke<{ policy: AgendaAutomationPolicy }>(
+			"task.automation.get",
+		);
+		return response.policy;
+	}
+
+	async setAgendaAutomationPolicy(
+		input: AgendaAutomationSetInput,
+	): Promise<AgendaAutomationPolicy> {
+		const response = await this.invoke<{ policy: AgendaAutomationPolicy }>(
+			"task.automation.set",
+			{ ...input },
+		);
+		return response.policy;
+	}
 }
 
 export const desktopClient = new DesktopClient();
diff --git a/sdk/ARCHITECTURE.md b/sdk/ARCHITECTURE.md
index 9758b5e5b4..0d4c000da5 100644
--- a/sdk/ARCHITECTURE.md
+++ b/sdk/ARCHITECTURE.md
@@ -533,6 +533,119 @@ Lower layers should not depend on optional feature packages.
 
 For remote config, that means shared owns the reusable bundle/materialization/blob primitives and core owns only the session-oriented wrapper exported to apps.
 
+## Hub-Owned Agenda Task Queue
+
+Agenda tasks are durable proposals for future work. They are intentionally
+separate from cron specs, queued prompts inside an existing session, and the
+agent-team task board. Shared, browser-safe contracts use `AgendaTaskRecord`
+and `AgendaTaskRunRecord`; orchestration and persistence remain in
+`@cline/core`.
+
+### Authority and persistence
+
+- A Hub process owns one Agenda task manager. Its
+  `AgendaTaskManagerApi` boundary is the only place allowed to change task
+  lifecycle, approval, run, or session-link state. Hub commands, file import,
+  and the agent tool all route mutations through that boundary.
+- User-editable intent is represented as Markdown with YAML frontmatter in
+  `~/.cline/tasks/*.task.md` for global tasks and
+  `<workspace>/.cline/tasks/*.task.md` for workspace tasks. Operational fields
+  such as status, revision, approval, and session IDs are not writable in a
+  spec. `AgendaTaskSpecFileStore` confines paths to the selected task directory
+  and writes specs atomically.
+- `SqliteAgendaTaskStore` owns `tasks.db` (resolved by
+  `resolveTasksDbPath()`). SQLite is the operational source of truth for task
+  status, revisions, run attempts, session links, and the automation policy;
+  the Markdown file is the canonical editable task description, not an
+  append-only queue or a substitute for concurrency control.
+- Task-file parsing and reconciliation must feed the manager instead of
+  writing SQLite directly. This preserves one validation and audit boundary
+  whether a change came from an editor, desktop client, SDK client, or agent.
+- Manager startup scans global task specs, recovers persisted task/run state,
+  and reattaches every known workspace whose directory still exists. Missing
+  historical workspaces are preserved in SQLite without recreating project
+  directories. Selecting/listing a workspace registers it so even its first
+  hand-authored task file is discovered and watched. Filesystem changes are
+  reconciled back through the same manager rather than applied from watcher
+  callbacks.
+- Raw-file creation and edits are attributed to `system:file_reconciler` and
+  always leave changed intent awaiting manual task approval. File edits never
+  reopen completed, cancelled, or expired tasks; terminal records remain
+  terminal and retain their last-known-good operational state.
+
+### Approval and session execution
+
+- Every new task starts at `pending_approval`. Approval is bound to the exact
+  task `revision` through `approvedRevision`; an execution-relevant edit
+  increments the revision and revokes stale approval. An approved revision is
+  therefore immutable at the point it is claimed for execution.
+- Approval and execution synchronously reconcile the backing Markdown file to
+  close the watcher debounce window. Both fail closed if that canonical spec
+  is missing, malformed, or does not semantically match the SQLite revision;
+  stale last-known-good intent is never approved or executed.
+- Hub `task.create` and `task.update` payloads omit actor fields; the command
+  service derives the user actor from the calling Hub client. Update,
+  approval, cancellation, and run requests carry the caller's displayed
+  `expectedRevision`; specifically, `task.approve`, `task.cancel`, and
+  `task.run` reject a missing or stale revision.
+- P0 is the most urgent priority and P5 is the least urgent. `expiresAt` is a
+  required latest-start boundary: expiry prevents a new run but does not abort
+  a session that already started.
+- Starting a task creates an `AgendaTaskRunRecord` and a normal Hub session.
+  The run owns the task/revision/session association, while the task keeps
+  `currentRunId`, `lastRunId`, and `lastSessionId` projections for UI lookup.
+  A global task remains globally scoped and resolves the Hub's shared chat
+  workspace only when its session starts.
+- The manager correlates Hub session completion, failure, and cancellation
+  with the linked run and updates both run and task. Startup recovery follows
+  the same boundary rather than manufacturing a second run. A completed task
+  does not own or delete its session; the linked session remains normal
+  session history that a user can reopen.
+
+### Hub, agent, and desktop surfaces
+
+- The Hub command family is `task.create`, `task.list`, `task.get`,
+  `task.update`, `task.approve`, `task.cancel`, `task.run`,
+  `task.automation.get`, and `task.automation.set`. Registered task events are
+  `task.created`, `task.updated`, `task.deleted`, `task.run.started`,
+  `task.run.completed`, `task.run.failed`, and `task.automation.updated`.
+  Events are invalidation and lifecycle signals; clients re-read the current
+  task or policy projection rather than rebuilding authority state from the
+  event stream.
+- Hub-hosted agent sessions receive one snake-case `tasks` tool with a required
+  `kind` discriminator. `kind: "todo"` creates, updates, lists, and gets durable
+  Agenda items within the current session's workspace (or the global scope for
+  chat sessions). It cannot approve, cancel, or start a Todo, so an agent cannot
+  self-authorize or terminate queue work.
+- `kind: "scheduled"` routes to `HubScheduleService` and manages the same
+  records shown by the desktop Routine view; the unified tool does not merge
+  the two persistence or lifecycle domains. Scheduled operations inherit the
+  current session workspace, cwd, and model, filter reads and mutations to that
+  workspace, and allow mutations only from an interactive session. One-time
+  schedules accept an exact future ISO timestamp; recurring schedules accept a
+  five-field cron expression and optional IANA timezone.
+- The Hub contributes one tool-conditional system-prompt rule for `tasks`. It
+  distinguishes reviewed Todo work from autonomous scheduled execution, states
+  that Todo `available_at` is not a timer, requires clarification for ambiguous
+  “remind me” requests, and prevents creating both record kinds unless the user
+  explicitly requests both.
+- `AgendaAutomationPolicy` is user-owned Hub state. `manual` preserves the
+  per-task review gate; `auto_start` and `unattended` are explicit opt-ins. The
+  manager's automation pump enforces the policy's concurrency, chain-depth,
+  and hourly-start guardrails. `auto_start` waits for a connected client with
+  the tool-approval capability and starts an interactive task session that
+  conservatively requires approval for each tool. Explicit `unattended` mode
+  may run headlessly and auto-approves enabled tools.
+- Automation never infers user consent from a raw task-file change. For
+  manager-backed intent, `applyToAgentCreated` governs tasks originally
+  created by an agent and tasks whose latest manager-backed edit came from an
+  agent; disabling it leaves those revisions pending manual approval.
+- Cline Code projects the same Hub state into an Agenda section in the desktop
+  sidebar and workspace-filtered `suggestion`/`reminder` quick actions below
+  the welcome composer. The sidebar supports review, start, cancellation,
+  linked-session navigation, and the automation toggle; it does not maintain a
+  second task store.
+
 ## File-Based And Event-Driven Automation (`ClineCore` / `CronService`)
 
 `@cline/core` ships a file-based automation subsystem under
diff --git a/sdk/packages/core/src/cron/service/index.ts b/sdk/packages/core/src/cron/service/index.ts
index df0a0f1b64..cb5568362b 100644
--- a/sdk/packages/core/src/cron/service/index.ts
+++ b/sdk/packages/core/src/cron/service/index.ts
@@ -1,3 +1,4 @@
 export * from "./cron-service";
 export * from "./schedule-command-service";
 export * from "./schedule-service";
+export * from "./schedule-tool";
diff --git a/sdk/packages/core/src/cron/service/schedule-command-service.ts b/sdk/packages/core/src/cron/service/schedule-command-service.ts
index 161c48c823..590f4dee2e 100644
--- a/sdk/packages/core/src/cron/service/schedule-command-service.ts
+++ b/sdk/packages/core/src/cron/service/schedule-command-service.ts
@@ -1,3 +1,4 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import type {
 	HubCommandEnvelope,
 	HubReplyEnvelope,
@@ -5,8 +6,31 @@ import type {
 	HubScheduleUpdateInput,
 } from "@cline/shared";
 import { createSessionId, readHubScheduleMode } from "@cline/shared";
+import type { HubConnectionAuthority } from "../../hub/server/command-transport";
 import type { HubScheduleService } from "./schedule-service";
 
+interface ScheduleCommandScope {
+	workspaceRoot: string;
+	cwd: string;
+}
+
+function scopedCwd(
+	scope: ScheduleCommandScope,
+	value: unknown,
+): string | undefined {
+	if (typeof value !== "string" || !value.trim()) return undefined;
+	const cwd = resolve(scope.workspaceRoot, value);
+	if (!pathWithin(scope.workspaceRoot, cwd)) {
+		throw new Error("schedule cwd is outside the client workspace scope");
+	}
+	return cwd;
+}
+
+function pathWithin(workspaceRoot: string, candidate: string): boolean {
+	const path = relative(workspaceRoot, candidate);
+	return path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+
 function okReply(
 	envelope: HubCommandEnvelope,
 	payload?: Record<string, unknown>,
@@ -37,13 +61,15 @@ export class HubScheduleCommandService {
 
 	public async handleCommand(
 		envelope: HubCommandEnvelope,
+		authority?: HubConnectionAuthority,
 	): Promise<HubReplyEnvelope> {
 		try {
+			const scope = this.resolveScope(authority);
 			switch (envelope.command) {
 				case "schedule.create":
 					return okReply(envelope, {
 						schedule: this.schedules.createSchedule(
-							this.toCreateInput(envelope.payload ?? {}),
+							this.toCreateInput(envelope.payload ?? {}, scope),
 						),
 					});
 				case "schedule.list":
@@ -60,37 +86,36 @@ export class HubScheduleCommandService {
 							tags: Array.isArray(envelope.payload?.tags)
 								? (envelope.payload?.tags as string[])
 								: undefined,
+							workspaceRoot: scope.workspaceRoot,
 						}),
 					});
 				case "schedule.get":
 					return okReply(envelope, {
-						schedule: this.schedules.getSchedule(
-							String(envelope.payload?.scheduleId ?? ""),
-						),
+						schedule: this.requireScopedSchedule(envelope, scope),
 					});
 				case "schedule.update":
 					return okReply(envelope, {
 						schedule: this.schedules.updateSchedule(
-							String(envelope.payload?.scheduleId ?? ""),
-							this.toUpdateInput(envelope.payload ?? {}),
+							this.requireScopedSchedule(envelope, scope).scheduleId,
+							this.toUpdateInput(envelope.payload ?? {}, scope),
 						),
 					});
 				case "schedule.delete":
 					return okReply(envelope, {
 						deleted: this.schedules.deleteSchedule(
-							String(envelope.payload?.scheduleId ?? ""),
+							this.requireScopedSchedule(envelope, scope).scheduleId,
 						),
 					});
 				case "schedule.enable":
 					return okReply(envelope, {
 						schedule: this.schedules.resumeSchedule(
-							String(envelope.payload?.scheduleId ?? ""),
+							this.requireScopedSchedule(envelope, scope).scheduleId,
 						),
 					});
 				case "schedule.disable":
 					return okReply(envelope, {
 						schedule: this.schedules.pauseSchedule(
-							String(envelope.payload?.scheduleId ?? ""),
+							this.requireScopedSchedule(envelope, scope).scheduleId,
 						),
 					});
 				case "schedule.trigger":
@@ -98,47 +123,42 @@ export class HubScheduleCommandService {
 						execution:
 							envelope.payload?.wait === false
 								? this.schedules.triggerScheduleNowDetached(
-										String(envelope.payload?.scheduleId ?? ""),
+										this.requireScopedSchedule(envelope, scope).scheduleId,
 									)
 								: await this.schedules.triggerScheduleNow(
-										String(envelope.payload?.scheduleId ?? ""),
+										this.requireScopedSchedule(envelope, scope).scheduleId,
 									),
 					});
 				case "schedule.list_executions":
 					return okReply(envelope, {
-						executions: this.schedules.listScheduleExecutions({
-							scheduleId:
-								typeof envelope.payload?.scheduleId === "string"
-									? envelope.payload.scheduleId
-									: undefined,
-							status:
-								typeof envelope.payload?.status === "string"
-									? (envelope.payload.status as never)
-									: undefined,
-							limit:
-								typeof envelope.payload?.limit === "number"
-									? envelope.payload.limit
-									: undefined,
-						}),
+						executions: this.listScopedExecutions(envelope, scope),
 					});
 				case "schedule.stats":
 					return okReply(envelope, {
 						stats: this.schedules.getScheduleStats(
-							String(envelope.payload?.scheduleId ?? ""),
+							this.requireScopedSchedule(envelope, scope).scheduleId,
 						),
 					});
-				case "schedule.active":
+				case "schedule.active": {
+					const scheduleIds = this.scopedScheduleIds(scope);
 					return okReply(envelope, {
-						executions: this.schedules.getActiveExecutions(),
+						executions: this.schedules
+							.getActiveExecutions()
+							.filter((execution) => scheduleIds.has(execution.scheduleId)),
 					});
-				case "schedule.upcoming":
+				}
+				case "schedule.upcoming": {
+					const scheduleIds = this.scopedScheduleIds(scope);
 					return okReply(envelope, {
-						runs: this.schedules.getUpcomingRuns(
-							typeof envelope.payload?.limit === "number"
-								? envelope.payload.limit
-								: undefined,
-						),
+						runs: this.schedules
+							.getUpcomingRuns(
+								typeof envelope.payload?.limit === "number"
+									? envelope.payload.limit
+									: undefined,
+							)
+							.filter((run) => scheduleIds.has(run.scheduleId)),
 					});
+				}
 				default:
 					return errorReply(
 						envelope,
@@ -155,8 +175,75 @@ export class HubScheduleCommandService {
 		}
 	}
 
+	private resolveScope(
+		authority: HubConnectionAuthority | undefined,
+	): ScheduleCommandScope {
+		const context = authority?.workspaceContext;
+		if (!authority?.clientId || !context?.workspaceRoot?.trim()) {
+			throw new Error(
+				"schedule commands require a registered workspace client",
+			);
+		}
+		const workspaceRoot = resolve(context.workspaceRoot);
+		const cwd = resolve(context.cwd?.trim() || workspaceRoot);
+		if (!pathWithin(workspaceRoot, cwd)) {
+			throw new Error("client cwd is outside its workspace scope");
+		}
+		return { workspaceRoot, cwd };
+	}
+
+	private requireScopedSchedule(
+		envelope: HubCommandEnvelope,
+		scope: ScheduleCommandScope,
+	) {
+		const scheduleId = String(envelope.payload?.scheduleId ?? "").trim();
+		const schedule = scheduleId
+			? this.schedules.getSchedule(scheduleId)
+			: undefined;
+		if (!schedule || resolve(schedule.workspaceRoot) !== scope.workspaceRoot) {
+			throw new Error("schedule does not exist in this workspace");
+		}
+		return schedule;
+	}
+
+	private scopedScheduleIds(scope: ScheduleCommandScope): Set<string> {
+		return new Set(
+			this.schedules
+				.listSchedules({ workspaceRoot: scope.workspaceRoot })
+				.map((schedule) => schedule.scheduleId),
+		);
+	}
+
+	private listScopedExecutions(
+		envelope: HubCommandEnvelope,
+		scope: ScheduleCommandScope,
+	) {
+		const requestedScheduleId =
+			typeof envelope.payload?.scheduleId === "string"
+				? envelope.payload.scheduleId.trim()
+				: undefined;
+		if (requestedScheduleId) {
+			this.requireScopedSchedule(envelope, scope);
+		}
+		const scheduleIds = this.scopedScheduleIds(scope);
+		return this.schedules
+			.listScheduleExecutions({
+				scheduleId: requestedScheduleId,
+				status:
+					typeof envelope.payload?.status === "string"
+						? (envelope.payload.status as never)
+						: undefined,
+				limit:
+					typeof envelope.payload?.limit === "number"
+						? envelope.payload.limit
+						: undefined,
+			})
+			.filter((execution) => scheduleIds.has(execution.scheduleId));
+	}
+
 	private toCreateInput(
 		payload: Record<string, unknown>,
+		scope: ScheduleCommandScope,
 	): HubScheduleCreateInput {
 		const mode = readHubScheduleMode(payload, "yolo");
 		const modelSelection =
@@ -174,11 +261,14 @@ export class HubScheduleCommandService {
 			...(payload as unknown as HubScheduleCreateInput),
 			modelSelection,
 			mode,
+			workspaceRoot: scope.workspaceRoot,
+			cwd: scopedCwd(scope, payload.cwd) ?? scope.cwd,
 		};
 	}
 
 	private toUpdateInput(
 		payload: Record<string, unknown>,
+		scope: ScheduleCommandScope,
 	): HubScheduleUpdateInput {
 		const mode = readHubScheduleMode(payload);
 		const modelSelection =
@@ -197,6 +287,15 @@ export class HubScheduleCommandService {
 			...(payload as unknown as HubScheduleUpdateInput),
 			modelSelection,
 			...(mode === undefined ? {} : { mode }),
+			workspaceRoot: scope.workspaceRoot,
+			...(Object.hasOwn(payload, "cwd")
+				? {
+						cwd:
+							payload.cwd === null
+								? scope.workspaceRoot
+								: (scopedCwd(scope, payload.cwd) ?? scope.cwd),
+					}
+				: {}),
 		};
 	}
 }
diff --git a/sdk/packages/core/src/cron/service/schedule-service.test.ts b/sdk/packages/core/src/cron/service/schedule-service.test.ts
index af51525e02..87f5040296 100644
--- a/sdk/packages/core/src/cron/service/schedule-service.test.ts
+++ b/sdk/packages/core/src/cron/service/schedule-service.test.ts
@@ -1,7 +1,7 @@
 import { mkdtemp, rm } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import {
 	type CronScheduleSpec,
 	ONE_TIME_SCHEDULE_CRON_PATTERN,
@@ -261,6 +261,65 @@ describe("HubScheduleService", () => {
 		},
 	);
 
+	sqliteIt("persists and validates recurring schedule timezones", async () => {
+		const dbPath = await createTempDbPath();
+		cleanupPaths.push(dbPath);
+		const service = new HubScheduleService({
+			dbPath,
+			specs: { cronSpecsDir: join(dirname(dbPath), "cron") },
+			runtimeHandlers: {
+				startSession: vi.fn(async () => ({ sessionId: "unused" })),
+				sendSession: vi.fn(async () => ({ result: { text: "unused" } })),
+				abortSession: vi.fn(async () => ({ applied: true })),
+				stopSession: vi.fn(async () => ({ applied: true })),
+			},
+		});
+		try {
+			const created = service.createSchedule({
+				name: "Pacific morning",
+				cronPattern: "0 9 * * 1-5",
+				timezone: "America/Los_Angeles",
+				prompt: "Review open pull requests.",
+				workspaceRoot: "/workspace",
+			});
+			expect(created.timezone).toBe("America/Los_Angeles");
+			service.createSchedule({
+				name: "Other workspace",
+				cronPattern: "0 9 * * *",
+				prompt: "Do other work.",
+				workspaceRoot: "/other-workspace",
+			});
+			expect(service.listSchedules({ workspaceRoot: "/workspace" })).toEqual([
+				expect.objectContaining({ scheduleId: created.scheduleId }),
+			]);
+
+			const updated = service.updateSchedule(created.scheduleId, {
+				scheduleId: created.scheduleId,
+				timezone: "UTC",
+			});
+			expect(updated?.timezone).toBe("UTC");
+			expect(updated?.nextRunAt).not.toBe(created.nextRunAt);
+
+			const cleared = service.updateSchedule(created.scheduleId, {
+				scheduleId: created.scheduleId,
+				timezone: null,
+			});
+			expect(cleared?.timezone).toBeUndefined();
+
+			expect(() =>
+				service.createSchedule({
+					name: "Invalid timezone",
+					cronPattern: "0 9 * * *",
+					timezone: "Not/A_Timezone",
+					prompt: "Do work.",
+					workspaceRoot: "/workspace",
+				}),
+			).toThrow();
+		} finally {
+			await service.dispose();
+		}
+	});
+
 	sqliteIt(
 		"handles schedule commands through the hub command adapter",
 		async () => {
@@ -278,21 +337,29 @@ describe("HubScheduleService", () => {
 			});
 			try {
 				const commands = new HubScheduleCommandService(service);
+				const workspaceAuthority = {
+					clientId: "workspace-client",
+					workspaceContext: { workspaceRoot: "/workspace", cwd: "/workspace" },
+				};
 
-				const createdReply = await commands.handleCommand({
-					version: "v1",
-					command: "schedule.create",
-					payload: {
-						name: "Command routine",
-						cronPattern: "15 * * * *",
-						prompt: "Run from command",
-						workspaceRoot: "/workspace",
-						modelSelection: {
-							providerId: "openai",
-							modelId: "gpt-5.3-codex",
+				const createdReply = await commands.handleCommand(
+					{
+						version: "v1",
+						command: "schedule.create",
+						clientId: "workspace-client",
+						payload: {
+							name: "Command routine",
+							cronPattern: "15 * * * *",
+							prompt: "Run from command",
+							workspaceRoot: "/workspace",
+							modelSelection: {
+								providerId: "openai",
+								modelId: "gpt-5.3-codex",
+							},
 						},
 					},
-				});
+					workspaceAuthority,
+				);
 				expect(createdReply.ok).toBe(true);
 				const created = createdReply.payload?.schedule as {
 					scheduleId: string;
@@ -300,32 +367,47 @@ describe("HubScheduleService", () => {
 				};
 				expect(created.mode).toBe("yolo");
 
-				const planReply = await commands.handleCommand({
-					version: "v1",
-					command: "schedule.update",
-					payload: { scheduleId: created.scheduleId, mode: "plan" },
-				});
+				const planReply = await commands.handleCommand(
+					{
+						version: "v1",
+						command: "schedule.update",
+						clientId: "workspace-client",
+						payload: { scheduleId: created.scheduleId, mode: "plan" },
+					},
+					workspaceAuthority,
+				);
 				expect(planReply.ok).toBe(true);
 				expect((planReply.payload?.schedule as { mode: string }).mode).toBe(
 					"plan",
 				);
 
-				const omittedModeReply = await commands.handleCommand({
-					version: "v1",
-					command: "schedule.update",
-					payload: { scheduleId: created.scheduleId, name: "Renamed routine" },
-				});
+				const omittedModeReply = await commands.handleCommand(
+					{
+						version: "v1",
+						command: "schedule.update",
+						clientId: "workspace-client",
+						payload: {
+							scheduleId: created.scheduleId,
+							name: "Renamed routine",
+						},
+					},
+					workspaceAuthority,
+				);
 				expect(omittedModeReply.ok).toBe(true);
 				expect(
 					(omittedModeReply.payload?.schedule as { mode: string }).mode,
 				).toBe("plan");
 
 				for (const invalidMode of [null, "", "invalid"]) {
-					const invalidUpdateReply = await commands.handleCommand({
-						version: "v1",
-						command: "schedule.update",
-						payload: { scheduleId: created.scheduleId, mode: invalidMode },
-					});
+					const invalidUpdateReply = await commands.handleCommand(
+						{
+							version: "v1",
+							command: "schedule.update",
+							clientId: "workspace-client",
+							payload: { scheduleId: created.scheduleId, mode: invalidMode },
+						},
+						workspaceAuthority,
+					);
 					expect(invalidUpdateReply).toMatchObject({
 						ok: false,
 						error: {
@@ -335,17 +417,21 @@ describe("HubScheduleService", () => {
 					});
 				}
 
-				const invalidCreateReply = await commands.handleCommand({
-					version: "v1",
-					command: "schedule.create",
-					payload: {
-						name: "Invalid routine",
-						cronPattern: "30 * * * *",
-						prompt: "Do not create",
-						workspaceRoot: "/workspace",
-						mode: "invalid",
+				const invalidCreateReply = await commands.handleCommand(
+					{
+						version: "v1",
+						command: "schedule.create",
+						clientId: "workspace-client",
+						payload: {
+							name: "Invalid routine",
+							cronPattern: "30 * * * *",
+							prompt: "Do not create",
+							workspaceRoot: "/workspace",
+							mode: "invalid",
+						},
 					},
-				});
+					workspaceAuthority,
+				);
 				expect(invalidCreateReply).toMatchObject({
 					ok: false,
 					error: {
@@ -354,11 +440,15 @@ describe("HubScheduleService", () => {
 					},
 				});
 
-				const listReply = await commands.handleCommand({
-					version: "v1",
-					command: "schedule.list",
-					payload: { limit: 10 },
-				});
+				const listReply = await commands.handleCommand(
+					{
+						version: "v1",
+						command: "schedule.list",
+						clientId: "workspace-client",
+						payload: { limit: 10 },
+					},
+					workspaceAuthority,
+				);
 				expect(listReply.ok).toBe(true);
 				const listedSchedule = (
 					listReply.payload?.schedules as Array<{
@@ -367,6 +457,44 @@ describe("HubScheduleService", () => {
 					}>
 				).find((item) => item.scheduleId === created.scheduleId);
 				expect(listedSchedule).toMatchObject({ mode: "plan" });
+
+				const foreignGet = await commands.handleCommand(
+					{
+						version: "v1",
+						command: "schedule.get",
+						clientId: "other-client",
+						payload: { scheduleId: created.scheduleId },
+					},
+					{
+						clientId: "other-client",
+						workspaceContext: { workspaceRoot: "/other-workspace" },
+					},
+				);
+				expect(foreignGet).toMatchObject({
+					ok: false,
+					error: {
+						code: "schedule_command_failed",
+						message: "schedule does not exist in this workspace",
+					},
+				});
+
+				const spoofedCreate = await commands.handleCommand(
+					{
+						version: "v1",
+						command: "schedule.create",
+						clientId: "workspace-client",
+						payload: {
+							name: "Scoped routine",
+							cronPattern: "30 * * * *",
+							prompt: "Stay in scope",
+							workspaceRoot: "/other-workspace",
+						},
+					},
+					workspaceAuthority,
+				);
+				expect(spoofedCreate.payload?.schedule).toMatchObject({
+					workspaceRoot: resolve("/workspace"),
+				});
 			} finally {
 				await service.dispose();
 			}
diff --git a/sdk/packages/core/src/cron/service/schedule-service.ts b/sdk/packages/core/src/cron/service/schedule-service.ts
index ded8f747b4..f0a17635fa 100644
--- a/sdk/packages/core/src/cron/service/schedule-service.ts
+++ b/sdk/packages/core/src/cron/service/schedule-service.ts
@@ -14,7 +14,7 @@ import {
 import type { ResolveCronSpecsDirOptions } from "@cline/shared/storage";
 import { CronMaterializer } from "../runner/cron-materializer";
 import { CronRunner } from "../runner/cron-runner";
-import { validateCronPattern } from "../schedule/scheduler";
+import { validateCronPattern, validateTimezone } from "../schedule/scheduler";
 import {
 	type CronRunRecord,
 	type CronSpecRecord,
@@ -92,6 +92,7 @@ export interface ListSchedulesOptions {
 	enabled?: boolean;
 	limit?: number;
 	tags?: string[];
+	workspaceRoot?: string;
 }
 
 export interface ListScheduleExecutionsOptions {
@@ -132,6 +133,7 @@ function specToSchedule(spec: CronSpecRecord): ScheduleRecord {
 			spec.triggerKind === "one_off"
 				? ONE_TIME_SCHEDULE_CRON_PATTERN
 				: (spec.scheduleExpr ?? ""),
+		timezone: spec.triggerKind === "schedule" ? spec.timezone : undefined,
 		prompt: spec.prompt ?? "",
 		workspaceRoot: spec.workspaceRoot ?? "",
 		cwd:
@@ -249,7 +251,12 @@ export class HubScheduleService {
 	}
 
 	public createSchedule(input: HubScheduleCreateInput): ScheduleRecord {
-		this.validateScheduleTiming(input.cronPattern, input.metadata, true);
+		this.validateScheduleTiming(
+			input.cronPattern,
+			input.timezone,
+			input.metadata,
+			true,
+		);
 		if (!input.workspaceRoot?.trim()) {
 			throw new Error("workspaceRoot is required for schedules");
 		}
@@ -279,8 +286,21 @@ export class HubScheduleService {
 				: current.workspaceRoot;
 		const nextEnabled = updates.enabled ?? current.enabled;
 		const currentSchedule = specToSchedule(current);
+		const nextCronPattern = updates.cronPattern ?? currentSchedule.cronPattern;
+		if (
+			nextCronPattern.trim() === ONE_TIME_SCHEDULE_CRON_PATTERN &&
+			typeof updates.timezone === "string" &&
+			updates.timezone.trim()
+		) {
+			throw new Error("timezone is only supported for recurring schedules");
+		}
 		this.validateScheduleTiming(
-			updates.cronPattern ?? currentSchedule.cronPattern,
+			nextCronPattern,
+			nextCronPattern.trim() === ONE_TIME_SCHEDULE_CRON_PATTERN
+				? undefined
+				: updates.timezone === null
+					? undefined
+					: (updates.timezone ?? currentSchedule.timezone),
 			updates.metadata ?? currentSchedule.metadata,
 			nextEnabled,
 		);
@@ -296,13 +316,18 @@ export class HubScheduleService {
 
 	private validateScheduleTiming(
 		cronPattern: string,
+		timezone: string | undefined,
 		metadata: HubScheduleCreateInput["metadata"],
 		requireFutureRunAt: boolean,
 	): void {
 		if (cronPattern.trim() !== ONE_TIME_SCHEDULE_CRON_PATTERN) {
 			validateCronPattern(cronPattern);
+			validateTimezone(timezone);
 			return;
 		}
+		if (timezone?.trim()) {
+			throw new Error("timezone is only supported for recurring schedules");
+		}
 		const runAt = metadata?.[ONE_TIME_SCHEDULE_RUN_AT_METADATA_KEY];
 		if (
 			typeof runAt !== "number" ||
diff --git a/sdk/packages/core/src/cron/service/schedule-tool.test.ts b/sdk/packages/core/src/cron/service/schedule-tool.test.ts
new file mode 100644
index 0000000000..d10ffd5f2f
--- /dev/null
+++ b/sdk/packages/core/src/cron/service/schedule-tool.test.ts
@@ -0,0 +1,310 @@
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type {
+	HubScheduleCreateInput,
+	HubScheduleUpdateInput,
+	ScheduleRecord,
+} from "@cline/shared";
+import {
+	ONE_TIME_SCHEDULE_CRON_PATTERN,
+	ONE_TIME_SCHEDULE_RUN_AT_METADATA_KEY,
+} from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import {
+	type AgentScheduleServiceApi,
+	executeScheduleOperation,
+	type ScheduledTaskInput,
+	type ScheduleTaskOperationOptions,
+} from "./schedule-tool";
+
+const WORKSPACE_ROOT = process.cwd();
+const OTHER_WORKSPACE_ROOT = tmpdir();
+
+function schedule(overrides: Partial<ScheduleRecord> = {}): ScheduleRecord {
+	return {
+		scheduleId: "sched_1",
+		name: "Morning review",
+		cronPattern: "0 9 * * 1-5",
+		timezone: "America/Los_Angeles",
+		prompt: "Review open pull requests.",
+		workspaceRoot: WORKSPACE_ROOT,
+		cwd: WORKSPACE_ROOT,
+		modelSelection: { providerId: "cline", modelId: "model-1" },
+		enabled: true,
+		mode: "yolo",
+		maxParallel: 1,
+		createdAt: Date.now(),
+		updatedAt: Date.now(),
+		...overrides,
+	};
+}
+
+function serviceMock(): AgentScheduleServiceApi {
+	return {
+		createSchedule: vi.fn((input: HubScheduleCreateInput) =>
+			schedule({
+				name: input.name,
+				cronPattern: input.cronPattern,
+				timezone: input.timezone,
+				prompt: input.prompt,
+				workspaceRoot: input.workspaceRoot,
+				cwd: input.cwd,
+				modelSelection: input.modelSelection,
+				createdBy: input.createdBy,
+				metadata: input.metadata,
+			}),
+		),
+		getSchedule: vi.fn(() => schedule()),
+		listSchedules: vi.fn(() => []),
+		updateSchedule: vi.fn(
+			(_scheduleId: string, updates: HubScheduleUpdateInput) =>
+				schedule({
+					cronPattern: updates.cronPattern ?? "0 9 * * 1-5",
+					timezone:
+						updates.timezone === null
+							? undefined
+							: (updates.timezone ?? "America/Los_Angeles"),
+					metadata: updates.metadata,
+				}),
+		),
+		deleteSchedule: vi.fn(() => true),
+		pauseSchedule: vi.fn(() => schedule({ enabled: false })),
+		resumeSchedule: vi.fn(() => schedule({ enabled: true })),
+		triggerScheduleNowDetached: vi.fn(() => ({
+			executionId: "exec_1",
+			scheduleId: "sched_1",
+			triggeredAt: Date.now(),
+			status: "pending" as const,
+		})),
+	};
+}
+
+const context = {
+	sessionId: "session_1",
+	agentId: "agent_1",
+	iteration: 1,
+};
+
+function scheduleOperations(options: ScheduleTaskOperationOptions) {
+	return {
+		execute: (input: ScheduledTaskInput, toolContext = context) =>
+			executeScheduleOperation(options, input, toolContext),
+	};
+}
+
+describe("schedule agent tool", () => {
+	it("creates a one-time schedule using current session defaults", async () => {
+		const schedules = serviceMock();
+		const publish = vi.fn();
+		const capture = vi.fn();
+		const tool = scheduleOperations({
+			schedules,
+			publish,
+			telemetry: { capture } as never,
+			resolveSessionDefaults: async () => ({
+				workspaceRoot: WORKSPACE_ROOT,
+				cwd: WORKSPACE_ROOT,
+				modelSelection: { providerId: "cline", modelId: "model-current" },
+				interactive: true,
+			}),
+		});
+
+		const result = await tool.execute(
+			{
+				operation: "create",
+				schedule_type: "once",
+				name: "Check CI",
+				prompt: "Check CI for PR #42 and summarize any failures.",
+				run_at: "2035-01-02T17:30:00-08:00",
+			},
+			context,
+		);
+
+		expect(result).toMatchObject({ ok: true, operation: "create" });
+		expect(capture).toHaveBeenCalledWith({
+			event: "task.tool_used",
+			properties: expect.objectContaining({
+				tool: "tasks.scheduled.create",
+				success: true,
+			}),
+		});
+		expect(schedules.createSchedule).toHaveBeenCalledWith(
+			expect.objectContaining({
+				name: "Check CI",
+				cronPattern: ONE_TIME_SCHEDULE_CRON_PATTERN,
+				workspaceRoot: WORKSPACE_ROOT,
+				cwd: WORKSPACE_ROOT,
+				modelSelection: {
+					providerId: "cline",
+					modelId: "model-current",
+				},
+				createdBy: "agent:agent_1",
+				metadata: {
+					[ONE_TIME_SCHEDULE_RUN_AT_METADATA_KEY]: Date.parse(
+						"2035-01-02T17:30:00-08:00",
+					),
+				},
+			}),
+		);
+		expect(publish).toHaveBeenCalledWith(
+			"schedule.created",
+			{ schedule: expect.objectContaining({ name: "Check CI" }) },
+			"session_1",
+		);
+	});
+
+	it("creates timezone-aware recurring schedules and filters list results", async () => {
+		const schedules = serviceMock();
+		vi.mocked(schedules.listSchedules).mockReturnValue([
+			schedule({ scheduleId: "mine", workspaceRoot: WORKSPACE_ROOT }),
+			schedule({
+				scheduleId: "other",
+				workspaceRoot: OTHER_WORKSPACE_ROOT,
+			}),
+		]);
+		const tool = scheduleOperations({
+			schedules,
+			resolveSessionDefaults: async () => ({
+				workspaceRoot: WORKSPACE_ROOT,
+				interactive: true,
+			}),
+		});
+
+		await tool.execute(
+			{
+				operation: "create",
+				schedule_type: "recurring",
+				name: "Weekday review",
+				prompt: "Review open pull requests.",
+				cron_pattern: "0 9 * * 1-5",
+				timezone: "America/Los_Angeles",
+			},
+			context,
+		);
+		expect(schedules.createSchedule).toHaveBeenCalledWith(
+			expect.objectContaining({
+				cronPattern: "0 9 * * 1-5",
+				timezone: "America/Los_Angeles",
+			}),
+		);
+
+		await expect(
+			tool.execute({ operation: "list" }, context),
+		).resolves.toMatchObject({
+			ok: true,
+			schedules: [expect.objectContaining({ scheduleId: "mine" })],
+		});
+		expect(schedules.listSchedules).toHaveBeenCalledWith(
+			expect.objectContaining({ workspaceRoot: WORKSPACE_ROOT, limit: 50 }),
+		);
+	});
+
+	it("blocks cross-workspace and unattended mutations", async () => {
+		const schedules = serviceMock();
+		vi.mocked(schedules.getSchedule)
+			.mockReturnValueOnce(schedule({ workspaceRoot: OTHER_WORKSPACE_ROOT }))
+			.mockReturnValueOnce(
+				schedule({ workspaceRoot: WORKSPACE_ROOT, cwd: OTHER_WORKSPACE_ROOT }),
+			);
+		const interactiveTool = scheduleOperations({
+			schedules,
+			resolveSessionDefaults: async () => ({
+				workspaceRoot: WORKSPACE_ROOT,
+				interactive: true,
+			}),
+		});
+		expect(
+			await interactiveTool.execute(
+				{ operation: "pause", schedule_id: "outside" },
+				context,
+			),
+		).toMatchObject({
+			ok: false,
+			error: { code: "schedule_operation_failed" },
+		});
+		expect(schedules.pauseSchedule).not.toHaveBeenCalled();
+		expect(
+			await interactiveTool.execute(
+				{ operation: "run_now", schedule_id: "outside-cwd" },
+				context,
+			),
+		).toMatchObject({
+			ok: false,
+			error: { code: "schedule_operation_failed" },
+		});
+		expect(schedules.triggerScheduleNowDetached).not.toHaveBeenCalled();
+
+		const unattendedTool = scheduleOperations({
+			schedules,
+			resolveSessionDefaults: async () => ({
+				workspaceRoot: WORKSPACE_ROOT,
+				interactive: false,
+			}),
+		});
+		expect(
+			await unattendedTool.execute(
+				{
+					operation: "create",
+					schedule_type: "recurring",
+					name: "Recursive schedule",
+					prompt: "Do more work.",
+					cron_pattern: "0 * * * *",
+				},
+				context,
+			),
+		).toMatchObject({
+			ok: false,
+			error: {
+				message: "schedule mutations require an interactive user session",
+			},
+		});
+		expect(schedules.createSchedule).not.toHaveBeenCalled();
+	});
+
+	it("rejects a symlink and parent-segment workspace escape", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-schedule-scope-"));
+		try {
+			const sessionWorkspace = join(root, "workspace");
+			const outside = join(root, "outside");
+			const outsideNested = join(outside, "nested");
+			mkdirSync(sessionWorkspace);
+			mkdirSync(outside);
+			mkdirSync(outsideNested);
+			mkdirSync(join(outside, "workspace"));
+			const link = join(root, "link");
+			symlinkSync(
+				outsideNested,
+				link,
+				process.platform === "win32" ? "junction" : "dir",
+			);
+			// Lexical normalization maps this to sessionWorkspace, while native
+			// filesystem traversal follows link before applying the parent segment.
+			const escapingWorkspace = `${link}/../workspace`;
+			const schedules = serviceMock();
+			vi.mocked(schedules.getSchedule).mockReturnValueOnce(
+				schedule({ workspaceRoot: escapingWorkspace }),
+			);
+			const tool = scheduleOperations({
+				schedules,
+				resolveSessionDefaults: async () => ({
+					workspaceRoot: sessionWorkspace,
+					interactive: true,
+				}),
+			});
+
+			expect(
+				await tool.execute(
+					{ operation: "run_now", schedule_id: "escaping" },
+					context,
+				),
+			).toMatchObject({
+				ok: false,
+				error: { code: "schedule_operation_failed" },
+			});
+			expect(schedules.triggerScheduleNowDetached).not.toHaveBeenCalled();
+		} finally {
+			rmSync(root, { recursive: true, force: true });
+		}
+	});
+});
diff --git a/sdk/packages/core/src/cron/service/schedule-tool.ts b/sdk/packages/core/src/cron/service/schedule-tool.ts
new file mode 100644
index 0000000000..1ad58d5026
--- /dev/null
+++ b/sdk/packages/core/src/cron/service/schedule-tool.ts
@@ -0,0 +1,486 @@
+import { realpathSync, statSync } from "node:fs";
+import { isAbsolute, relative, sep } from "node:path";
+import type {
+	AgentTool,
+	GatewayModelSelection,
+	HubScheduleCreateInput,
+	HubScheduleUpdateInput,
+	ITelemetryService,
+	ScheduleExecutionRecord,
+	ScheduleRecord,
+} from "@cline/shared";
+import {
+	ONE_TIME_SCHEDULE_CRON_PATTERN,
+	ONE_TIME_SCHEDULE_RUN_AT_METADATA_KEY,
+} from "@cline/shared";
+import { z } from "zod";
+import { captureToolUsage } from "../../services/telemetry/core-events";
+import type { ListSchedulesOptions } from "./schedule-service";
+
+const ScheduleOperationSchema = z.enum([
+	"create",
+	"update",
+	"list",
+	"get",
+	"pause",
+	"resume",
+	"delete",
+	"run_now",
+]);
+
+const ModelSelectionSchema = z.object({
+	provider_id: z.string().min(1),
+	model_id: z.string().min(1).optional(),
+});
+
+export const ScheduledTaskInputSchema = z.object({
+	operation: ScheduleOperationSchema,
+	schedule_id: z.string().min(1).optional(),
+	schedule_type: z.enum(["once", "recurring"]).optional(),
+	name: z.string().min(1).optional(),
+	prompt: z.string().min(1).optional(),
+	run_at: z.string().datetime({ offset: true }).optional(),
+	cron_pattern: z.string().min(1).optional(),
+	timezone: z.string().min(1).nullable().optional(),
+	enabled: z.boolean().optional(),
+	mode: z.enum(["act", "plan", "yolo"]).optional(),
+	system_prompt: z.string().nullable().optional(),
+	max_iterations: z.number().int().positive().nullable().optional(),
+	timeout_seconds: z.number().int().positive().nullable().optional(),
+	max_parallel: z.number().int().positive().max(32).optional(),
+	tags: z.array(z.string().min(1)).optional(),
+	model_selection: ModelSelectionSchema.optional(),
+	limit: z.number().int().positive().max(200).optional(),
+});
+
+export type ScheduledTaskInput = z.infer<typeof ScheduledTaskInputSchema>;
+
+export interface ScheduleSessionDefaults {
+	workspaceRoot: string;
+	cwd?: string;
+	modelSelection?: GatewayModelSelection;
+	interactive: boolean;
+}
+
+export interface AgentScheduleServiceApi {
+	createSchedule(input: HubScheduleCreateInput): ScheduleRecord;
+	getSchedule(scheduleId: string): ScheduleRecord | undefined;
+	listSchedules(options?: ListSchedulesOptions): ScheduleRecord[];
+	updateSchedule(
+		scheduleId: string,
+		updates: HubScheduleUpdateInput,
+	): ScheduleRecord | undefined;
+	deleteSchedule(scheduleId: string): boolean;
+	pauseSchedule(scheduleId: string): ScheduleRecord | undefined;
+	resumeSchedule(scheduleId: string): ScheduleRecord | undefined;
+	triggerScheduleNowDetached(
+		scheduleId: string,
+	): ScheduleExecutionRecord | undefined;
+}
+
+export interface ScheduleTaskOperationOptions {
+	schedules: AgentScheduleServiceApi;
+	telemetry?: ITelemetryService;
+	resolveSessionDefaults: (
+		sessionId: string,
+	) => Promise<ScheduleSessionDefaults | undefined>;
+	publish?: (
+		event:
+			| "schedule.created"
+			| "schedule.updated"
+			| "schedule.deleted"
+			| "schedule.triggered",
+		payload: Record<string, unknown>,
+		sessionId: string,
+	) => void;
+}
+
+function captureScheduleMutation(
+	options: ScheduleTaskOperationOptions,
+	input: ScheduledTaskInput,
+	context: Parameters<
+		AgentTool<ScheduledTaskInput, ScheduledTaskResult>["execute"]
+	>[1],
+	success: boolean,
+): void {
+	if (!MUTATING_OPERATIONS.has(input.operation)) return;
+	captureToolUsage(options.telemetry, {
+		ulid: context.sessionId ?? context.conversationId ?? context.agentId,
+		tool: `tasks.scheduled.${input.operation}`,
+		success,
+		agentId: context.agentId,
+	});
+}
+
+export type ScheduledTaskResult =
+	| {
+			ok: true;
+			operation: ScheduledTaskInput["operation"];
+			schedule?: ScheduleRecord;
+			schedules?: ScheduleRecord[];
+			execution?: ScheduleExecutionRecord;
+			deleted?: boolean;
+	  }
+	| {
+			ok: false;
+			operation?: ScheduledTaskInput["operation"];
+			error: { code: string; message: string };
+	  };
+
+const MUTATING_OPERATIONS = new Set<ScheduledTaskInput["operation"]>([
+	"create",
+	"update",
+	"pause",
+	"resume",
+	"delete",
+	"run_now",
+]);
+
+function requiredString(value: string | undefined, field: string): string {
+	const normalized = value?.trim();
+	if (!normalized) throw new Error(`${field} is required for this operation`);
+	return normalized;
+}
+
+function canonicalExistingPath(value: string, field: string): string {
+	try {
+		const canonical = realpathSync.native(value);
+		if (!statSync(canonical).isDirectory()) {
+			throw new Error("not a directory");
+		}
+		return canonical;
+	} catch {
+		throw new Error(`${field} does not resolve to an existing safe path`);
+	}
+}
+
+function sameWorkspace(left: string, right: string): boolean {
+	try {
+		return realpathSync.native(left) === realpathSync.native(right);
+	} catch {
+		return false;
+	}
+}
+
+function assertPathWithin(
+	workspaceRoot: string,
+	candidate: string,
+	field: string,
+): void {
+	const relativePath = relative(workspaceRoot, candidate);
+	if (
+		relativePath === ".." ||
+		relativePath.startsWith(`..${sep}`) ||
+		isAbsolute(relativePath)
+	) {
+		throw new Error(`${field} is outside the workspace scope`);
+	}
+}
+
+function canonicalWorkspacePath(
+	workspaceRoot: string,
+	value: string,
+	field: string,
+): string {
+	return canonicalExistingPath(
+		isAbsolute(value) ? value : `${workspaceRoot}${sep}${value}`,
+		field,
+	);
+}
+
+function canonicalSessionDefaults(
+	defaults: ScheduleSessionDefaults,
+): ScheduleSessionDefaults {
+	const workspaceRoot = canonicalExistingPath(
+		defaults.workspaceRoot,
+		"workspaceRoot",
+	);
+	const cwd = defaults.cwd
+		? canonicalWorkspacePath(workspaceRoot, defaults.cwd, "cwd")
+		: workspaceRoot;
+	assertPathWithin(workspaceRoot, cwd, "cwd");
+	return { ...defaults, workspaceRoot, cwd };
+}
+
+function assertScheduleScope(
+	schedule: ScheduleRecord | undefined,
+	defaults: ScheduleSessionDefaults,
+): asserts schedule is ScheduleRecord {
+	if (!schedule) throw new Error("schedule does not exist");
+	if (!sameWorkspace(schedule.workspaceRoot, defaults.workspaceRoot)) {
+		throw new Error("schedule is outside this session's workspace scope");
+	}
+	const scheduleWorkspaceRoot = canonicalExistingPath(
+		schedule.workspaceRoot,
+		"schedule workspaceRoot",
+	);
+	if (schedule.cwd) {
+		const scheduleCwd = canonicalWorkspacePath(
+			scheduleWorkspaceRoot,
+			schedule.cwd,
+			"schedule cwd",
+		);
+		assertPathWithin(scheduleWorkspaceRoot, scheduleCwd, "schedule cwd");
+	}
+}
+
+function modelSelectionOf(
+	value: ScheduledTaskInput["model_selection"],
+): GatewayModelSelection | undefined {
+	if (!value) return undefined;
+	return {
+		providerId: value.provider_id.trim(),
+		modelId: value.model_id?.trim() || undefined,
+	};
+}
+
+function normalizedTags(tags: string[] | undefined): string[] | undefined {
+	if (!tags) return undefined;
+	return [...new Set(tags.map((tag) => tag.trim()).filter(Boolean))];
+}
+
+function parseRunAt(value: string | undefined): number {
+	const runAt = Date.parse(requiredString(value, "run_at"));
+	if (!Number.isFinite(runAt))
+		throw new Error("run_at must be an ISO timestamp");
+	if (runAt <= Date.now()) throw new Error("run_at must be in the future");
+	return runAt;
+}
+
+function createTiming(
+	input: ScheduledTaskInput,
+): Pick<HubScheduleCreateInput, "cronPattern" | "timezone" | "metadata"> {
+	if (input.schedule_type === "once") {
+		if (input.cron_pattern) {
+			throw new Error("cron_pattern cannot be used with a one-time schedule");
+		}
+		if (input.timezone) {
+			throw new Error("timezone is encoded in run_at for a one-time schedule");
+		}
+		return {
+			cronPattern: ONE_TIME_SCHEDULE_CRON_PATTERN,
+			metadata: {
+				[ONE_TIME_SCHEDULE_RUN_AT_METADATA_KEY]: parseRunAt(input.run_at),
+			},
+		};
+	}
+	if (input.schedule_type === "recurring") {
+		if (input.run_at) {
+			throw new Error("run_at cannot be used with a recurring schedule");
+		}
+		return {
+			cronPattern: requiredString(input.cron_pattern, "cron_pattern"),
+			timezone: input.timezone?.trim() || undefined,
+		};
+	}
+	throw new Error("schedule_type is required for create");
+}
+
+function updateTiming(
+	input: ScheduledTaskInput,
+): Pick<HubScheduleUpdateInput, "cronPattern" | "timezone" | "metadata"> {
+	if (input.run_at && input.cron_pattern) {
+		throw new Error("run_at and cron_pattern cannot be updated together");
+	}
+	if (input.schedule_type === "once" || input.run_at) {
+		if (input.cron_pattern) {
+			throw new Error("cron_pattern cannot be used with a one-time schedule");
+		}
+		if (input.timezone) {
+			throw new Error("timezone is encoded in run_at for a one-time schedule");
+		}
+		return {
+			cronPattern: ONE_TIME_SCHEDULE_CRON_PATTERN,
+			timezone: null,
+			metadata: {
+				[ONE_TIME_SCHEDULE_RUN_AT_METADATA_KEY]: parseRunAt(input.run_at),
+			},
+		};
+	}
+	if (input.schedule_type === "recurring" || input.cron_pattern) {
+		return {
+			cronPattern: requiredString(input.cron_pattern, "cron_pattern"),
+			timezone:
+				input.timezone === null ? null : input.timezone?.trim() || undefined,
+		};
+	}
+	return {
+		timezone:
+			input.timezone === null ? null : input.timezone?.trim() || undefined,
+	};
+}
+
+function requireScheduleId(input: ScheduledTaskInput): string {
+	return requiredString(input.schedule_id, "schedule_id");
+}
+
+/** Execute a scheduled-work operation through the Hub schedule service. */
+export async function executeScheduleOperation(
+	options: ScheduleTaskOperationOptions,
+	rawInput: unknown,
+	context: Parameters<
+		AgentTool<ScheduledTaskInput, ScheduledTaskResult>["execute"]
+	>[1],
+): Promise<ScheduledTaskResult> {
+	const parsed = ScheduledTaskInputSchema.safeParse(rawInput);
+	if (!parsed.success) {
+		return {
+			ok: false,
+			error: {
+				code: "invalid_schedule_input",
+				message: parsed.error.issues[0]?.message ?? "Invalid schedule input",
+			},
+		};
+	}
+	const input = parsed.data;
+	try {
+		if (!context.sessionId) {
+			throw new Error("tasks requires a Hub session");
+		}
+		const resolvedDefaults = await options.resolveSessionDefaults(
+			context.sessionId,
+		);
+		if (!resolvedDefaults?.workspaceRoot.trim()) {
+			throw new Error("tasks could not resolve the current workspace");
+		}
+		const defaults = canonicalSessionDefaults(resolvedDefaults);
+		if (MUTATING_OPERATIONS.has(input.operation) && !defaults.interactive) {
+			throw new Error("schedule mutations require an interactive user session");
+		}
+
+		switch (input.operation) {
+			case "create": {
+				const schedule = options.schedules.createSchedule({
+					name: requiredString(input.name, "name"),
+					...createTiming(input),
+					prompt: requiredString(input.prompt, "prompt"),
+					workspaceRoot: defaults.workspaceRoot,
+					cwd: defaults.cwd,
+					modelSelection:
+						modelSelectionOf(input.model_selection) ?? defaults.modelSelection,
+					enabled: input.enabled,
+					mode: input.mode ?? "yolo",
+					systemPrompt: input.system_prompt ?? undefined,
+					maxIterations: input.max_iterations ?? undefined,
+					timeoutSeconds: input.timeout_seconds ?? undefined,
+					maxParallel: input.max_parallel ?? 1,
+					createdBy: `agent:${context.agentId}`,
+					tags: normalizedTags(input.tags),
+				});
+				options.publish?.("schedule.created", { schedule }, context.sessionId);
+				captureScheduleMutation(options, input, context, true);
+				return { ok: true, operation: input.operation, schedule };
+			}
+			case "update": {
+				const scheduleId = requireScheduleId(input);
+				assertScheduleScope(
+					options.schedules.getSchedule(scheduleId),
+					defaults,
+				);
+				const schedule = options.schedules.updateSchedule(scheduleId, {
+					scheduleId,
+					...updateTiming(input),
+					name: input.name?.trim() || undefined,
+					prompt: input.prompt?.trim() || undefined,
+					modelSelection: modelSelectionOf(input.model_selection),
+					enabled: input.enabled,
+					mode: input.mode,
+					systemPrompt: input.system_prompt,
+					maxIterations: input.max_iterations,
+					timeoutSeconds: input.timeout_seconds,
+					maxParallel: input.max_parallel,
+					tags: normalizedTags(input.tags),
+				});
+				if (!schedule) throw new Error("schedule does not exist");
+				options.publish?.("schedule.updated", { schedule }, context.sessionId);
+				captureScheduleMutation(options, input, context, true);
+				return { ok: true, operation: input.operation, schedule };
+			}
+			case "list": {
+				const schedules = options.schedules
+					.listSchedules({
+						enabled: input.enabled,
+						tags: normalizedTags(input.tags),
+						workspaceRoot: defaults.workspaceRoot,
+						limit: input.limit ?? 50,
+					})
+					.filter((schedule) => {
+						try {
+							assertScheduleScope(schedule, defaults);
+							return true;
+						} catch {
+							return false;
+						}
+					})
+					.slice(0, input.limit ?? 50);
+				return { ok: true, operation: input.operation, schedules };
+			}
+			case "get": {
+				const schedule = options.schedules.getSchedule(
+					requireScheduleId(input),
+				);
+				assertScheduleScope(schedule, defaults);
+				return { ok: true, operation: input.operation, schedule };
+			}
+			case "pause":
+			case "resume": {
+				const scheduleId = requireScheduleId(input);
+				assertScheduleScope(
+					options.schedules.getSchedule(scheduleId),
+					defaults,
+				);
+				const schedule =
+					input.operation === "pause"
+						? options.schedules.pauseSchedule(scheduleId)
+						: options.schedules.resumeSchedule(scheduleId);
+				if (!schedule) throw new Error("schedule does not exist");
+				options.publish?.("schedule.updated", { schedule }, context.sessionId);
+				captureScheduleMutation(options, input, context, true);
+				return { ok: true, operation: input.operation, schedule };
+			}
+			case "delete": {
+				const scheduleId = requireScheduleId(input);
+				assertScheduleScope(
+					options.schedules.getSchedule(scheduleId),
+					defaults,
+				);
+				const deleted = options.schedules.deleteSchedule(scheduleId);
+				if (!deleted) throw new Error("schedule does not exist");
+				options.publish?.(
+					"schedule.deleted",
+					{ deleted, scheduleId },
+					context.sessionId,
+				);
+				captureScheduleMutation(options, input, context, true);
+				return { ok: true, operation: input.operation, deleted };
+			}
+			case "run_now": {
+				const scheduleId = requireScheduleId(input);
+				assertScheduleScope(
+					options.schedules.getSchedule(scheduleId),
+					defaults,
+				);
+				const execution =
+					options.schedules.triggerScheduleNowDetached(scheduleId);
+				if (!execution) throw new Error("schedule does not exist");
+				options.publish?.(
+					"schedule.triggered",
+					{ execution },
+					context.sessionId,
+				);
+				captureScheduleMutation(options, input, context, true);
+				return { ok: true, operation: input.operation, execution };
+			}
+		}
+	} catch (error) {
+		captureScheduleMutation(options, input, context, false);
+		return {
+			ok: false,
+			operation: input.operation,
+			error: {
+				code: "schedule_operation_failed",
+				message: error instanceof Error ? error.message : String(error),
+			},
+		};
+	}
+}
diff --git a/sdk/packages/core/src/cron/store/sqlite-cron-store.ts b/sdk/packages/core/src/cron/store/sqlite-cron-store.ts
index 9ab239d7f4..98def89e90 100644
--- a/sdk/packages/core/src/cron/store/sqlite-cron-store.ts
+++ b/sdk/packages/core/src/cron/store/sqlite-cron-store.ts
@@ -422,6 +422,7 @@ function hubScheduleInputToCronSpec(input: HubScheduleCreateInput): CronSpec {
 				...common,
 				triggerKind: "schedule",
 				schedule: input.cronPattern.trim(),
+				timezone: input.timezone?.trim() || undefined,
 			};
 }
 
@@ -474,6 +475,12 @@ function cronSpecRecordToHubScheduleInput(
 	return {
 		name: updates.name ?? current.title,
 		cronPattern,
+		timezone:
+			updates.timezone === null
+				? undefined
+				: updates.timezone !== undefined
+					? updates.timezone
+					: current.timezone,
 		prompt: updates.prompt ?? current.prompt ?? "",
 		workspaceRoot: updates.workspaceRoot ?? current.workspaceRoot ?? "",
 		cwd,
@@ -673,7 +680,12 @@ export class SqliteCronStore {
 	}
 
 	public listHubSchedules(
-		options: { enabled?: boolean; limit?: number; tags?: string[] } = {},
+		options: {
+			enabled?: boolean;
+			limit?: number;
+			tags?: string[];
+			workspaceRoot?: string;
+		} = {},
 	): CronSpecRecord[] {
 		const where = [
 			"source = 'hub-schedule'",
@@ -685,6 +697,10 @@ export class SqliteCronStore {
 			where.push("enabled = ?");
 			params.push(options.enabled ? 1 : 0);
 		}
+		if (options.workspaceRoot?.trim()) {
+			where.push("workspace_root = ?");
+			params.push(options.workspaceRoot.trim());
+		}
 		if (options.tags && options.tags.length > 0) {
 			for (const tag of options.tags) {
 				where.push("tags_json LIKE ?");
@@ -732,6 +748,7 @@ export class SqliteCronStore {
 			}
 			if (
 				updates.cronPattern !== undefined ||
+				updates.timezone !== undefined ||
 				updates.metadata?.[ONE_TIME_SCHEDULE_RUN_AT_METADATA_KEY] !==
 					undefined ||
 				updates.enabled !== undefined
diff --git a/sdk/packages/core/src/extensions/tools/runtime.test.ts b/sdk/packages/core/src/extensions/tools/runtime.test.ts
index 56822072a3..a5250a7860 100644
--- a/sdk/packages/core/src/extensions/tools/runtime.test.ts
+++ b/sdk/packages/core/src/extensions/tools/runtime.test.ts
@@ -13,6 +13,23 @@ describe("builtin tool catalog", () => {
 		expect(catalog.some((entry) => entry.id === "teams")).toBe(true);
 	});
 
+	it("includes the unified tasks tool outside yolo mode", () => {
+		for (const mode of ["act", "plan"] as const) {
+			const entry = getCoreBuiltinToolCatalog({ mode }).find(
+				(candidate) => candidate.id === "tasks",
+			);
+			expect(entry).toMatchObject({
+				defaultEnabled: true,
+				headlessToolNames: ["tasks"],
+			});
+		}
+		expect(
+			getCoreBuiltinToolCatalog({ mode: "yolo" }).some(
+				(entry) => entry.id === "tasks",
+			),
+		).toBe(false);
+	});
+
 	it("marks teams enabled by default in act mode", () => {
 		const catalog = getCoreBuiltinToolCatalog({ mode: "act" });
 		expect(catalog.find((entry) => entry.id === "teams")?.defaultEnabled).toBe(
diff --git a/sdk/packages/core/src/extensions/tools/runtime.ts b/sdk/packages/core/src/extensions/tools/runtime.ts
index eb736db938..07aff3596c 100644
--- a/sdk/packages/core/src/extensions/tools/runtime.ts
+++ b/sdk/packages/core/src/extensions/tools/runtime.ts
@@ -77,6 +77,12 @@ const BASE_TOOL_CATALOG: readonly RuntimeToolCatalogEntry[] = [
 			"Ask the user a single clarifying question with 2-5 selectable options.",
 		headlessToolNames: ["ask_question"],
 	},
+	{
+		id: "tasks",
+		description:
+			"Create and manage durable Todo items or explicitly requested one-time and recurring agent schedules.",
+		headlessToolNames: ["tasks"],
+	},
 	{
 		id: "spawn_agent",
 		description: createSpawnAgentTool({ configProvider: {} as never })
@@ -185,6 +191,9 @@ function isEntryEnabledByDefault(
 	if (entryId === "teams") {
 		return flags.enableAgentTeams === true;
 	}
+	if (entryId === "tasks") {
+		return true;
+	}
 	if (entryId === "editor") {
 		return flags.enableEditor === true || flags.enableApplyPatch === true;
 	}
@@ -219,11 +228,12 @@ export function getCoreBuiltinToolCatalog(
 ): ToolCatalogEntry[] {
 	return BASE_TOOL_CATALOG.filter(
 		(entry) =>
-			entry.id !== "web_search" ||
-			supportsModelTool(
-				{ providerId: context.providerId ?? "", modelId: context.modelId },
-				"web_search",
-			),
+			(entry.id !== "tasks" || resolveContextMode(context.mode) !== "yolo") &&
+			(entry.id !== "web_search" ||
+				supportsModelTool(
+					{ providerId: context.providerId ?? "", modelId: context.modelId },
+					"web_search",
+				)),
 	).map((entry) => buildCatalogEntry(entry, context));
 }
 
diff --git a/sdk/packages/core/src/hub/client/index.ts b/sdk/packages/core/src/hub/client/index.ts
index c808902a83..09aee34426 100644
--- a/sdk/packages/core/src/hub/client/index.ts
+++ b/sdk/packages/core/src/hub/client/index.ts
@@ -172,6 +172,7 @@ export interface HubClientOptions {
 	workspaceRoot?: string;
 	cwd?: string;
 	authToken?: string;
+	capabilities?: HubClientRegistration["capabilities"];
 }
 
 export interface LocalHubResolutionOptions {
@@ -308,12 +309,14 @@ export class NodeHubClient {
 	);
 	private sawSocketClose = false;
 	private registered = false;
+	private capabilities: NonNullable<HubClientRegistration["capabilities"]>;
 
 	constructor(private readonly options: HubClientOptions) {
 		this.clientId =
 			options.clientId ??
 			`core-${Math.random().toString(36).slice(2, 10)}-${Date.now().toString(36)}`;
 		this.currentUrl = options.url;
+		this.capabilities = [...(options.capabilities ?? [])];
 	}
 
 	getClientId(): string {
@@ -332,6 +335,16 @@ export class NodeHubClient {
 		return this.isConnected() ? null : this.lastCloseError;
 	}
 
+	async updateCapabilities(
+		capabilities: NonNullable<HubClientRegistration["capabilities"]>,
+	): Promise<void> {
+		this.capabilities = capabilities.map((capability) => ({ ...capability }));
+		if (!this.registered) return;
+		await this.command("client.update", {
+			capabilities: this.capabilities,
+		});
+	}
+
 	async connect(): Promise<void> {
 		if (
 			this.socket &&
@@ -442,6 +455,7 @@ export class NodeHubClient {
 			displayName: this.options.displayName ?? "core",
 			transport: "native",
 			actorKind: "client",
+			capabilities: this.capabilities,
 			workspaceContext: {
 				workspaceRoot: this.options.workspaceRoot,
 				cwd: this.options.cwd,
diff --git a/sdk/packages/core/src/hub/client/session-client.test.ts b/sdk/packages/core/src/hub/client/session-client.test.ts
index c53c7350d6..2970ea236f 100644
--- a/sdk/packages/core/src/hub/client/session-client.test.ts
+++ b/sdk/packages/core/src/hub/client/session-client.test.ts
@@ -1,3 +1,10 @@
+import type {
+	AgendaAutomationPolicy,
+	AgendaTaskCreateInput,
+	AgendaTaskRecord,
+	AgendaTaskRunRecord,
+	AgendaTaskUpdateInput,
+} from "@cline/shared";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { HubSessionClient } from "./session-client";
 
@@ -5,6 +12,11 @@ type SocketListener = (...args: unknown[]) => void;
 
 class MockWebSocket {
 	static instances: MockWebSocket[] = [];
+	static sentCommands: Array<{
+		command: string;
+		payload?: Record<string, unknown>;
+	}> = [];
+	static commandPayloads = new Map<string, Record<string, unknown>>();
 
 	readyState = 0;
 	private readonly listeners = new Map<string, SocketListener[]>();
@@ -19,16 +31,27 @@ class MockWebSocket {
 
 	static reset(): void {
 		MockWebSocket.instances = [];
+		MockWebSocket.sentCommands = [];
+		MockWebSocket.commandPayloads.clear();
 	}
 
 	send(data: string): void {
 		const frame = JSON.parse(data) as {
 			kind?: string;
-			envelope?: { requestId?: string; command?: string };
+			envelope?: {
+				requestId?: string;
+				command?: string;
+				payload?: Record<string, unknown>;
+			};
 		};
 		if (frame.kind !== "command" || !frame.envelope?.requestId) {
 			return;
 		}
+		const command = frame.envelope.command ?? "";
+		MockWebSocket.sentCommands.push({
+			command,
+			payload: frame.envelope.payload,
+		});
 		queueMicrotask(() => {
 			this.emitFrame({
 				kind: "reply",
@@ -37,7 +60,7 @@ class MockWebSocket {
 					requestId: frame.envelope?.requestId,
 					command: frame.envelope?.command,
 					ok: true,
-					payload: {},
+					payload: MockWebSocket.commandPayloads.get(command) ?? {},
 				},
 			});
 		});
@@ -400,4 +423,129 @@ describe("HubSessionClient", () => {
 		unsubscribe();
 		client.close();
 	});
+
+	it("sends typed task commands and returns their task queue payloads", async () => {
+		vi.stubGlobal("WebSocket", MockWebSocket);
+		const client = new HubSessionClient({
+			address: "ws://127.0.0.1:25463/hub",
+			clientId: "client-1",
+		});
+		const task: AgendaTaskRecord = {
+			taskId: "task-1",
+			type: "todo",
+			status: "pending_approval",
+			title: "Check the build",
+			instructions: "Run the build and fix any failures.",
+			scope: "workspace",
+			workspaceRoot: "/repo",
+			resourcePaths: [],
+			priority: 1,
+			availableAt: "2026-08-14T00:00:00.000Z",
+			expiresAt: "2026-08-21T00:00:00.000Z",
+			automationEligible: true,
+			revision: 1,
+			createdBy: { kind: "user", clientId: "client-1" },
+			updatedBy: { kind: "user", clientId: "client-1" },
+			createdAt: "2026-08-14T00:00:00.000Z",
+			updatedAt: "2026-08-14T00:00:00.000Z",
+		};
+		const run: AgendaTaskRunRecord = {
+			runId: "run-1",
+			taskId: task.taskId,
+			taskRevision: 1,
+			attempt: 1,
+			status: "starting",
+			claimedAt: "2026-08-14T00:01:00.000Z",
+			createdAt: "2026-08-14T00:01:00.000Z",
+			updatedAt: "2026-08-14T00:01:00.000Z",
+		};
+		const policy: AgendaAutomationPolicy = {
+			scopeKey: "global",
+			mode: "manual",
+			applyToAgentCreated: true,
+			maxConcurrentRuns: 2,
+			maxChainDepth: 1,
+			maxStartsPerHour: 20,
+			updatedAt: "2026-08-14T00:00:00.000Z",
+		};
+		MockWebSocket.commandPayloads.set("task.create", { task });
+		MockWebSocket.commandPayloads.set("task.list", { tasks: [task] });
+		MockWebSocket.commandPayloads.set("task.get", { task });
+		MockWebSocket.commandPayloads.set("task.update", { task });
+		MockWebSocket.commandPayloads.set("task.approve", { task });
+		MockWebSocket.commandPayloads.set("task.cancel", { task });
+		MockWebSocket.commandPayloads.set("task.run", { task, run });
+		MockWebSocket.commandPayloads.set("task.automation.get", { policy });
+		MockWebSocket.commandPayloads.set("task.automation.set", { policy });
+
+		const createInput: AgendaTaskCreateInput = {
+			type: "todo",
+			title: task.title,
+			instructions: task.instructions,
+			scope: "workspace",
+			workspaceRoot: "/repo",
+			expiresAt: task.expiresAt,
+			createdBy: task.createdBy,
+		};
+		const updateInput: AgendaTaskUpdateInput = {
+			taskId: task.taskId,
+			expectedRevision: 1,
+			priority: 0,
+			updatedBy: task.updatedBy,
+		};
+		const policyInput: Omit<AgendaAutomationPolicy, "updatedAt"> = {
+			scopeKey: "global",
+			mode: "manual",
+			applyToAgentCreated: true,
+			maxConcurrentRuns: 2,
+			maxChainDepth: 1,
+			maxStartsPerHour: 20,
+		};
+
+		expect(await client.createTask(createInput)).toEqual(task);
+		expect(await client.listTasks({ priorities: [1] })).toEqual([task]);
+		expect(await client.getTask(task.taskId)).toEqual(task);
+		expect(await client.updateTask(updateInput)).toEqual(task);
+		expect(await client.approveTask(task.taskId, 1)).toEqual(task);
+		expect(await client.cancelTask(task.taskId, 1, "no longer needed")).toEqual(
+			task,
+		);
+		expect(await client.runTask(task.taskId, 1)).toEqual({ task, run });
+		expect(await client.getTaskAutomation()).toEqual(policy);
+		expect(await client.setTaskAutomation(policyInput)).toEqual(policy);
+
+		expect(
+			MockWebSocket.sentCommands.filter(({ command }) =>
+				command.startsWith("task."),
+			),
+		).toEqual([
+			{ command: "task.create", payload: createInput },
+			{ command: "task.list", payload: { priorities: [1] } },
+			{ command: "task.get", payload: { taskId: "task-1" } },
+			{ command: "task.update", payload: updateInput },
+			{
+				command: "task.approve",
+				payload: { taskId: "task-1", expectedRevision: 1 },
+			},
+			{
+				command: "task.cancel",
+				payload: {
+					taskId: "task-1",
+					reason: "no longer needed",
+					expectedRevision: 1,
+				},
+			},
+			{
+				command: "task.run",
+				payload: { taskId: "task-1", expectedRevision: 1 },
+			},
+			{ command: "task.automation.get", payload: {} },
+			{
+				command: "task.automation.set",
+				payload: { policy: policyInput },
+			},
+		]);
+
+		client.close();
+	});
 });
diff --git a/sdk/packages/core/src/hub/client/session-client.ts b/sdk/packages/core/src/hub/client/session-client.ts
index fd178c8c5f..6a5773d336 100644
--- a/sdk/packages/core/src/hub/client/session-client.ts
+++ b/sdk/packages/core/src/hub/client/session-client.ts
@@ -1,10 +1,19 @@
 import type * as LlmsProviders from "@cline/llms";
 import type {
+	AgendaAutomationPolicy,
+	AgendaTaskListInput,
+	AgendaTaskRecord,
+	AgendaTaskRunRecord,
 	ChatRunTurnRequest,
 	ChatStartSessionRequest,
 	ChatStartSessionResponse,
 	ChatTurnResult,
+	HubCommandInput,
+	HubCommandOutput,
 	HubEventEnvelope,
+	HubTaskCreateInput,
+	HubTaskUpdateInput,
+	HubTypedCommandName,
 	TeamProgressProjectionEvent,
 } from "@cline/shared";
 import type { CheckpointEntry } from "../../hooks/checkpoint-hooks";
@@ -307,6 +316,18 @@ export class HubSessionClient {
 		await this.ensureMetadataApplied();
 	}
 
+	private async taskCommand<TCommand extends HubTypedCommandName>(
+		command: TCommand,
+		input: HubCommandInput<TCommand>,
+	): Promise<HubCommandOutput<TCommand>> {
+		await this.ensureMetadataApplied();
+		const reply = await this.client.command(
+			command,
+			input as unknown as Record<string, unknown>,
+		);
+		return (reply.payload ?? {}) as HubCommandOutput<TCommand>;
+	}
+
 	close(): void {
 		this.client.close();
 	}
@@ -756,4 +777,69 @@ export class HubSessionClient {
 			? (reply.payload?.upcoming as Array<Record<string, unknown>>)
 			: [];
 	}
+
+	async createTask(input: HubTaskCreateInput): Promise<AgendaTaskRecord> {
+		const result = await this.taskCommand("task.create", input);
+		return result.task;
+	}
+
+	async listTasks(
+		input: AgendaTaskListInput = {},
+	): Promise<AgendaTaskRecord[]> {
+		const result = await this.taskCommand("task.list", input);
+		return Array.isArray(result.tasks) ? result.tasks : [];
+	}
+
+	async getTask(taskId: string): Promise<AgendaTaskRecord | undefined> {
+		const result = await this.taskCommand("task.get", { taskId });
+		return result.task;
+	}
+
+	async updateTask(input: HubTaskUpdateInput): Promise<AgendaTaskRecord> {
+		const result = await this.taskCommand("task.update", input);
+		return result.task;
+	}
+
+	async approveTask(
+		taskId: string,
+		expectedRevision: number,
+	): Promise<AgendaTaskRecord> {
+		const result = await this.taskCommand("task.approve", {
+			taskId,
+			expectedRevision,
+		});
+		return result.task;
+	}
+
+	async cancelTask(
+		taskId: string,
+		expectedRevision: number,
+		reason?: string,
+	): Promise<AgendaTaskRecord> {
+		const result = await this.taskCommand("task.cancel", {
+			taskId,
+			reason,
+			expectedRevision,
+		});
+		return result.task;
+	}
+
+	async runTask(
+		taskId: string,
+		expectedRevision: number,
+	): Promise<{ task: AgendaTaskRecord; run?: AgendaTaskRunRecord }> {
+		return await this.taskCommand("task.run", { taskId, expectedRevision });
+	}
+
+	async getTaskAutomation(): Promise<AgendaAutomationPolicy> {
+		const result = await this.taskCommand("task.automation.get", {});
+		return result.policy;
+	}
+
+	async setTaskAutomation(
+		policy: Omit<AgendaAutomationPolicy, "updatedAt">,
+	): Promise<AgendaAutomationPolicy> {
+		const result = await this.taskCommand("task.automation.set", { policy });
+		return result.policy;
+	}
 }
diff --git a/sdk/packages/core/src/hub/daemon/entry.ts b/sdk/packages/core/src/hub/daemon/entry.ts
index 46068e1fa1..1d0da5fa19 100644
--- a/sdk/packages/core/src/hub/daemon/entry.ts
+++ b/sdk/packages/core/src/hub/daemon/entry.ts
@@ -234,6 +234,7 @@ async function main(): Promise<void> {
 	let server: Awaited<ReturnType<typeof startHubWebSocketServer>>;
 	try {
 		server = await startHubWebSocketServerWithBindRetry(bindDeadline, {
+			workspaceRoot: options.cwd,
 			onShutdownRequested: () => {
 				void requestOrQueueShutdown({
 					reason: "authenticated HTTP shutdown request",
diff --git a/sdk/packages/core/src/hub/index.ts b/sdk/packages/core/src/hub/index.ts
index 5387593571..cc28406cd5 100644
--- a/sdk/packages/core/src/hub/index.ts
+++ b/sdk/packages/core/src/hub/index.ts
@@ -1,6 +1,14 @@
 export type { ITelemetryService } from "@cline/shared";
 export { HubScheduleCommandService } from "../cron/service/schedule-command-service";
 export { HubScheduleService } from "../cron/service/schedule-service";
+export {
+	type AgentScheduleServiceApi,
+	executeScheduleOperation,
+	type ScheduledTaskInput,
+	ScheduledTaskInputSchema,
+	type ScheduledTaskResult,
+	type ScheduleTaskOperationOptions,
+} from "../cron/service/schedule-tool";
 /**
  * Re-exported so detached hub daemon entry points (e.g. the VS Code
  * `hub-daemon.ts` companion process) can construct a telemetry service
@@ -21,6 +29,16 @@ export {
 	createConfiguredTelemetryHandle,
 	createConfiguredTelemetryService,
 } from "../services/telemetry/OpenTelemetryProvider";
+export {
+	type CreateTasksToolOptions,
+	createTasksPromptExtension,
+	createTasksTool,
+	TASKS_SYSTEM_PROMPT_RULE,
+	TASKS_TOOL_NAME,
+	type TasksToolInput,
+	TasksToolInputSchema,
+	type TasksToolResult,
+} from "../tasks/task-tool";
 export * from "./client";
 export * from "./client/connect";
 export * from "./client/managed-hub-build-watcher";
diff --git a/sdk/packages/core/src/hub/server/agenda-task-hub.test.ts b/sdk/packages/core/src/hub/server/agenda-task-hub.test.ts
new file mode 100644
index 0000000000..8241498cd6
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/agenda-task-hub.test.ts
@@ -0,0 +1,397 @@
+import { mkdirSync, mkdtempSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type {
+	HubEventEnvelope,
+	ToolApprovalRequest,
+	ToolApprovalResult,
+} from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@ai-sdk/provider-utils", () => ({
+	createProviderDefinedToolFactory: vi.fn(() => vi.fn()),
+}));
+
+import type {
+	StartSessionInput,
+	StartSessionResult,
+} from "../../runtime/host/runtime-host";
+import { HubServerTransport } from "./hub-server-transport";
+
+describe("Hub agenda task vertical slice", () => {
+	it("creates an approved user task, starts it, and completes it", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-hub-agenda-"));
+		const chatWorkspace = join(root, "chat-workspace");
+		mkdirSync(chatWorkspace);
+		const canonicalChatWorkspace = realpathSync.native(chatWorkspace);
+		const sessions = new Map<string, Record<string, unknown>>();
+		let capturedStart: StartSessionInput | undefined;
+		let requestToolApproval:
+			| ((
+					request: ToolApprovalRequest,
+			  ) => Promise<ToolApprovalResult> | ToolApprovalResult)
+			| undefined;
+		const startSession = vi.fn(
+			async (input: StartSessionInput): Promise<StartSessionResult> => {
+				capturedStart = input;
+				requestToolApproval = input.capabilities?.requestToolApproval;
+				const sessionId = input.config.sessionId ?? "task-session";
+				const workspaceRoot =
+					input.config.workspaceRoot ?? join(root, "chat-workspace");
+				sessions.set(sessionId, {
+					sessionId,
+					source: "core",
+					status: "running",
+					startedAt: new Date().toISOString(),
+					updatedAt: new Date().toISOString(),
+					interactive: input.interactive === true,
+					provider: input.config.providerId,
+					model: input.config.modelId,
+					cwd: input.config.cwd ?? workspaceRoot,
+					workspaceRoot,
+					enableTools: true,
+					enableSpawn: true,
+					enableTeams: true,
+					isSubagent: false,
+					metadata: input.sessionMetadata,
+				});
+				return {
+					sessionId,
+					manifest: {
+						version: 1,
+						session_id: sessionId,
+						source: "core",
+						pid: 1,
+						started_at: new Date().toISOString(),
+						status: "running",
+						interactive: input.interactive === true,
+						provider: input.config.providerId,
+						model: input.config.modelId,
+						cwd: input.config.cwd ?? workspaceRoot,
+						workspace_root: workspaceRoot,
+						enable_tools: true,
+						enable_spawn: true,
+						enable_teams: true,
+					},
+					manifestPath: "",
+					messagesPath: "",
+				};
+			},
+		);
+		const runTurn = vi.fn(async () => {
+			if (!requestToolApproval) {
+				throw new Error("task session did not receive an approval bridge");
+			}
+			const approval = await requestToolApproval({
+				sessionId: capturedStart?.config.sessionId ?? "task-session",
+				agentId: "task-agent",
+				conversationId: "task-conversation",
+				iteration: 1,
+				toolCallId: "tool-call-1",
+				toolName: "write_to_file",
+				input: { path: "src/task.ts" },
+				policy: { autoApprove: false },
+			});
+			if (!approval.approved) throw new Error("task tool was not approved");
+			return {
+				text: "Task finished",
+				usage: { inputTokens: 1, outputTokens: 1 },
+				iterations: 1,
+				finishReason: "completed" as const,
+				toolCalls: [],
+			};
+		});
+		const transport = new HubServerTransport({
+			workspaceRoot: canonicalChatWorkspace,
+			runtimeHandlers: {
+				startSession: vi.fn(),
+				sendSession: vi.fn(),
+				abortSession: vi.fn(),
+				stopSession: vi.fn(),
+			},
+			scheduleOptions: { dbPath: ":memory:" },
+			taskOptions: {
+				dbPath: join(root, "tasks.db"),
+				globalSpecsDir: join(root, "specs"),
+				watchFiles: false,
+			},
+			sessionHost: {
+				subscribe: vi.fn(() => () => {}),
+				startSession,
+				runTurn,
+				stopSession: vi.fn(async () => {}),
+				abort: vi.fn(async () => {}),
+				dispose: vi.fn(async () => {}),
+				getSession: vi.fn(async (sessionId: string) => sessions.get(sessionId)),
+				getAccumulatedUsage: vi.fn(async () => undefined),
+				listSessions: vi.fn(async () => [...sessions.values()]),
+				deleteSession: vi.fn(async () => false),
+				updateSession: vi.fn(async () => ({ updated: false })),
+				updateSessionCompactionState: vi.fn(async () => ({ updated: false })),
+				readSessionCompactionState: vi.fn(async () => undefined),
+				readSessionMessages: vi.fn(async () => []),
+				dispatchHookEvent: vi.fn(async () => {}),
+				restoreSession: vi.fn(),
+			} as never,
+		});
+		const events: HubEventEnvelope[] = [];
+		transport.subscribe("observer", (event) => {
+			events.push(event);
+			if (
+				event.event === "approval.requested" &&
+				typeof event.payload?.approvalId === "string"
+			) {
+				void transport.handleCommand({
+					version: "v1",
+					command: "approval.respond",
+					clientId: "desktop",
+					payload: {
+						approvalId: event.payload.approvalId,
+						approved: true,
+					},
+				});
+			}
+		});
+		await transport.start();
+
+		try {
+			sessions.set("origin-session", {
+				sessionId: "origin-session",
+				metadata: { autoApproveTools: true },
+			});
+			const created = await transport.handleCommand({
+				version: "v1",
+				command: "task.create",
+				clientId: "desktop",
+				payload: {
+					type: "follow-up",
+					title: "Review the implementation",
+					instructions: "Review the implementation and summarize risks.",
+					scope: "global",
+					priority: 0,
+					originSessionId: "origin-session",
+					expiresAt: new Date(Date.now() + 86_400_000).toISOString(),
+				},
+			});
+			expect(created.ok).toBe(true);
+			const approved = created.payload?.task as {
+				taskId: string;
+				status: string;
+				revision: number;
+				createdBy: { kind: string; clientId?: string };
+			};
+			expect(approved).toMatchObject({
+				status: "approved",
+				createdBy: { kind: "user", clientId: "desktop" },
+			});
+			const started = await transport.handleCommand({
+				version: "v1",
+				command: "task.run",
+				clientId: "desktop",
+				payload: {
+					taskId: approved.taskId,
+					expectedRevision: approved.revision,
+				},
+			});
+			expect(started.ok).toBe(true);
+			expect(started.payload?.task).toMatchObject({
+				status: "in_progress",
+				lastSessionId: expect.any(String),
+			});
+			expect(
+				capturedStart?.localRuntime?.extraTools?.some(
+					(tool) => tool.name === "tasks",
+				),
+			).toBe(true);
+			expect(capturedStart?.localRuntime?.extraTools).toHaveLength(1);
+			expect(
+				capturedStart?.localRuntime?.extensions?.some(
+					(extension) => extension.name === "hub-task-guidance",
+				),
+			).toBe(true);
+			expect(capturedStart?.config.workspaceRoot).toBe(canonicalChatWorkspace);
+			expect(capturedStart?.toolPolicies).toMatchObject({
+				"*": { autoApprove: true, enabled: true },
+			});
+
+			const tasksTool = capturedStart?.localRuntime?.extraTools?.find(
+				(tool) => tool.name === "tasks",
+			);
+			expect(tasksTool).toBeDefined();
+			const scheduled = await tasksTool?.execute(
+				{
+					kind: "scheduled",
+					operation: "create",
+					schedule_type: "recurring",
+					name: "Review task output",
+					prompt: "Review the task output and summarize any risks.",
+					cron_pattern: "0 9 * * 1-5",
+					timezone: "America/Los_Angeles",
+				},
+				{
+					sessionId: capturedStart?.config.sessionId,
+					agentId: "task-agent",
+					iteration: 2,
+				},
+			);
+			expect(scheduled).toMatchObject({
+				ok: true,
+				kind: "scheduled",
+				schedule: {
+					name: "Review task output",
+					workspaceRoot: canonicalChatWorkspace,
+					timezone: "America/Los_Angeles",
+					createdBy: "agent:task-agent",
+				},
+			});
+			const beforeRegistration = await transport.handleCommand(
+				{
+					version: "v1",
+					command: "schedule.list",
+					clientId: "unregistered-client",
+				},
+				null,
+			);
+			expect(beforeRegistration).toMatchObject({
+				ok: false,
+				error: {
+					code: "schedule_command_failed",
+					message: "schedule commands require a registered workspace client",
+				},
+			});
+			await transport.handleCommand({
+				version: "v1",
+				command: "client.register",
+				clientId: "schedule-client",
+				payload: {
+					clientId: "schedule-client",
+					clientType: "test-client",
+					transport: "native",
+					workspaceContext: {
+						workspaceRoot: canonicalChatWorkspace,
+						cwd: canonicalChatWorkspace,
+					},
+				},
+			});
+			const listedSchedules = await transport.handleCommand(
+				{
+					version: "v1",
+					command: "schedule.list",
+					clientId: "schedule-client",
+					payload: { workspaceRoot: canonicalChatWorkspace },
+				},
+				{
+					clientId: "schedule-client",
+					workspaceContext: {
+						workspaceRoot: canonicalChatWorkspace,
+						cwd: canonicalChatWorkspace,
+					},
+				},
+			);
+			expect(listedSchedules.payload?.schedules).toEqual([
+				expect.objectContaining({ name: "Review task output" }),
+			]);
+
+			await vi.waitFor(async () => {
+				const listed = await transport.handleCommand({
+					version: "v1",
+					command: "task.list",
+					clientId: "desktop",
+					payload: {},
+				});
+				expect(listed.payload?.tasks).toEqual([
+					expect.objectContaining({
+						taskId: approved.taskId,
+						status: "completed",
+						lastSessionId: expect.any(String),
+					}),
+				]);
+			});
+			expect(runTurn).toHaveBeenCalledTimes(1);
+			expect(events.map((event) => event.event)).toEqual(
+				expect.arrayContaining([
+					"task.created",
+					"task.updated",
+					"task.run.started",
+					"task.run.completed",
+					"schedule.created",
+				]),
+			);
+			expect(events).toContainEqual(
+				expect.objectContaining({
+					event: "approval.requested",
+					payload: expect.objectContaining({
+						agendaTaskId: approved.taskId,
+						toolName: "write_to_file",
+					}),
+				}),
+			);
+
+			const automated = await transport.handleCommand({
+				version: "v1",
+				command: "task.create",
+				clientId: "desktop",
+				payload: {
+					type: "todo",
+					title: "Wait for an approval client",
+					instructions: "Start only while a review surface is connected.",
+					scope: "global",
+					expiresAt: new Date(Date.now() + 86_400_000).toISOString(),
+				},
+			});
+			const automatedTask = automated.payload?.task as {
+				taskId: string;
+				revision: number;
+			};
+			await transport.handleCommand({
+				version: "v1",
+				command: "task.automation.set",
+				clientId: "desktop",
+				payload: {
+					policy: {
+						scopeKey: "global",
+						mode: "auto_start",
+						applyToAgentCreated: true,
+						maxConcurrentRuns: 1,
+						maxChainDepth: 3,
+						maxStartsPerHour: 20,
+					},
+				},
+			});
+			await vi.waitFor(async () => {
+				const waiting = await transport.handleCommand({
+					version: "v1",
+					command: "task.get",
+					clientId: "desktop",
+					payload: { taskId: automatedTask.taskId },
+				});
+				expect(waiting.payload?.task).toMatchObject({ status: "approved" });
+			});
+			expect(startSession).toHaveBeenCalledTimes(1);
+
+			await transport.handleCommand({
+				version: "v1",
+				command: "client.register",
+				clientId: "desktop",
+				payload: {
+					clientId: "desktop",
+					clientType: "code-sidecar-observer",
+					transport: "native",
+					capabilities: [{ name: "approval.respond" }],
+				},
+			});
+			await vi.waitFor(async () => {
+				const completed = await transport.handleCommand({
+					version: "v1",
+					command: "task.get",
+					clientId: "desktop",
+					payload: { taskId: automatedTask.taskId },
+				});
+				expect(completed.payload?.task).toMatchObject({ status: "completed" });
+			});
+			expect(startSession).toHaveBeenCalledTimes(2);
+		} finally {
+			await transport.stop();
+		}
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/boundary.test.ts b/sdk/packages/core/src/hub/server/boundary.test.ts
index 3953508f3d..6e51e7245f 100644
--- a/sdk/packages/core/src/hub/server/boundary.test.ts
+++ b/sdk/packages/core/src/hub/server/boundary.test.ts
@@ -903,6 +903,7 @@ describe("HubServerTransport boundaries", () => {
 			payload: {
 				metadata: {
 					hubCapabilityOwnerClientId: "attacker-client",
+					autoApproveTools: true,
 					title: "safe title",
 				},
 			},
diff --git a/sdk/packages/core/src/hub/server/browser-websocket.test.ts b/sdk/packages/core/src/hub/server/browser-websocket.test.ts
index 4618943fa0..3576ff0f0e 100644
--- a/sdk/packages/core/src/hub/server/browser-websocket.test.ts
+++ b/sdk/packages/core/src/hub/server/browser-websocket.test.ts
@@ -1,6 +1,8 @@
-import type { HubReplyEnvelope } from "@cline/shared";
+import { resolve } from "node:path";
+import type { HubCommandEnvelope, HubReplyEnvelope } from "@cline/shared";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import { BrowserWebSocketHubAdapter } from "./browser-websocket";
+import type { HubConnectionAuthority } from "./command-transport";
 
 function createSocket() {
 	const messageListeners = new Set<(event: { data: string }) => void>();
@@ -78,6 +80,248 @@ describe("BrowserWebSocketHubAdapter", () => {
 		}
 	});
 
+	it("binds client identity to the Hub-authorized workspace", async () => {
+		const transport = {
+			command: vi.fn(
+				async (
+					envelope: HubCommandEnvelope,
+					_authority?: HubConnectionAuthority,
+				) => ({
+					version: "v1" as const,
+					requestId: envelope.requestId,
+					ok: true,
+				}),
+			),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		new BrowserWebSocketHubAdapter(
+			transport,
+			undefined,
+			"/server-workspace",
+		).attach(socket);
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "client.register",
+					requestId: "register",
+					clientId: "client-1",
+					payload: {
+						clientId: "client-1",
+						clientType: "test",
+						transport: "websocket",
+						workspaceContext: {
+							workspaceRoot: "/server-workspace",
+							cwd: "/server-workspace/project",
+						},
+					},
+				},
+			}),
+		);
+		await vi.waitFor(() => expect(socket.sent).toHaveLength(1));
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "schedule.list",
+					requestId: "list",
+					clientId: "client-1",
+				},
+			}),
+		);
+		await vi.waitFor(() => expect(transport.command).toHaveBeenCalledTimes(2));
+		expect(transport.command.mock.calls[1]?.[1]).toEqual({
+			clientId: "client-1",
+			workspaceContext: {
+				workspaceRoot: resolve("/server-workspace"),
+				cwd: resolve("/server-workspace/project"),
+			},
+		});
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "schedule.list",
+					requestId: "spoofed",
+					clientId: "other-client",
+				},
+			}),
+		);
+		await vi.waitFor(() =>
+			expect(socket.sent.map((entry) => JSON.parse(entry))).toContainEqual({
+				kind: "reply",
+				envelope: {
+					version: "v1",
+					requestId: "spoofed",
+					ok: false,
+					error: {
+						code: "client_authority_mismatch",
+						message: "Command clientId does not belong to this connection.",
+					},
+				},
+			}),
+		);
+		expect(transport.command).toHaveBeenCalledTimes(2);
+	});
+
+	it("rejects a client-declared workspace outside Hub authority", async () => {
+		const transport = {
+			command: vi.fn(async (envelope: HubCommandEnvelope) => ({
+				version: "v1" as const,
+				requestId: envelope.requestId,
+				ok: true,
+			})),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		new BrowserWebSocketHubAdapter(
+			transport,
+			undefined,
+			"/server-workspace",
+		).attach(socket);
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "client.register",
+					requestId: "register-spoofed-workspace",
+					clientId: "client-1",
+					payload: {
+						clientId: "client-1",
+						workspaceContext: {
+							workspaceRoot: "/other-workspace",
+						},
+					},
+				},
+			}),
+		);
+
+		await vi.waitFor(() => expect(socket.sent).toHaveLength(1));
+		expect(JSON.parse(socket.sent[0] ?? "")).toMatchObject({
+			kind: "reply",
+			envelope: {
+				ok: false,
+				error: {
+					code: "invalid_client_registration",
+					message:
+						"Registration workspace must match the Hub-authorized workspace",
+				},
+			},
+		});
+		expect(transport.command).not.toHaveBeenCalled();
+	});
+
+	it("allows a token-authenticated client to bind its registered workspace", async () => {
+		const transport = {
+			command: vi.fn(
+				async (
+					envelope: HubCommandEnvelope,
+					_authority?: HubConnectionAuthority | null,
+				) => ({
+					version: "v1" as const,
+					requestId: envelope.requestId,
+					ok: true,
+				}),
+			),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		new BrowserWebSocketHubAdapter(
+			transport,
+			undefined,
+			"/daemon-workspace",
+		).attach(socket, { allowRegisteredWorkspace: true });
+
+		for (const [requestId, command] of [
+			["register", "client.register"],
+			["list", "schedule.list"],
+		] as const) {
+			socket.emitMessage(
+				JSON.stringify({
+					kind: "command",
+					envelope: {
+						version: "v1",
+						command,
+						requestId,
+						clientId: "client-1",
+						payload:
+							command === "client.register"
+								? {
+									clientId: "client-1",
+									clientType: "test",
+									transport: "websocket",
+									workspaceContext: {
+										workspaceRoot: "/second-workspace",
+										cwd: "/second-workspace/project",
+									},
+								}
+								: undefined,
+					},
+				}),
+			);
+			await vi.waitFor(() =>
+				expect(transport.command).toHaveBeenCalledTimes(
+					requestId === "register" ? 1 : 2,
+				),
+			);
+			if (requestId === "register") {
+				await vi.waitFor(() => expect(socket.sent).toHaveLength(1));
+			}
+		}
+
+		expect(transport.command.mock.calls[1]?.[1]).toEqual({
+			clientId: "client-1",
+			workspaceContext: {
+				workspaceRoot: resolve("/second-workspace"),
+				cwd: resolve("/second-workspace/project"),
+			},
+		});
+	});
+
+	it("marks commands before registration as explicitly unauthorized", async () => {
+		const transport = {
+			command: vi.fn(async (envelope: HubCommandEnvelope) => ({
+				version: "v1" as const,
+				requestId: envelope.requestId,
+				ok: false,
+			})),
+			subscribe: vi.fn(),
+		};
+		const socket = createSocket();
+		new BrowserWebSocketHubAdapter(
+			transport,
+			undefined,
+			"/server-workspace",
+		).attach(socket);
+
+		socket.emitMessage(
+			JSON.stringify({
+				kind: "command",
+				envelope: {
+					version: "v1",
+					command: "schedule.list",
+					requestId: "before-register",
+					clientId: "spoofed-client",
+				},
+			}),
+		);
+
+		await vi.waitFor(() => expect(transport.command).toHaveBeenCalledOnce());
+		expect(transport.command).toHaveBeenCalledWith(
+			expect.objectContaining({ command: "schedule.list" }),
+			null,
+		);
+	});
+
 	it("keeps run.start open past the default command timeout", async () => {
 		vi.useFakeTimers();
 		vi.spyOn(console, "error").mockImplementation(() => {});
diff --git a/sdk/packages/core/src/hub/server/browser-websocket.ts b/sdk/packages/core/src/hub/server/browser-websocket.ts
index ab280a558c..26d26f1abc 100644
--- a/sdk/packages/core/src/hub/server/browser-websocket.ts
+++ b/sdk/packages/core/src/hub/server/browser-websocket.ts
@@ -1,3 +1,4 @@
+import { isAbsolute, relative, resolve, sep } from "node:path";
 import type {
 	HubClientRegistration,
 	HubEventEnvelope,
@@ -11,7 +12,10 @@ import {
 	resolveHubCommandTimeoutMs,
 	safeJsonParse,
 } from "@cline/shared";
-import type { HubCommandTransport } from "./command-transport";
+import type {
+	HubCommandTransport,
+	HubConnectionAuthority,
+} from "./command-transport";
 import { logHubMessage } from "./hub-server-logging";
 
 type HubCommandFrame = HubTransportFrame & { kind: "command" };
@@ -52,15 +56,61 @@ function commandErrorReply(
 	};
 }
 
+function registrationAuthority(
+	frame: HubCommandFrame,
+	serverWorkspaceRoot?: string,
+	allowRegisteredWorkspace = false,
+): HubConnectionAuthority {
+	const registration = (frame.envelope.payload ??
+		{}) as unknown as HubClientRegistration;
+	const envelopeClientId = frame.envelope.clientId?.trim();
+	const clientId = registration.clientId?.trim() || envelopeClientId;
+	if (!clientId || (envelopeClientId && clientId !== envelopeClientId)) {
+		throw new Error("Registration clientId must match the command connection");
+	}
+	const requestedRoot = registration.workspaceContext?.workspaceRoot?.trim();
+	const authorizedRoot = allowRegisteredWorkspace
+		? requestedRoot || serverWorkspaceRoot?.trim()
+		: serverWorkspaceRoot?.trim();
+	if (!authorizedRoot) return { clientId };
+	const workspaceRoot = resolve(authorizedRoot);
+	if (
+		!allowRegisteredWorkspace &&
+		requestedRoot &&
+		resolve(requestedRoot) !== workspaceRoot
+	) {
+		throw new Error(
+			"Registration workspace must match the Hub-authorized workspace",
+		);
+	}
+	const cwd = resolve(
+		registration.workspaceContext?.cwd?.trim() || workspaceRoot,
+	);
+	const relativeCwd = relative(workspaceRoot, cwd);
+	if (
+		relativeCwd === ".." ||
+		relativeCwd.startsWith(`..${sep}`) ||
+		isAbsolute(relativeCwd)
+	) {
+		throw new Error("Registration cwd must be inside its workspace");
+	}
+	return { clientId, workspaceContext: { workspaceRoot, cwd } };
+}
+
 export class BrowserWebSocketHubAdapter {
 	constructor(
 		private readonly transport: HubCommandTransport,
 		private readonly telemetry?: ITelemetryService,
+		private readonly workspaceRoot?: string,
 	) {}
 
-	attach(socket: BrowserHubSocketLike): () => void {
+	attach(
+		socket: BrowserHubSocketLike,
+		options: { allowRegisteredWorkspace?: boolean } = {},
+	): () => void {
 		const subscriptions = new Map<string, () => void>();
 		const registeredClientIds = new Set<string>();
+		let authority: HubConnectionAuthority | undefined;
 		let closed = false;
 
 		const sendFrame = (frame: HubTransportFrame): void => {
@@ -86,6 +136,51 @@ export class BrowserWebSocketHubAdapter {
 				const frame = JSON.parse(event.data) as HubTransportFrame;
 				switch (frame.kind) {
 					case "command": {
+						let registration: HubConnectionAuthority | undefined;
+						if (authority && frame.envelope.command === "client.register") {
+							sendFrame({
+								kind: "reply",
+								envelope: commandErrorReply(
+									frame,
+									"client_already_registered",
+									"This connection already owns a registered client.",
+								),
+							});
+							break;
+						}
+						if (
+							authority &&
+							frame.envelope.clientId?.trim() !== authority.clientId
+						) {
+							sendFrame({
+								kind: "reply",
+								envelope: commandErrorReply(
+									frame,
+									"client_authority_mismatch",
+									"Command clientId does not belong to this connection.",
+								),
+							});
+							break;
+						}
+						if (frame.envelope.command === "client.register") {
+							try {
+								registration = registrationAuthority(
+									frame,
+									this.workspaceRoot,
+									options.allowRegisteredWorkspace,
+								);
+							} catch (error) {
+								sendFrame({
+									kind: "reply",
+									envelope: commandErrorReply(
+										frame,
+										"invalid_client_registration",
+										error instanceof Error ? error.message : String(error),
+									),
+								});
+								break;
+							}
+						}
 						const startedAt = performance.now();
 						let settled = false;
 						const context = commandLogContext(frame);
@@ -97,7 +192,10 @@ export class BrowserWebSocketHubAdapter {
 								elapsedMs: Math.round(performance.now() - startedAt),
 							});
 						}, HUB_COMMAND_SLOW_LOG_MS);
-						const commandPromise = this.transport.command(frame.envelope);
+						const commandPromise = this.transport.command(
+							frame.envelope,
+							authority ?? null,
+						);
 						commandPromise.then(
 							(lateReply) => {
 								if (!settled) return;
@@ -186,13 +284,9 @@ export class BrowserWebSocketHubAdapter {
 							});
 						}
 						if (frame.envelope.command === "client.register" && reply.ok) {
-							const registration = (frame.envelope.payload ??
-								{}) as unknown as HubClientRegistration;
-							const clientId =
-								registration.clientId?.trim() ||
-								frame.envelope.clientId?.trim();
-							if (clientId) {
-								registeredClientIds.add(clientId);
+							if (registration) {
+								registeredClientIds.add(registration.clientId);
+								authority = registration;
 							}
 						} else if (
 							frame.envelope.command === "client.unregister" &&
@@ -201,6 +295,7 @@ export class BrowserWebSocketHubAdapter {
 							const clientId = frame.envelope.clientId?.trim();
 							if (clientId) {
 								registeredClientIds.delete(clientId);
+								authority = undefined;
 							}
 						}
 						sendFrame({
diff --git a/sdk/packages/core/src/hub/server/command-transport.ts b/sdk/packages/core/src/hub/server/command-transport.ts
index 608766b4e8..dc76e73af8 100644
--- a/sdk/packages/core/src/hub/server/command-transport.ts
+++ b/sdk/packages/core/src/hub/server/command-transport.ts
@@ -1,11 +1,22 @@
 import type {
+	HubClientRegistration,
 	HubCommandEnvelope,
 	HubEventEnvelope,
 	HubReplyEnvelope,
 } from "@cline/shared";
 
+/** Authority captured once by an authenticated transport connection. */
+export interface HubConnectionAuthority {
+	clientId: string;
+	workspaceContext?: HubClientRegistration["workspaceContext"];
+}
+
 export interface HubCommandTransport {
-	command(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+	command(
+		envelope: HubCommandEnvelope,
+		/** `null` means the remote connection has not registered yet. */
+		authority?: HubConnectionAuthority | null,
+	): Promise<HubReplyEnvelope>;
 	subscribe(
 		clientId: string,
 		listener: (event: HubEventEnvelope) => void,
diff --git a/sdk/packages/core/src/hub/server/handlers/approval-handlers.ts b/sdk/packages/core/src/hub/server/handlers/approval-handlers.ts
index 64ff59c970..dc4a48392f 100644
--- a/sdk/packages/core/src/hub/server/handlers/approval-handlers.ts
+++ b/sdk/packages/core/src/hub/server/handlers/approval-handlers.ts
@@ -20,6 +20,18 @@ export async function requestToolApproval(
 				"Tool approval requires an interactive session, but this session is non-interactive.",
 		};
 	}
+	let session:
+		| Awaited<ReturnType<typeof ctx.sessionHost.getSession>>
+		| undefined;
+	try {
+		session = await ctx.sessionHost.getSession(sessionId);
+	} catch {
+		session = undefined;
+	}
+	const agendaTaskId =
+		typeof session?.metadata?.agendaTaskId === "string"
+			? session.metadata.agendaTaskId
+			: undefined;
 	return await new Promise((resolve) => {
 		ctx.pendingApprovals.set(approvalId, {
 			sessionId,
@@ -38,6 +50,7 @@ export async function requestToolApproval(
 					toolName: request.toolName,
 					inputJson: JSON.stringify(request.input ?? null),
 					policy: request.policy,
+					agendaTaskId,
 				},
 				sessionId,
 			),
diff --git a/sdk/packages/core/src/hub/server/handlers/client-handlers.ts b/sdk/packages/core/src/hub/server/handlers/client-handlers.ts
index 1b372586b7..6302bc63af 100644
--- a/sdk/packages/core/src/hub/server/handlers/client-handlers.ts
+++ b/sdk/packages/core/src/hub/server/handlers/client-handlers.ts
@@ -61,6 +61,28 @@ export function handleClientUpdate(
 	if (metadata) {
 		client.metadata = JSON.parse(JSON.stringify(metadata));
 	}
+	if (Array.isArray(envelope.payload?.capabilities)) {
+		client.capabilities = envelope.payload.capabilities.flatMap((value) => {
+			if (!value || typeof value !== "object" || Array.isArray(value))
+				return [];
+			const capability = value as Record<string, unknown>;
+			if (typeof capability.name !== "string" || !capability.name.trim()) {
+				return [];
+			}
+			return [
+				{
+					name: capability.name.trim(),
+					...(typeof capability.description === "string"
+						? { description: capability.description }
+						: {}),
+					...(Array.isArray(capability.scopes) &&
+					capability.scopes.every((scope) => typeof scope === "string")
+						? { scopes: capability.scopes }
+						: {}),
+				},
+			];
+		});
+	}
 	return okReply(envelope);
 }
 
diff --git a/sdk/packages/core/src/hub/server/handlers/context.ts b/sdk/packages/core/src/hub/server/handlers/context.ts
index cf0709c02b..924d47a2ea 100644
--- a/sdk/packages/core/src/hub/server/handlers/context.ts
+++ b/sdk/packages/core/src/hub/server/handlers/context.ts
@@ -1,4 +1,6 @@
 import type {
+	AgentExtension,
+	AgentTool,
 	HubClientRecord,
 	HubCommandEnvelope,
 	HubEventEnvelope,
@@ -63,6 +65,10 @@ export interface HubTransportContext {
 	 */
 	readonly activeRpcTurnCountBySession: Map<string, number>;
 	readonly telemetry?: ITelemetryService;
+	/** Hub-owned tools injected into every local session runtime. */
+	readonly sessionTools?: readonly AgentTool[];
+	/** Hub-owned extensions injected into every local session runtime. */
+	readonly sessionExtensions?: readonly AgentExtension[];
 	readonly sessionHost: RuntimeHost &
 		Partial<
 			CommandExecutionRuntimeService &
diff --git a/sdk/packages/core/src/hub/server/handlers/session-handlers.test.ts b/sdk/packages/core/src/hub/server/handlers/session-handlers.test.ts
index df952ae7cb..4fd4177839 100644
--- a/sdk/packages/core/src/hub/server/handlers/session-handlers.test.ts
+++ b/sdk/packages/core/src/hub/server/handlers/session-handlers.test.ts
@@ -1,5 +1,33 @@
 import { describe, expect, it } from "vitest";
-import { readSessionConnectionUpdate } from "./session-handlers";
+import {
+	readSessionConnectionUpdate,
+	resolveSessionAutoApproveTools,
+	selectSessionTools,
+} from "./session-handlers";
+
+const tool = (name: string) => ({ name });
+
+describe("selectSessionTools", () => {
+	it("excludes tasks in yolo mode only", () => {
+		const tools = [tool("read_files"), tool("tasks")];
+
+		expect(selectSessionTools(tools, "act").map(({ name }) => name)).toEqual([
+			"read_files",
+			"tasks",
+		]);
+		expect(selectSessionTools(tools, "plan").map(({ name }) => name)).toEqual([
+			"read_files",
+			"tasks",
+		]);
+		expect(selectSessionTools(tools, "zen").map(({ name }) => name)).toEqual([
+			"read_files",
+			"tasks",
+		]);
+		expect(selectSessionTools(tools, "yolo").map(({ name }) => name)).toEqual([
+			"read_files",
+		]);
+	});
+});
 
 describe("readSessionConnectionUpdate", () => {
 	it("enables thinking when a positive budget is supplied without thinking", () => {
@@ -25,3 +53,27 @@ describe("readSessionConnectionUpdate", () => {
 		expect(updates.thinkingBudgetTokens).toBeUndefined();
 	});
 });
+
+describe("resolveSessionAutoApproveTools", () => {
+	it("prefers the effective global tool policy", () => {
+		expect(
+			resolveSessionAutoApproveTools(
+				{ "*": { autoApprove: false } },
+				{ autoApproveTools: true },
+			),
+		).toBe(false);
+		expect(
+			resolveSessionAutoApproveTools(
+				{ "*": { autoApprove: true } },
+				{ autoApproveTools: false },
+			),
+		).toBe(true);
+	});
+
+	it("falls back to the runtime option", () => {
+		expect(resolveSessionAutoApproveTools(undefined, {})).toBe(false);
+		expect(
+			resolveSessionAutoApproveTools(undefined, { autoApproveTools: true }),
+		).toBe(true);
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/handlers/session-handlers.ts b/sdk/packages/core/src/hub/server/handlers/session-handlers.ts
index 5ea6c1e4c8..5cf577b5ba 100644
--- a/sdk/packages/core/src/hub/server/handlers/session-handlers.ts
+++ b/sdk/packages/core/src/hub/server/handlers/session-handlers.ts
@@ -19,6 +19,7 @@ import {
 	SessionVersioningError,
 	SessionVersioningService,
 } from "../../../session/session-versioning-service";
+import { TASKS_TOOL_NAME } from "../../../tasks/task-tool";
 import {
 	createHubClientContributionRuntime,
 	parseHubClientContributions,
@@ -40,6 +41,15 @@ import {
 
 const CAPABILITY_OWNER_METADATA_KEY = "hubCapabilityOwnerClientId";
 
+export function selectSessionTools<T extends { name: string }>(
+	tools: readonly T[],
+	mode: string,
+): T[] {
+	return mode === "yolo"
+		? tools.filter((tool) => tool.name !== TASKS_TOOL_NAME)
+		: [...tools];
+}
+
 function readConnectionString(value: unknown): string | undefined {
 	return typeof value === "string" && value.trim().length > 0
 		? value.trim()
@@ -114,15 +124,32 @@ function stripServerOwnedSessionMetadata(
 	metadata: Record<string, JsonValue | undefined> | undefined,
 ): Record<string, JsonValue | undefined> | undefined {
 	// Clients may echo old records back through session.update; keep ownership
-	// on the live hub state only.
-	if (!metadata || !(CAPABILITY_OWNER_METADATA_KEY in metadata)) {
+	// and approval policy on server-created session state only.
+	if (
+		!metadata ||
+		(!("autoApproveTools" in metadata) &&
+			!(CAPABILITY_OWNER_METADATA_KEY in metadata))
+	) {
 		return metadata;
 	}
 	const sanitized = { ...metadata };
 	delete sanitized[CAPABILITY_OWNER_METADATA_KEY];
+	delete sanitized.autoApproveTools;
 	return sanitized;
 }
 
+export function resolveSessionAutoApproveTools(
+	toolPolicies: unknown,
+	runtimeOptions: Record<string, unknown>,
+): boolean {
+	const policies = asPlainRecord(toolPolicies);
+	const globalPolicy = asPlainRecord(policies?.["*"]);
+	if (typeof globalPolicy?.autoApprove === "boolean") {
+		return globalPolicy.autoApprove;
+	}
+	return runtimeOptions.autoApproveTools === true;
+}
+
 function authorizeSessionCompactionAccess(input: {
 	sessionId: string;
 	ctx: HubTransportContext;
@@ -198,6 +225,10 @@ export async function handleSessionCreate(
 	} else if (runtimeOptions.checkpointEnabled === true) {
 		metadata.checkpointEnabled = true;
 	}
+	metadata.autoApproveTools = resolveSessionAutoApproveTools(
+		payload.toolPolicies,
+		runtimeOptions,
+	);
 	const modelSelection =
 		payload.modelSelection && typeof payload.modelSelection === "object"
 			? (payload.modelSelection as Record<string, unknown>)
@@ -257,6 +288,11 @@ export async function handleSessionCreate(
 					? metadata.model
 					: "hub"),
 	});
+	const sessionMode =
+		sessionConfig?.mode ??
+		(runtimeOptions.mode === "plan" || runtimeOptions.mode === "yolo"
+			? runtimeOptions.mode
+			: "act");
 	const started = await ctx.sessionHost.startSession({
 		source: typeof metadata.source === "string" ? metadata.source : undefined,
 		interactive: metadata.interactive !== false,
@@ -275,6 +311,17 @@ export async function handleSessionCreate(
 			},
 			configExtensions,
 			...clientContributionRuntime.localRuntime,
+			extensions: [
+				...(ctx.sessionExtensions ?? []),
+				...(clientContributionRuntime.localRuntime.extensions ?? []),
+			],
+			extraTools: selectSessionTools(
+				[
+					...(ctx.sessionTools ?? []),
+					...(clientContributionRuntime.localRuntime.extraTools ?? []),
+				],
+				sessionMode,
+			),
 		},
 		capabilities: {
 			toolExecutors: clientContributionRuntime.toolExecutors,
@@ -313,11 +360,7 @@ export async function handleSessionCreate(
 				(typeof runtimeOptions.systemPrompt === "string"
 					? runtimeOptions.systemPrompt
 					: ""),
-			mode:
-				sessionConfig?.mode ??
-				(runtimeOptions.mode === "plan" || runtimeOptions.mode === "yolo"
-					? runtimeOptions.mode
-					: "act"),
+			mode: sessionMode,
 			maxIterations:
 				sessionConfig?.maxIterations ??
 				(typeof runtimeOptions.maxIterations === "number"
@@ -467,6 +510,10 @@ export async function handleSessionRestore(
 		} else if (runtimeOptions.checkpointEnabled === true) {
 			metadata.checkpointEnabled = true;
 		}
+		metadata.autoApproveTools = resolveSessionAutoApproveTools(
+			payload.toolPolicies,
+			runtimeOptions,
+		);
 
 		const modelSelection =
 			payload.modelSelection && typeof payload.modelSelection === "object"
@@ -522,6 +569,11 @@ export async function handleSessionRestore(
 							? payload.cwd.trim()
 							: context.sourceSession.workspaceRoot ||
 								context.sourceSession.cwd;
+				const sessionMode =
+					sessionConfig?.mode ??
+					(runtimeOptions.mode === "plan" || runtimeOptions.mode === "yolo"
+						? runtimeOptions.mode
+						: "act");
 				return {
 					source:
 						typeof metadata.source === "string" ? metadata.source : undefined,
@@ -540,6 +592,17 @@ export async function handleSessionRestore(
 						},
 						configExtensions,
 						...clientContributionRuntime.localRuntime,
+						extensions: [
+							...(ctx.sessionExtensions ?? []),
+							...(clientContributionRuntime.localRuntime.extensions ?? []),
+						],
+						extraTools: selectSessionTools(
+							[
+								...(ctx.sessionTools ?? []),
+								...(clientContributionRuntime.localRuntime.extraTools ?? []),
+							],
+							sessionMode,
+						),
 					},
 					capabilities: {
 						toolExecutors: clientContributionRuntime.toolExecutors,
@@ -570,11 +633,7 @@ export async function handleSessionRestore(
 							(typeof runtimeOptions.systemPrompt === "string"
 								? runtimeOptions.systemPrompt
 								: ""),
-						mode:
-							sessionConfig?.mode ??
-							(runtimeOptions.mode === "plan" || runtimeOptions.mode === "yolo"
-								? runtimeOptions.mode
-								: "act"),
+						mode: sessionMode,
 						maxIterations:
 							sessionConfig?.maxIterations ??
 							(typeof runtimeOptions.maxIterations === "number"
diff --git a/sdk/packages/core/src/hub/server/hub-server-options.ts b/sdk/packages/core/src/hub/server/hub-server-options.ts
index d98441cfdb..004dc19fc4 100644
--- a/sdk/packages/core/src/hub/server/hub-server-options.ts
+++ b/sdk/packages/core/src/hub/server/hub-server-options.ts
@@ -10,9 +10,12 @@ import type {
 	RuntimeHost,
 } from "../../runtime/host/runtime-host";
 import type { CoreSettingsService } from "../../settings";
+import type { AgendaTaskManagerOptions } from "../../tasks";
 import type { HubOwnerContext } from "../discovery";
 
 export interface HubWebSocketServerOptions {
+	/** Workspace authority assigned by the Hub to authenticated clients. */
+	workspaceRoot?: string;
 	host?: string;
 	port?: number;
 	pathname?: string;
@@ -20,6 +23,8 @@ export interface HubWebSocketServerOptions {
 	sessionHost?: RuntimeHost &
 		Partial<PendingPromptsRuntimeService & CommandExecutionRuntimeService>;
 	settingsService?: CoreSettingsService;
+	/** File/DB/watcher overrides for the Hub-owned agenda task manager. */
+	taskOptions?: Omit<AgendaTaskManagerOptions, "runtime" | "publish">;
 	runtimeHandlers: HubScheduleRuntimeHandlers;
 	scheduleOptions?: Omit<HubScheduleServiceOptions, "runtimeHandlers">;
 	/**
diff --git a/sdk/packages/core/src/hub/server/hub-server-transport.ts b/sdk/packages/core/src/hub/server/hub-server-transport.ts
index 46d0b85578..4e0b83e6ef 100644
--- a/sdk/packages/core/src/hub/server/hub-server-transport.ts
+++ b/sdk/packages/core/src/hub/server/hub-server-transport.ts
@@ -1,11 +1,22 @@
+import { resolve } from "node:path";
 import type {
+	AgendaTaskRecord,
+	AgendaTaskRunRecord,
+	AgentExtension,
+	AgentTool,
 	HubClientRecord,
 	HubCommandEnvelope,
 	HubEventEnvelope,
 	HubReplyEnvelope,
 	ToolApprovalRequest,
 } from "@cline/shared";
-import { captureSdkError, createSessionId } from "@cline/shared";
+import {
+	CLINE_DEFAULT_MODEL_ID,
+	captureSdkError,
+	createSessionId,
+	HUB_CLIENT_TOOL_APPROVAL_CAPABILITY,
+} from "@cline/shared";
+import { isChatWorkspacePath } from "@cline/shared/storage";
 import { CronService } from "../../cron/service/cron-service";
 import { HubScheduleCommandService } from "../../cron/service/schedule-command-service";
 import { HubScheduleService } from "../../cron/service/schedule-service";
@@ -16,6 +27,7 @@ import type {
 	RuntimeHost,
 } from "../../runtime/host/runtime-host";
 import { SqliteSessionStore } from "../../services/storage/sqlite-session-store";
+import { withSessionHistoryOriginMetadata } from "../../session/history-origin";
 import { CoreSessionService } from "../../session/services/session-service";
 import {
 	type CoreSettingsListInput,
@@ -23,7 +35,15 @@ import {
 	type CoreSettingsToggleInput,
 	type CoreSettingsType,
 } from "../../settings";
+import {
+	AgendaTaskManager,
+	type AgendaTaskRuntimeResult,
+	createTasksPromptExtension,
+	createTasksTool,
+} from "../../tasks";
+import { SessionSource } from "../../types/common";
 import type { CoreSessionEvent } from "../../types/events";
+import type { HubConnectionAuthority } from "./command-transport";
 import {
 	handleApprovalRespond,
 	requestToolApproval as requestToolApprovalHandler,
@@ -79,6 +99,10 @@ import { logHubBoundaryError } from "./hub-server-logging";
 import type { HubWebSocketServerOptions } from "./hub-server-options";
 import type { HubSessionState } from "./hub-session-records";
 import type { NativeHubTransport } from "./native-transport";
+import {
+	HubAgendaTaskCommandService,
+	isAgendaTaskCommand,
+} from "./task-command-service";
 
 const SETTINGS_TYPES = new Set<CoreSettingsType>([
 	"skills",
@@ -180,6 +204,10 @@ export class HubServerTransport implements NativeHubTransport {
 	private readonly activeRpcTurnCountBySession = new Map<string, number>();
 	private readonly schedules: HubScheduleService;
 	private readonly scheduleCommands: HubScheduleCommandService;
+	private readonly tasks: AgendaTaskManager;
+	private readonly taskCommands: HubAgendaTaskCommandService;
+	private readonly sessionTools: AgentTool[] = [];
+	private readonly sessionExtensions: AgentExtension[] = [];
 	private readonly settings: CoreSettingsService;
 	private readonly cronService?: CronService;
 	private readonly sessionHost: RuntimeHost &
@@ -205,6 +233,8 @@ export class HubServerTransport implements NativeHubTransport {
 				this.suppressNextTerminalEventBySession,
 			activeRpcTurnCountBySession: this.activeRpcTurnCountBySession,
 			telemetry: options.telemetry,
+			sessionTools: this.sessionTools,
+			sessionExtensions: this.sessionExtensions,
 			sessionHost: this.sessionHost,
 			publish: (event) => this.publish(event),
 			buildEvent: buildHubEvent,
@@ -224,6 +254,35 @@ export class HubServerTransport implements NativeHubTransport {
 					onProgress,
 				),
 		};
+		this.tasks = new AgendaTaskManager({
+			...options.taskOptions,
+			runtime: {
+				isInteractiveClientAvailable: () =>
+					[...this.clients.values()].some((client) =>
+						client.capabilities.some(
+							(capability) =>
+								capability.name === HUB_CLIENT_TOOL_APPROVAL_CAPABILITY,
+						),
+					),
+				startSession: (task, run, requestedByClientId, runtimeOptions) =>
+					this.startAgendaTaskSession(
+						task,
+						run,
+						requestedByClientId,
+						runtimeOptions?.unattended === true,
+					),
+				runSession: (sessionId, task, run) =>
+					this.runAgendaTaskSession(sessionId, task, run),
+				abortSession: async (sessionId, reason) => {
+					await this.sessionHost.abort(sessionId, reason);
+				},
+			},
+			logger: options.taskOptions?.logger ?? options.logger,
+			publish: (event, payload, sessionId) => {
+				this.publish(buildHubEvent(event, payload, sessionId));
+			},
+		});
+		this.taskCommands = new HubAgendaTaskCommandService(this.tasks);
 		this.schedules = new HubScheduleService({
 			...options.scheduleOptions,
 			runtimeHandlers: options.runtimeHandlers,
@@ -248,6 +307,54 @@ export class HubServerTransport implements NativeHubTransport {
 			},
 		});
 		this.scheduleCommands = new HubScheduleCommandService(this.schedules);
+		this.sessionTools.push(
+			createTasksTool({
+				todo: {
+					manager: this.tasks,
+					telemetry: options.telemetry,
+					resolveSessionDefaults: async (sessionId) => {
+						const session = await this.sessionHost.getSession(sessionId);
+						if (!session) return undefined;
+						const projectWorkspace = !isChatWorkspacePath(session.workspaceRoot)
+							? session.workspaceRoot
+							: undefined;
+						return {
+							workspaceRoot: projectWorkspace,
+							cwd: projectWorkspace ? session.cwd : undefined,
+							modelSelection: {
+								providerId: session.provider,
+								modelId: session.model,
+							},
+							originTaskId:
+								typeof session.metadata?.agendaTaskId === "string"
+									? session.metadata.agendaTaskId
+									: undefined,
+						};
+					},
+				},
+				scheduled: {
+					schedules: this.schedules,
+					telemetry: options.telemetry,
+					publish: (event, payload, sessionId) => {
+						this.publish(buildHubEvent(event, payload, sessionId));
+					},
+					resolveSessionDefaults: async (sessionId) => {
+						const session = await this.sessionHost.getSession(sessionId);
+						if (!session) return undefined;
+						return {
+							workspaceRoot: session.workspaceRoot,
+							cwd: session.cwd,
+							modelSelection: {
+								providerId: session.provider,
+								modelId: session.model,
+							},
+							interactive: session.interactive,
+						};
+					},
+				},
+			}) as AgentTool,
+		);
+		this.sessionExtensions.push(createTasksPromptExtension());
 		this.settings = options.settingsService ?? new CoreSettingsService();
 		if (options.cronOptions) {
 			this.cronService = new CronService({
@@ -273,6 +380,152 @@ export class HubServerTransport implements NativeHubTransport {
 		});
 	}
 
+	private async startAgendaTaskSession(
+		task: AgendaTaskRecord,
+		run: AgendaTaskRunRecord,
+		requestedByClientId?: string,
+		unattended = false,
+	): Promise<{ sessionId: string }> {
+		const originSession = task.originSessionId
+			? await this.sessionHost.getSession(task.originSessionId)
+			: undefined;
+		const inheritedAutoApproveTools =
+			originSession?.metadata?.autoApproveTools === true;
+		const autoApproveTools = unattended || inheritedAutoApproveTools;
+		const providerId = task.modelSelection?.providerId?.trim() || "cline";
+		const modelId =
+			task.modelSelection?.modelId?.trim() ||
+			(providerId === "cline" ? CLINE_DEFAULT_MODEL_ID : "");
+		const metadata = withSessionHistoryOriginMetadata(
+			{
+				title: task.title,
+				agendaTaskId: task.taskId,
+				agendaTaskRunId: run.runId,
+				agendaTaskAssignee: task.assignee,
+				interactive: !unattended,
+				source: SessionSource.CORE,
+			},
+			{ mode: "task", trigger: "agenda_task" },
+		);
+		const clientId = requestedByClientId?.trim() || "agenda-task-manager";
+		const reply = await handleSessionCreate(
+			this.ctx,
+			{
+				version: "v1",
+				command: "session.create",
+				requestId: createSessionId("task_session_"),
+				clientId,
+				payload: {
+					workspaceRoot: task.workspaceRoot,
+					cwd: task.cwd,
+					sessionConfig: {
+						providerId,
+						modelId,
+						systemPrompt: task.systemPrompt ?? "",
+						mode: task.mode ?? "act",
+						maxIterations: task.maxIterations,
+						enableTools: true,
+						enableSpawnAgent: true,
+						enableAgentTeams: true,
+					},
+					metadata,
+					runtimeOptions: {
+						mode: task.mode ?? "act",
+						maxIterations: task.maxIterations,
+						enableTools: true,
+						enableSpawn: true,
+						enableTeams: true,
+					},
+					toolPolicies: {
+						"*": { autoApprove: autoApproveTools, enabled: true },
+					},
+				},
+			},
+			(request) => requestToolApprovalHandler(this.ctx, request),
+		);
+		if (!reply.ok) {
+			throw new Error(reply.error?.message ?? "failed to create task session");
+		}
+		const session = reply.payload?.session as
+			| { sessionId?: unknown }
+			| undefined;
+		const snapshot = reply.payload?.snapshot as
+			| { sessionId?: unknown }
+			| undefined;
+		const sessionId =
+			typeof snapshot?.sessionId === "string"
+				? snapshot.sessionId
+				: typeof session?.sessionId === "string"
+					? session.sessionId
+					: "";
+		if (!sessionId) throw new Error("task session did not return a session id");
+		return { sessionId };
+	}
+
+	private async runAgendaTaskSession(
+		sessionId: string,
+		task: AgendaTaskRecord,
+		run: AgendaTaskRunRecord,
+	): Promise<AgendaTaskRuntimeResult> {
+		const resources = task.resourcePaths.length
+			? `\n\nRelevant resources (paths are relative to workspace root ${task.workspaceRoot}):\n${task.resourcePaths
+					.map(
+						(path) =>
+							`- ${path} (absolute: ${resolve(task.workspaceRoot ?? task.cwd ?? "", path)})`,
+					)
+					.join("\n")}`
+			: "";
+		const assignment = task.assignee
+			? `\nAssigned agent: ${task.assignee}. If a configured agent or subagent with this name is available, delegate the work to it and oversee completion; otherwise execute it directly and mention the fallback in the summary.`
+			: "";
+		const prompt = `Execute this approved agenda task.\n\nTitle: ${task.title}\nType: ${task.type}\nPriority: P${task.priority}${assignment}\n\n${task.instructions}${resources}`;
+		const reply = await handleSessionInput(this.ctx, {
+			version: "v1",
+			command: "run.start",
+			requestId: createSessionId("task_run_"),
+			clientId: run.requestedByClientId ?? "agenda-task-manager",
+			sessionId,
+			payload: {
+				sessionId,
+				input: prompt,
+				mode: task.mode ?? "act",
+				timeoutSeconds: task.timeoutSeconds,
+			},
+		});
+		if (!reply.ok) {
+			return {
+				status: "failed",
+				error: reply.error?.message ?? "task session run failed",
+			};
+		}
+		const result = reply.payload?.result as
+			| { finishReason?: unknown; text?: unknown }
+			| undefined;
+		const finishReason =
+			typeof result?.finishReason === "string"
+				? result.finishReason
+				: undefined;
+		const summary =
+			typeof result?.text === "string" && result.text.trim()
+				? result.text.trim()
+				: undefined;
+		if (finishReason === "completed") {
+			return { status: "completed", summary };
+		}
+		if (finishReason === "aborted") {
+			return { status: "cancelled", summary };
+		}
+		return {
+			status: "failed",
+			summary,
+			error:
+				summary ??
+				(finishReason
+					? `Task session ended with ${finishReason}`
+					: "Task session did not return a completion result"),
+		};
+	}
+
 	getCronService(): CronService | undefined {
 		return this.cronService;
 	}
@@ -282,6 +535,7 @@ export class HubServerTransport implements NativeHubTransport {
 	}
 
 	async start(): Promise<void> {
+		await this.tasks.start();
 		await this.schedules.start();
 		if (this.cronService) {
 			try {
@@ -304,6 +558,7 @@ export class HubServerTransport implements NativeHubTransport {
 			() => true,
 			"Hub shutting down before capability request was resolved.",
 		);
+		await this.tasks.dispose();
 		await this.sessionHost.dispose("hub_server_stop");
 		await this.schedules.dispose();
 		if (this.cronService) {
@@ -315,9 +570,28 @@ export class HubServerTransport implements NativeHubTransport {
 		}
 	}
 
-	async handleCommand(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope> {
+	async handleCommand(
+		envelope: HubCommandEnvelope,
+		authority?: HubConnectionAuthority | null,
+	): Promise<HubReplyEnvelope> {
 		try {
-			const reply = await this.dispatchCommand(envelope);
+			const clientId = envelope.clientId?.trim();
+			// Omitted authority is reserved for trusted in-process callers. A remote
+			// transport passes null until registration so caller-controlled envelope
+			// fields can never acquire daemon workspace authority implicitly.
+			const effectiveAuthority =
+				authority === undefined
+					? this.options.workspaceRoot?.trim() && clientId
+						? {
+								clientId,
+								workspaceContext: {
+									workspaceRoot: this.options.workspaceRoot,
+									cwd: this.options.workspaceRoot,
+								},
+							}
+						: undefined
+					: (authority ?? undefined);
+			const reply = await this.dispatchCommand(envelope, effectiveAuthority);
 			this.captureFailedReply(envelope, reply);
 			return reply;
 		} catch (error) {
@@ -335,17 +609,30 @@ export class HubServerTransport implements NativeHubTransport {
 
 	private async dispatchCommand(
 		envelope: HubCommandEnvelope,
+		authority?: HubConnectionAuthority,
 	): Promise<HubReplyEnvelope> {
+		if (isAgendaTaskCommand(envelope.command)) {
+			return await this.taskCommands.handleCommand(envelope, authority);
+		}
 		switch (envelope.command) {
-			case "client.register":
-				return handleClientRegister(this.ctx, envelope);
-			case "client.update":
-				return handleClientUpdate(this.ctx, envelope);
-			case "client.unregister":
-				return handleClientUnregister(this.ctx, envelope, (clientId) => {
+			case "client.register": {
+				const reply = handleClientRegister(this.ctx, envelope);
+				this.tasks.notifyAutomationReadinessChanged();
+				return reply;
+			}
+			case "client.update": {
+				const reply = handleClientUpdate(this.ctx, envelope);
+				this.tasks.notifyAutomationReadinessChanged();
+				return reply;
+			}
+			case "client.unregister": {
+				const reply = handleClientUnregister(this.ctx, envelope, (clientId) => {
 					this.listeners.delete(clientId);
 					this.detachClientFromSessions(clientId);
 				});
+				this.tasks.notifyAutomationReadinessChanged();
+				return reply;
+			}
 			case "client.list":
 				return handleClientList(this.ctx, envelope);
 			case "session.create":
@@ -434,7 +721,10 @@ export class HubServerTransport implements NativeHubTransport {
 					},
 				};
 			default: {
-				const reply = await this.scheduleCommands.handleCommand(envelope);
+				const reply = await this.scheduleCommands.handleCommand(
+					envelope,
+					authority,
+				);
 				if (reply.ok) {
 					const event = eventNameForScheduleCommand(envelope.command);
 					if (event) {
diff --git a/sdk/packages/core/src/hub/server/hub-websocket-server.ts b/sdk/packages/core/src/hub/server/hub-websocket-server.ts
index 41794815e8..697a98b91e 100644
--- a/sdk/packages/core/src/hub/server/hub-websocket-server.ts
+++ b/sdk/packages/core/src/hub/server/hub-websocket-server.ts
@@ -349,6 +349,7 @@ export async function startHubWebSocketServer(
 	const adapter = new BrowserWebSocketHubAdapter(
 		new NativeHubTransportAdapter(transport),
 		options.telemetry,
+		options.workspaceRoot,
 	);
 	const cleanup = new Set<() => void>();
 	const startedAt = new Date().toISOString();
@@ -575,11 +576,12 @@ export async function startHubWebSocketServer(
 			socket.destroy();
 			return;
 		}
+		const isTokenAuthorized = isValidHubAuthToken(
+			readWebSocketAuthToken(request.headers["sec-websocket-protocol"]),
+			authToken,
+		);
 		const isAuthorized =
-			isValidHubAuthToken(
-				readWebSocketAuthToken(request.headers["sec-websocket-protocol"]),
-				authToken,
-			) ||
+			isTokenAuthorized ||
 			(isLocalHubHostName(host) && isLocalHubOrigin(request.headers.origin));
 		if (!isAuthorized) {
 			rejectUnauthorizedUpgradeSocket(socket);
@@ -597,7 +599,9 @@ export async function startHubWebSocketServer(
 						tracked.isAlive = true;
 					});
 					sockets.add(tracked);
-					const detach = adapter.attach(wrapWsSocket(websocket));
+					const detach = adapter.attach(wrapWsSocket(websocket), {
+						allowRegisteredWorkspace: isTokenAuthorized,
+					});
 					cleanup.add(detach);
 					websocket.once("close", () => {
 						sockets.delete(tracked);
diff --git a/sdk/packages/core/src/hub/server/native-transport.ts b/sdk/packages/core/src/hub/server/native-transport.ts
index 0bcb2887a0..1128515757 100644
--- a/sdk/packages/core/src/hub/server/native-transport.ts
+++ b/sdk/packages/core/src/hub/server/native-transport.ts
@@ -3,10 +3,16 @@ import type {
 	HubEventEnvelope,
 	HubReplyEnvelope,
 } from "@cline/shared";
-import type { HubCommandTransport } from "./command-transport";
+import type {
+	HubCommandTransport,
+	HubConnectionAuthority,
+} from "./command-transport";
 
 export interface NativeHubTransport {
-	handleCommand(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope>;
+	handleCommand(
+		envelope: HubCommandEnvelope,
+		authority?: HubConnectionAuthority | null,
+	): Promise<HubReplyEnvelope>;
 	subscribe(
 		clientId: string,
 		listener: (event: HubEventEnvelope) => void,
@@ -17,8 +23,11 @@ export interface NativeHubTransport {
 export class NativeHubTransportAdapter implements HubCommandTransport {
 	constructor(private readonly transport: NativeHubTransport) {}
 
-	command(envelope: HubCommandEnvelope): Promise<HubReplyEnvelope> {
-		return this.transport.handleCommand(envelope);
+	command(
+		envelope: HubCommandEnvelope,
+		authority?: HubConnectionAuthority | null,
+	): Promise<HubReplyEnvelope> {
+		return this.transport.handleCommand(envelope, authority);
 	}
 
 	subscribe(
diff --git a/sdk/packages/core/src/hub/server/task-command-service.test.ts b/sdk/packages/core/src/hub/server/task-command-service.test.ts
new file mode 100644
index 0000000000..64f5e11699
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/task-command-service.test.ts
@@ -0,0 +1,274 @@
+import { resolve } from "node:path";
+import type {
+	AgendaAutomationPolicy,
+	AgendaTaskRecord,
+	HubCommandEnvelope,
+} from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import type { AgendaTaskManagerApi } from "../../tasks/agenda-task-api";
+import { HubAgendaTaskCommandService } from "./task-command-service";
+
+function task(overrides: Partial<AgendaTaskRecord> = {}): AgendaTaskRecord {
+	return {
+		taskId: "task_1",
+		type: "follow-up",
+		status: "pending_approval",
+		title: "Review the PR",
+		instructions: "Review the open pull request.",
+		scope: "workspace",
+		workspaceRoot: "/repo",
+		resourcePaths: [],
+		priority: 2,
+		availableAt: "2026-08-13T00:00:00.000Z",
+		expiresAt: "2026-08-20T00:00:00.000Z",
+		automationEligible: true,
+		revision: 1,
+		createdBy: { kind: "user", clientId: "desktop" },
+		updatedBy: { kind: "user", clientId: "desktop" },
+		createdAt: "2026-08-13T00:00:00.000Z",
+		updatedAt: "2026-08-13T00:00:00.000Z",
+		...overrides,
+	};
+}
+
+const policy: AgendaAutomationPolicy = {
+	scopeKey: "global",
+	mode: "manual",
+	applyToAgentCreated: true,
+	maxConcurrentRuns: 1,
+	maxChainDepth: 3,
+	maxStartsPerHour: 20,
+	updatedAt: "2026-08-13T00:00:00.000Z",
+};
+
+const AUTHORITY = {
+	clientId: "desktop",
+	workspaceContext: { workspaceRoot: "/repo", cwd: "/repo" },
+};
+
+function managerMock(): AgendaTaskManagerApi {
+	return {
+		createTask: vi.fn(async (input) =>
+			task({ createdBy: input.createdBy, updatedBy: input.createdBy }),
+		),
+		listTasks: vi.fn(async () => [task()]),
+		getTask: vi.fn(async () => task()),
+		updateTask: vi.fn(async (input) => task({ updatedBy: input.updatedBy })),
+		approveTask: vi.fn(async (_id, actor) =>
+			task({ status: "approved", approvedRevision: 1, updatedBy: actor }),
+		),
+		cancelTask: vi.fn(async (_id, actor) =>
+			task({ status: "cancelled", updatedBy: actor }),
+		),
+		runTask: vi.fn(async () => ({
+			task: task({ status: "in_progress" }),
+		})),
+		getAutomationPolicy: vi.fn(async () => policy),
+		setAutomationPolicy: vi.fn(async (input, actor) => ({
+			...input,
+			enabledBy: actor,
+			updatedAt: "2026-08-13T00:00:01.000Z",
+		})),
+	};
+}
+
+function envelope(
+	command: HubCommandEnvelope["command"],
+	payload: Record<string, unknown> = {},
+): HubCommandEnvelope {
+	return {
+		version: "v1",
+		command,
+		requestId: "request_1",
+		clientId: "desktop",
+		payload,
+	};
+}
+
+describe("HubAgendaTaskCommandService", () => {
+	it("uses the authenticated Hub client as the create actor", async () => {
+		const manager = managerMock();
+		const service = new HubAgendaTaskCommandService(manager);
+		const reply = await service.handleCommand(
+			envelope("task.create", {
+				type: "follow-up",
+				title: "Review the PR",
+				instructions: "Review it",
+				scope: "workspace",
+				workspaceRoot: "/repo",
+				expiresAt: "2026-08-20T00:00:00.000Z",
+				createdBy: { kind: "system", id: "spoofed" },
+			}),
+			AUTHORITY,
+		);
+
+		expect(reply.ok).toBe(true);
+		expect(manager.createTask).toHaveBeenCalledWith(
+			expect.objectContaining({
+				requiresApproval: false,
+				createdBy: {
+					kind: "user",
+					id: "desktop",
+					clientId: "desktop",
+				},
+			}),
+		);
+	});
+
+	it("routes approval and execution through the manager", async () => {
+		const manager = managerMock();
+		const service = new HubAgendaTaskCommandService(manager);
+
+		const approved = await service.handleCommand(
+			envelope("task.approve", { taskId: "task_1", expectedRevision: 1 }),
+			AUTHORITY,
+		);
+		const started = await service.handleCommand(
+			envelope("task.run", { taskId: "task_1", expectedRevision: 1 }),
+			AUTHORITY,
+		);
+		const cancelled = await service.handleCommand(
+			envelope("task.cancel", {
+				taskId: "task_1",
+				expectedRevision: 1,
+				reason: "No longer needed",
+			}),
+			AUTHORITY,
+		);
+
+		expect(approved.payload?.task).toMatchObject({ status: "approved" });
+		expect(started.payload?.task).toMatchObject({ status: "in_progress" });
+		expect(cancelled.payload?.task).toMatchObject({ status: "cancelled" });
+		expect(manager.approveTask).toHaveBeenCalledWith(
+			"task_1",
+			expect.objectContaining({ kind: "user", clientId: "desktop" }),
+			1,
+		);
+		expect(manager.runTask).toHaveBeenCalledWith(
+			"task_1",
+			expect.objectContaining({ kind: "user", clientId: "desktop" }),
+			1,
+			"desktop",
+		);
+		expect(manager.cancelTask).toHaveBeenCalledWith(
+			"task_1",
+			expect.objectContaining({ kind: "user", clientId: "desktop" }),
+			1,
+			"No longer needed",
+		);
+	});
+
+	it("rejects task access outside the Hub-authorized workspace", async () => {
+		const manager = managerMock();
+		const service = new HubAgendaTaskCommandService(manager);
+		const reply = await service.handleCommand(
+			envelope("task.get", { taskId: "task_1" }),
+			{
+				clientId: "desktop",
+				workspaceContext: { workspaceRoot: "/other-repo" },
+			},
+		);
+
+		expect(reply).toMatchObject({
+			ok: false,
+			error: {
+				code: "task_command_failed",
+				message: "task does not exist in this workspace",
+			},
+		});
+	});
+
+	it("lists and permits access to global tasks from a workspace client", async () => {
+		const globalTask = task({
+			taskId: "task_global",
+			scope: "global",
+			workspaceRoot: undefined,
+		});
+		const manager = managerMock();
+		vi.mocked(manager.listTasks).mockImplementation(async (input) =>
+			input?.scope === "global" ? [globalTask] : [task()],
+		);
+		vi.mocked(manager.getTask).mockResolvedValue(globalTask);
+		vi.mocked(manager.updateTask).mockResolvedValue(globalTask);
+		const service = new HubAgendaTaskCommandService(manager);
+
+		const listed = await service.handleCommand(
+			envelope("task.list"),
+			AUTHORITY,
+		);
+		const fetched = await service.handleCommand(
+			envelope("task.get", { taskId: globalTask.taskId }),
+			AUTHORITY,
+		);
+		await service.handleCommand(
+			envelope("task.update", {
+				taskId: globalTask.taskId,
+				title: "Updated global task",
+			}),
+			AUTHORITY,
+		);
+
+		expect(listed.payload?.tasks).toEqual([task(), globalTask]);
+		expect(fetched.payload?.task).toEqual(globalTask);
+		expect(manager.updateTask).toHaveBeenCalledWith(
+			expect.objectContaining({
+				taskId: globalTask.taskId,
+				scope: "global",
+				workspaceRoot: null,
+				cwd: null,
+			}),
+		);
+	});
+
+	it.each([
+		"task.approve",
+		"task.cancel",
+		"task.run",
+	] as const)("rejects %s without a revision", async (command) => {
+		const manager = managerMock();
+		const service = new HubAgendaTaskCommandService(manager);
+		const reply = await service.handleCommand(
+			envelope(command, { taskId: "task_1" }),
+			AUTHORITY,
+		);
+
+		expect(reply).toMatchObject({
+			ok: false,
+			error: {
+				code: "task_command_failed",
+				message: "expectedRevision must be a positive integer",
+			},
+		});
+	});
+
+	it("returns a structured Hub error for invalid policy input", async () => {
+		const service = new HubAgendaTaskCommandService(managerMock());
+		const reply = await service.handleCommand(
+			envelope("task.automation.set", {}),
+			AUTHORITY,
+		);
+
+		expect(reply).toMatchObject({
+			ok: false,
+			error: { code: "task_command_failed" },
+		});
+	});
+
+	it("binds automation policy access to the Hub-authorized workspace", async () => {
+		const manager = managerMock();
+		const service = new HubAgendaTaskCommandService(manager);
+		await service.handleCommand(envelope("task.automation.get"), AUTHORITY);
+		await service.handleCommand(
+			envelope("task.automation.set", {
+				policy: { ...policy, scopeKey: "/spoofed" },
+			}),
+			AUTHORITY,
+		);
+
+		expect(manager.getAutomationPolicy).toHaveBeenCalledWith(resolve("/repo"));
+		expect(manager.setAutomationPolicy).toHaveBeenCalledWith(
+			expect.objectContaining({ scopeKey: resolve("/repo") }),
+			expect.anything(),
+		);
+	});
+});
diff --git a/sdk/packages/core/src/hub/server/task-command-service.ts b/sdk/packages/core/src/hub/server/task-command-service.ts
new file mode 100644
index 0000000000..aa50bafa09
--- /dev/null
+++ b/sdk/packages/core/src/hub/server/task-command-service.ts
@@ -0,0 +1,203 @@
+import { resolve } from "node:path";
+import type {
+	AgendaAutomationPolicy,
+	AgendaTaskCreateInput,
+	AgendaTaskListInput,
+	AgendaTaskUpdateInput,
+	HubCommandEnvelope,
+	HubCommandName,
+	HubReplyEnvelope,
+} from "@cline/shared";
+import type { AgendaTaskManagerApi } from "../../tasks/agenda-task-api";
+import type { HubConnectionAuthority } from "./command-transport";
+import { errorReply, okReply } from "./handlers/context";
+
+const TASK_COMMANDS = new Set<HubCommandName>([
+	"task.create",
+	"task.list",
+	"task.get",
+	"task.update",
+	"task.approve",
+	"task.cancel",
+	"task.run",
+	"task.automation.get",
+	"task.automation.set",
+]);
+
+export function isAgendaTaskCommand(command: HubCommandName): boolean {
+	return TASK_COMMANDS.has(command);
+}
+
+function payloadOf(envelope: HubCommandEnvelope): Record<string, unknown> {
+	return envelope.payload && typeof envelope.payload === "object"
+		? envelope.payload
+		: {};
+}
+
+function taskIdOf(payload: Record<string, unknown>): string {
+	return typeof payload.taskId === "string" ? payload.taskId.trim() : "";
+}
+
+function requiredRevision(payload: Record<string, unknown>): number {
+	const revision = payload.expectedRevision;
+	if (
+		typeof revision !== "number" ||
+		!Number.isInteger(revision) ||
+		revision < 1
+	) {
+		throw new Error("expectedRevision must be a positive integer");
+	}
+	return revision;
+}
+
+export class HubAgendaTaskCommandService {
+	constructor(private readonly tasks: AgendaTaskManagerApi) {}
+
+	async handleCommand(
+		envelope: HubCommandEnvelope,
+		authority?: HubConnectionAuthority,
+	): Promise<HubReplyEnvelope> {
+		const payload = payloadOf(envelope);
+		const actor = {
+			kind: "user" as const,
+			id: envelope.clientId?.trim() || "hub-client",
+			clientId: envelope.clientId?.trim() || undefined,
+		};
+		try {
+			const workspaceRoot = this.resolveWorkspace(authority);
+			switch (envelope.command) {
+				case "task.create": {
+					const task = await this.tasks.createTask({
+						...(payload as unknown as AgendaTaskCreateInput),
+						scope: "workspace",
+						workspaceRoot,
+						cwd: workspaceRoot,
+						requiresApproval: false,
+						createdBy: actor,
+					});
+					return okReply(envelope, { task });
+				}
+				case "task.list": {
+					const listInput = payload as unknown as AgendaTaskListInput;
+					const [workspaceTasks, globalTasks] = await Promise.all([
+						this.tasks.listTasks({
+							...listInput,
+							scope: "workspace",
+							workspaceRoot,
+						}),
+						this.tasks.listTasks({
+							...listInput,
+							scope: "global",
+							workspaceRoot: undefined,
+						}),
+					]);
+					return okReply(envelope, {
+						tasks: [...workspaceTasks, ...globalTasks],
+					});
+				}
+				case "task.get": {
+					const task = await this.requireScopedTask(payload, workspaceRoot);
+					return okReply(envelope, {
+						task,
+					});
+				}
+				case "task.update": {
+					const current = await this.requireScopedTask(payload, workspaceRoot);
+					const task = await this.tasks.updateTask({
+						...(payload as unknown as AgendaTaskUpdateInput),
+						scope: current.scope,
+						workspaceRoot: current.workspaceRoot ?? null,
+						cwd: current.cwd ?? null,
+						updatedBy: actor,
+					});
+					return okReply(envelope, { task });
+				}
+				case "task.approve":
+					await this.requireScopedTask(payload, workspaceRoot);
+					return okReply(envelope, {
+						task: await this.tasks.approveTask(
+							taskIdOf(payload),
+							actor,
+							requiredRevision(payload),
+						),
+					});
+				case "task.cancel":
+					await this.requireScopedTask(payload, workspaceRoot);
+					return okReply(envelope, {
+						task: await this.tasks.cancelTask(
+							taskIdOf(payload),
+							actor,
+							requiredRevision(payload),
+							typeof payload.reason === "string" ? payload.reason : undefined,
+						),
+					});
+				case "task.run": {
+					await this.requireScopedTask(payload, workspaceRoot);
+					const result = await this.tasks.runTask(
+						taskIdOf(payload),
+						actor,
+						requiredRevision(payload),
+						envelope.clientId,
+					);
+					return okReply(envelope, result);
+				}
+				case "task.automation.get":
+					return okReply(envelope, {
+						policy: await this.tasks.getAutomationPolicy(workspaceRoot),
+					});
+				case "task.automation.set": {
+					const rawPolicy =
+						payload.policy &&
+						typeof payload.policy === "object" &&
+						!Array.isArray(payload.policy)
+							? (payload.policy as Omit<AgendaAutomationPolicy, "updatedAt">)
+							: undefined;
+					if (!rawPolicy) {
+						throw new Error("task.automation.set requires a policy object");
+					}
+					return okReply(envelope, {
+						policy: await this.tasks.setAutomationPolicy(
+							{ ...rawPolicy, scopeKey: workspaceRoot },
+							actor,
+						),
+					});
+				}
+				default:
+					return errorReply(
+						envelope,
+						"unsupported_command",
+						`Unsupported agenda task command: ${envelope.command}`,
+					);
+			}
+		} catch (error) {
+			return errorReply(
+				envelope,
+				"task_command_failed",
+				error instanceof Error ? error.message : String(error),
+			);
+		}
+	}
+
+	private resolveWorkspace(authority?: HubConnectionAuthority): string {
+		const workspaceRoot = authority?.workspaceContext?.workspaceRoot?.trim();
+		if (!authority?.clientId || !workspaceRoot) {
+			throw new Error("task commands require a Hub-authorized workspace");
+		}
+		return resolve(workspaceRoot);
+	}
+
+	private async requireScopedTask(
+		payload: Record<string, unknown>,
+		workspaceRoot: string,
+	) {
+		const task = await this.tasks.getTask(taskIdOf(payload));
+		if (
+			!task ||
+			(task.scope === "workspace" &&
+				(!task.workspaceRoot || resolve(task.workspaceRoot) !== workspaceRoot))
+		) {
+			throw new Error("task does not exist in this workspace");
+		}
+		return task;
+	}
+}
diff --git a/sdk/packages/core/src/index.ts b/sdk/packages/core/src/index.ts
index 49828b00cc..5853d1ead4 100644
--- a/sdk/packages/core/src/index.ts
+++ b/sdk/packages/core/src/index.ts
@@ -872,6 +872,7 @@ export {
 	CoreSettingsService,
 	createCoreSettingsService,
 } from "./settings";
+export * from "./tasks";
 export type {
 	ChatMessage,
 	ChatMessageImage,
diff --git a/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.test.ts b/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.test.ts
index 7a7c3393f1..975f9f57b4 100644
--- a/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.test.ts
+++ b/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.test.ts
@@ -369,6 +369,57 @@ describe("SessionRuntime.getExtensionRegistry", () => {
 		);
 	});
 
+	it("composes tool-conditional rules only when the tool is enabled", async () => {
+		const conditionalRuleExtension: AgentExtension = {
+			name: "conditional-tool-rule",
+			manifest: { capabilities: ["rules"] },
+			setup: (api) => {
+				api.registerRule({
+					id: "conditional-tool-rule:guidance",
+					content: "Use tasks for durable follow-up work.",
+					whenToolAvailable: "tasks",
+				});
+			},
+		};
+		const todoListTool: AgentTool = {
+			name: "tasks",
+			description: "Manage durable agenda items.",
+			inputSchema: { type: "object", properties: {} },
+			execute: async () => ({ ok: true }),
+		};
+
+		const enabledCapture = withCapturingFakeRuntime();
+		const enabledSession = new SessionRuntime(
+			makeAgentConfig({
+				systemPrompt: "Base prompt.",
+				tools: [todoListTool],
+				extensions: [conditionalRuleExtension],
+			}),
+			enabledCapture.deps,
+		);
+		await enabledSession.run("go");
+
+		expect(enabledCapture.configs[0]?.systemPrompt).toBe(
+			"Base prompt.\n\nUse tasks for durable follow-up work.",
+		);
+		expect(enabledCapture.configs[0]?.tools).toContainEqual(todoListTool);
+
+		const disabledCapture = withCapturingFakeRuntime();
+		const disabledSession = new SessionRuntime(
+			makeAgentConfig({
+				systemPrompt: "Base prompt.",
+				tools: [todoListTool],
+				extensions: [conditionalRuleExtension],
+				toolPolicies: { tasks: { enabled: false } },
+			}),
+			disabledCapture.deps,
+		);
+		await disabledSession.run("go");
+
+		expect(disabledCapture.configs[0]?.systemPrompt).toBe("Base prompt.");
+		expect(disabledCapture.configs[0]?.tools).toEqual([]);
+	});
+
 	it("passes session, caller, and logger context into extension setup()", async () => {
 		const logger = {
 			debug: vi.fn(),
diff --git a/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.ts b/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.ts
index 5558969348..ad9f4c0e6a 100644
--- a/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.ts
+++ b/sdk/packages/core/src/runtime/orchestration/session-runtime-orchestrator.ts
@@ -700,9 +700,17 @@ export class SessionRuntime {
 	// Private implementation
 	// -------------------------------------------------------------------
 
-	private async composeSystemPrompt(): Promise<string> {
+	private async composeSystemPrompt(
+		availableToolNames: ReadonlySet<string>,
+	): Promise<string> {
 		const rules: string[] = [];
 		for (const rule of this.contributionRegistry.getRegisteredRules()) {
+			if (
+				rule.whenToolAvailable &&
+				!availableToolNames.has(rule.whenToolAvailable)
+			) {
+				continue;
+			}
 			const content = await resolveRuleContent(rule);
 			if (content) {
 				rules.push(content);
@@ -815,7 +823,6 @@ export class SessionRuntime {
 		}
 
 		// Build the AgentRuntime for this turn.
-		const systemPrompt = await this.composeSystemPrompt();
 		const agentModel = createAgentModelFromConfig(
 			this.config,
 			this.logger,
@@ -852,9 +859,14 @@ export class SessionRuntime {
 		);
 		const toolCallingDisabled =
 			dedicatedImageGeneration || !modelSupportsToolCalling(modelInfo ?? {});
-		const tools = toolCallingDisabled
-			? []
-			: Array.from(mergedToolsByName.values());
+		const availableTools = filterAvailableExtensionTools(
+			Array.from(mergedToolsByName.values()),
+			this.config.toolPolicies,
+		);
+		const tools = toolCallingDisabled ? [] : availableTools;
+		const systemPrompt = await this.composeSystemPrompt(
+			new Set(tools.map((tool) => tool.name)),
+		);
 		// Seed initialMessages with the full prior transcript (including
 		// the user message we just appended) so multi-turn history is
 		// preserved across runs. Fixes P1 #1: prior turns were silently
diff --git a/sdk/packages/core/src/services/workspace/mention-enricher.test.ts b/sdk/packages/core/src/services/workspace/mention-enricher.test.ts
index da2bc88de2..128433311a 100644
--- a/sdk/packages/core/src/services/workspace/mention-enricher.test.ts
+++ b/sdk/packages/core/src/services/workspace/mention-enricher.test.ts
@@ -62,6 +62,31 @@ describe("enrichPromptWithMentions", () => {
 		}
 	});
 
+	it("strips trailing punctuation without backtracking", async () => {
+		const cwd = await createTempWorkspace();
+		try {
+			await writeFile(path.join(cwd, "file.ts"), "export {}\n", "utf8");
+			// A non-matching punctuation run is the worst case for the former
+			// unanchored /...+$/ expression.
+			const punctuationRun = "!".repeat(25_000);
+			const result = await enrichPromptWithMentions(
+				`Review @${punctuationRun}file.ts and @file.ts${punctuationRun}`,
+				cwd,
+			);
+
+			expect(result.mentions).toHaveLength(2);
+			expect(result.mentions[0]).toHaveLength(
+				punctuationRun.length + "file.ts".length,
+			);
+			expect(result.mentions[0]?.endsWith("file.ts")).toBe(true);
+			expect(result.mentions[1]).toBe("file.ts");
+			expect(result.matchedFiles).toEqual(["file.ts"]);
+			expect(result.ignoredMentions).toHaveLength(1);
+		} finally {
+			await rm(cwd, { recursive: true, force: true });
+		}
+	});
+
 	it("respects maxTotalBytes while keeping prompt unchanged", async () => {
 		const cwd = await createTempWorkspace();
 		try {
diff --git a/sdk/packages/core/src/services/workspace/mention-enricher.ts b/sdk/packages/core/src/services/workspace/mention-enricher.ts
index 5e10c15b8a..ca710d637e 100644
--- a/sdk/packages/core/src/services/workspace/mention-enricher.ts
+++ b/sdk/packages/core/src/services/workspace/mention-enricher.ts
@@ -2,7 +2,7 @@ import { stat } from "node:fs/promises";
 import path from "node:path";
 import { type FastFileIndexOptions, getFileIndex } from "./file-indexer";
 
-const TRAILING_PUNCTUATION = /[),.:;!?`'"]+$/;
+const TRAILING_PUNCTUATION_CHARS = new Set("),.:;!?`'\"");
 const LEADING_WRAPPERS = /^[(`'"]+/;
 
 export interface MentionEnricherOptions extends FastFileIndexOptions {
@@ -18,6 +18,14 @@ export interface MentionEnrichmentResult {
 	ignoredMentions: string[];
 }
 
+function stripTrailingPunctuation(input: string): string {
+	let end = input.length;
+	while (end > 0 && TRAILING_PUNCTUATION_CHARS.has(input.charAt(end - 1))) {
+		end -= 1;
+	}
+	return input.slice(0, end);
+}
+
 function extractMentionTokens(input: string): string[] {
 	const matches = input.matchAll(/(^|[\s])@([^\s]+)/g);
 	const mentions: string[] = [];
@@ -26,9 +34,9 @@ function extractMentionTokens(input: string): string[] {
 		if (token.length === 0) {
 			continue;
 		}
-		const normalized = token
-			.replace(LEADING_WRAPPERS, "")
-			.replace(TRAILING_PUNCTUATION, "");
+		const normalized = stripTrailingPunctuation(
+			token.replace(LEADING_WRAPPERS, ""),
+		);
 		if (normalized.length === 0 || normalized.includes("@")) {
 			continue;
 		}
diff --git a/sdk/packages/core/src/tasks/agenda-task-api.ts b/sdk/packages/core/src/tasks/agenda-task-api.ts
new file mode 100644
index 0000000000..859c1ad4d7
--- /dev/null
+++ b/sdk/packages/core/src/tasks/agenda-task-api.ts
@@ -0,0 +1,43 @@
+import type {
+	AgendaAutomationPolicy,
+	AgendaTaskActor,
+	AgendaTaskCreateInput,
+	AgendaTaskListInput,
+	AgendaTaskRecord,
+	AgendaTaskRunRecord,
+	AgendaTaskUpdateInput,
+} from "@cline/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>;
+}
diff --git a/sdk/packages/core/src/tasks/agenda-task-manager.test.ts b/sdk/packages/core/src/tasks/agenda-task-manager.test.ts
new file mode 100644
index 0000000000..a3bfb1fc1e
--- /dev/null
+++ b/sdk/packages/core/src/tasks/agenda-task-manager.test.ts
@@ -0,0 +1,922 @@
+import {
+	existsSync,
+	mkdirSync,
+	mkdtempSync,
+	renameSync,
+	symlinkSync,
+	writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { AgendaTaskRecord } from "@cline/shared";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+	AgendaTaskManager,
+	type AgendaTaskRuntime,
+} from "./agenda-task-manager";
+import { AgendaTaskSpecFileStore } from "./specs/task-spec-file-store";
+import { SqliteAgendaTaskStore } from "./store/sqlite-task-store";
+
+const managers: AgendaTaskManager[] = [];
+
+afterEach(async () => {
+	await Promise.all(managers.splice(0).map((manager) => manager.dispose()));
+});
+
+function future(days = 7): string {
+	return new Date(Date.now() + days * 86_400_000).toISOString();
+}
+
+function createHarness(
+	result: "completed" | "failed" = "completed",
+	options: { interactiveClientAvailable?: boolean } = {},
+) {
+	const root = mkdtempSync(join(tmpdir(), "cline-agenda-manager-"));
+	const events: string[] = [];
+	let interactiveClientAvailable = options.interactiveClientAvailable ?? true;
+	const runtime: AgendaTaskRuntime = {
+		isInteractiveClientAvailable: vi.fn(() => interactiveClientAvailable),
+		startSession: vi.fn(async (_task, run) => ({
+			sessionId: `session_${run.runId}`,
+		})),
+		runSession: vi.fn(async () => ({
+			status: result,
+			summary: result === "completed" ? "done" : undefined,
+			error: result === "failed" ? "failed on purpose" : undefined,
+		})),
+		abortSession: vi.fn(async () => {}),
+	};
+	const manager = new AgendaTaskManager({
+		runtime,
+		dbPath: join(root, "tasks.db"),
+		globalSpecsDir: join(root, "specs"),
+		watchFiles: false,
+		publish: (event) => events.push(event),
+	});
+	managers.push(manager);
+	return {
+		root,
+		manager,
+		runtime,
+		events,
+		setInteractiveClientAvailable(value: boolean) {
+			interactiveClientAvailable = value;
+		},
+	};
+}
+
+async function createPending(
+	manager: AgendaTaskManager,
+	overrides: Partial<AgendaTaskRecord> = {},
+) {
+	return await manager.createTask({
+		type: overrides.type ?? "follow-up",
+		title: overrides.title ?? "Review the pull request",
+		instructions: overrides.instructions ?? "Review the pull request.",
+		scope: "global",
+		priority: overrides.priority,
+		expiresAt: overrides.expiresAt ?? future(),
+		createdBy: { kind: "user", clientId: "desktop" },
+	});
+}
+
+describe("AgendaTaskManager", () => {
+	it("requires approval, links a session, and completes the task", async () => {
+		const { manager, runtime, events } = createHarness();
+		await manager.start();
+		const pending = await createPending(manager);
+
+		await expect(
+			manager.runTask(pending.taskId, { kind: "user" }, pending.revision),
+		).rejects.toThrow("must be approved");
+		const approved = await manager.approveTask(
+			pending.taskId,
+			{ kind: "user", clientId: "desktop" },
+			pending.revision,
+		);
+		const started = await manager.runTask(
+			approved.taskId,
+			{ kind: "user", clientId: "desktop" },
+			approved.revision,
+			"desktop",
+		);
+
+		expect(started.task).toMatchObject({
+			status: "in_progress",
+			approvedRevision: approved.revision,
+		});
+		expect(started.task.lastSessionId).toMatch(/^session_run_/);
+		expect(runtime.startSession).toHaveBeenCalledTimes(1);
+		await vi.waitFor(async () => {
+			expect((await manager.getTask(pending.taskId))?.status).toBe("completed");
+		});
+		expect(events).toContain("task.run.started");
+		expect(events).toContain("task.run.completed");
+	});
+
+	it("does not revive a task cancelled while its session is starting", async () => {
+		const { manager, runtime } = createHarness();
+		let finishStarting: ((value: { sessionId: string }) => void) | undefined;
+		vi.mocked(runtime.startSession).mockImplementationOnce(
+			async () =>
+				await new Promise<{ sessionId: string }>((resolve) => {
+					finishStarting = resolve;
+				}),
+		);
+		await manager.start();
+		const pending = await createPending(manager);
+		const approved = await manager.approveTask(
+			pending.taskId,
+			{ kind: "user" },
+			pending.revision,
+		);
+
+		const starting = manager.runTask(
+			approved.taskId,
+			{ kind: "user" },
+			approved.revision,
+		);
+		await vi.waitFor(() => expect(runtime.startSession).toHaveBeenCalledOnce());
+		await manager.cancelTask(
+			approved.taskId,
+			{ kind: "user" },
+			approved.revision,
+			"Changed my mind",
+		);
+		finishStarting?.({ sessionId: "late-session" });
+
+		await expect(starting).rejects.toThrow("cancelled while starting");
+		expect(runtime.runSession).not.toHaveBeenCalled();
+		expect(runtime.abortSession).toHaveBeenCalledWith(
+			"late-session",
+			"Agenda task was cancelled while its session was starting",
+		);
+		expect(await manager.getTask(approved.taskId)).toMatchObject({
+			status: "cancelled",
+			currentRunId: undefined,
+		});
+	});
+
+	it("increments revision and revokes approval when editable fields change", async () => {
+		const { manager } = createHarness();
+		await manager.start();
+		const pending = await createPending(manager);
+		const approved = await manager.approveTask(
+			pending.taskId,
+			{ kind: "user" },
+			pending.revision,
+		);
+
+		const updated = await manager.updateTask({
+			taskId: approved.taskId,
+			expectedRevision: approved.revision,
+			title: "Review the updated pull request",
+			updatedBy: { kind: "agent", agentId: "agent_1" },
+		});
+
+		expect(updated).toMatchObject({
+			revision: approved.revision + 1,
+			status: "pending_approval",
+			title: "Review the updated pull request",
+		});
+		expect(updated.approvedRevision).toBeUndefined();
+	});
+
+	it("binds approval and execution to the current valid Markdown intent", async () => {
+		const { root, manager, runtime } = createHarness();
+		await manager.start();
+		const pending = await createPending(manager, {
+			title: "Original intent",
+			instructions: "Perform the original work.",
+		});
+		if (!pending.specPath) throw new Error("task has no spec path");
+		const files = new AgendaTaskSpecFileStore({
+			scope: "global",
+			taskSpecsDir: join(root, "specs"),
+		});
+		const source = files.readSpec(pending.specPath);
+		if (!source.ok || !source.spec.taskId) {
+			throw new Error("task spec fixture is invalid");
+		}
+		files.writeSpec(
+			{
+				...source.spec,
+				taskId: source.spec.taskId,
+				title: "Edited intent",
+				instructions: "Perform the edited work.",
+			},
+			{
+				specPath: source.specPath,
+				expectedContentHash: source.contentHash,
+			},
+		);
+
+		await expect(
+			manager.approveTask(pending.taskId, { kind: "user" }, pending.revision),
+		).rejects.toThrow("requested revision is stale");
+		const edited = await manager.getTask(pending.taskId);
+		expect(edited).toMatchObject({
+			title: "Edited intent",
+			instructions: "Perform the edited work.",
+			revision: pending.revision + 1,
+			status: "pending_approval",
+		});
+		if (!edited) throw new Error("edited task was not persisted");
+		const approved = await manager.approveTask(
+			edited.taskId,
+			{ kind: "user" },
+			edited.revision,
+		);
+		writeFileSync(approved.specPath ?? "", "not valid task Markdown");
+
+		await expect(
+			manager.runTask(approved.taskId, { kind: "user" }, approved.revision),
+		).rejects.toThrow("task spec is invalid");
+		expect(runtime.startSession).not.toHaveBeenCalled();
+	});
+
+	it("rehydrates known workspaces and watches their task specs after restart", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-agenda-workspace-"));
+		const workspaceRoot = join(root, "workspace");
+		const dbPath = join(root, "tasks.db");
+		const globalSpecsDir = join(root, "global-specs");
+		mkdirSync(workspaceRoot);
+		const runtime: AgendaTaskRuntime = {
+			isInteractiveClientAvailable: () => true,
+			startSession: vi.fn(),
+			runSession: vi.fn(),
+			abortSession: vi.fn(),
+		};
+		const first = new AgendaTaskManager({
+			runtime,
+			dbPath,
+			globalSpecsDir,
+			watchFiles: false,
+		});
+		managers.push(first);
+		await first.start();
+		const created = await first.createTask({
+			type: "todo",
+			title: "Before restart",
+			instructions: "Keep this workspace task synchronized.",
+			scope: "workspace",
+			workspaceRoot,
+			expiresAt: future(),
+			createdBy: { kind: "user" },
+		});
+		await first.dispose();
+		if (!created.specPath) throw new Error("workspace task has no spec path");
+		const files = new AgendaTaskSpecFileStore({
+			scope: "workspace",
+			workspaceRoot,
+		});
+		const beforeRestart = files.readSpec(created.specPath);
+		if (!beforeRestart.ok || !beforeRestart.spec.taskId) {
+			throw new Error("workspace task spec fixture is invalid");
+		}
+		files.writeSpec(
+			{
+				...beforeRestart.spec,
+				taskId: beforeRestart.spec.taskId,
+				title: "Reconciled at restart",
+			},
+			{
+				specPath: beforeRestart.specPath,
+				expectedContentHash: beforeRestart.contentHash,
+			},
+		);
+
+		const events: string[] = [];
+		const restarted = new AgendaTaskManager({
+			runtime,
+			dbPath,
+			globalSpecsDir,
+			watcherDebounceMs: 0,
+			publish: (event) => events.push(event),
+		});
+		managers.push(restarted);
+		await restarted.start();
+		expect(await restarted.getTask(created.taskId)).toMatchObject({
+			title: "Reconciled at restart",
+			revision: created.revision + 1,
+		});
+
+		events.length = 0;
+		const afterRestart = files.readSpec(created.specPath);
+		if (!afterRestart.ok || !afterRestart.spec.taskId) {
+			throw new Error("restarted task spec fixture is invalid");
+		}
+		files.writeSpec(
+			{
+				...afterRestart.spec,
+				taskId: afterRestart.spec.taskId,
+				title: "Updated by watcher",
+			},
+			{
+				specPath: afterRestart.specPath,
+				expectedContentHash: afterRestart.contentHash,
+			},
+		);
+		await vi.waitFor(() => expect(events).toContain("task.updated"), {
+			timeout: 5_000,
+		});
+		expect(await restarted.getTask(created.taskId)).toMatchObject({
+			title: "Updated by watcher",
+			revision: created.revision + 2,
+		});
+	});
+
+	it("does not recreate a missing historical workspace during startup", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-agenda-missing-root-"));
+		const workspaceRoot = join(root, "workspace");
+		const movedWorkspaceRoot = join(root, "workspace-moved");
+		const dbPath = join(root, "tasks.db");
+		mkdirSync(workspaceRoot);
+		const runtime: AgendaTaskRuntime = {
+			isInteractiveClientAvailable: () => true,
+			startSession: vi.fn(),
+			runSession: vi.fn(),
+			abortSession: vi.fn(),
+		};
+		const first = new AgendaTaskManager({
+			runtime,
+			dbPath,
+			globalSpecsDir: join(root, "global-specs"),
+			watchFiles: false,
+		});
+		managers.push(first);
+		await first.start();
+		const created = await first.createTask({
+			type: "todo",
+			title: "Historical workspace task",
+			instructions: "Keep the task without recreating its project.",
+			scope: "workspace",
+			workspaceRoot,
+			expiresAt: future(),
+			createdBy: { kind: "user" },
+		});
+		await first.dispose();
+		renameSync(workspaceRoot, movedWorkspaceRoot);
+		expect(existsSync(workspaceRoot)).toBe(false);
+
+		const restarted = new AgendaTaskManager({
+			runtime,
+			dbPath,
+			globalSpecsDir: join(root, "global-specs"),
+		});
+		managers.push(restarted);
+		await restarted.start();
+
+		expect(existsSync(workspaceRoot)).toBe(false);
+		expect(await restarted.getTask(created.taskId)).toMatchObject({
+			title: "Historical workspace task",
+		});
+	});
+
+	it.skipIf(process.platform === "win32")(
+		"isolates an unsafe task source while starting other Hub task scopes",
+		async () => {
+			const root = mkdtempSync(
+				join(tmpdir(), "cline-agenda-source-isolation-"),
+			);
+			const badWorkspace = join(root, "bad-workspace");
+			const goodWorkspace = join(root, "good-workspace");
+			const dbPath = join(root, "tasks.db");
+			const globalSpecsDir = join(root, "global-specs");
+			mkdirSync(badWorkspace);
+			mkdirSync(goodWorkspace);
+			const runtime: AgendaTaskRuntime = {
+				isInteractiveClientAvailable: () => true,
+				startSession: vi.fn(),
+				runSession: vi.fn(),
+				abortSession: vi.fn(),
+			};
+			const first = new AgendaTaskManager({
+				runtime,
+				dbPath,
+				globalSpecsDir,
+				watchFiles: false,
+			});
+			managers.push(first);
+			await first.start();
+			await first.createTask({
+				type: "todo",
+				title: "Unsafe source task",
+				instructions: "This source should be isolated.",
+				scope: "workspace",
+				workspaceRoot: badWorkspace,
+				expiresAt: future(),
+				createdBy: { kind: "user" },
+			});
+			const good = await first.createTask({
+				type: "todo",
+				title: "Good source task",
+				instructions: "This source should still reconcile.",
+				scope: "workspace",
+				workspaceRoot: goodWorkspace,
+				expiresAt: future(),
+				createdBy: { kind: "user" },
+			});
+			await first.dispose();
+
+			const goodFiles = new AgendaTaskSpecFileStore({
+				scope: "workspace",
+				workspaceRoot: goodWorkspace,
+			});
+			if (!good.specPath) throw new Error("good task has no spec path");
+			const goodSource = goodFiles.readSpec(good.specPath);
+			if (!goodSource.ok || !goodSource.spec.taskId) {
+				throw new Error("good task spec fixture is invalid");
+			}
+			goodFiles.writeSpec(
+				{
+					...goodSource.spec,
+					taskId: goodSource.spec.taskId,
+					title: "Good source reconciled",
+				},
+				{
+					specPath: goodSource.specPath,
+					expectedContentHash: goodSource.contentHash,
+				},
+			);
+			const badSpecsDir = join(badWorkspace, ".cline", "tasks");
+			const badSpecsBackup = join(badWorkspace, ".cline", "tasks-real");
+			renameSync(badSpecsDir, badSpecsBackup);
+			symlinkSync(badSpecsBackup, badSpecsDir, "dir");
+
+			const logError = vi.fn();
+			const restarted = new AgendaTaskManager({
+				runtime,
+				dbPath,
+				globalSpecsDir,
+				logger: { log: vi.fn(), debug: vi.fn(), error: logError },
+			});
+			managers.push(restarted);
+			await expect(restarted.start()).resolves.toBeUndefined();
+			expect(await restarted.getTask(good.taskId)).toMatchObject({
+				title: "Good source reconciled",
+				revision: good.revision + 1,
+			});
+			expect(logError).toHaveBeenCalledWith(
+				"agenda task source startup reconciliation failed",
+				expect.objectContaining({
+					scope: "workspace",
+					workspaceRoot: badWorkspace,
+					error: expect.anything(),
+				}),
+			);
+			await expect(createPending(restarted)).resolves.toMatchObject({
+				scope: "global",
+				status: "pending_approval",
+			});
+		},
+	);
+
+	it("does not leave a task spec behind when task validation fails", async () => {
+		const { root, manager } = createHarness();
+		await manager.start();
+		await expect(
+			manager.createTask({
+				taskId: "invalid_window",
+				type: "todo",
+				title: "Impossible window",
+				instructions: "This task must not be persisted.",
+				scope: "global",
+				availableAt: future(2),
+				expiresAt: future(1),
+				createdBy: { kind: "user" },
+			}),
+		).rejects.toThrow("availableAt must be before expiresAt");
+
+		const files = new AgendaTaskSpecFileStore({
+			scope: "global",
+			taskSpecsDir: join(root, "specs"),
+		});
+		expect(files.listSpecPaths()).toEqual([]);
+		expect(await manager.getTask("invalid_window")).toBeUndefined();
+	});
+
+	it("imports and reconciles user-edited Markdown specs", async () => {
+		const { root, manager } = createHarness();
+		await manager.start();
+		const files = new AgendaTaskSpecFileStore({
+			scope: "global",
+			taskSpecsDir: join(root, "specs"),
+		});
+		const spec = files.writeSpec({
+			taskId: "task_from_file",
+			type: "reminder",
+			title: "Check CI",
+			instructions: "Check the CI result.",
+			priority: 1,
+			expiresAt: future(),
+		});
+
+		let imported = (await manager.listTasks({ scope: "global" })).find(
+			(task) => task.taskId === "task_from_file",
+		);
+		expect(imported).toMatchObject({
+			status: "pending_approval",
+			priority: 1,
+		});
+		files.writeSpec(
+			{ ...spec, title: "Check CI and release notes" },
+			{ specPath: spec.specPath },
+		);
+		await manager.listTasks({ scope: "global" });
+		imported = await manager.getTask("task_from_file");
+
+		expect(imported).toMatchObject({
+			revision: 2,
+			title: "Check CI and release notes",
+			status: "pending_approval",
+		});
+
+		files.writeSpec(
+			{
+				...spec,
+				taskId: "replacement_id",
+				title: "Check CI without changing identity",
+			},
+			{ specPath: spec.specPath },
+		);
+		await manager.listTasks({ scope: "global" });
+		expect(await manager.getTask("replacement_id")).toBeUndefined();
+		expect(await manager.getTask("task_from_file")).toMatchObject({
+			revision: 3,
+			title: "Check CI without changing identity",
+		});
+		expect(files.readSpec(spec.specPath)).toMatchObject({
+			ok: true,
+			spec: { taskId: "task_from_file" },
+		});
+	});
+
+	it("discovers the first task file in a selected workspace", async () => {
+		const { root, manager } = createHarness();
+		const workspaceRoot = join(root, "selected-workspace");
+		mkdirSync(workspaceRoot);
+		await manager.start();
+		const globalTask = await createPending(manager, { title: "General task" });
+		const files = new AgendaTaskSpecFileStore({
+			scope: "workspace",
+			workspaceRoot,
+		});
+		files.writeSpec({
+			taskId: "first_workspace_task",
+			type: "suggestion",
+			title: "First workspace suggestion",
+			instructions: "Discover this file when the workspace is selected.",
+			expiresAt: future(),
+		});
+
+		const visible = await manager.listTasks({ workspaceRoot });
+		expect(new Set(visible.map((task) => task.taskId))).toEqual(
+			new Set([globalTask.taskId, "first_workspace_task"]),
+		);
+	});
+
+	it("isolates stale hand-authored specs during startup reconciliation", async () => {
+		const { root, manager } = createHarness();
+		const files = new AgendaTaskSpecFileStore({
+			scope: "global",
+			taskSpecsDir: join(root, "specs"),
+		});
+		files.writeSpec({
+			taskId: "stale_task",
+			type: "reminder",
+			title: "Old reminder",
+			instructions: "This reminder is already stale.",
+			expiresAt: "2020-01-01T00:00:00.000Z",
+		});
+		files.writeSpec({
+			taskId: "valid_task",
+			type: "todo",
+			title: "Current task",
+			instructions: "Keep processing other valid files.",
+			expiresAt: future(),
+		});
+
+		await expect(manager.start()).resolves.toBeUndefined();
+		expect(await manager.getTask("stale_task")).toMatchObject({
+			status: "expired",
+		});
+		expect(await manager.getTask("valid_task")).toMatchObject({
+			status: "pending_approval",
+		});
+	});
+
+	it("auto-approves and starts eligible work only after automation is enabled", async () => {
+		const { manager, runtime } = createHarness();
+		await manager.start();
+		await manager.setAutomationPolicy(
+			{
+				scopeKey: "global",
+				mode: "auto_start",
+				applyToAgentCreated: true,
+				maxConcurrentRuns: 1,
+				maxChainDepth: 3,
+				maxStartsPerHour: 20,
+			},
+			{ kind: "user", clientId: "desktop" },
+		);
+		const task = await createPending(manager);
+
+		await vi.waitFor(async () => {
+			expect((await manager.getTask(task.taskId))?.status).toBe("completed");
+		});
+		expect(runtime.startSession).toHaveBeenCalledTimes(1);
+	});
+
+	it("only automates tasks in the policy workspace", async () => {
+		const { root, manager, runtime } = createHarness();
+		await manager.start();
+		const repoA = join(root, "repo-a");
+		const repoB = join(root, "repo-b");
+		mkdirSync(repoA, { recursive: true });
+		mkdirSync(repoB, { recursive: true });
+		const createWorkspaceTask = (workspaceRoot: string, title: string) =>
+			manager.createTask({
+				type: "follow-up",
+				title,
+				instructions: title,
+				scope: "workspace",
+				workspaceRoot,
+				cwd: workspaceRoot,
+				expiresAt: future(),
+				createdBy: { kind: "user", clientId: "desktop" },
+			});
+		const inScope = await createWorkspaceTask(repoA, "In scope");
+		const outOfScope = await createWorkspaceTask(repoB, "Out of scope");
+
+		await manager.setAutomationPolicy(
+			{
+				scopeKey: repoA,
+				mode: "auto_start",
+				applyToAgentCreated: true,
+				maxConcurrentRuns: 1,
+				maxChainDepth: 3,
+				maxStartsPerHour: 20,
+			},
+			{ kind: "user", clientId: "desktop" },
+		);
+
+		await vi.waitFor(async () => {
+			expect((await manager.getTask(inScope.taskId))?.status).toBe("completed");
+		});
+		expect((await manager.getTask(outOfScope.taskId))?.status).toBe(
+			"pending_approval",
+		);
+		expect(runtime.startSession).toHaveBeenCalledTimes(1);
+	});
+
+	it("keeps auto-start work approved until an interactive client is available", async () => {
+		const { manager, runtime, setInteractiveClientAvailable } = createHarness(
+			"completed",
+			{ interactiveClientAvailable: false },
+		);
+		await manager.start();
+		await manager.setAutomationPolicy(
+			{
+				scopeKey: "global",
+				mode: "auto_start",
+				applyToAgentCreated: true,
+				maxConcurrentRuns: 1,
+				maxChainDepth: 3,
+				maxStartsPerHour: 20,
+			},
+			{ kind: "user" },
+		);
+		const task = await createPending(manager);
+
+		await vi.waitFor(async () => {
+			expect((await manager.getTask(task.taskId))?.status).toBe("approved");
+		});
+		expect(runtime.startSession).not.toHaveBeenCalled();
+
+		setInteractiveClientAvailable(true);
+		manager.notifyAutomationReadinessChanged();
+		await vi.waitFor(async () => {
+			expect((await manager.getTask(task.taskId))?.status).toBe("completed");
+		});
+	});
+
+	it("drains saturated automation scopes without a microtask loop", async () => {
+		const { manager, runtime } = createHarness();
+		await manager.start();
+		await manager.setAutomationPolicy(
+			{
+				scopeKey: "global",
+				mode: "auto_start",
+				applyToAgentCreated: true,
+				maxConcurrentRuns: 1,
+				maxChainDepth: 3,
+				maxStartsPerHour: 20,
+			},
+			{ kind: "user" },
+		);
+		const task = await createPending(manager);
+		await vi.waitFor(async () => {
+			expect((await manager.getTask(task.taskId))?.status).toBe("completed");
+		});
+
+		const saturatedPolicy = (scopeKey: string) =>
+			manager.setAutomationPolicy(
+				{
+					scopeKey,
+					mode: "auto_start",
+					applyToAgentCreated: true,
+					maxConcurrentRuns: 1,
+					maxChainDepth: 3,
+					maxStartsPerHour: 1,
+				},
+				{ kind: "user" },
+			);
+		await Promise.all([
+			saturatedPolicy("/workspace-a"),
+			saturatedPolicy("/workspace-b"),
+		]);
+		await new Promise((resolve) => setTimeout(resolve, 0));
+
+		expect(runtime.startSession).toHaveBeenCalledTimes(1);
+	});
+
+	it("does not auto-approve agent-edited or raw-file intent", async () => {
+		const { root, manager, runtime } = createHarness();
+		await manager.start();
+		const userTask = await createPending(manager);
+		const edited = await manager.updateTask({
+			taskId: userTask.taskId,
+			expectedRevision: userTask.revision,
+			title: "Agent changed the requested work",
+			updatedBy: { kind: "agent", agentId: "agent_1" },
+		});
+		const files = new AgendaTaskSpecFileStore({
+			scope: "global",
+			taskSpecsDir: join(root, "specs"),
+		});
+		files.writeSpec({
+			taskId: "raw_file_task",
+			type: "todo",
+			title: "Raw file task",
+			instructions: "Do not infer that this came from a user.",
+			expiresAt: future(),
+		});
+		await manager.listTasks({ scope: "global" });
+		await manager.setAutomationPolicy(
+			{
+				scopeKey: "global",
+				mode: "auto_start",
+				applyToAgentCreated: false,
+				maxConcurrentRuns: 2,
+				maxChainDepth: 3,
+				maxStartsPerHour: 20,
+			},
+			{ kind: "user" },
+		);
+
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		expect(await manager.getTask(edited.taskId)).toMatchObject({
+			status: "pending_approval",
+		});
+		expect(await manager.getTask("raw_file_task")).toMatchObject({
+			status: "pending_approval",
+		});
+		expect(runtime.startSession).not.toHaveBeenCalled();
+	});
+
+	it("stops claiming candidates when automation is paused mid-pump", async () => {
+		const { manager, runtime } = createHarness();
+		let finishStarting: ((value: { sessionId: string }) => void) | undefined;
+		vi.mocked(runtime.startSession).mockImplementationOnce(
+			async () =>
+				await new Promise<{ sessionId: string }>((resolve) => {
+					finishStarting = resolve;
+				}),
+		);
+		await manager.start();
+		const first = await createPending(manager, { title: "First" });
+		const second = await createPending(manager, { title: "Second" });
+		await manager.setAutomationPolicy(
+			{
+				scopeKey: "global",
+				mode: "auto_start",
+				applyToAgentCreated: true,
+				maxConcurrentRuns: 2,
+				maxChainDepth: 3,
+				maxStartsPerHour: 20,
+			},
+			{ kind: "user" },
+		);
+		await vi.waitFor(() => expect(runtime.startSession).toHaveBeenCalledOnce());
+		await manager.setAutomationPolicy(
+			{
+				scopeKey: "global",
+				mode: "manual",
+				applyToAgentCreated: true,
+				maxConcurrentRuns: 2,
+				maxChainDepth: 3,
+				maxStartsPerHour: 20,
+			},
+			{ kind: "user" },
+		);
+		finishStarting?.({ sessionId: "first-session" });
+		await vi.waitFor(async () => {
+			expect((await manager.getTask(first.taskId))?.status).toBe("completed");
+		});
+		expect(runtime.startSession).toHaveBeenCalledTimes(1);
+		expect((await manager.getTask(second.taskId))?.status).toBe(
+			"pending_approval",
+		);
+	});
+
+	it("recovers a crash during session startup back to approved", async () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-agenda-recovery-"));
+		const store = new SqliteAgendaTaskStore({ dbPath: join(root, "tasks.db") });
+		const files = new AgendaTaskSpecFileStore({
+			scope: "global",
+			taskSpecsDir: join(root, "specs"),
+		});
+		const spec = files.writeSpec({
+			taskId: "recover_starting",
+			type: "todo",
+			title: "Recover me",
+			instructions: "Retry after the Hub restarts.",
+			expiresAt: future(),
+		});
+		const created = store.createTask({
+			...spec,
+			taskId: spec.taskId,
+			createdBy: { kind: "user" },
+		});
+		const approved = store.updateTaskState(created.taskId, {
+			status: "approved",
+			approvedRevision: created.revision,
+		});
+		if (!approved) throw new Error("failed to approve recovery fixture");
+		const run = store.createRun({
+			taskId: approved.taskId,
+			taskRevision: approved.revision,
+		});
+		store.updateTaskState(approved.taskId, {
+			currentRunId: run.runId,
+			lastRunId: run.runId,
+		});
+		const runtime: AgendaTaskRuntime = {
+			isInteractiveClientAvailable: () => true,
+			startSession: vi.fn(),
+			runSession: vi.fn(),
+			abortSession: vi.fn(),
+		};
+		const manager = new AgendaTaskManager({
+			runtime,
+			store,
+			globalSpecsDir: join(root, "specs"),
+			watchFiles: false,
+		});
+		managers.push(manager);
+
+		await manager.start();
+		expect(await manager.getTask(approved.taskId)).toMatchObject({
+			status: "approved",
+			currentRunId: undefined,
+		});
+		expect(store.getRun(run.runId)).toMatchObject({ status: "interrupted" });
+	});
+
+	it("preserves terminal tasks and last-known-good state across raw edits", async () => {
+		const { manager, runtime } = createHarness();
+		await manager.start();
+		const pending = await createPending(manager);
+		const approved = await manager.approveTask(
+			pending.taskId,
+			{ kind: "user" },
+			pending.revision,
+		);
+		await manager.runTask(approved.taskId, { kind: "user" }, approved.revision);
+		await vi.waitFor(async () => {
+			expect((await manager.getTask(approved.taskId))?.status).toBe(
+				"completed",
+			);
+		});
+		const completed = await manager.getTask(approved.taskId);
+		if (!completed) throw new Error("completed task was not persisted");
+		await expect(
+			manager.updateTask({
+				taskId: completed.taskId,
+				expectedRevision: completed.revision,
+				title: "Do it again",
+				updatedBy: { kind: "user" },
+			}),
+		).rejects.toThrow("cannot be edited from completed");
+		if (!completed.specPath) throw new Error("completed task has no spec path");
+		writeFileSync(completed.specPath, "not valid task Markdown");
+		await manager.listTasks({ scope: "global" });
+		expect(await manager.getTask(completed.taskId)).toMatchObject({
+			status: "completed",
+			revision: completed.revision,
+			archivedAt: undefined,
+		});
+		expect(runtime.startSession).toHaveBeenCalledTimes(1);
+	});
+});
diff --git a/sdk/packages/core/src/tasks/agenda-task-manager.ts b/sdk/packages/core/src/tasks/agenda-task-manager.ts
new file mode 100644
index 0000000000..2de95be33f
--- /dev/null
+++ b/sdk/packages/core/src/tasks/agenda-task-manager.ts
@@ -0,0 +1,1433 @@
+import type { FSWatcher } from "node:fs";
+import { existsSync, statSync, watch } from "node:fs";
+import { relative } from "node:path";
+import type {
+	AgendaAutomationPolicy,
+	AgendaTaskActor,
+	AgendaTaskCreateInput,
+	AgendaTaskListInput,
+	AgendaTaskRecord,
+	AgendaTaskRunRecord,
+	AgendaTaskUpdateInput,
+	BasicLogger,
+} from "@cline/shared";
+import { createSessionId, noopBasicLogger } from "@cline/shared";
+import type { AgendaTaskManagerApi } from "./agenda-task-api";
+import { AgendaTaskSpecFileStore } from "./specs/task-spec-file-store";
+import {
+	type AgendaTaskSpec,
+	agendaTaskSpecToCreateInput,
+} from "./specs/task-spec-parser";
+import { SqliteAgendaTaskStore } from "./store/sqlite-task-store";
+import { normalizeAgendaTaskLocation } from "./task-location";
+
+const FILE_RECONCILER_ACTOR: AgendaTaskActor = {
+	kind: "system",
+	id: "file_reconciler",
+};
+const TASK_MANAGER_ACTOR: AgendaTaskActor = {
+	kind: "system",
+	id: "task_manager",
+};
+const AUTOMATION_ACTOR: AgendaTaskActor = {
+	kind: "automation_policy",
+	id: "global",
+};
+const TERMINAL_RUN_STATUSES = new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"interrupted",
+]);
+const MAINTENANCE_INTERVAL_MS = 30_000;
+const DEFAULT_WATCH_DEBOUNCE_MS = 250;
+
+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;
+	logger?: BasicLogger;
+	publish?: (
+		event: AgendaTaskManagerEventName,
+		payload: Record<string, unknown>,
+		sessionId?: string,
+	) => void;
+}
+
+type WatchedScope = {
+	store: AgendaTaskSpecFileStore;
+	watcher?: FSWatcher;
+	timer?: ReturnType<typeof setTimeout>;
+};
+
+function nowIso(): string {
+	return new Date().toISOString();
+}
+
+function optionalTrimmed(value: string | null | undefined): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function assertFutureExpiry(expiresAt: string): void {
+	const timestamp = Date.parse(expiresAt);
+	if (!Number.isFinite(timestamp)) {
+		throw new Error("expiresAt must be a valid ISO-8601 timestamp");
+	}
+	if (timestamp <= Date.now()) {
+		throw new Error("expiresAt must be in the future");
+	}
+}
+
+function isPathInside(parent: string, child: string): boolean {
+	const rel = relative(parent, child);
+	return rel !== "" && !rel.startsWith("..") && !rel.startsWith("/");
+}
+
+function isExistingDirectory(path: string | undefined): path is string {
+	if (!path || !existsSync(path)) return false;
+	try {
+		return statSync(path).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+function specSignature(
+	spec: AgendaTaskSpec,
+	current: AgendaTaskRecord,
+): string {
+	return JSON.stringify({
+		type: spec.type,
+		title: spec.title,
+		description: spec.description,
+		instructions: spec.instructions,
+		scope: spec.scope,
+		workspaceRoot: spec.workspaceRoot,
+		cwd: spec.cwd,
+		resourcePaths: spec.resourcePaths,
+		priority: spec.priority,
+		assignee: spec.assignee,
+		modelSelection: spec.modelSelection,
+		mode: spec.mode,
+		systemPrompt: spec.systemPrompt,
+		maxIterations: spec.maxIterations,
+		timeoutSeconds: spec.timeoutSeconds,
+		availableAt: spec.availableAt ?? current.availableAt,
+		expiresAt: spec.expiresAt,
+		automationEligible: spec.automationEligible,
+	});
+}
+
+function taskSignature(task: AgendaTaskRecord): string {
+	return JSON.stringify({
+		type: task.type,
+		title: task.title,
+		description: task.description,
+		instructions: task.instructions,
+		scope: task.scope,
+		workspaceRoot: task.workspaceRoot,
+		cwd: task.cwd,
+		resourcePaths: task.resourcePaths,
+		priority: task.priority,
+		assignee: task.assignee,
+		modelSelection: task.modelSelection,
+		mode: task.mode,
+		systemPrompt: task.systemPrompt,
+		maxIterations: task.maxIterations,
+		timeoutSeconds: task.timeoutSeconds,
+		availableAt: task.availableAt,
+		expiresAt: task.expiresAt,
+		automationEligible: task.automationEligible,
+	});
+}
+
+function specUpdate(
+	spec: AgendaTaskSpec,
+	current: AgendaTaskRecord,
+): AgendaTaskUpdateInput {
+	return {
+		taskId: current.taskId,
+		expectedRevision: current.revision,
+		type: spec.type,
+		title: spec.title,
+		description: spec.description ?? null,
+		instructions: spec.instructions,
+		scope: spec.scope,
+		workspaceRoot: spec.workspaceRoot ?? null,
+		cwd: spec.cwd ?? null,
+		resourcePaths: spec.resourcePaths,
+		priority: spec.priority,
+		assignee: spec.assignee ?? null,
+		modelSelection: spec.modelSelection ?? null,
+		mode: spec.mode ?? null,
+		systemPrompt: spec.systemPrompt ?? null,
+		maxIterations: spec.maxIterations ?? null,
+		timeoutSeconds: spec.timeoutSeconds ?? null,
+		availableAt: spec.availableAt ?? current.availableAt,
+		expiresAt: spec.expiresAt,
+		automationEligible: spec.automationEligible,
+		updatedBy: FILE_RECONCILER_ACTOR,
+	};
+}
+
+function mergedEditableTask(
+	current: AgendaTaskRecord,
+	input: AgendaTaskUpdateInput,
+): AgendaTaskRecord {
+	return {
+		...current,
+		type: input.type ?? current.type,
+		title: input.title ?? current.title,
+		description:
+			input.description === null
+				? undefined
+				: (input.description ?? current.description),
+		instructions: input.instructions ?? current.instructions,
+		scope: input.scope ?? current.scope,
+		workspaceRoot:
+			input.workspaceRoot === null
+				? undefined
+				: (input.workspaceRoot ?? current.workspaceRoot),
+		cwd: input.cwd === null ? undefined : (input.cwd ?? current.cwd),
+		resourcePaths: input.resourcePaths ?? current.resourcePaths,
+		priority: input.priority ?? current.priority,
+		assignee:
+			input.assignee === null
+				? undefined
+				: (input.assignee ?? current.assignee),
+		modelSelection:
+			input.modelSelection === null
+				? undefined
+				: (input.modelSelection ?? current.modelSelection),
+		mode: input.mode === null ? undefined : (input.mode ?? current.mode),
+		systemPrompt:
+			input.systemPrompt === null
+				? undefined
+				: (input.systemPrompt ?? current.systemPrompt),
+		maxIterations:
+			input.maxIterations === null
+				? undefined
+				: (input.maxIterations ?? current.maxIterations),
+		timeoutSeconds:
+			input.timeoutSeconds === null
+				? undefined
+				: (input.timeoutSeconds ?? current.timeoutSeconds),
+		availableAt: input.availableAt ?? current.availableAt,
+		expiresAt: input.expiresAt ?? current.expiresAt,
+		automationEligible: input.automationEligible ?? current.automationEligible,
+	};
+}
+
+/** Hub-owned lifecycle coordinator and the only operational task writer. */
+export class AgendaTaskManager implements AgendaTaskManagerApi {
+	private readonly runtime: AgendaTaskRuntime;
+	private readonly store: SqliteAgendaTaskStore;
+	private readonly ownsStore: boolean;
+	private readonly globalSpecsDir?: string;
+	private readonly watcherDebounceMs: number;
+	private readonly watchFiles: boolean;
+	private readonly logger: BasicLogger;
+	private readonly publishEvent: NonNullable<
+		AgendaTaskManagerOptions["publish"]
+	>;
+	private readonly scopes = new Map<string, WatchedScope>();
+	private readonly activeRuns = new Map<
+		string,
+		{ runId: string; sessionId?: string }
+	>();
+	private readonly backgroundRuns = new Set<Promise<void>>();
+	private maintenanceTimer?: ReturnType<typeof setInterval>;
+	private readonly queuedAutomationScopes = new Set<string>();
+	private automationPumping = false;
+	private automationPolicyGeneration = 0;
+	private started = false;
+	private disposed = false;
+
+	constructor(options: AgendaTaskManagerOptions) {
+		this.runtime = options.runtime;
+		this.ownsStore = !options.store;
+		this.store =
+			options.store ?? new SqliteAgendaTaskStore({ dbPath: options.dbPath });
+		this.globalSpecsDir = options.globalSpecsDir;
+		this.watcherDebounceMs = Math.max(
+			0,
+			options.watcherDebounceMs ?? DEFAULT_WATCH_DEBOUNCE_MS,
+		);
+		this.watchFiles = options.watchFiles !== false;
+		this.logger = options.logger ?? noopBasicLogger;
+		this.publishEvent = options.publish ?? (() => {});
+	}
+
+	async start(): Promise<void> {
+		if (this.disposed) throw new Error("AgendaTaskManager disposed");
+		if (this.started) return;
+		this.started = true;
+		this.recoverInterruptedRuns();
+		await this.reconcileSourceForProjection("global", undefined, "startup");
+		for (const workspaceRoot of this.store.listWorkspaceRoots()) {
+			if (isExistingDirectory(workspaceRoot)) {
+				await this.reconcileSourceForProjection(
+					"workspace",
+					workspaceRoot,
+					"startup",
+				);
+			}
+		}
+		this.expireTasks();
+		this.maintenanceTimer = setInterval(() => {
+			this.expireTasks();
+			this.queueAutomation();
+		}, MAINTENANCE_INTERVAL_MS);
+		this.maintenanceTimer.unref?.();
+		this.queueAutomation();
+	}
+
+	async dispose(): Promise<void> {
+		if (this.disposed) return;
+		this.disposed = true;
+		if (this.maintenanceTimer) clearInterval(this.maintenanceTimer);
+		for (const scope of this.scopes.values()) {
+			if (scope.timer) clearTimeout(scope.timer);
+			scope.watcher?.close();
+		}
+		this.scopes.clear();
+		for (const active of this.activeRuns.values()) {
+			if (active.sessionId) {
+				await this.runtime
+					.abortSession(active.sessionId, "Hub task manager stopped")
+					.catch(() => {});
+			}
+		}
+		await Promise.allSettled(this.backgroundRuns);
+		for (const [taskId, active] of this.activeRuns) {
+			this.store.updateRun(active.runId, {
+				status: "interrupted",
+				completedAt: nowIso(),
+				error: "Hub task manager stopped before the run completed.",
+			});
+			this.store.updateTaskState(taskId, {
+				status: "failed",
+				currentRunId: null,
+				error: "Hub task manager stopped before the run completed.",
+				updatedBy: TASK_MANAGER_ACTOR,
+			});
+		}
+		this.activeRuns.clear();
+		if (this.ownsStore) this.store.close();
+	}
+
+	async createTask(input: AgendaTaskCreateInput): Promise<AgendaTaskRecord> {
+		this.assertUsable();
+		assertFutureExpiry(input.expiresAt);
+		const location = normalizeAgendaTaskLocation(input);
+		const normalizedInput: AgendaTaskCreateInput = { ...input, ...location };
+		const taskId =
+			optionalTrimmed(normalizedInput.taskId) ?? createSessionId("task_");
+		await this.reconcileScope(
+			normalizedInput.scope,
+			normalizedInput.workspaceRoot,
+		);
+		if (this.store.getTask(taskId)) {
+			throw new Error(`task ${taskId} already exists`);
+		}
+		const fileStore = this.ensureScope(
+			normalizedInput.scope,
+			normalizedInput.workspaceRoot,
+		);
+		const specPath = fileStore.resolveWritePath(
+			taskId,
+			normalizedInput.specPath,
+		);
+		if (existsSync(specPath) || this.store.getTaskBySpecPath(specPath)) {
+			throw new Error(`task spec already exists: ${specPath}`);
+		}
+		const task = this.store.createTask({
+			...normalizedInput,
+			taskId,
+			specPath,
+		});
+		try {
+			fileStore.writeSpec(
+				{ ...normalizedInput, taskId },
+				{ specPath, createOnly: true },
+			);
+		} catch (error) {
+			this.store.deleteTask(taskId);
+			throw error;
+		}
+		this.publish("task.created", task);
+		this.expireTask(task);
+		this.queueAutomation();
+		return this.requireTask(taskId);
+	}
+
+	async listTasks(
+		input: AgendaTaskListInput = {},
+	): Promise<AgendaTaskRecord[]> {
+		this.assertUsable();
+		if (!input.scope || input.scope === "global") {
+			await this.reconcileSourceForProjection("global", undefined, "list");
+		}
+		if (input.workspaceRoot) {
+			if (isExistingDirectory(input.workspaceRoot)) {
+				await this.reconcileSourceForProjection(
+					"workspace",
+					input.workspaceRoot,
+					"list",
+				);
+			}
+		} else if (input.scope !== "global") {
+			for (const workspaceRoot of this.store.listWorkspaceRoots()) {
+				if (isExistingDirectory(workspaceRoot)) {
+					await this.reconcileSourceForProjection(
+						"workspace",
+						workspaceRoot,
+						"list",
+					);
+				}
+			}
+		}
+		this.expireTasks();
+		return this.store.listTasks(input);
+	}
+
+	async getTask(taskId: string): Promise<AgendaTaskRecord | undefined> {
+		this.assertUsable();
+		const current = this.store.getTask(taskId.trim());
+		if (
+			current?.scope === "workspace" &&
+			isExistingDirectory(current.workspaceRoot)
+		) {
+			await this.reconcileSourceForProjection(
+				"workspace",
+				current.workspaceRoot,
+				"read",
+			);
+		} else if (current?.scope === "global") {
+			await this.reconcileSourceForProjection("global", undefined, "read");
+		}
+		const task = this.store.getTask(taskId.trim());
+		if (task) this.expireTask(task);
+		return this.store.getTask(taskId.trim());
+	}
+
+	async updateTask(input: AgendaTaskUpdateInput): Promise<AgendaTaskRecord> {
+		this.assertUsable();
+		const current = this.requireTask(input.taskId);
+		if (current.revision !== input.expectedRevision) {
+			// Let the store produce its canonical conflict error and current record.
+			this.store.updateTask(input);
+		}
+		if (current.status === "in_progress") {
+			throw new Error("an in-progress task cannot be edited");
+		}
+		if (
+			current.status === "completed" ||
+			current.status === "cancelled" ||
+			current.status === "expired"
+		) {
+			throw new Error(
+				`task ${current.taskId} cannot be edited from ${current.status}; create a new task instead`,
+			);
+		}
+		const desired = mergedEditableTask(current, input);
+		assertFutureExpiry(desired.expiresAt);
+		const location = normalizeAgendaTaskLocation(desired);
+		const normalizedDesired = { ...desired, ...location };
+		const normalizedInput: AgendaTaskUpdateInput = {
+			...input,
+			scope: normalizedDesired.scope,
+			workspaceRoot: normalizedDesired.workspaceRoot ?? null,
+			cwd: normalizedDesired.cwd ?? null,
+			resourcePaths: normalizedDesired.resourcePaths,
+		};
+		const targetStore = this.ensureScope(
+			normalizedDesired.scope,
+			normalizedDesired.workspaceRoot,
+		);
+		const staysInSameStore =
+			current.specPath !== undefined &&
+			isPathInside(targetStore.specsDir, current.specPath);
+		if (!staysInSameStore) {
+			await this.reconcileFileStore(targetStore);
+		}
+		const targetSpecPath = targetStore.resolveWritePath(
+			current.taskId,
+			staysInSameStore ? current.specPath : undefined,
+		);
+		if (
+			targetSpecPath !== current.specPath &&
+			(existsSync(targetSpecPath) ||
+				this.store.getTaskBySpecPath(targetSpecPath))
+		) {
+			throw new Error(`task spec already exists: ${targetSpecPath}`);
+		}
+		let expectedContentHash: string | undefined;
+		if (staysInSameStore && current.specPath) {
+			const source = targetStore.readSpec(current.specPath);
+			if (!source.ok) {
+				throw new Error(`task spec is invalid: ${source.error}`);
+			}
+			if (
+				input.updatedBy.id !== FILE_RECONCILER_ACTOR.id &&
+				specSignature(source.spec, current) !== taskSignature(current)
+			) {
+				throw new Error(
+					`task spec changed outside the manager; reconcile task ${current.taskId} and retry`,
+				);
+			}
+			expectedContentHash = source.contentHash;
+		}
+		let spec: AgendaTaskSpec | undefined;
+		let updated: AgendaTaskRecord | undefined;
+		try {
+			spec = targetStore.writeSpec(normalizedDesired, {
+				specPath: targetSpecPath,
+				expectedContentHash,
+				createOnly: !staysInSameStore,
+			});
+			updated = this.store.updateTask(normalizedInput);
+		} catch (error) {
+			try {
+				if (spec && staysInSameStore && current.specPath) {
+					targetStore.writeSpec(current, {
+						specPath: current.specPath,
+						expectedContentHash: spec.contentHash,
+					});
+				} else if (spec) {
+					targetStore.deleteSpec(targetSpecPath, {
+						expectedContentHash: spec.contentHash,
+					});
+				}
+			} catch (cleanupError) {
+				this.logError("agenda task update rollback failed", cleanupError, {
+					taskId: current.taskId,
+					specPath: targetSpecPath,
+				});
+			}
+			throw error;
+		}
+		if (!updated || !spec) throw new Error(`unknown task: ${input.taskId}`);
+		const normalized = this.store.updateTaskState(
+			updated.taskId,
+			{
+				status: "pending_approval",
+				approvedRevision: null,
+				currentRunId: null,
+				specPath: spec.specPath,
+				error: null,
+				completedAt: null,
+				archivedAt: null,
+				updatedBy: input.updatedBy,
+			},
+			updated.revision,
+		);
+		if (current.specPath && current.specPath !== spec.specPath) {
+			this.fileStoreForTask(current).deleteSpec(current.specPath);
+		}
+		const task = normalized ?? this.requireTask(input.taskId);
+		this.publish("task.updated", task);
+		this.expireTask(task);
+		this.queueAutomation();
+		return this.requireTask(input.taskId);
+	}
+
+	async approveTask(
+		taskId: string,
+		actor: AgendaTaskActor,
+		expectedRevision: number,
+	): Promise<AgendaTaskRecord> {
+		this.assertUsable();
+		const current = await this.refreshAndVerifyTaskIntent(taskId);
+		this.assertRevision(current, expectedRevision);
+		if (this.isExpired(current)) {
+			this.expireTask(current);
+			throw new Error(`task ${taskId} has expired`);
+		}
+		if (
+			current.status === "approved" &&
+			current.approvedRevision === current.revision
+		) {
+			return current;
+		}
+		if (current.status !== "pending_approval" && current.status !== "failed") {
+			throw new Error(
+				`task ${taskId} cannot be approved from ${current.status}`,
+			);
+		}
+		const task = this.store.updateTaskState(
+			taskId,
+			{
+				status: "approved",
+				approvedRevision: current.revision,
+				error: null,
+				updatedBy: actor,
+			},
+			current.revision,
+		);
+		if (!task) throw new Error(`unknown task: ${taskId}`);
+		this.publish("task.updated", task);
+		this.queueAutomation();
+		return task;
+	}
+
+	async cancelTask(
+		taskId: string,
+		actor: AgendaTaskActor,
+		expectedRevision: number,
+		reason?: string,
+	): Promise<AgendaTaskRecord> {
+		this.assertUsable();
+		const current = this.requireTask(taskId);
+		this.assertRevision(current, expectedRevision);
+		if (current.status === "cancelled") return current;
+		if (current.status === "completed" || current.status === "expired") {
+			throw new Error(
+				`task ${taskId} cannot be cancelled from ${current.status}`,
+			);
+		}
+		const active = current.currentRunId
+			? this.store.getRun(current.currentRunId)
+			: undefined;
+		const cancellationReason = reason?.trim() || "Agenda task cancelled";
+		if (active && !TERMINAL_RUN_STATUSES.has(active.status)) {
+			this.store.updateRun(active.runId, {
+				status: "cancelled",
+				completedAt: nowIso(),
+				error: reason?.trim() || undefined,
+			});
+		}
+		this.activeRuns.delete(taskId);
+		const task = this.store.updateTaskState(
+			taskId,
+			{
+				status: "cancelled",
+				approvedRevision: null,
+				currentRunId: null,
+				error: reason?.trim() || null,
+				updatedBy: actor,
+			},
+			current.revision,
+		);
+		if (!task) throw new Error(`unknown task: ${taskId}`);
+		this.publish("task.updated", task, active);
+		if (active?.sessionId) {
+			try {
+				await this.runtime.abortSession(active.sessionId, cancellationReason);
+			} catch (error) {
+				this.logError("agenda task session abort failed", error, {
+					taskId,
+					runId: active.runId,
+					sessionId: active.sessionId,
+				});
+			}
+		}
+		return task;
+	}
+
+	async runTask(
+		taskId: string,
+		actor: AgendaTaskActor,
+		expectedRevision: number,
+		requestedByClientId?: string,
+	): Promise<{ task: AgendaTaskRecord; run?: AgendaTaskRunRecord }> {
+		this.assertUsable();
+		const current = await this.refreshAndVerifyTaskIntent(taskId);
+		this.assertRevision(current, expectedRevision);
+		if (this.isExpired(current)) {
+			this.expireTask(current);
+			throw new Error(`task ${taskId} has expired`);
+		}
+		if (Date.parse(current.availableAt) > Date.now()) {
+			throw new Error(`task ${taskId} is not available yet`);
+		}
+		if (current.status !== "approved" && current.status !== "failed") {
+			throw new Error(`task ${taskId} must be approved before it can run`);
+		}
+		if (current.approvedRevision !== current.revision) {
+			throw new Error(`task ${taskId} approval is stale`);
+		}
+		if (this.activeRuns.has(taskId) || current.currentRunId) {
+			throw new Error(`task ${taskId} already has an active run`);
+		}
+		let run = this.store.createRun({
+			taskId,
+			taskRevision: current.revision,
+			requestedByClientId,
+		});
+		let task = this.store.updateTaskState(
+			taskId,
+			{
+				currentRunId: run.runId,
+				lastRunId: run.runId,
+				error: null,
+				completedAt: null,
+				updatedBy: actor,
+			},
+			current.revision,
+		);
+		if (!task) throw new Error(`unknown task: ${taskId}`);
+		this.activeRuns.set(taskId, { runId: run.runId });
+		this.publish("task.updated", task, run);
+		try {
+			const started = await this.runtime.startSession(
+				task,
+				run,
+				requestedByClientId,
+				{
+					unattended:
+						actor.kind === "automation_policy" &&
+						this.store.getAutomationPolicy(
+							task.scope === "workspace" && task.workspaceRoot
+								? task.workspaceRoot
+								: "global",
+						).mode === "unattended",
+				},
+			);
+			const latestRun = this.store.getRun(run.runId);
+			const latestTask = this.store.getTask(taskId);
+			if (
+				!latestRun ||
+				TERMINAL_RUN_STATUSES.has(latestRun.status) ||
+				latestTask?.status !== current.status ||
+				latestTask.currentRunId !== run.runId
+			) {
+				if (latestRun && !TERMINAL_RUN_STATUSES.has(latestRun.status)) {
+					this.store.updateRun(run.runId, {
+						status: "cancelled",
+						sessionId: started.sessionId,
+						completedAt: nowIso(),
+						error:
+							"Task changed or was cancelled while its session was starting.",
+					});
+				} else if (latestRun) {
+					this.store.updateRun(run.runId, { sessionId: started.sessionId });
+				}
+				this.activeRuns.delete(taskId);
+				await this.runtime
+					.abortSession(
+						started.sessionId,
+						"Agenda task was cancelled while its session was starting",
+					)
+					.catch((error) =>
+						this.logError("cancelled agenda task session abort failed", error, {
+							taskId,
+							runId: run.runId,
+							sessionId: started.sessionId,
+						}),
+					);
+				throw new Error(
+					`task ${taskId} changed or was cancelled while starting`,
+				);
+			}
+			run =
+				this.store.updateRun(run.runId, {
+					status: "running",
+					sessionId: started.sessionId,
+					startedAt: nowIso(),
+				}) ?? run;
+			task =
+				this.store.updateTaskState(taskId, {
+					status: "in_progress",
+					lastSessionId: started.sessionId,
+					updatedBy: actor,
+				}) ?? task;
+			this.activeRuns.set(taskId, {
+				runId: run.runId,
+				sessionId: started.sessionId,
+			});
+			this.publish("task.run.started", task, run);
+			const completion = this.finishRun(task, run, started.sessionId);
+			this.backgroundRuns.add(completion);
+			void completion.finally(() => this.backgroundRuns.delete(completion));
+			return { task, run };
+		} catch (error) {
+			await this.finishRunFailure(task, run, error);
+			throw error;
+		}
+	}
+
+	async getAutomationPolicy(
+		scopeKey = "global",
+	): Promise<AgendaAutomationPolicy> {
+		this.assertUsable();
+		return this.store.getAutomationPolicy(scopeKey);
+	}
+
+	async setAutomationPolicy(
+		policy: Omit<AgendaAutomationPolicy, "updatedAt">,
+		actor: AgendaTaskActor,
+	): Promise<AgendaAutomationPolicy> {
+		this.assertUsable();
+		const now = nowIso();
+		const next = this.store.setAutomationPolicy({
+			...policy,
+			enabledBy: policy.mode === "manual" ? undefined : actor,
+			enabledAt: policy.mode === "manual" ? undefined : now,
+		});
+		this.automationPolicyGeneration += 1;
+		this.publishEvent("task.automation.updated", { policy: next });
+		this.queueAutomation(next.scopeKey);
+		return next;
+	}
+
+	/** Re-evaluate auto-start work after Hub client readiness changes. */
+	notifyAutomationReadinessChanged(): void {
+		if (!this.disposed) this.queueAutomation();
+	}
+
+	private async finishRun(
+		task: AgendaTaskRecord,
+		run: AgendaTaskRunRecord,
+		sessionId: string,
+	): Promise<void> {
+		try {
+			const result = await this.runtime.runSession(sessionId, task, run);
+			const latestRun = this.store.getRun(run.runId);
+			if (!latestRun || TERMINAL_RUN_STATUSES.has(latestRun.status)) return;
+			if (result.status === "completed") {
+				const completedAt = nowIso();
+				const finalRun =
+					this.store.updateRun(run.runId, {
+						status: "completed",
+						completedAt,
+						resultSummary: result.summary,
+						error: null,
+					}) ?? latestRun;
+				const finalTask =
+					this.store.updateTaskState(task.taskId, {
+						status: "completed",
+						currentRunId: null,
+						error: null,
+						completedAt,
+						updatedBy: TASK_MANAGER_ACTOR,
+					}) ?? this.requireTask(task.taskId);
+				this.publish("task.run.completed", finalTask, finalRun);
+			} else if (result.status === "cancelled") {
+				await this.cancelTask(
+					task.taskId,
+					TASK_MANAGER_ACTOR,
+					task.revision,
+					result.error || "Task session was cancelled",
+				);
+			} else {
+				await this.finishRunFailure(
+					task,
+					run,
+					new Error(result.error || result.summary || "Task session failed"),
+				);
+			}
+		} catch (error) {
+			await this.finishRunFailure(task, run, error);
+		} finally {
+			this.activeRuns.delete(task.taskId);
+			const latest = this.store.getTask(task.taskId);
+			const reconciliation =
+				latest?.scope === "workspace" && latest.workspaceRoot
+					? this.reconcileScope("workspace", latest.workspaceRoot)
+					: this.reconcileScope("global");
+			void reconciliation.catch((error) =>
+				this.logError("post-run agenda task reconciliation failed", error, {
+					taskId: task.taskId,
+				}),
+			);
+			this.queueAutomation();
+		}
+	}
+
+	private async finishRunFailure(
+		task: AgendaTaskRecord,
+		run: AgendaTaskRunRecord,
+		error: unknown,
+	): Promise<void> {
+		const latestRun = this.store.getRun(run.runId);
+		if (!latestRun || TERMINAL_RUN_STATUSES.has(latestRun.status)) return;
+		const message = error instanceof Error ? error.message : String(error);
+		const finalRun =
+			this.store.updateRun(run.runId, {
+				status: "failed",
+				completedAt: nowIso(),
+				error: message,
+			}) ?? latestRun;
+		const latestTask = this.store.getTask(task.taskId);
+		if (!latestTask || latestTask.status === "cancelled") return;
+		if (latestTask.currentRunId !== run.runId) {
+			this.activeRuns.delete(task.taskId);
+			this.publish("task.run.failed", latestTask, finalRun);
+			return;
+		}
+		const finalTask =
+			this.store.updateTaskState(task.taskId, {
+				status: "failed",
+				currentRunId: null,
+				error: message,
+				updatedBy: TASK_MANAGER_ACTOR,
+			}) ?? latestTask;
+		this.activeRuns.delete(task.taskId);
+		this.publish("task.run.failed", finalTask, finalRun);
+	}
+
+	private ensureScope(
+		scope: "global" | "workspace",
+		workspaceRoot?: string,
+	): AgendaTaskSpecFileStore {
+		const root = optionalTrimmed(workspaceRoot);
+		if (scope === "workspace" && !root) {
+			throw new Error("workspaceRoot is required for workspace task scope");
+		}
+		if (scope === "workspace" && !isExistingDirectory(root)) {
+			throw new Error("workspaceRoot must be an existing directory");
+		}
+		const key = scope === "global" ? "global" : `workspace:${root}`;
+		const existing = this.scopes.get(key);
+		if (existing) return existing.store;
+		const store = new AgendaTaskSpecFileStore({
+			scope,
+			workspaceRoot: root,
+			taskSpecsDir: scope === "global" ? this.globalSpecsDir : undefined,
+		});
+		const watched: WatchedScope = { store };
+		let cacheScope = true;
+		try {
+			store.ensureSpecsDir();
+			if (this.watchFiles) {
+				watched.watcher = watch(store.specsDir, (_event, filename) => {
+					if (!filename || !String(filename).endsWith(".task.md")) return;
+					if (watched.timer) clearTimeout(watched.timer);
+					watched.timer = setTimeout(() => {
+						watched.timer = undefined;
+						void this.reconcileFileStore(store).catch((error) =>
+							this.logError(
+								"agenda task watcher reconciliation failed",
+								error,
+								{
+									specsDir: store.specsDir,
+								},
+							),
+						);
+					}, this.watcherDebounceMs);
+				});
+				watched.watcher.on("error", (error) =>
+					this.logError("agenda task watcher failed", error, {
+						specsDir: store.specsDir,
+					}),
+				);
+			}
+		} catch (error) {
+			cacheScope = false;
+			this.logError("agenda task source could not be attached", error, {
+				specsDir: store.specsDir,
+			});
+		}
+		if (cacheScope) this.scopes.set(key, watched);
+		return store;
+	}
+
+	private async reconcileScope(
+		scope: "global" | "workspace",
+		workspaceRoot?: string,
+	): Promise<void> {
+		const store = this.ensureScope(scope, workspaceRoot);
+		await this.reconcileFileStore(store);
+	}
+
+	private async reconcileSourceForProjection(
+		scope: "global" | "workspace",
+		workspaceRoot: string | undefined,
+		phase: "startup" | "list" | "read",
+	): Promise<void> {
+		try {
+			await this.reconcileScope(scope, workspaceRoot);
+		} catch (error) {
+			this.logError(
+				`agenda task source ${phase} reconciliation failed`,
+				error,
+				{ scope, ...(workspaceRoot ? { workspaceRoot } : {}) },
+			);
+		}
+	}
+
+	private async reconcileFileStore(
+		fileStore: AgendaTaskSpecFileStore,
+	): Promise<void> {
+		if (this.disposed) return;
+		const seen = new Set<string>();
+		for (const parsed of fileStore.listSpecs()) {
+			seen.add(parsed.specPath);
+			if (!parsed.ok) {
+				this.logger.log("agenda task spec is invalid", {
+					severity: "warn",
+					specPath: parsed.specPath,
+					error: parsed.error,
+				});
+				continue;
+			}
+			try {
+				let spec = parsed.spec;
+				if (!spec.taskId) {
+					spec = fileStore.writeSpec(
+						{ ...spec, taskId: createSessionId("task_") },
+						{
+							specPath: spec.specPath,
+							expectedContentHash: spec.contentHash,
+						},
+					);
+				}
+				const existingByPath = this.store.getTaskBySpecPath(spec.specPath);
+				if (
+					existingByPath &&
+					spec.taskId &&
+					spec.taskId !== existingByPath.taskId
+				) {
+					this.logger.log("agenda task id is immutable for an existing spec", {
+						severity: "warn",
+						taskId: existingByPath.taskId,
+						requestedTaskId: spec.taskId,
+						specPath: spec.specPath,
+					});
+					spec = fileStore.writeSpec(
+						{ ...spec, taskId: existingByPath.taskId },
+						{
+							specPath: spec.specPath,
+							expectedContentHash: spec.contentHash,
+						},
+					);
+				}
+				const existingById = spec.taskId
+					? this.store.getTask(spec.taskId)
+					: undefined;
+				let existing = existingByPath ?? existingById;
+				if (existingById?.specPath && existingById.specPath !== spec.specPath) {
+					this.logger.log("agenda task id is already owned by another spec", {
+						severity: "warn",
+						taskId: spec.taskId,
+						specPath: spec.specPath,
+					});
+					continue;
+				}
+				if (!existing) {
+					const created = this.store.createTask(
+						agendaTaskSpecToCreateInput(spec, FILE_RECONCILER_ACTOR),
+					);
+					this.publish("task.created", created);
+					this.expireTask(created);
+					continue;
+				}
+				if (existing.archivedAt) {
+					const wasDeletedBeforeStart =
+						existing.status === "cancelled" &&
+						existing.error === "Task spec was deleted.";
+					const restored = this.store.updateTaskState(existing.taskId, {
+						status: wasDeletedBeforeStart
+							? "pending_approval"
+							: existing.status,
+						approvedRevision: wasDeletedBeforeStart
+							? null
+							: existing.approvedRevision,
+						archivedAt: null,
+						error: wasDeletedBeforeStart ? null : existing.error,
+						updatedBy: FILE_RECONCILER_ACTOR,
+					});
+					if (restored) {
+						existing = restored;
+						this.publish("task.updated", restored);
+					}
+				}
+				if (specSignature(spec, existing) === taskSignature(existing)) continue;
+				if (existing.status === "in_progress") {
+					this.logger.log("agenda task edit deferred until its run completes", {
+						severity: "warn",
+						taskId: existing.taskId,
+					});
+					continue;
+				}
+				if (
+					existing.status === "completed" ||
+					existing.status === "cancelled" ||
+					existing.status === "expired"
+				) {
+					this.logger.log("terminal agenda task edits are not applied", {
+						severity: "warn",
+						taskId: existing.taskId,
+						status: existing.status,
+					});
+					fileStore.writeSpec(existing, {
+						specPath: spec.specPath,
+						expectedContentHash: spec.contentHash,
+					});
+					continue;
+				}
+				await this.updateTask(specUpdate(spec, existing));
+			} catch (error) {
+				this.logError("agenda task spec reconciliation failed", error, {
+					specPath: parsed.spec.specPath,
+				});
+			}
+		}
+
+		const scopedTasks = this.store.listTasks({
+			scope: fileStore.scope,
+			workspaceRoot: fileStore.workspaceRoot,
+			includeArchived: true,
+			limit: 1000,
+		});
+		for (const task of scopedTasks) {
+			if (
+				!task.specPath ||
+				!isPathInside(fileStore.specsDir, task.specPath) ||
+				seen.has(task.specPath) ||
+				task.archivedAt
+			) {
+				continue;
+			}
+			if (task.status === "in_progress") {
+				await this.cancelTask(
+					task.taskId,
+					FILE_RECONCILER_ACTOR,
+					task.revision,
+					"Task spec was deleted.",
+				);
+			}
+			const archived = this.store.updateTaskState(task.taskId, {
+				status:
+					task.status === "completed" || task.status === "expired"
+						? task.status
+						: "cancelled",
+				approvedRevision: null,
+				currentRunId: null,
+				error:
+					task.status === "cancelled"
+						? (task.error ?? null)
+						: "Task spec was deleted.",
+				archivedAt: nowIso(),
+				updatedBy: FILE_RECONCILER_ACTOR,
+			});
+			if (archived) this.publish("task.deleted", archived);
+		}
+		this.queueAutomation();
+	}
+
+	private expireTasks(): void {
+		for (const task of this.store.listTasks({ limit: 1000 })) {
+			this.expireTask(task);
+		}
+	}
+
+	private expireTask(task: AgendaTaskRecord): void {
+		if (!this.isExpired(task)) return;
+		if (
+			task.currentRunId ||
+			task.status === "in_progress" ||
+			task.status === "completed" ||
+			task.status === "cancelled" ||
+			task.status === "expired"
+		) {
+			return;
+		}
+		const expired = this.store.updateTaskState(task.taskId, {
+			status: "expired",
+			approvedRevision: null,
+			currentRunId: null,
+			error: "Task expired before it was started.",
+			updatedBy: TASK_MANAGER_ACTOR,
+		});
+		if (expired) this.publish("task.updated", expired);
+	}
+
+	private isExpired(task: AgendaTaskRecord): boolean {
+		return Date.parse(task.expiresAt) <= Date.now();
+	}
+
+	private recoverInterruptedRuns(): void {
+		const interruptedAt = nowIso();
+		for (const run of this.store.listRuns({
+			status: ["starting", "running"],
+			limit: 1000,
+		})) {
+			this.store.updateRun(run.runId, {
+				status: "interrupted",
+				completedAt: interruptedAt,
+				error: "Hub restarted while this task was running.",
+			});
+			const task = this.store.getTask(run.taskId);
+			if (!task || task.currentRunId !== run.runId) continue;
+			if (
+				task.status === "completed" ||
+				task.status === "cancelled" ||
+				task.status === "expired"
+			) {
+				this.store.updateTaskState(task.taskId, { currentRunId: null });
+				continue;
+			}
+			if (
+				run.status === "starting" &&
+				task.approvedRevision === run.taskRevision &&
+				task.revision === run.taskRevision &&
+				!this.isExpired(task)
+			) {
+				this.store.updateTaskState(task.taskId, {
+					status: "approved",
+					currentRunId: null,
+					error: "Hub restarted before this task session was linked.",
+					updatedBy: TASK_MANAGER_ACTOR,
+				});
+				continue;
+			}
+			this.store.updateTaskState(task.taskId, {
+				status: run.status === "starting" ? "pending_approval" : "failed",
+				approvedRevision:
+					run.status === "starting" ? null : task.approvedRevision,
+				currentRunId: null,
+				error: "Hub restarted while this task was running.",
+				updatedBy: TASK_MANAGER_ACTOR,
+			});
+		}
+	}
+
+	private queueAutomation(scopeKey?: string): void {
+		if (this.disposed) return;
+		if (scopeKey) {
+			this.queuedAutomationScopes.add(scopeKey);
+		} else {
+			for (const policy of this.store.listAutomationPolicies()) {
+				this.queuedAutomationScopes.add(policy.scopeKey);
+			}
+		}
+		if (this.automationPumping) return;
+		queueMicrotask(() => {
+			void this.pumpAutomation().catch((error) =>
+				this.logError("agenda task automation pump failed", error, {}),
+			);
+		});
+	}
+
+	private async pumpAutomation(): Promise<void> {
+		if (this.disposed || this.automationPumping) return;
+		this.automationPumping = true;
+		const policyGeneration = this.automationPolicyGeneration;
+		try {
+			while (this.queuedAutomationScopes.size > 0) {
+				const scopeKey = this.queuedAutomationScopes.values().next().value;
+				if (!scopeKey) break;
+				this.queuedAutomationScopes.delete(scopeKey);
+				const policy = this.store.getAutomationPolicy(scopeKey);
+				if (policy.mode === "manual") continue;
+				this.expireTasks();
+				const recentStarts = this.store
+					.listRuns({ limit: 1000 })
+					.filter(
+						(run) => Date.parse(run.claimedAt) >= Date.now() - 3_600_000,
+					).length;
+				let capacity = Math.min(
+					Math.max(0, policy.maxConcurrentRuns - this.activeRuns.size),
+					Math.max(0, policy.maxStartsPerHour - recentStarts),
+				);
+				if (capacity <= 0) continue;
+				const candidates = this.store.listTasks({
+					statuses: ["pending_approval", "approved"],
+					...(scopeKey === "global"
+						? {}
+						: { scope: "workspace" as const, workspaceRoot: scopeKey }),
+					automationEligible: true,
+					availableBefore: nowIso(),
+					limit: 1000,
+				});
+				for (const candidate of candidates) {
+					if (capacity <= 0) break;
+					if (policyGeneration !== this.automationPolicyGeneration) return;
+					try {
+						let runnable = candidate;
+						if (runnable.status === "pending_approval") {
+							if (!this.canAutomaticallyApprove(runnable, policy)) continue;
+							runnable = await this.approveTask(
+								runnable.taskId,
+								AUTOMATION_ACTOR,
+								runnable.revision,
+							);
+						}
+						if (policyGeneration !== this.automationPolicyGeneration) return;
+						if (
+							policy.mode === "auto_start" &&
+							this.runtime.isInteractiveClientAvailable?.() !== true
+						) {
+							continue;
+						}
+						await this.runTask(
+							runnable.taskId,
+							AUTOMATION_ACTOR,
+							runnable.revision,
+						);
+						capacity -= 1;
+					} catch (error) {
+						this.logError("agenda task automation start failed", error, {
+							taskId: candidate.taskId,
+						});
+					}
+				}
+			}
+		} finally {
+			this.automationPumping = false;
+			if (this.queuedAutomationScopes.size > 0) {
+				this.queueAutomation();
+			}
+		}
+	}
+
+	private canAutomaticallyApprove(
+		task: AgendaTaskRecord,
+		policy: AgendaAutomationPolicy,
+	): boolean {
+		const latestIntentActors = [task.createdBy, task.updatedBy];
+		if (
+			latestIntentActors.some(
+				(actor) => actor.kind === "system" && actor.id === "file_reconciler",
+			)
+		) {
+			return false;
+		}
+		if (
+			!policy.applyToAgentCreated &&
+			latestIntentActors.some((actor) => actor.kind === "agent")
+		) {
+			return false;
+		}
+		return this.taskChainDepth(task) <= policy.maxChainDepth;
+	}
+
+	private taskChainDepth(task: AgendaTaskRecord): number {
+		let depth = 0;
+		let current = task;
+		const seen = new Set([task.taskId]);
+		while (current.originTaskId) {
+			if (seen.has(current.originTaskId)) return Number.POSITIVE_INFINITY;
+			seen.add(current.originTaskId);
+			const parent = this.store.getTask(current.originTaskId);
+			if (!parent) break;
+			depth += 1;
+			current = parent;
+		}
+		return depth;
+	}
+
+	private fileStoreForTask(task: AgendaTaskRecord): AgendaTaskSpecFileStore {
+		return this.ensureScope(task.scope, task.workspaceRoot);
+	}
+
+	/**
+	 * 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 async refreshAndVerifyTaskIntent(
+		taskId: string,
+	): Promise<AgendaTaskRecord> {
+		const known = this.requireTask(taskId);
+		await this.reconcileScope(known.scope, known.workspaceRoot);
+		const current = this.requireTask(taskId);
+		if (current.archivedAt) {
+			throw new Error(`task ${taskId} no longer has an active task spec`);
+		}
+		if (!current.specPath) {
+			throw new Error(`task ${taskId} has no canonical task spec`);
+		}
+		let parsed: ReturnType<AgendaTaskSpecFileStore["readSpec"]>;
+		try {
+			parsed = this.fileStoreForTask(current).readSpec(current.specPath);
+		} catch (error) {
+			throw new Error(
+				`task ${taskId} task spec is unavailable: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+		if (!parsed.ok) {
+			throw new Error(`task ${taskId} task spec is invalid: ${parsed.error}`);
+		}
+		if (
+			parsed.spec.taskId !== current.taskId ||
+			specSignature(parsed.spec, current) !== taskSignature(current)
+		) {
+			throw new Error(
+				`task ${taskId} task spec does not match revision ${current.revision}`,
+			);
+		}
+		return current;
+	}
+
+	private requireTask(taskId: string): AgendaTaskRecord {
+		const normalized = taskId.trim();
+		if (!normalized) throw new Error("taskId is required");
+		const task = this.store.getTask(normalized);
+		if (!task) throw new Error(`unknown task: ${normalized}`);
+		return task;
+	}
+
+	private assertRevision(
+		task: AgendaTaskRecord,
+		expectedRevision: number,
+	): void {
+		if (task.revision !== expectedRevision) {
+			throw new Error(
+				`task ${task.taskId} is at revision ${task.revision}; the requested revision is stale`,
+			);
+		}
+	}
+
+	private publish(
+		event: AgendaTaskManagerEventName,
+		task: AgendaTaskRecord,
+		run?: AgendaTaskRunRecord,
+	): void {
+		this.publishEvent(
+			event,
+			{ task, ...(run ? { run } : {}) },
+			run?.sessionId ?? task.lastSessionId,
+		);
+	}
+
+	private logError(
+		message: string,
+		error: unknown,
+		metadata: Record<string, unknown>,
+	): void {
+		if (this.logger.error) this.logger.error(message, { ...metadata, error });
+		else this.logger.log(message, { ...metadata, error, severity: "error" });
+	}
+
+	private assertUsable(): void {
+		if (this.disposed) throw new Error("AgendaTaskManager disposed");
+	}
+}
diff --git a/sdk/packages/core/src/tasks/agenda-task-tool.test.ts b/sdk/packages/core/src/tasks/agenda-task-tool.test.ts
new file mode 100644
index 0000000000..f28bd4baf5
--- /dev/null
+++ b/sdk/packages/core/src/tasks/agenda-task-tool.test.ts
@@ -0,0 +1,158 @@
+import type { AgendaTaskRecord } from "@cline/shared";
+import { describe, expect, it, vi } from "vitest";
+import type { AgendaTaskManagerApi } from "./agenda-task-api";
+import {
+	executeTodoTaskOperation,
+	type TodoTaskInput,
+	type TodoTaskOperationOptions,
+} from "./agenda-task-tool";
+
+function task(overrides: Partial<AgendaTaskRecord> = {}): AgendaTaskRecord {
+	return {
+		taskId: "task_1",
+		type: "todo",
+		status: "pending_approval",
+		title: "Review the change",
+		instructions: "Review it carefully.",
+		scope: "workspace",
+		workspaceRoot: "/repo",
+		resourcePaths: [],
+		priority: 2,
+		availableAt: "2035-01-01T00:00:00.000Z",
+		expiresAt: "2035-01-02T00:00:00.000Z",
+		automationEligible: true,
+		revision: 1,
+		createdBy: { kind: "agent" },
+		updatedBy: { kind: "agent" },
+		createdAt: "2035-01-01T00:00:00.000Z",
+		updatedAt: "2035-01-01T00:00:00.000Z",
+		...overrides,
+	};
+}
+
+function managerMock(): AgendaTaskManagerApi {
+	return {
+		createTask: vi.fn(async (input) =>
+			task({
+				title: input.title,
+				workspaceRoot: input.workspaceRoot,
+				createdBy: input.createdBy,
+				updatedBy: input.createdBy,
+			}),
+		),
+		listTasks: vi.fn(async () => []),
+		getTask: vi.fn(async () => task()),
+		updateTask: vi.fn(async () => task()),
+		approveTask: vi.fn(async () => task()),
+		cancelTask: vi.fn(async () => task()),
+		runTask: vi.fn(async () => ({ task: task() })),
+		getAutomationPolicy: vi.fn(async () => ({
+			scopeKey: "global",
+			mode: "manual" as const,
+			applyToAgentCreated: true,
+			maxConcurrentRuns: 1,
+			maxChainDepth: 1,
+			maxStartsPerHour: 20,
+			updatedAt: "2035-01-01T00:00:00.000Z",
+		})),
+		setAutomationPolicy: vi.fn(async (policy) => ({
+			...policy,
+			updatedAt: "2035-01-01T00:00:00.000Z",
+		})),
+	};
+}
+
+const context = {
+	sessionId: "session_1",
+	agentId: "agent_1",
+	iteration: 1,
+};
+
+function todoOperations(options: TodoTaskOperationOptions) {
+	return {
+		execute: (input: TodoTaskInput, toolContext = context) =>
+			executeTodoTaskOperation(options, input, toolContext),
+	};
+}
+
+describe("Todo task operations", () => {
+	it("captures usage telemetry for durable mutations", async () => {
+		const capture = vi.fn();
+		const tool = todoOperations({
+			manager: managerMock(),
+			telemetry: { capture } as never,
+			resolveSessionDefaults: async () => ({ workspaceRoot: "/repo" }),
+		});
+
+		await tool.execute(
+			{
+				operation: "create",
+				type: "todo",
+				title: "Review telemetry",
+				instructions: "Verify durable mutation telemetry.",
+				expires_at: "2035-01-02T00:00:00.000Z",
+			},
+			context,
+		);
+
+		expect(capture).toHaveBeenCalledWith({
+			event: "task.tool_used",
+			properties: expect.objectContaining({
+				tool: "tasks.todo.create",
+				success: true,
+			}),
+		});
+	});
+
+	it("pins list and create operations to the current session workspace", async () => {
+		const manager = managerMock();
+		const tool = todoOperations({
+			manager,
+			resolveSessionDefaults: async () => ({
+				workspaceRoot: "/repo",
+				cwd: "/repo",
+			}),
+		});
+
+		await expect(
+			tool.execute({ operation: "list" }, context),
+		).resolves.toMatchObject({
+			ok: true,
+		});
+		expect(manager.listTasks).toHaveBeenCalledWith(
+			expect.objectContaining({ scope: "workspace", workspaceRoot: "/repo" }),
+		);
+
+		const escaped = await tool.execute(
+			{ operation: "list", workspace_root: "/another-repo" },
+			context,
+		);
+		expect(escaped).toMatchObject({
+			ok: false,
+			error: { code: "task_operation_failed" },
+		});
+		expect(manager.listTasks).toHaveBeenCalledTimes(1);
+	});
+
+	it("cannot inspect another scope or request cancellation", async () => {
+		const manager = managerMock();
+		vi.mocked(manager.getTask).mockResolvedValueOnce(
+			task({ scope: "global", workspaceRoot: undefined }),
+		);
+		const tool = todoOperations({
+			manager,
+			resolveSessionDefaults: async () => ({ workspaceRoot: "/repo" }),
+		});
+
+		expect(
+			await tool.execute({ operation: "get", task_id: "global_task" }, context),
+		).toMatchObject({ ok: false, error: { code: "task_operation_failed" } });
+		expect(
+			await tool.execute(
+				{ operation: "cancel", task_id: "task_1" } as never,
+				context,
+			),
+		).toMatchObject({ ok: false, error: { code: "invalid_task_input" } });
+		expect(manager.cancelTask).not.toHaveBeenCalled();
+	});
+});
diff --git a/sdk/packages/core/src/tasks/agenda-task-tool.ts b/sdk/packages/core/src/tasks/agenda-task-tool.ts
new file mode 100644
index 0000000000..b81f456d24
--- /dev/null
+++ b/sdk/packages/core/src/tasks/agenda-task-tool.ts
@@ -0,0 +1,329 @@
+import { resolve } from "node:path";
+import type {
+	AgendaTaskActor,
+	AgendaTaskCreateInput,
+	AgendaTaskListInput,
+	AgendaTaskPriority,
+	AgendaTaskStatus,
+	AgendaTaskType,
+	AgentTool,
+	GatewayModelSelection,
+	ITelemetryService,
+} from "@cline/shared";
+import { z } from "zod";
+import { captureToolUsage } from "../services/telemetry/core-events";
+import type { AgendaTaskManagerApi } from "./agenda-task-api";
+
+const TaskTypeSchema = z.enum([
+	"suggestion",
+	"follow-up",
+	"todo",
+	"handoff",
+	"idea",
+	"reminder",
+]);
+const TaskStatusSchema = z.enum([
+	"pending_approval",
+	"approved",
+	"in_progress",
+	"completed",
+	"failed",
+	"cancelled",
+	"expired",
+]);
+const TaskPrioritySchema = z.union([
+	z.literal(0),
+	z.literal(1),
+	z.literal(2),
+	z.literal(3),
+	z.literal(4),
+	z.literal(5),
+]);
+const ModelSelectionSchema = z.object({
+	provider_id: z.string().min(1),
+	model_id: z.string().min(1).optional(),
+});
+
+export const TodoTaskInputSchema = z.object({
+	operation: z.enum(["create", "update", "list", "get"]),
+	task_id: z.string().min(1).optional(),
+	expected_revision: z.number().int().positive().optional(),
+	type: TaskTypeSchema.optional(),
+	title: z.string().min(1).optional(),
+	description: z.string().nullable().optional(),
+	instructions: z.string().min(1).optional(),
+	scope: z.enum(["workspace", "global"]).optional(),
+	workspace_root: z.string().min(1).nullable().optional(),
+	cwd: z.string().min(1).nullable().optional(),
+	resource_paths: z.array(z.string().min(1)).optional(),
+	priority: TaskPrioritySchema.optional(),
+	assignee: z.string().min(1).nullable().optional(),
+	model_selection: ModelSelectionSchema.nullable().optional(),
+	mode: z.enum(["act", "plan", "yolo"]).nullable().optional(),
+	system_prompt: z.string().nullable().optional(),
+	max_iterations: z.number().int().positive().nullable().optional(),
+	timeout_seconds: z.number().int().positive().nullable().optional(),
+	available_at: z.string().datetime().optional(),
+	expires_at: z.string().datetime().optional(),
+	automation_eligible: z.boolean().optional(),
+	statuses: z.array(TaskStatusSchema).optional(),
+	types: z.array(TaskTypeSchema).optional(),
+	priorities: z.array(TaskPrioritySchema).optional(),
+	limit: z.number().int().positive().max(500).optional(),
+});
+
+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>;
+}
+
+const MUTATING_OPERATIONS = new Set<TodoTaskInput["operation"]>([
+	"create",
+	"update",
+]);
+
+function captureTodoTaskMutation(
+	options: TodoTaskOperationOptions,
+	input: TodoTaskInput,
+	context: Parameters<AgentTool<TodoTaskInput, TodoTaskResult>["execute"]>[1],
+	success: boolean,
+): void {
+	if (!MUTATING_OPERATIONS.has(input.operation)) return;
+	captureToolUsage(options.telemetry, {
+		ulid: context.sessionId ?? context.conversationId ?? context.agentId,
+		tool: `tasks.todo.${input.operation}`,
+		success,
+		agentId: context.agentId,
+	});
+}
+
+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 };
+	  };
+
+function requiredString(value: string | undefined, field: string): string {
+	const normalized = value?.trim();
+	if (!normalized) throw new Error(`${field} is required for this operation`);
+	return normalized;
+}
+
+function modelSelectionOf(
+	value: TodoTaskInput["model_selection"],
+): GatewayModelSelection | null | undefined {
+	if (value === undefined || value === null) return value;
+	return {
+		providerId: value.provider_id,
+		modelId: value.model_id,
+	};
+}
+
+function sameWorkspace(left: string, right: string): boolean {
+	return resolve(left) === resolve(right);
+}
+
+function assertSessionScope(
+	task: Awaited<ReturnType<AgendaTaskManagerApi["getTask"]>>,
+	defaults: AgendaTaskSessionDefaults,
+): void {
+	if (!task) throw new Error("task does not exist");
+	if (defaults.workspaceRoot) {
+		if (
+			task.scope !== "workspace" ||
+			!task.workspaceRoot ||
+			!sameWorkspace(task.workspaceRoot, defaults.workspaceRoot)
+		) {
+			throw new Error("task is outside this session's workspace scope");
+		}
+		return;
+	}
+	if (task.scope !== "global") {
+		throw new Error("task is outside this session's global scope");
+	}
+}
+
+function assertRequestedScope(
+	input: TodoTaskInput,
+	defaults: AgendaTaskSessionDefaults,
+): "workspace" | "global" {
+	const scope = defaults.workspaceRoot ? "workspace" : "global";
+	if (input.scope && input.scope !== scope) {
+		throw new Error(`this session can only manage ${scope} tasks`);
+	}
+	if (input.workspace_root !== undefined) {
+		if (
+			!defaults.workspaceRoot ||
+			input.workspace_root === null ||
+			!sameWorkspace(input.workspace_root, defaults.workspaceRoot)
+		) {
+			throw new Error(`this session can only manage ${scope} tasks`);
+		}
+	}
+	return scope;
+}
+
+/** Execute a Todo operation while preserving Agenda scope and authority rules. */
+export async function executeTodoTaskOperation(
+	options: TodoTaskOperationOptions,
+	rawInput: unknown,
+	context: Parameters<AgentTool<TodoTaskInput, TodoTaskResult>["execute"]>[1],
+): Promise<TodoTaskResult> {
+	const parsed = TodoTaskInputSchema.safeParse(rawInput);
+	if (!parsed.success) {
+		return {
+			ok: false,
+			error: {
+				code: "invalid_task_input",
+				message: parsed.error.issues[0]?.message ?? "Invalid task input",
+			},
+		};
+	}
+	const input = parsed.data;
+	const actor: AgendaTaskActor = {
+		kind: "agent",
+		id: context.agentId,
+		agentId: context.agentId,
+		sessionId: context.sessionId,
+	};
+	try {
+		if (!context.sessionId) {
+			throw new Error("tasks requires a Hub session");
+		}
+		const defaults = await options.resolveSessionDefaults(context.sessionId);
+		if (!defaults) {
+			throw new Error("tasks could not resolve the current session");
+		}
+		const sessionScope = assertRequestedScope(input, defaults);
+		switch (input.operation) {
+			case "create": {
+				const createInput: AgendaTaskCreateInput = {
+					type: requiredString(input.type, "type") as AgendaTaskType,
+					title: requiredString(input.title, "title"),
+					description: input.description ?? undefined,
+					instructions: requiredString(input.instructions, "instructions"),
+					scope: sessionScope,
+					workspaceRoot: defaults.workspaceRoot,
+					cwd:
+						sessionScope === "workspace"
+							? (input.cwd ?? defaults.cwd)?.trim() || undefined
+							: undefined,
+					resourcePaths: input.resource_paths,
+					priority: input.priority,
+					assignee: input.assignee ?? undefined,
+					modelSelection:
+						modelSelectionOf(input.model_selection) ?? defaults.modelSelection,
+					mode: input.mode ?? undefined,
+					systemPrompt: input.system_prompt ?? undefined,
+					maxIterations: input.max_iterations ?? undefined,
+					timeoutSeconds: input.timeout_seconds ?? undefined,
+					availableAt: input.available_at,
+					expiresAt: requiredString(input.expires_at, "expires_at"),
+					automationEligible: input.automation_eligible,
+					createdBy: actor,
+					originSessionId: context.sessionId,
+					originTaskId: defaults.originTaskId,
+				};
+				const result = {
+					ok: true,
+					operation: input.operation,
+					task: await options.manager.createTask(createInput),
+				} as const;
+				captureTodoTaskMutation(options, input, context, true);
+				return result;
+			}
+			case "update": {
+				const taskId = requiredString(input.task_id, "task_id");
+				assertSessionScope(await options.manager.getTask(taskId), defaults);
+				if (!input.expected_revision) {
+					throw new Error("expected_revision is required for update");
+				}
+				const result = {
+					ok: true,
+					operation: input.operation,
+					task: await options.manager.updateTask({
+						taskId,
+						expectedRevision: input.expected_revision,
+						type: input.type,
+						title: input.title,
+						description: input.description,
+						instructions: input.instructions,
+						scope: sessionScope,
+						workspaceRoot: defaults.workspaceRoot ?? null,
+						cwd: input.cwd,
+						resourcePaths: input.resource_paths,
+						priority: input.priority,
+						assignee: input.assignee,
+						modelSelection: modelSelectionOf(input.model_selection),
+						mode: input.mode,
+						systemPrompt: input.system_prompt,
+						maxIterations: input.max_iterations,
+						timeoutSeconds: input.timeout_seconds,
+						availableAt: input.available_at,
+						expiresAt: input.expires_at,
+						automationEligible: input.automation_eligible,
+						updatedBy: actor,
+					}),
+				} as const;
+				captureTodoTaskMutation(options, input, context, true);
+				return result;
+			}
+			case "list": {
+				const filters: AgendaTaskListInput = {
+					statuses: input.statuses as AgendaTaskStatus[] | undefined,
+					types: input.types as AgendaTaskType[] | undefined,
+					scope: sessionScope,
+					workspaceRoot: defaults.workspaceRoot,
+					priorities: input.priorities as AgendaTaskPriority[] | undefined,
+					automationEligible: input.automation_eligible,
+					limit: input.limit,
+				};
+				return {
+					ok: true,
+					operation: input.operation,
+					tasks: await options.manager.listTasks(filters),
+				};
+			}
+			case "get": {
+				const task = await options.manager.getTask(
+					requiredString(input.task_id, "task_id"),
+				);
+				assertSessionScope(task, defaults);
+				return {
+					ok: true,
+					operation: input.operation,
+					task,
+				};
+			}
+		}
+	} catch (error) {
+		captureTodoTaskMutation(options, input, context, false);
+		return {
+			ok: false,
+			operation: input.operation,
+			error: {
+				code: "task_operation_failed",
+				message: error instanceof Error ? error.message : String(error),
+			},
+		};
+	}
+}
diff --git a/sdk/packages/core/src/tasks/index.ts b/sdk/packages/core/src/tasks/index.ts
new file mode 100644
index 0000000000..a4955567b8
--- /dev/null
+++ b/sdk/packages/core/src/tasks/index.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";
diff --git a/sdk/packages/core/src/tasks/specs/task-spec-file-store.ts b/sdk/packages/core/src/tasks/specs/task-spec-file-store.ts
new file mode 100644
index 0000000000..160cfb188d
--- /dev/null
+++ b/sdk/packages/core/src/tasks/specs/task-spec-file-store.ts
@@ -0,0 +1,255 @@
+import {
+	existsSync,
+	linkSync,
+	lstatSync,
+	mkdirSync,
+	readdirSync,
+	readFileSync,
+	realpathSync,
+	renameSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import {
+	basename,
+	dirname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+	sep,
+} from "node:path";
+import type { AgendaTaskScope } from "@cline/shared";
+import { resolveTaskSpecsDir } from "@cline/shared/storage";
+import {
+	type AgendaTaskSpec,
+	type AgendaTaskSpecParseResult,
+	type AgendaTaskSpecWriteInput,
+	parseAgendaTaskSpec,
+	serializeAgendaTaskSpec,
+} 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 };
+
+function safeTaskFilename(taskId: string): string {
+	const normalized = taskId.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
+	if (!normalized) {
+		throw new Error("taskId must contain at least one filename-safe character");
+	}
+	return `${normalized}.task.md`;
+}
+
+function isContained(root: string, candidate: string): boolean {
+	const rel = relative(root, candidate);
+	return (
+		rel === "" ||
+		(!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel))
+	);
+}
+
+export class AgendaTaskSpecFileStore {
+	public readonly specsDir: string;
+	public readonly scope: AgendaTaskScope;
+	public readonly workspaceRoot?: string;
+
+	constructor(options: AgendaTaskSpecFileStoreOptions) {
+		this.scope = options.scope;
+		this.workspaceRoot = options.workspaceRoot?.trim() || undefined;
+		this.specsDir = resolve(
+			resolveTaskSpecsDir({
+				scope: options.scope,
+				workspaceRoot: this.workspaceRoot,
+				taskSpecsDir: options.taskSpecsDir,
+			}),
+		);
+	}
+
+	public listSpecPaths(): string[] {
+		if (!existsSync(this.specsDir)) return [];
+		this.assertSpecsDirSafe();
+		return readdirSync(this.specsDir, { withFileTypes: true })
+			.filter((entry) => entry.isFile() && entry.name.endsWith(".task.md"))
+			.map((entry) => join(this.specsDir, entry.name))
+			.sort((left, right) => left.localeCompare(right));
+	}
+
+	public listSpecs(): AgendaTaskSpecParseResult[] {
+		return this.listSpecPaths().map((path) => {
+			try {
+				return this.readSpec(path);
+			} catch (error) {
+				return {
+					ok: false,
+					specPath: path,
+					contentHash: "",
+					error: error instanceof Error ? error.message : String(error),
+				};
+			}
+		});
+	}
+
+	public readSpec(specPath: string): AgendaTaskSpecParseResult {
+		this.assertSpecsDirSafe();
+		const path = this.resolveSpecPath(specPath);
+		if (lstatSync(path).isSymbolicLink()) {
+			throw new Error("task spec files cannot be symbolic links");
+		}
+		return parseAgendaTaskSpec({
+			specPath: path,
+			raw: readFileSync(path, "utf8"),
+			scope: this.scope,
+			workspaceRoot: this.workspaceRoot,
+		});
+	}
+
+	public writeSpec(
+		input: AgendaTaskSpecWriteInput,
+		options: WriteAgendaTaskSpecOptions = {},
+	): WrittenAgendaTaskSpec {
+		if (!input.taskId.trim()) throw new Error("taskId is required");
+		this.ensureSpecsDir();
+		const target = this.resolveWritePath(input.taskId, options.specPath);
+		if (options.createOnly && existsSync(target)) {
+			throw new Error(`task spec already exists: ${target}`);
+		}
+		if (existsSync(target) && lstatSync(target).isSymbolicLink()) {
+			throw new Error("task spec files cannot be symbolic links");
+		}
+		const raw = serializeAgendaTaskSpec(input);
+		const validated = parseAgendaTaskSpec({
+			specPath: target,
+			raw,
+			scope: this.scope,
+			workspaceRoot: this.workspaceRoot,
+		});
+		if (!validated.ok) {
+			throw new Error(`invalid task spec: ${validated.error}`);
+		}
+		const temporaryPath = join(
+			this.specsDir,
+			`.${basename(target)}.${process.pid}.${Date.now()}.tmp`,
+		);
+		try {
+			writeFileSync(temporaryPath, raw, {
+				encoding: "utf8",
+				mode: 0o600,
+			});
+			this.assertExpectedContent(target, options);
+			if (options.createOnly) {
+				linkSync(temporaryPath, target);
+			} else {
+				renameSync(temporaryPath, target);
+			}
+		} finally {
+			if (existsSync(temporaryPath)) {
+				rmSync(temporaryPath, { force: true });
+			}
+		}
+		return validated.spec as WrittenAgendaTaskSpec;
+	}
+
+	/** Resolve the canonical target before a manager reserves it in SQLite. */
+	public resolveWritePath(taskId: string, specPath?: string): string {
+		return this.resolveSpecPath(specPath ?? safeTaskFilename(taskId));
+	}
+
+	/** Validate the root both before and after creating missing directories. */
+	public ensureSpecsDir(): void {
+		this.assertSpecsDirSafe();
+		mkdirSync(this.specsDir, { recursive: true });
+		this.assertSpecsDirSafe();
+	}
+
+	public deleteSpec(
+		specPath: string,
+		options: { expectedContentHash?: string } = {},
+	): boolean {
+		this.assertSpecsDirSafe();
+		const path = this.resolveSpecPath(specPath);
+		if (!existsSync(path)) return false;
+		if (options.expectedContentHash) {
+			const current = this.readSpec(path);
+			if (current.contentHash !== options.expectedContentHash) {
+				throw new Error(`task spec changed before delete: ${path}`);
+			}
+		}
+		rmSync(path);
+		return true;
+	}
+
+	private assertExpectedContent(
+		target: string,
+		options: WriteAgendaTaskSpecOptions,
+	): void {
+		if (options.createOnly) {
+			if (existsSync(target)) {
+				throw new Error(`task spec already exists: ${target}`);
+			}
+			return;
+		}
+		if (!options.expectedContentHash) return;
+		if (!existsSync(target)) {
+			throw new Error(`task spec disappeared before update: ${target}`);
+		}
+		const current = this.readSpec(target);
+		if (current.contentHash !== options.expectedContentHash) {
+			throw new Error(`task spec changed before update: ${target}`);
+		}
+	}
+
+	private assertSpecsDirSafe(): void {
+		if (
+			existsSync(this.specsDir) &&
+			lstatSync(this.specsDir).isSymbolicLink()
+		) {
+			throw new Error("task specs directory cannot be a symbolic link");
+		}
+		if (!this.workspaceRoot || !existsSync(this.workspaceRoot)) return;
+		const canonicalWorkspace = realpathSync(this.workspaceRoot);
+		let existing = this.specsDir;
+		while (!existsSync(existing)) {
+			const parent = dirname(existing);
+			if (parent === existing) break;
+			existing = parent;
+		}
+		if (
+			existsSync(existing) &&
+			!isContained(canonicalWorkspace, realpathSync(existing))
+		) {
+			throw new Error("task specs directory escapes the workspace");
+		}
+	}
+
+	private resolveSpecPath(input: string): string {
+		const target = resolve(
+			isAbsolute(input) ? input : join(this.specsDir, input),
+		);
+		const fromRoot = relative(this.specsDir, target);
+		if (
+			fromRoot === "" ||
+			fromRoot.startsWith("..") ||
+			isAbsolute(fromRoot) ||
+			!target.endsWith(".task.md")
+		) {
+			throw new Error(
+				"task spec path must be a *.task.md file within the specs directory",
+			);
+		}
+		return target;
+	}
+}
diff --git a/sdk/packages/core/src/tasks/specs/task-spec-parser.test.ts b/sdk/packages/core/src/tasks/specs/task-spec-parser.test.ts
new file mode 100644
index 0000000000..b245ca59e5
--- /dev/null
+++ b/sdk/packages/core/src/tasks/specs/task-spec-parser.test.ts
@@ -0,0 +1,268 @@
+import {
+	mkdirSync,
+	mkdtempSync,
+	readdirSync,
+	rmSync,
+	symlinkSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { AgendaTaskSpecFileStore } from "./task-spec-file-store";
+import { parseAgendaTaskSpec } from "./task-spec-parser";
+
+const roots: string[] = [];
+const WORKSPACE_ROOT = resolve("/workspace");
+
+afterEach(() => {
+	for (const root of roots.splice(0)) {
+		rmSync(root, { recursive: true, force: true });
+	}
+});
+
+describe("parseAgendaTaskSpec", () => {
+	it("parses canonical frontmatter and derives workspace scope", () => {
+		const result = parseAgendaTaskSpec({
+			specPath: join(WORKSPACE_ROOT, ".cline", "tasks", "check-pr.task.md"),
+			scope: "workspace",
+			workspaceRoot: WORKSPACE_ROOT,
+			raw: `---
+taskId: task_check_pr
+type: follow-up
+priority: 0
+title: Check PR after CI
+description: Verify the required checks.
+availableAt: 2035-01-01T00:00:00.000Z
+expiresAt: 2035-01-02T00:00:00.000Z
+resourcePaths:
+  - apps/api/router.ts
+modelSelection:
+  providerId: anthropic
+  modelId: claude
+mode: act
+maxIterations: 12
+timeoutSeconds: 300
+automationEligible: true
+---
+
+Inspect the CI checks and fix any regressions.
+`,
+		});
+
+		expect(result.ok).toBe(true);
+		if (!result.ok) return;
+		expect(result.spec).toMatchObject({
+			taskId: "task_check_pr",
+			type: "follow-up",
+			priority: 0,
+			scope: "workspace",
+			workspaceRoot: WORKSPACE_ROOT,
+			resourcePaths: [join("apps", "api", "router.ts")],
+			instructions: "Inspect the CI checks and fix any regressions.",
+			modelSelection: { providerId: "anthropic", modelId: "claude" },
+		});
+		expect(result.spec.contentHash).toHaveLength(64);
+	});
+
+	it("rejects manager-owned fields and invalid priorities", () => {
+		const reserved = parseAgendaTaskSpec({
+			specPath: "/tmp/task.task.md",
+			scope: "global",
+			raw: `---
+type: todo
+title: Unsafe
+priority: 2
+expiresAt: 2035-01-02T00:00:00.000Z
+status: approved
+---
+Do it.
+`,
+		});
+		expect(reserved).toMatchObject({
+			ok: false,
+			error: expect.stringContaining("operational field"),
+		});
+
+		const badPriority = parseAgendaTaskSpec({
+			specPath: "/tmp/task.task.md",
+			scope: "global",
+			raw: `---
+type: todo
+title: Invalid
+priority: 6
+expiresAt: 2035-01-02T00:00:00.000Z
+---
+Do it.
+`,
+		});
+		expect(badPriority).toMatchObject({
+			ok: false,
+			error: "priority must be an integer from 0 to 5",
+		});
+	});
+
+	it("rejects an availability window that ends before it begins", () => {
+		const result = parseAgendaTaskSpec({
+			specPath: "/tmp/task.task.md",
+			scope: "global",
+			raw: `---
+type: reminder
+title: Too late
+availableAt: 2035-01-03T00:00:00.000Z
+expiresAt: 2035-01-02T00:00:00.000Z
+---
+Remember this.
+`,
+		});
+		expect(result).toMatchObject({
+			ok: false,
+			error: "availableAt must be before expiresAt",
+		});
+	});
+
+	it("rejects global file references and workspace traversal", () => {
+		const global = parseAgendaTaskSpec({
+			specPath: "/tmp/task.task.md",
+			scope: "global",
+			raw: `---
+type: todo
+title: Unsafe global file
+expiresAt: 2035-01-02T00:00:00.000Z
+resourcePaths: [secrets.txt]
+---
+Read it.
+`,
+		});
+		expect(global).toMatchObject({
+			ok: false,
+			error: "global tasks cannot reference workspace files",
+		});
+
+		const traversal = parseAgendaTaskSpec({
+			specPath: join(WORKSPACE_ROOT, ".cline", "tasks", "task.task.md"),
+			scope: "workspace",
+			workspaceRoot: WORKSPACE_ROOT,
+			raw: `---
+type: todo
+title: Unsafe traversal
+expiresAt: 2035-01-02T00:00:00.000Z
+resourcePaths: [../secrets.txt]
+---
+Read it.
+`,
+		});
+		expect(traversal).toMatchObject({
+			ok: false,
+			error: "resourcePaths must be workspace-relative without '..'",
+		});
+	});
+});
+
+describe("AgendaTaskSpecFileStore", () => {
+	it("atomically writes and reads a canonical task spec", () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-task-specs-"));
+		roots.push(root);
+		const store = new AgendaTaskSpecFileStore({
+			scope: "workspace",
+			workspaceRoot: root,
+			taskSpecsDir: join(root, ".cline", "tasks"),
+		});
+
+		const written = store.writeSpec({
+			taskId: "task_roundtrip",
+			type: "suggestion",
+			title: "Review changes",
+			description: "Call out risky changes.",
+			instructions: "Review the current changes and report risks.",
+			priority: 1,
+			resourcePaths: ["src/index.ts"],
+			availableAt: "2035-01-01T00:00:00.000Z",
+			expiresAt: "2035-01-04T00:00:00.000Z",
+			mode: "plan",
+		});
+
+		expect(written).toMatchObject({
+			taskId: "task_roundtrip",
+			type: "suggestion",
+			priority: 1,
+			workspaceRoot: root,
+			instructions: "Review the current changes and report risks.",
+		});
+		expect(store.listSpecs()).toHaveLength(1);
+		expect(
+			readdirSync(store.specsDir).every((entry) => !entry.endsWith(".tmp")),
+		).toBe(true);
+	});
+
+	it("does not allow paths outside its managed directory", () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-task-specs-"));
+		roots.push(root);
+		const store = new AgendaTaskSpecFileStore({
+			scope: "global",
+			taskSpecsDir: join(root, "tasks"),
+		});
+
+		expect(() => store.readSpec(join(root, "outside.task.md"))).toThrow(
+			"within the specs directory",
+		);
+	});
+
+	it("refuses create collisions and stale conditional updates", () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-task-specs-"));
+		roots.push(root);
+		const store = new AgendaTaskSpecFileStore({
+			scope: "global",
+			taskSpecsDir: join(root, "tasks"),
+		});
+		const first = store.writeSpec(
+			{
+				taskId: "conditional_task",
+				type: "todo",
+				title: "First",
+				instructions: "First version.",
+				expiresAt: "2035-01-04T00:00:00.000Z",
+			},
+			{ createOnly: true },
+		);
+		expect(() =>
+			store.writeSpec(
+				{ ...first, title: "Collision" },
+				{ specPath: first.specPath, createOnly: true },
+			),
+		).toThrow("already exists");
+		const second = store.writeSpec(
+			{ ...first, title: "Second" },
+			{
+				specPath: first.specPath,
+				expectedContentHash: first.contentHash,
+			},
+		);
+		expect(() =>
+			store.writeSpec(
+				{ ...second, title: "Stale overwrite" },
+				{
+					specPath: second.specPath,
+					expectedContentHash: first.contentHash,
+				},
+			),
+		).toThrow("changed before update");
+		expect(store.readSpec(second.specPath)).toMatchObject({
+			ok: true,
+			spec: { title: "Second" },
+		});
+	});
+
+	it("rejects a workspace task directory that escapes through a symlink", () => {
+		const root = mkdtempSync(join(tmpdir(), "cline-task-specs-"));
+		const outside = mkdtempSync(join(tmpdir(), "cline-task-specs-outside-"));
+		roots.push(root, outside);
+		mkdirSync(join(root, ".cline"));
+		symlinkSync(outside, join(root, ".cline", "tasks"), "dir");
+		const store = new AgendaTaskSpecFileStore({
+			scope: "workspace",
+			workspaceRoot: root,
+		});
+
+		expect(() => store.ensureSpecsDir()).toThrow("symbolic link");
+	});
+});
diff --git a/sdk/packages/core/src/tasks/specs/task-spec-parser.ts b/sdk/packages/core/src/tasks/specs/task-spec-parser.ts
new file mode 100644
index 0000000000..fb568f3f6f
--- /dev/null
+++ b/sdk/packages/core/src/tasks/specs/task-spec-parser.ts
@@ -0,0 +1,494 @@
+import { createHash } from "node:crypto";
+import type {
+	AgendaTaskActor,
+	AgendaTaskCreateInput,
+	AgendaTaskPriority,
+	AgendaTaskScope,
+	AgendaTaskType,
+	GatewayModelSelection,
+} from "@cline/shared";
+import YAML from "yaml";
+import { normalizeAgendaTaskLocation } from "../task-location";
+
+const TASK_TYPES = new Set<AgendaTaskType>([
+	"suggestion",
+	"follow-up",
+	"todo",
+	"handoff",
+	"idea",
+	"reminder",
+]);
+
+const RESERVED_FIELDS = new Set([
+	"status",
+	"instructions",
+	"revision",
+	"approvedRevision",
+	"createdBy",
+	"updatedBy",
+	"currentRunId",
+	"lastRunId",
+	"lastSessionId",
+	"error",
+	"createdAt",
+	"updatedAt",
+	"completedAt",
+	"archivedAt",
+]);
+
+const ALLOWED_FIELDS = new Set([
+	"taskId",
+	"type",
+	"priority",
+	"title",
+	"description",
+	"availableAt",
+	"expiresAt",
+	"cwd",
+	"resourcePaths",
+	"assignee",
+	"modelSelection",
+	"mode",
+	"systemPrompt",
+	"maxIterations",
+	"timeoutSeconds",
+	"automationEligible",
+]);
+
+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;
+}
+
+function splitFrontmatter(raw: string): {
+	frontmatter?: string;
+	body: string;
+} {
+	const normalized = raw.replace(/\r\n/g, "\n");
+	if (!normalized.startsWith("---\n")) {
+		return { body: normalized };
+	}
+	const afterOpen = normalized.slice(4);
+	const closeIndex = afterOpen.indexOf("\n---");
+	if (closeIndex === -1) {
+		return { body: normalized };
+	}
+	let body = afterOpen.slice(closeIndex + 4);
+	if (body.startsWith("\n")) body = body.slice(1);
+	return {
+		frontmatter: afterOpen.slice(0, closeIndex),
+		body,
+	};
+}
+
+function hashContent(frontmatter: unknown, body: string): string {
+	return createHash("sha256")
+		.update(JSON.stringify(frontmatter))
+		.update("\n")
+		.update(body.trim())
+		.digest("hex");
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+	if (typeof value !== "string") return undefined;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function parseIsoTimestamp(value: unknown, field: string): string | Error {
+	const text = asNonEmptyString(value);
+	if (!text || !Number.isFinite(Date.parse(text))) {
+		return new Error(`${field} must be a valid ISO-8601 timestamp`);
+	}
+	return new Date(text).toISOString();
+}
+
+function parsePositiveInteger(
+	value: unknown,
+	field: string,
+): number | undefined | Error {
+	if (value === undefined) return undefined;
+	if (!Number.isInteger(value) || (value as number) <= 0) {
+		return new Error(`${field} must be a positive integer`);
+	}
+	return value as number;
+}
+
+function parseStringList(value: unknown, field: string): string[] | Error {
+	if (value === undefined) return [];
+	if (!Array.isArray(value)) {
+		return new Error(`${field} must be an array of strings`);
+	}
+	const result: string[] = [];
+	const seen = new Set<string>();
+	for (const entry of value) {
+		const normalized = asNonEmptyString(entry);
+		if (!normalized) {
+			return new Error(`${field} must contain only non-empty strings`);
+		}
+		if (!seen.has(normalized)) {
+			seen.add(normalized);
+			result.push(normalized);
+		}
+	}
+	return result;
+}
+
+function parseModelSelection(
+	value: unknown,
+): GatewayModelSelection | undefined | Error {
+	if (value === undefined) return undefined;
+	if (!value || typeof value !== "object" || Array.isArray(value)) {
+		return new Error("modelSelection must be a mapping");
+	}
+	const record = value as Record<string, unknown>;
+	const unknownKeys = Object.keys(record).filter(
+		(key) => key !== "providerId" && key !== "modelId",
+	);
+	if (unknownKeys.length > 0) {
+		return new Error(
+			`modelSelection contains unknown field(s): ${unknownKeys.join(", ")}`,
+		);
+	}
+	const providerId = asNonEmptyString(record.providerId);
+	if (!providerId) {
+		return new Error("modelSelection.providerId is required");
+	}
+	const modelId = asNonEmptyString(record.modelId);
+	return { providerId, ...(modelId ? { modelId } : {}) };
+}
+
+function invalid(
+	input: ParseAgendaTaskSpecInput,
+	contentHash: string,
+	error: string,
+): AgendaTaskSpecParseResult {
+	return {
+		ok: false,
+		specPath: input.specPath,
+		contentHash,
+		error,
+	};
+}
+
+/** Parse one task Markdown file without throwing for invalid user content. */
+export function parseAgendaTaskSpec(
+	input: ParseAgendaTaskSpecInput,
+): AgendaTaskSpecParseResult {
+	const { frontmatter, body } = splitFrontmatter(input.raw);
+	if (frontmatter === undefined) {
+		return invalid(
+			input,
+			hashContent({}, body),
+			"task spec must begin with YAML frontmatter",
+		);
+	}
+
+	let data: Record<string, unknown>;
+	try {
+		const parsed = YAML.parse(frontmatter) as unknown;
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+			return invalid(
+				input,
+				hashContent({}, body),
+				"frontmatter must be a YAML mapping",
+			);
+		}
+		data = parsed as Record<string, unknown>;
+	} catch (error) {
+		return invalid(
+			input,
+			hashContent({}, body),
+			error instanceof Error
+				? `failed to parse frontmatter: ${error.message}`
+				: "failed to parse frontmatter",
+		);
+	}
+
+	const contentHash = hashContent(data, body);
+	const reserved = Object.keys(data).filter((key) => RESERVED_FIELDS.has(key));
+	if (reserved.length > 0) {
+		return invalid(
+			input,
+			contentHash,
+			`operational field(s) cannot be set in a task spec: ${reserved.join(", ")}`,
+		);
+	}
+	const unknown = Object.keys(data).filter((key) => !ALLOWED_FIELDS.has(key));
+	if (unknown.length > 0) {
+		return invalid(
+			input,
+			contentHash,
+			`unknown task spec field(s): ${unknown.join(", ")}`,
+		);
+	}
+
+	if (input.scope === "workspace" && !asNonEmptyString(input.workspaceRoot)) {
+		return invalid(
+			input,
+			contentHash,
+			"workspaceRoot is required for workspace-scoped task specs",
+		);
+	}
+
+	const type = asNonEmptyString(data.type) as AgendaTaskType | undefined;
+	if (!type || !TASK_TYPES.has(type)) {
+		return invalid(
+			input,
+			contentHash,
+			"type must be one of: suggestion, follow-up, todo, handoff, idea, reminder",
+		);
+	}
+
+	const title = asNonEmptyString(data.title);
+	if (!title) {
+		return invalid(input, contentHash, "title is required");
+	}
+	const instructions = body.trim();
+	if (!instructions) {
+		return invalid(
+			input,
+			contentHash,
+			"markdown body instructions are required",
+		);
+	}
+
+	const rawPriority = data.priority ?? 3;
+	if (
+		!Number.isInteger(rawPriority) ||
+		(rawPriority as number) < 0 ||
+		(rawPriority as number) > 5
+	) {
+		return invalid(
+			input,
+			contentHash,
+			"priority must be an integer from 0 to 5",
+		);
+	}
+
+	const expiresAt = parseIsoTimestamp(data.expiresAt, "expiresAt");
+	if (expiresAt instanceof Error) {
+		return invalid(input, contentHash, expiresAt.message);
+	}
+	let availableAt: string | undefined;
+	if (data.availableAt !== undefined) {
+		const parsed = parseIsoTimestamp(data.availableAt, "availableAt");
+		if (parsed instanceof Error) {
+			return invalid(input, contentHash, parsed.message);
+		}
+		availableAt = parsed;
+		if (Date.parse(availableAt) >= Date.parse(expiresAt)) {
+			return invalid(
+				input,
+				contentHash,
+				"availableAt must be before expiresAt",
+			);
+		}
+	}
+
+	const resourcePaths = parseStringList(data.resourcePaths, "resourcePaths");
+	if (resourcePaths instanceof Error) {
+		return invalid(input, contentHash, resourcePaths.message);
+	}
+	let location: ReturnType<typeof normalizeAgendaTaskLocation>;
+	try {
+		location = normalizeAgendaTaskLocation({
+			scope: input.scope,
+			workspaceRoot: input.workspaceRoot,
+			cwd: asNonEmptyString(data.cwd),
+			resourcePaths,
+		});
+	} catch (error) {
+		return invalid(
+			input,
+			contentHash,
+			error instanceof Error ? error.message : String(error),
+		);
+	}
+	const modelSelection = parseModelSelection(data.modelSelection);
+	if (modelSelection instanceof Error) {
+		return invalid(input, contentHash, modelSelection.message);
+	}
+	const maxIterations = parsePositiveInteger(
+		data.maxIterations,
+		"maxIterations",
+	);
+	if (maxIterations instanceof Error) {
+		return invalid(input, contentHash, maxIterations.message);
+	}
+	const timeoutSeconds = parsePositiveInteger(
+		data.timeoutSeconds,
+		"timeoutSeconds",
+	);
+	if (timeoutSeconds instanceof Error) {
+		return invalid(input, contentHash, timeoutSeconds.message);
+	}
+
+	const rawMode = data.mode;
+	if (
+		rawMode !== undefined &&
+		rawMode !== "act" &&
+		rawMode !== "plan" &&
+		rawMode !== "yolo"
+	) {
+		return invalid(input, contentHash, "mode must be one of: act, plan, yolo");
+	}
+	if (
+		data.automationEligible !== undefined &&
+		typeof data.automationEligible !== "boolean"
+	) {
+		return invalid(input, contentHash, "automationEligible must be a boolean");
+	}
+
+	return {
+		ok: true,
+		specPath: input.specPath,
+		contentHash,
+		spec: {
+			taskId: asNonEmptyString(data.taskId),
+			type,
+			title,
+			description: asNonEmptyString(data.description),
+			instructions,
+			scope: input.scope,
+			workspaceRoot: location.workspaceRoot,
+			cwd: location.cwd,
+			resourcePaths: location.resourcePaths,
+			priority: rawPriority as AgendaTaskPriority,
+			assignee: asNonEmptyString(data.assignee),
+			modelSelection,
+			mode: rawMode as "act" | "plan" | "yolo" | undefined,
+			systemPrompt: asNonEmptyString(data.systemPrompt),
+			maxIterations,
+			timeoutSeconds,
+			availableAt,
+			expiresAt,
+			automationEligible: data.automationEligible !== false,
+			specPath: input.specPath,
+			contentHash,
+		},
+	};
+}
+
+/** Render the canonical, user-editable task spec representation. */
+export function serializeAgendaTaskSpec(
+	input: AgendaTaskSpecWriteInput,
+): string {
+	const frontmatter = {
+		taskId: input.taskId,
+		type: input.type,
+		priority: input.priority ?? 3,
+		title: input.title,
+		...(input.description ? { description: input.description } : {}),
+		...(input.availableAt ? { availableAt: input.availableAt } : {}),
+		expiresAt: input.expiresAt,
+		...(input.cwd ? { cwd: input.cwd } : {}),
+		resourcePaths: input.resourcePaths ?? [],
+		...(input.assignee ? { assignee: input.assignee } : {}),
+		...(input.modelSelection ? { modelSelection: input.modelSelection } : {}),
+		...(input.mode ? { mode: input.mode } : {}),
+		...(input.systemPrompt ? { systemPrompt: input.systemPrompt } : {}),
+		...(input.maxIterations !== undefined
+			? { maxIterations: input.maxIterations }
+			: {}),
+		...(input.timeoutSeconds !== undefined
+			? { timeoutSeconds: input.timeoutSeconds }
+			: {}),
+		automationEligible: input.automationEligible !== false,
+	};
+	const yaml = YAML.stringify(frontmatter, { lineWidth: 0 }).trimEnd();
+	return `---\n${yaml}\n---\n\n${input.instructions.trim()}\n`;
+}
+
+export function agendaTaskSpecToCreateInput(
+	spec: AgendaTaskSpec,
+	createdBy: AgendaTaskActor,
+): AgendaTaskCreateInput {
+	const expiresAtMs = Date.parse(spec.expiresAt);
+	const defaultAvailableAt = new Date(
+		Math.min(Date.now(), expiresAtMs - 1),
+	).toISOString();
+	return {
+		taskId: spec.taskId,
+		type: spec.type,
+		title: spec.title,
+		description: spec.description,
+		instructions: spec.instructions,
+		scope: spec.scope,
+		workspaceRoot: spec.workspaceRoot,
+		cwd: spec.cwd,
+		resourcePaths: spec.resourcePaths,
+		priority: spec.priority,
+		assignee: spec.assignee,
+		modelSelection: spec.modelSelection,
+		mode: spec.mode,
+		systemPrompt: spec.systemPrompt,
+		maxIterations: spec.maxIterations,
+		timeoutSeconds: spec.timeoutSeconds,
+		availableAt: spec.availableAt ?? defaultAvailableAt,
+		expiresAt: spec.expiresAt,
+		automationEligible: spec.automationEligible,
+		createdBy,
+		specPath: spec.specPath,
+	};
+}
diff --git a/sdk/packages/core/src/tasks/store/sqlite-task-store.test.ts b/sdk/packages/core/src/tasks/store/sqlite-task-store.test.ts
new file mode 100644
index 0000000000..2cecda0511
--- /dev/null
+++ b/sdk/packages/core/src/tasks/store/sqlite-task-store.test.ts
@@ -0,0 +1,262 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import type { AgendaTaskActor, AgendaTaskCreateInput } from "@cline/shared";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+	AgendaTaskRevisionConflictError,
+	SqliteAgendaTaskStore,
+} from "./sqlite-task-store";
+
+const USER: AgendaTaskActor = { kind: "user", id: "user-1" };
+const AGENT: AgendaTaskActor = {
+	kind: "agent",
+	id: "agent-1",
+	sessionId: "origin-session",
+};
+const WORKSPACE_ROOT = resolve("/workspace");
+const OTHER_WORKSPACE_ROOT = resolve("/other-workspace");
+
+describe("SqliteAgendaTaskStore", () => {
+	let directory: string;
+	let store: SqliteAgendaTaskStore;
+
+	beforeEach(() => {
+		directory = mkdtempSync(join(tmpdir(), "cline-task-store-"));
+		store = new SqliteAgendaTaskStore({
+			dbPath: join(directory, "tasks.db"),
+		});
+	});
+
+	afterEach(() => {
+		store.close();
+		rmSync(directory, { recursive: true, force: true });
+	});
+
+	function createInput(
+		taskId: string,
+		priority: 0 | 1 | 2 | 3 | 4 | 5 = 3,
+	): AgendaTaskCreateInput {
+		return {
+			taskId,
+			type: "todo",
+			title: `Task ${taskId}`,
+			instructions: "Complete the task.",
+			scope: "workspace",
+			workspaceRoot: WORKSPACE_ROOT,
+			resourcePaths: ["src/index.ts", "src/index.ts"],
+			priority,
+			availableAt: "2035-01-01T00:00:00.000Z",
+			expiresAt: "2035-01-10T00:00:00.000Z",
+			createdBy: AGENT,
+			specPath: join(WORKSPACE_ROOT, ".cline", "tasks", `${taskId}.task.md`),
+		};
+	}
+
+	it("creates, reads, updates, and deletes a task", () => {
+		const created = store.createTask(createInput("task_crud", 2));
+		expect(created).toMatchObject({
+			taskId: "task_crud",
+			status: "pending_approval",
+			priority: 2,
+			revision: 1,
+			resourcePaths: [join("src", "index.ts")],
+			createdBy: AGENT,
+		});
+		expect(store.getTaskBySpecPath(created.specPath ?? "")).toEqual(created);
+
+		const approved = store.updateTaskState(
+			created.taskId,
+			{
+				status: "approved",
+				approvedRevision: 1,
+				updatedBy: USER,
+			},
+			1,
+		);
+		expect(approved).toMatchObject({ status: "approved", approvedRevision: 1 });
+
+		const updated = store.updateTask({
+			taskId: created.taskId,
+			expectedRevision: 1,
+			title: "Updated title",
+			priority: 0,
+			updatedBy: USER,
+		});
+		expect(updated).toMatchObject({
+			title: "Updated title",
+			priority: 0,
+			revision: 2,
+			status: "pending_approval",
+		});
+		expect(updated?.approvedRevision).toBeUndefined();
+
+		expect(() =>
+			store.updateTask({
+				taskId: created.taskId,
+				expectedRevision: 1,
+				title: "Stale",
+				updatedBy: USER,
+			}),
+		).toThrow(AgendaTaskRevisionConflictError);
+		expect(store.deleteTask(created.taskId)).toBe(true);
+		expect(store.getTask(created.taskId)).toBeUndefined();
+	});
+
+	it("auto-approves user-authored tasks but keeps agent suggestions pending", () => {
+		const userTask = store.createTask({
+			...createInput("user-authored"),
+			createdBy: USER,
+			requiresApproval: false,
+		});
+		const agentSuggestion = store.createTask(createInput("agent-suggestion"));
+
+		expect(userTask).toMatchObject({
+			status: "approved",
+			approvedRevision: 1,
+			createdBy: USER,
+		});
+		expect(agentSuggestion).toMatchObject({
+			status: "pending_approval",
+			createdBy: AGENT,
+		});
+		expect(agentSuggestion.approvedRevision).toBeUndefined();
+	});
+
+	it("orders ready work P0 first and applies workspace-view scope semantics", () => {
+		store.createTask(createInput("p4", 4));
+		store.createTask(createInput("p0", 0));
+		store.createTask(createInput("p2", 2));
+		store.createTask({
+			...createInput("other-workspace", 1),
+			workspaceRoot: OTHER_WORKSPACE_ROOT,
+			specPath: join(
+				OTHER_WORKSPACE_ROOT,
+				".cline",
+				"tasks",
+				"other-workspace.task.md",
+			),
+		});
+		store.createTask({
+			...createInput("global-p0", 0),
+			scope: "global",
+			workspaceRoot: undefined,
+			resourcePaths: [],
+			availableAt: "2034-12-31T00:00:00.000Z",
+			specPath: "/global/global-p0.task.md",
+		});
+
+		expect(store.listTasks().map((task) => task.taskId)).toEqual([
+			"global-p0",
+			"p0",
+			"other-workspace",
+			"p2",
+			"p4",
+		]);
+		expect(
+			store
+				.listTasks({ workspaceRoot: WORKSPACE_ROOT })
+				.map((task) => task.taskId),
+		).toEqual(["global-p0", "p0", "p2", "p4"]);
+		expect(
+			store
+				.listTasks({
+					statuses: ["pending_approval"],
+					scope: "workspace",
+					workspaceRoot: WORKSPACE_ROOT,
+				})
+				.map((task) => task.taskId),
+		).toEqual(["p0", "p2", "p4"]);
+		expect(
+			store
+				.listTasks({ scope: "global", workspaceRoot: WORKSPACE_ROOT })
+				.map((task) => task.taskId),
+		).toEqual(["global-p0"]);
+	});
+
+	it("lists distinct canonical workspace roots including archived tasks", () => {
+		store.createTask(createInput("workspace-active"));
+		const canonicalOther = resolve(directory, "other-workspace");
+		const archived = store.createTask({
+			...createInput("workspace-archived"),
+			workspaceRoot: join(canonicalOther, "nested", ".."),
+			specPath: join(
+				canonicalOther,
+				".cline",
+				"tasks",
+				"workspace-archived.task.md",
+			),
+		});
+		store.createTask({
+			...createInput("workspace-duplicate"),
+			workspaceRoot: canonicalOther,
+			specPath: join(
+				canonicalOther,
+				".cline",
+				"tasks",
+				"workspace-duplicate.task.md",
+			),
+		});
+		store.updateTaskState(archived.taskId, {
+			archivedAt: "2035-01-02T00:00:00.000Z",
+		});
+
+		expect(store.listWorkspaceRoots()).toEqual(
+			[WORKSPACE_ROOT, canonicalOther].sort((left, right) =>
+				left.localeCompare(right),
+			),
+		);
+	});
+
+	it("persists run attempts and prevents two active runs for one task", () => {
+		const task = store.createTask(createInput("task_runs"));
+		const first = store.createRun({
+			taskId: task.taskId,
+			taskRevision: task.revision,
+			claimToken: "claim-1",
+		});
+		expect(first).toMatchObject({ attempt: 1, status: "starting" });
+		expect(() =>
+			store.createRun({
+				taskId: task.taskId,
+				taskRevision: task.revision,
+			}),
+		).toThrow();
+
+		store.updateRun(first.runId, {
+			status: "completed",
+			sessionId: "session-1",
+			completedAt: "2035-01-02T00:00:00.000Z",
+		});
+		const second = store.createRun({
+			taskId: task.taskId,
+			taskRevision: task.revision,
+		});
+		expect(second.attempt).toBe(2);
+		expect(store.listRuns({ taskId: task.taskId })).toHaveLength(2);
+	});
+
+	it("provides and updates the global automation policy", () => {
+		expect(store.getAutomationPolicy()).toMatchObject({
+			scopeKey: "global",
+			mode: "manual",
+			maxConcurrentRuns: 2,
+		});
+
+		const policy = store.setAutomationPolicy({
+			scopeKey: "global",
+			mode: "unattended",
+			applyToAgentCreated: true,
+			maxConcurrentRuns: 3,
+			maxChainDepth: 2,
+			maxStartsPerHour: 30,
+			enabledBy: USER,
+			enabledAt: "2035-01-01T00:00:00.000Z",
+		});
+		expect(policy).toMatchObject({
+			mode: "unattended",
+			maxConcurrentRuns: 3,
+			enabledBy: USER,
+		});
+	});
+});
diff --git a/sdk/packages/core/src/tasks/store/sqlite-task-store.ts b/sdk/packages/core/src/tasks/store/sqlite-task-store.ts
new file mode 100644
index 0000000000..5571170850
--- /dev/null
+++ b/sdk/packages/core/src/tasks/store/sqlite-task-store.ts
@@ -0,0 +1,787 @@
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import type {
+	AgendaAutomationPolicy,
+	AgendaTaskActor,
+	AgendaTaskCreateInput,
+	AgendaTaskListInput,
+	AgendaTaskRecord,
+	AgendaTaskRunRecord,
+	AgendaTaskRunStatus,
+	AgendaTaskStatus,
+	AgendaTaskUpdateInput,
+	GatewayModelSelection,
+} from "@cline/shared";
+import {
+	asOptionalString,
+	asString,
+	loadSqliteDb,
+	nowIso,
+	type SqliteDb,
+} from "@cline/shared/db";
+import { resolveTasksDbPath } from "@cline/shared/storage";
+import { normalizeAgendaTaskLocation } from "../task-location";
+import { ensureAgendaTaskSchema } from "./task-schema";
+
+const SYSTEM_ACTOR: AgendaTaskActor = { kind: "system", id: "task_store" };
+
+export interface SqliteAgendaTaskStoreOptions {
+	dbPath?: string;
+}
+
+export class AgendaTaskRevisionConflictError extends Error {
+	constructor(public readonly current: AgendaTaskRecord) {
+		super(
+			`task ${current.taskId} is at revision ${current.revision}; the requested revision is stale`,
+		);
+		this.name = "AgendaTaskRevisionConflictError";
+	}
+}
+
+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;
+}
+
+function parseJson<T>(value: unknown): T | undefined {
+	if (typeof value !== "string" || !value) return undefined;
+	try {
+		return JSON.parse(value) as T;
+	} catch {
+		return undefined;
+	}
+}
+
+function toInteger(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isFinite(value)) {
+		return Math.floor(value);
+	}
+	if (typeof value === "bigint") return Number(value);
+	return undefined;
+}
+
+function taskRowToRecord(row: Record<string, unknown>): AgendaTaskRecord {
+	return {
+		taskId: asString(row.task_id),
+		type: asString(row.type) as AgendaTaskRecord["type"],
+		status: asString(row.status) as AgendaTaskStatus,
+		title: asString(row.title),
+		description: asOptionalString(row.description),
+		instructions: asString(row.instructions),
+		scope: asString(row.scope) as AgendaTaskRecord["scope"],
+		workspaceRoot: asOptionalString(row.workspace_root),
+		cwd: asOptionalString(row.cwd),
+		resourcePaths:
+			parseJson<string[]>(row.resource_paths_json)?.filter(
+				(path) => typeof path === "string",
+			) ?? [],
+		priority: (toInteger(row.priority) ?? 3) as AgendaTaskRecord["priority"],
+		assignee: asOptionalString(row.assignee),
+		modelSelection: parseJson<GatewayModelSelection>(row.model_selection_json),
+		mode: asOptionalString(row.mode) as AgendaTaskRecord["mode"],
+		systemPrompt: asOptionalString(row.system_prompt),
+		maxIterations: toInteger(row.max_iterations),
+		timeoutSeconds: toInteger(row.timeout_seconds),
+		availableAt: asString(row.available_at),
+		expiresAt: asString(row.expires_at),
+		automationEligible: Number(row.automation_eligible ?? 0) === 1,
+		revision: toInteger(row.revision) ?? 1,
+		approvedRevision: toInteger(row.approved_revision),
+		createdBy: parseJson<AgendaTaskActor>(row.created_by_json) ?? SYSTEM_ACTOR,
+		updatedBy: parseJson<AgendaTaskActor>(row.updated_by_json) ?? SYSTEM_ACTOR,
+		originSessionId: asOptionalString(row.origin_session_id),
+		originTaskId: asOptionalString(row.origin_task_id),
+		currentRunId: asOptionalString(row.current_run_id),
+		lastRunId: asOptionalString(row.last_run_id),
+		lastSessionId: asOptionalString(row.last_session_id),
+		specPath: asOptionalString(row.spec_path),
+		error: asOptionalString(row.error),
+		createdAt: asString(row.created_at),
+		updatedAt: asString(row.updated_at),
+		completedAt: asOptionalString(row.completed_at),
+		archivedAt: asOptionalString(row.archived_at),
+	};
+}
+
+function runRowToRecord(row: Record<string, unknown>): AgendaTaskRunRecord {
+	return {
+		runId: asString(row.run_id),
+		taskId: asString(row.task_id),
+		taskRevision: toInteger(row.task_revision) ?? 1,
+		attempt: toInteger(row.attempt) ?? 1,
+		status: asString(row.status) as AgendaTaskRunStatus,
+		claimToken: asOptionalString(row.claim_token),
+		claimUntilAt: asOptionalString(row.claim_until_at),
+		requestedByClientId: asOptionalString(row.requested_by_client_id),
+		sessionId: asOptionalString(row.session_id),
+		claimedAt: asString(row.claimed_at),
+		startedAt: asOptionalString(row.started_at),
+		completedAt: asOptionalString(row.completed_at),
+		resultSummary: asOptionalString(row.result_summary),
+		error: asOptionalString(row.error),
+		createdAt: asString(row.created_at),
+		updatedAt: asString(row.updated_at),
+	};
+}
+
+function policyRowToRecord(
+	row: Record<string, unknown>,
+): AgendaAutomationPolicy {
+	return {
+		scopeKey: asString(row.scope_key),
+		mode: asString(row.mode) as AgendaAutomationPolicy["mode"],
+		applyToAgentCreated: Number(row.apply_to_agent_created ?? 0) === 1,
+		maxConcurrentRuns: toInteger(row.max_concurrent_runs) ?? 2,
+		maxChainDepth: toInteger(row.max_chain_depth) ?? 1,
+		maxStartsPerHour: toInteger(row.max_starts_per_hour) ?? 20,
+		enabledBy: parseJson<AgendaTaskActor>(row.enabled_by_json),
+		enabledAt: asOptionalString(row.enabled_at),
+		updatedAt: asString(row.updated_at),
+	};
+}
+
+function requiredText(value: string, field: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) throw new Error(`${field} is required`);
+	return trimmed;
+}
+
+function optionalText(value: string | undefined | null): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function isoTimestamp(value: string, field: string): string {
+	const milliseconds = Date.parse(value);
+	if (!Number.isFinite(milliseconds)) {
+		throw new Error(`${field} must be a valid ISO-8601 timestamp`);
+	}
+	return new Date(milliseconds).toISOString();
+}
+
+function optionalIsoTimestamp(
+	value: string | undefined | null,
+	field: string,
+): string | undefined {
+	return value == null ? undefined : isoTimestamp(value, field);
+}
+
+function positiveInteger(
+	value: number | undefined | null,
+	field: string,
+): number | undefined {
+	if (value == null) return undefined;
+	if (!Number.isInteger(value) || value <= 0) {
+		throw new Error(`${field} must be a positive integer`);
+	}
+	return value;
+}
+
+function assertTimeWindow(availableAt: string, expiresAt: string): void {
+	if (Date.parse(availableAt) >= Date.parse(expiresAt)) {
+		throw new Error("availableAt must be before expiresAt");
+	}
+}
+
+function placeholders(count: number): string {
+	return new Array(count).fill("?").join(", ");
+}
+
+export class SqliteAgendaTaskStore {
+	private readonly db: SqliteDb;
+
+	constructor(options: SqliteAgendaTaskStoreOptions = {}) {
+		this.db = loadSqliteDb(options.dbPath ?? resolveTasksDbPath());
+		ensureAgendaTaskSchema(this.db);
+		const now = nowIso();
+		this.db
+			.prepare(
+				`INSERT OR IGNORE INTO agenda_task_automation (
+					scope_key, mode, apply_to_agent_created, max_concurrent_runs,
+					max_chain_depth, max_starts_per_hour, updated_at
+				) VALUES ('global', 'manual', 1, 2, 1, 20, ?)`,
+			)
+			.run(now);
+	}
+
+	public close(): void {
+		this.db.close?.();
+	}
+
+	public createTask(input: AgendaTaskCreateInput): AgendaTaskRecord {
+		const now = nowIso();
+		const taskId = optionalText(input.taskId) ?? `task_${randomUUID()}`;
+		const location = normalizeAgendaTaskLocation(input);
+		const availableAt = isoTimestamp(input.availableAt ?? now, "availableAt");
+		const expiresAt = isoTimestamp(input.expiresAt, "expiresAt");
+		assertTimeWindow(availableAt, expiresAt);
+		const priority = input.priority ?? 3;
+		if (!Number.isInteger(priority) || priority < 0 || priority > 5) {
+			throw new Error("priority must be an integer from 0 to 5");
+		}
+		const maxIterations = positiveInteger(input.maxIterations, "maxIterations");
+		const timeoutSeconds = positiveInteger(
+			input.timeoutSeconds,
+			"timeoutSeconds",
+		);
+		const requiresApproval = input.requiresApproval !== false;
+		const initialStatus = requiresApproval ? "pending_approval" : "approved";
+		const approvedRevision = requiresApproval ? null : 1;
+		this.db
+			.prepare(
+				`INSERT INTO agenda_tasks (
+					task_id, type, status, title, description, instructions, scope,
+					workspace_root, cwd, resource_paths_json, priority, assignee,
+					model_selection_json, mode, system_prompt, max_iterations,
+					timeout_seconds, available_at, expires_at, automation_eligible,
+					revision, approved_revision, created_by_json, updated_by_json, origin_session_id,
+					origin_task_id, spec_path, created_at, updated_at
+				) VALUES (
+					?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?,
+					?, ?, ?, 1, ?, ?, ?, ?, ?, ?, ?, ?
+				)`,
+			)
+			.run(
+				taskId,
+				input.type,
+				initialStatus,
+				requiredText(input.title, "title"),
+				optionalText(input.description) ?? null,
+				requiredText(input.instructions, "instructions"),
+				input.scope,
+				location.workspaceRoot ?? null,
+				location.cwd ?? null,
+				JSON.stringify(location.resourcePaths),
+				priority,
+				optionalText(input.assignee) ?? null,
+				input.modelSelection ? JSON.stringify(input.modelSelection) : null,
+				input.mode ?? null,
+				optionalText(input.systemPrompt) ?? null,
+				maxIterations ?? null,
+				timeoutSeconds ?? null,
+				availableAt,
+				expiresAt,
+				input.automationEligible === false ? 0 : 1,
+				approvedRevision,
+				JSON.stringify(input.createdBy),
+				JSON.stringify(input.createdBy),
+				optionalText(input.originSessionId) ?? null,
+				optionalText(input.originTaskId) ?? null,
+				optionalText(input.specPath) ?? null,
+				now,
+				now,
+			);
+		const record = this.getTask(taskId);
+		if (!record) throw new Error(`failed to create task ${taskId}`);
+		return record;
+	}
+
+	public getTask(taskId: string): AgendaTaskRecord | undefined {
+		const row = this.db
+			.prepare("SELECT * FROM agenda_tasks WHERE task_id = ?")
+			.get(taskId);
+		return row ? taskRowToRecord(row) : undefined;
+	}
+
+	public getTaskBySpecPath(specPath: string): AgendaTaskRecord | undefined {
+		const row = this.db
+			.prepare("SELECT * FROM agenda_tasks WHERE spec_path = ?")
+			.get(specPath);
+		return row ? taskRowToRecord(row) : 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.
+	 */
+	public listWorkspaceRoots(): string[] {
+		const rows = this.db
+			.prepare(
+				`SELECT DISTINCT workspace_root FROM agenda_tasks
+				WHERE scope = 'workspace' AND workspace_root IS NOT NULL
+				ORDER BY workspace_root ASC`,
+			)
+			.all();
+		const roots = new Set<string>();
+		for (const row of rows) {
+			const root = asOptionalString(row.workspace_root);
+			if (root) roots.add(resolve(root));
+		}
+		return [...roots].sort((left, right) => left.localeCompare(right));
+	}
+
+	public listTasks(input: AgendaTaskListInput = {}): AgendaTaskRecord[] {
+		if (
+			input.statuses?.length === 0 ||
+			input.types?.length === 0 ||
+			input.priorities?.length === 0
+		) {
+			return [];
+		}
+		const where: string[] = [];
+		const params: unknown[] = [];
+		if (input.statuses) {
+			where.push(`status IN (${placeholders(input.statuses.length)})`);
+			params.push(...input.statuses);
+		}
+		if (input.types) {
+			where.push(`type IN (${placeholders(input.types.length)})`);
+			params.push(...input.types);
+		}
+		const workspaceRoot = input.workspaceRoot?.trim()
+			? resolve(input.workspaceRoot)
+			: undefined;
+		if (input.scope === "workspace") {
+			where.push("scope = 'workspace'");
+			if (workspaceRoot) {
+				where.push("workspace_root = ?");
+				params.push(workspaceRoot);
+			}
+		} else if (input.scope === "global") {
+			where.push("scope = 'global'");
+		} else if (workspaceRoot) {
+			where.push(
+				"(scope = 'global' OR (scope = 'workspace' AND workspace_root = ?))",
+			);
+			params.push(workspaceRoot);
+		}
+		if (input.priorities) {
+			where.push(`priority IN (${placeholders(input.priorities.length)})`);
+			params.push(...input.priorities);
+		}
+		if (typeof input.automationEligible === "boolean") {
+			where.push("automation_eligible = ?");
+			params.push(input.automationEligible ? 1 : 0);
+		}
+		if (input.availableBefore) {
+			where.push("available_at <= ?");
+			params.push(isoTimestamp(input.availableBefore, "availableBefore"));
+		}
+		if (!input.includeArchived) {
+			where.push("archived_at IS NULL");
+		}
+		const limit = Math.min(1000, Math.max(1, Math.floor(input.limit ?? 200)));
+		const rows = this.db
+			.prepare(
+				`SELECT * FROM agenda_tasks
+				${where.length > 0 ? `WHERE ${where.join(" AND ")}` : ""}
+				ORDER BY priority ASC, available_at ASC, created_at ASC, task_id ASC
+				LIMIT ?`,
+			)
+			.all(...params, limit);
+		return rows.map(taskRowToRecord);
+	}
+
+	/** Apply user-editable fields, increment revision, and revoke old approval. */
+	public updateTask(
+		input: AgendaTaskUpdateInput,
+	): AgendaTaskRecord | undefined {
+		const current = this.getTask(input.taskId);
+		if (!current) return undefined;
+		if (current.revision !== input.expectedRevision) {
+			throw new AgendaTaskRevisionConflictError(current);
+		}
+		if (current.status === "in_progress") {
+			throw new Error("an in-progress task cannot be edited");
+		}
+
+		const scope = input.scope ?? current.scope;
+		const location = normalizeAgendaTaskLocation({
+			scope,
+			workspaceRoot:
+				input.workspaceRoot === null
+					? undefined
+					: (input.workspaceRoot ?? current.workspaceRoot),
+			cwd: input.cwd === null ? undefined : (input.cwd ?? current.cwd),
+			resourcePaths: input.resourcePaths ?? current.resourcePaths,
+		});
+		const availableAt = isoTimestamp(
+			input.availableAt ?? current.availableAt,
+			"availableAt",
+		);
+		const expiresAt = isoTimestamp(
+			input.expiresAt ?? current.expiresAt,
+			"expiresAt",
+		);
+		assertTimeWindow(availableAt, expiresAt);
+		const priority = input.priority ?? current.priority;
+		if (!Number.isInteger(priority) || priority < 0 || priority > 5) {
+			throw new Error("priority must be an integer from 0 to 5");
+		}
+		const status =
+			current.status === "approved" || current.status === "failed"
+				? "pending_approval"
+				: current.status;
+		const revision = current.revision + 1;
+		const now = nowIso();
+		this.db
+			.prepare(
+				`UPDATE agenda_tasks SET
+					type = ?, status = ?, title = ?, description = ?, instructions = ?,
+					scope = ?, workspace_root = ?, cwd = ?, resource_paths_json = ?,
+					priority = ?, assignee = ?, model_selection_json = ?, mode = ?,
+					system_prompt = ?, max_iterations = ?, timeout_seconds = ?,
+					available_at = ?, expires_at = ?, automation_eligible = ?, revision = ?,
+					approved_revision = NULL, error = NULL, updated_by_json = ?, updated_at = ?
+				WHERE task_id = ? AND revision = ?`,
+			)
+			.run(
+				input.type ?? current.type,
+				status,
+				requiredText(input.title ?? current.title, "title"),
+				input.description === null
+					? null
+					: (optionalText(input.description ?? current.description) ?? null),
+				requiredText(
+					input.instructions ?? current.instructions,
+					"instructions",
+				),
+				scope,
+				location.workspaceRoot ?? null,
+				location.cwd ?? null,
+				JSON.stringify(location.resourcePaths),
+				priority,
+				input.assignee === null
+					? null
+					: (optionalText(input.assignee ?? current.assignee) ?? null),
+				input.modelSelection === null
+					? null
+					: JSON.stringify(input.modelSelection ?? current.modelSelection) ||
+							null,
+				input.mode === null ? null : (input.mode ?? current.mode ?? null),
+				input.systemPrompt === null
+					? null
+					: (optionalText(input.systemPrompt ?? current.systemPrompt) ?? null),
+				positiveInteger(
+					input.maxIterations === null
+						? undefined
+						: (input.maxIterations ?? current.maxIterations),
+					"maxIterations",
+				) ?? null,
+				positiveInteger(
+					input.timeoutSeconds === null
+						? undefined
+						: (input.timeoutSeconds ?? current.timeoutSeconds),
+					"timeoutSeconds",
+				) ?? null,
+				availableAt,
+				expiresAt,
+				(input.automationEligible ?? current.automationEligible) ? 1 : 0,
+				revision,
+				JSON.stringify(input.updatedBy),
+				now,
+				input.taskId,
+				current.revision,
+			);
+		return this.getTask(input.taskId);
+	}
+
+	/** Mutate manager-owned lifecycle fields without changing the task revision. */
+	public updateTaskState(
+		taskId: string,
+		patch: AgendaTaskStatePatch,
+		expectedRevision?: number,
+	): AgendaTaskRecord | undefined {
+		const current = this.getTask(taskId);
+		if (!current) return undefined;
+		if (
+			expectedRevision !== undefined &&
+			current.revision !== expectedRevision
+		) {
+			throw new AgendaTaskRevisionConflictError(current);
+		}
+		const approvedRevision =
+			patch.approvedRevision === null
+				? undefined
+				: (patch.approvedRevision ?? current.approvedRevision);
+		const status = patch.status ?? current.status;
+		if (status === "in_progress" && approvedRevision !== current.revision) {
+			throw new Error(
+				"in-progress task must be approved for its current revision",
+			);
+		}
+		const now = nowIso();
+		this.db
+			.prepare(
+				`UPDATE agenda_tasks SET
+					status = ?, approved_revision = ?, current_run_id = ?, last_run_id = ?,
+					last_session_id = ?, spec_path = ?, error = ?, completed_at = ?,
+					archived_at = ?, updated_by_json = ?, updated_at = ?
+				WHERE task_id = ? AND revision = ?`,
+			)
+			.run(
+				status,
+				approvedRevision ?? null,
+				patch.currentRunId === null
+					? null
+					: (patch.currentRunId ?? current.currentRunId ?? null),
+				patch.lastRunId === null
+					? null
+					: (patch.lastRunId ?? current.lastRunId ?? null),
+				patch.lastSessionId === null
+					? null
+					: (patch.lastSessionId ?? current.lastSessionId ?? null),
+				patch.specPath === null
+					? null
+					: (patch.specPath ?? current.specPath ?? null),
+				patch.error === null ? null : (patch.error ?? current.error ?? null),
+				patch.completedAt === null
+					? null
+					: (patch.completedAt ?? current.completedAt ?? null),
+				patch.archivedAt === null
+					? null
+					: (patch.archivedAt ?? current.archivedAt ?? null),
+				JSON.stringify(patch.updatedBy ?? current.updatedBy),
+				now,
+				taskId,
+				current.revision,
+			);
+		return this.getTask(taskId);
+	}
+
+	public deleteTask(taskId: string): boolean {
+		return (
+			(this.db.prepare("DELETE FROM agenda_tasks WHERE task_id = ?").run(taskId)
+				.changes ?? 0) > 0
+		);
+	}
+
+	public createRun(input: CreateAgendaTaskRunInput): AgendaTaskRunRecord {
+		const task = this.getTask(input.taskId);
+		if (!task) throw new Error(`task ${input.taskId} does not exist`);
+		if (task.revision !== input.taskRevision) {
+			throw new AgendaTaskRevisionConflictError(task);
+		}
+		const attemptRow = this.db
+			.prepare(
+				"SELECT COALESCE(MAX(attempt), 0) AS max_attempt FROM agenda_task_runs WHERE task_id = ?",
+			)
+			.get(input.taskId);
+		const attempt = (toInteger(attemptRow?.max_attempt) ?? 0) + 1;
+		const runId = `run_${randomUUID()}`;
+		const now = nowIso();
+		const claimedAt = input.claimedAt
+			? isoTimestamp(input.claimedAt, "claimedAt")
+			: now;
+		this.db
+			.prepare(
+				`INSERT INTO agenda_task_runs (
+					run_id, task_id, task_revision, attempt, status, claim_token,
+					claim_until_at, requested_by_client_id, session_id, claimed_at,
+					created_at, updated_at
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+			)
+			.run(
+				runId,
+				input.taskId,
+				input.taskRevision,
+				attempt,
+				input.status ?? "starting",
+				optionalText(input.claimToken) ?? null,
+				optionalIsoTimestamp(input.claimUntilAt, "claimUntilAt") ?? null,
+				optionalText(input.requestedByClientId) ?? null,
+				optionalText(input.sessionId) ?? null,
+				claimedAt,
+				now,
+				now,
+			);
+		const run = this.getRun(runId);
+		if (!run) throw new Error(`failed to create run ${runId}`);
+		return run;
+	}
+
+	public getRun(runId: string): AgendaTaskRunRecord | undefined {
+		const row = this.db
+			.prepare("SELECT * FROM agenda_task_runs WHERE run_id = ?")
+			.get(runId);
+		return row ? runRowToRecord(row) : undefined;
+	}
+
+	public updateRun(
+		runId: string,
+		input: UpdateAgendaTaskRunInput,
+	): AgendaTaskRunRecord | undefined {
+		const current = this.getRun(runId);
+		if (!current) return undefined;
+		const now = nowIso();
+		this.db
+			.prepare(
+				`UPDATE agenda_task_runs SET
+					status = ?, claim_token = ?, claim_until_at = ?,
+					requested_by_client_id = ?, session_id = ?, started_at = ?,
+					completed_at = ?, result_summary = ?, error = ?, updated_at = ?
+				WHERE run_id = ?`,
+			)
+			.run(
+				input.status ?? current.status,
+				input.claimToken === null
+					? null
+					: (input.claimToken ?? current.claimToken ?? null),
+				input.claimUntilAt === null
+					? null
+					: (input.claimUntilAt ?? current.claimUntilAt ?? null),
+				input.requestedByClientId === null
+					? null
+					: (input.requestedByClientId ?? current.requestedByClientId ?? null),
+				input.sessionId === null
+					? null
+					: (input.sessionId ?? current.sessionId ?? null),
+				input.startedAt === null
+					? null
+					: (input.startedAt ?? current.startedAt ?? null),
+				input.completedAt === null
+					? null
+					: (input.completedAt ?? current.completedAt ?? null),
+				input.resultSummary === null
+					? null
+					: (input.resultSummary ?? current.resultSummary ?? null),
+				input.error === null ? null : (input.error ?? current.error ?? null),
+				now,
+				runId,
+			);
+		return this.getRun(runId);
+	}
+
+	public listRuns(input: ListAgendaTaskRunsInput = {}): AgendaTaskRunRecord[] {
+		const where: string[] = [];
+		const params: unknown[] = [];
+		if (input.taskId) {
+			where.push("task_id = ?");
+			params.push(input.taskId);
+		}
+		if (input.sessionId) {
+			where.push("session_id = ?");
+			params.push(input.sessionId);
+		}
+		const statuses = Array.isArray(input.status)
+			? input.status
+			: input.status
+				? [input.status]
+				: undefined;
+		if (statuses?.length === 0) return [];
+		if (statuses) {
+			where.push(`status IN (${placeholders(statuses.length)})`);
+			params.push(...statuses);
+		}
+		const limit = Math.min(1000, Math.max(1, Math.floor(input.limit ?? 200)));
+		const rows = this.db
+			.prepare(
+				`SELECT * FROM agenda_task_runs
+				${where.length > 0 ? `WHERE ${where.join(" AND ")}` : ""}
+				ORDER BY created_at DESC, attempt DESC LIMIT ?`,
+			)
+			.all(...params, limit);
+		return rows.map(runRowToRecord);
+	}
+
+	public getAutomationPolicy(scopeKey = "global"): AgendaAutomationPolicy {
+		let row = this.db
+			.prepare("SELECT * FROM agenda_task_automation WHERE scope_key = ?")
+			.get(scopeKey);
+		if (!row) {
+			this.db
+				.prepare(
+					`INSERT OR IGNORE INTO agenda_task_automation (
+						scope_key, mode, apply_to_agent_created, max_concurrent_runs,
+						max_chain_depth, max_starts_per_hour, updated_at
+					) VALUES (?, 'manual', 1, 2, 1, 20, ?)`,
+				)
+				.run(scopeKey, nowIso());
+			row = this.db
+				.prepare("SELECT * FROM agenda_task_automation WHERE scope_key = ?")
+				.get(scopeKey);
+		}
+		if (!row)
+			throw new Error(`failed to initialize automation policy ${scopeKey}`);
+		return policyRowToRecord(row);
+	}
+
+	public listAutomationPolicies(): AgendaAutomationPolicy[] {
+		return this.db
+			.prepare("SELECT * FROM agenda_task_automation ORDER BY scope_key")
+			.all()
+			.map((row) => policyRowToRecord(row));
+	}
+
+	public setAutomationPolicy(
+		input: Omit<AgendaAutomationPolicy, "updatedAt">,
+	): AgendaAutomationPolicy {
+		const scopeKey = requiredText(input.scopeKey, "scopeKey");
+		const maxConcurrentRuns = positiveInteger(
+			input.maxConcurrentRuns,
+			"maxConcurrentRuns",
+		);
+		const maxChainDepth = positiveInteger(input.maxChainDepth, "maxChainDepth");
+		const maxStartsPerHour = positiveInteger(
+			input.maxStartsPerHour,
+			"maxStartsPerHour",
+		);
+		const now = nowIso();
+		this.db
+			.prepare(
+				`INSERT INTO agenda_task_automation (
+					scope_key, mode, apply_to_agent_created, max_concurrent_runs,
+					max_chain_depth, max_starts_per_hour, enabled_by_json,
+					enabled_at, updated_at
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+				ON CONFLICT(scope_key) DO UPDATE SET
+					mode = excluded.mode,
+					apply_to_agent_created = excluded.apply_to_agent_created,
+					max_concurrent_runs = excluded.max_concurrent_runs,
+					max_chain_depth = excluded.max_chain_depth,
+					max_starts_per_hour = excluded.max_starts_per_hour,
+					enabled_by_json = excluded.enabled_by_json,
+					enabled_at = excluded.enabled_at,
+					updated_at = excluded.updated_at`,
+			)
+			.run(
+				scopeKey,
+				input.mode,
+				input.applyToAgentCreated ? 1 : 0,
+				maxConcurrentRuns,
+				maxChainDepth,
+				maxStartsPerHour,
+				input.enabledBy ? JSON.stringify(input.enabledBy) : null,
+				optionalIsoTimestamp(input.enabledAt, "enabledAt") ?? null,
+				now,
+			);
+		return this.getAutomationPolicy(scopeKey);
+	}
+}
diff --git a/sdk/packages/core/src/tasks/store/task-schema.ts b/sdk/packages/core/src/tasks/store/task-schema.ts
new file mode 100644
index 0000000000..9c4985f1fb
--- /dev/null
+++ b/sdk/packages/core/src/tasks/store/task-schema.ts
@@ -0,0 +1,97 @@
+import type { SqliteDb } from "@cline/shared/db";
+
+const TASK_SCHEMA_STATEMENTS: readonly string[] = [
+	`CREATE TABLE IF NOT EXISTS agenda_tasks (
+		task_id TEXT PRIMARY KEY,
+		type TEXT NOT NULL CHECK (type IN ('suggestion', 'follow-up', 'todo', 'handoff', 'idea', 'reminder')),
+		status TEXT NOT NULL CHECK (status IN ('pending_approval', 'approved', 'in_progress', 'completed', 'failed', 'cancelled', 'expired')),
+		title TEXT NOT NULL,
+		description TEXT,
+		instructions TEXT NOT NULL,
+		scope TEXT NOT NULL CHECK (scope IN ('workspace', 'global')),
+		workspace_root TEXT,
+		cwd TEXT,
+		resource_paths_json TEXT NOT NULL DEFAULT '[]',
+		priority INTEGER NOT NULL DEFAULT 3 CHECK (priority BETWEEN 0 AND 5),
+		assignee TEXT,
+		model_selection_json TEXT,
+		mode TEXT CHECK (mode IS NULL OR mode IN ('act', 'plan', 'yolo')),
+		system_prompt TEXT,
+		max_iterations INTEGER,
+		timeout_seconds INTEGER,
+		available_at TEXT NOT NULL,
+		expires_at TEXT NOT NULL,
+		automation_eligible INTEGER NOT NULL DEFAULT 1,
+		revision INTEGER NOT NULL DEFAULT 1,
+		approved_revision INTEGER,
+		created_by_json TEXT NOT NULL,
+		updated_by_json TEXT NOT NULL,
+		origin_session_id TEXT,
+		origin_task_id TEXT,
+		current_run_id TEXT,
+		last_run_id TEXT,
+		last_session_id TEXT,
+		spec_path TEXT UNIQUE,
+		error TEXT,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL,
+		completed_at TEXT,
+		archived_at TEXT,
+		CHECK (
+			(scope = 'workspace' AND workspace_root IS NOT NULL) OR
+			(scope = 'global' AND workspace_root IS NULL)
+		)
+	);`,
+	`CREATE TABLE IF NOT EXISTS agenda_task_runs (
+		run_id TEXT PRIMARY KEY,
+		task_id TEXT NOT NULL REFERENCES agenda_tasks(task_id) ON DELETE CASCADE,
+		task_revision INTEGER NOT NULL,
+		attempt INTEGER NOT NULL,
+		status TEXT NOT NULL CHECK (status IN ('starting', 'running', 'completed', 'failed', 'cancelled', 'interrupted')),
+		claim_token TEXT,
+		claim_until_at TEXT,
+		requested_by_client_id TEXT,
+		session_id TEXT,
+		claimed_at TEXT NOT NULL,
+		started_at TEXT,
+		completed_at TEXT,
+		result_summary TEXT,
+		error TEXT,
+		created_at TEXT NOT NULL,
+		updated_at TEXT NOT NULL,
+		UNIQUE (task_id, attempt)
+	);`,
+	`CREATE TABLE IF NOT EXISTS agenda_task_automation (
+		scope_key TEXT PRIMARY KEY,
+		mode TEXT NOT NULL CHECK (mode IN ('manual', 'auto_start', 'unattended')),
+		apply_to_agent_created INTEGER NOT NULL DEFAULT 1,
+		max_concurrent_runs INTEGER NOT NULL DEFAULT 2,
+		max_chain_depth INTEGER NOT NULL DEFAULT 1,
+		max_starts_per_hour INTEGER NOT NULL DEFAULT 20,
+		enabled_by_json TEXT,
+		enabled_at TEXT,
+		updated_at TEXT NOT NULL
+	);`,
+	`CREATE INDEX IF NOT EXISTS agenda_tasks_ready_idx
+		ON agenda_tasks(status, priority, available_at, expires_at, created_at);`,
+	`CREATE INDEX IF NOT EXISTS agenda_tasks_scope_idx
+		ON agenda_tasks(scope, workspace_root, status, available_at);`,
+	`CREATE INDEX IF NOT EXISTS agenda_tasks_origin_session_idx
+		ON agenda_tasks(origin_session_id, created_at);`,
+	`CREATE INDEX IF NOT EXISTS agenda_task_runs_task_idx
+		ON agenda_task_runs(task_id, attempt DESC);`,
+	`CREATE INDEX IF NOT EXISTS agenda_task_runs_session_idx
+		ON agenda_task_runs(session_id);`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS agenda_task_runs_one_active_idx
+		ON agenda_task_runs(task_id)
+		WHERE status IN ('starting', 'running');`,
+];
+
+export function ensureAgendaTaskSchema(db: SqliteDb): void {
+	db.exec("PRAGMA journal_mode = WAL;");
+	db.exec("PRAGMA busy_timeout = 5000;");
+	db.exec("PRAGMA foreign_keys = ON;");
+	for (const statement of TASK_SCHEMA_STATEMENTS) {
+		db.exec(statement);
+	}
+}
diff --git a/sdk/packages/core/src/tasks/task-location.ts b/sdk/packages/core/src/tasks/task-location.ts
new file mode 100644
index 0000000000..3d3b31e60c
--- /dev/null
+++ b/sdk/packages/core/src/tasks/task-location.ts
@@ -0,0 +1,125 @@
+import { existsSync, realpathSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import type { AgendaTaskScope } from "@cline/shared";
+
+export interface AgendaTaskLocationInput {
+	scope: AgendaTaskScope;
+	workspaceRoot?: string;
+	cwd?: string;
+	resourcePaths?: readonly string[];
+}
+
+export interface NormalizedAgendaTaskLocation {
+	workspaceRoot?: string;
+	cwd?: string;
+	resourcePaths: string[];
+}
+
+function optionalText(value: string | undefined): string | undefined {
+	const trimmed = value?.trim();
+	return trimmed || undefined;
+}
+
+function isContained(root: string, candidate: string): boolean {
+	const rel = relative(root, candidate);
+	return (
+		rel === "" ||
+		(!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel))
+	);
+}
+
+function assertNoSymlinkEscape(
+	workspaceRoot: string,
+	candidate: string,
+	field: string,
+): void {
+	if (!existsSync(workspaceRoot)) return;
+	const canonicalRoot = realpathSync(workspaceRoot);
+	let existing = candidate;
+	while (!existsSync(existing)) {
+		const parent = dirname(existing);
+		if (parent === existing) break;
+		existing = parent;
+	}
+	if (!existsSync(existing)) return;
+	const canonicalExisting = realpathSync(existing);
+	if (!isContained(canonicalRoot, canonicalExisting)) {
+		throw new Error(`${field} escapes the workspace through a symbolic link`);
+	}
+}
+
+function normalizeWorkspacePath(
+	workspaceRoot: string,
+	value: string,
+	field: string,
+	allowRoot: boolean,
+): string {
+	const candidate = resolve(
+		workspaceRoot,
+		isAbsolute(value) ? relative(workspaceRoot, value) : value,
+	);
+	if (
+		!isContained(workspaceRoot, candidate) ||
+		(!allowRoot && candidate === workspaceRoot)
+	) {
+		throw new Error(`${field} must stay within the task workspace`);
+	}
+	assertNoSymlinkEscape(workspaceRoot, candidate, field);
+	return candidate;
+}
+
+/** Enforce the queue's global/chat and workspace filesystem boundaries. */
+export function normalizeAgendaTaskLocation(
+	input: AgendaTaskLocationInput,
+): NormalizedAgendaTaskLocation {
+	const rawResources = input.resourcePaths ?? [];
+	if (input.scope === "global") {
+		if (optionalText(input.workspaceRoot)) {
+			throw new Error("global tasks cannot set workspaceRoot");
+		}
+		if (optionalText(input.cwd)) {
+			throw new Error("global tasks cannot set cwd");
+		}
+		if (rawResources.some((path) => path.trim())) {
+			throw new Error("global tasks cannot reference workspace files");
+		}
+		return { resourcePaths: [] };
+	}
+
+	const workspaceText = optionalText(input.workspaceRoot);
+	if (!workspaceText) {
+		throw new Error("workspaceRoot is required for workspace tasks");
+	}
+	const workspaceRoot = resolve(workspaceText);
+	const cwdText = optionalText(input.cwd);
+	const cwd = cwdText
+		? normalizeWorkspacePath(workspaceRoot, cwdText, "cwd", true)
+		: undefined;
+	const resourcePaths: string[] = [];
+	const seen = new Set<string>();
+	for (const rawPath of rawResources) {
+		const resourcePath = rawPath.trim();
+		if (!resourcePath) {
+			throw new Error("resourcePaths must contain only non-empty paths");
+		}
+		if (
+			isAbsolute(resourcePath) ||
+			resourcePath.split(/[\\/]+/u).includes("..")
+		) {
+			throw new Error("resourcePaths must be workspace-relative without '..'");
+		}
+		const candidate = normalizeWorkspacePath(
+			workspaceRoot,
+			resourcePath,
+			"resourcePaths",
+			false,
+		);
+		const normalized = relative(workspaceRoot, candidate);
+		if (!seen.has(normalized)) {
+			seen.add(normalized);
+			resourcePaths.push(normalized);
+		}
+	}
+
+	return { workspaceRoot, cwd, resourcePaths };
+}
diff --git a/sdk/packages/core/src/tasks/task-tool.test.ts b/sdk/packages/core/src/tasks/task-tool.test.ts
new file mode 100644
index 0000000000..53e474e7ec
--- /dev/null
+++ b/sdk/packages/core/src/tasks/task-tool.test.ts
@@ -0,0 +1,124 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+	createTasksPromptExtension,
+	createTasksTool,
+	TASKS_SYSTEM_PROMPT_RULE,
+} from "./task-tool";
+
+const context = {
+	sessionId: "session_1",
+	agentId: "agent_1",
+	iteration: 1,
+};
+
+function options() {
+	const manager = {
+		listTasks: vi.fn(async () => []),
+	};
+	const schedules = {
+		listSchedules: vi.fn(() => []),
+	};
+	return {
+		manager,
+		schedules,
+		tool: createTasksTool({
+			todo: {
+				manager: manager as never,
+				resolveSessionDefaults: async () => ({
+					workspaceRoot: process.cwd(),
+				}),
+			},
+			scheduled: {
+				schedules: schedules as never,
+				resolveSessionDefaults: async () => ({
+					workspaceRoot: process.cwd(),
+					interactive: true,
+				}),
+			},
+		}),
+	};
+}
+
+describe("tasks agent tool", () => {
+	it("routes Todo and scheduled operations through one tool", async () => {
+		const { manager, schedules, tool } = options();
+
+		await expect(
+			tool.execute({ kind: "todo", operation: "list" }, context),
+		).resolves.toMatchObject({ ok: true, kind: "todo", tasks: [] });
+		expect(manager.listTasks).toHaveBeenCalledOnce();
+
+		await expect(
+			tool.execute({ kind: "scheduled", operation: "list" }, context),
+		).resolves.toMatchObject({ ok: true, kind: "scheduled", schedules: [] });
+		expect(schedules.listSchedules).toHaveBeenCalledOnce();
+	});
+
+	it("advertises an Anthropic-compatible top-level object schema", () => {
+		const { tool } = options();
+		const schema = tool.inputSchema as Record<string, unknown>;
+
+		expect(schema.type).toBe("object");
+		expect(schema).not.toHaveProperty("oneOf");
+		expect(schema).not.toHaveProperty("anyOf");
+		expect(schema).not.toHaveProperty("allOf");
+		expect(schema.required).toEqual(
+			expect.arrayContaining(["kind", "operation"]),
+		);
+		expect(schema.properties).toMatchObject({
+			kind: { enum: ["todo", "scheduled"] },
+			operation: {
+				enum: [
+					"create",
+					"update",
+					"list",
+					"get",
+					"pause",
+					"resume",
+					"delete",
+					"run_now",
+				],
+			},
+		});
+	});
+
+	it("rejects missing and mixed domain discriminators", async () => {
+		const { tool } = options();
+		await expect(
+			tool.execute({ operation: "list" } as never, context),
+		).resolves.toMatchObject({
+			ok: false,
+			error: { code: "invalid_tasks_input" },
+		});
+		await expect(
+			tool.execute(
+				{
+					kind: "todo",
+					operation: "create",
+					type: "todo",
+					title: "Ambiguous",
+					instructions: "Do the work.",
+					expires_at: "2035-01-02T00:00:00.000Z",
+					run_at: "2035-01-01T00:00:00.000Z",
+				} as never,
+				context,
+			),
+		).resolves.toMatchObject({
+			ok: false,
+			kind: "todo",
+			error: { code: "invalid_tasks_input" },
+		});
+	});
+
+	it("registers one prompt rule conditional on the tasks tool", async () => {
+		const extension = createTasksPromptExtension();
+		const registerRule = vi.fn();
+		await extension.setup?.({ registerRule } as never, {});
+
+		expect(registerRule).toHaveBeenCalledWith({
+			id: "hub:task-guidance",
+			content: TASKS_SYSTEM_PROMPT_RULE,
+			whenToolAvailable: "tasks",
+		});
+	});
+});
diff --git a/sdk/packages/core/src/tasks/task-tool.ts b/sdk/packages/core/src/tasks/task-tool.ts
new file mode 100644
index 0000000000..7baebc95ce
--- /dev/null
+++ b/sdk/packages/core/src/tasks/task-tool.ts
@@ -0,0 +1,150 @@
+import type { AgentExtension, AgentTool } from "@cline/shared";
+import { createTool, zodToJsonSchema } from "@cline/shared";
+import { z } from "zod";
+import {
+	executeScheduleOperation,
+	ScheduledTaskInputSchema,
+	type ScheduledTaskResult,
+	type ScheduleTaskOperationOptions,
+} from "../cron/service/schedule-tool";
+import {
+	executeTodoTaskOperation,
+	TodoTaskInputSchema,
+	type TodoTaskOperationOptions,
+	type TodoTaskResult,
+} from "./agenda-task-tool";
+
+export const TASKS_TOOL_NAME = "tasks";
+
+export const TASKS_SYSTEM_PROMPT_RULE = `# Tasks
+
+Use the \`tasks\` tool to manage durable Todo items and explicitly requested scheduled agent work.
+
+- 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.
+- 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\`.
+- "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.
+- Never create both kinds for the same request unless the user explicitly requests both. Check existing items before creating a likely duplicate.
+- Todo instructions and scheduled prompts must be self-contained. Include the goal, constraints, relevant project context, and expected output.
+- 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.`;
+
+const TodoRequestSchema = TodoTaskInputSchema.extend({
+	kind: z.literal("todo"),
+}).strict();
+
+const ScheduledRequestSchema = ScheduledTaskInputSchema.extend({
+	kind: z.literal("scheduled"),
+}).strict();
+
+export const TasksToolInputSchema = z.discriminatedUnion("kind", [
+	TodoRequestSchema,
+	ScheduledRequestSchema,
+]);
+
+// Anthropic requires a plain object at the top level of a tool input schema and
+// rejects the oneOf emitted by a discriminated union. Advertise the union of
+// both domains' fields as one object, then retain strict domain validation with
+// TasksToolInputSchema inside execute().
+const TasksToolProviderInputSchema = z
+	.object({
+		...ScheduledTaskInputSchema.shape,
+		...TodoTaskInputSchema.shape,
+		kind: z.enum(["todo", "scheduled"]),
+		operation: z.enum([
+			"create",
+			"update",
+			"list",
+			"get",
+			"pause",
+			"resume",
+			"delete",
+			"run_now",
+		]),
+	})
+	.strict();
+
+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 {
+	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 function createTasksTool(
+	options: CreateTasksToolOptions,
+): AgentTool<TasksToolInput, TasksToolResult> {
+	return createTool<TasksToolInput, TasksToolResult>({
+		name: TASKS_TOOL_NAME,
+		description:
+			"Create and manage reviewed Todo items or explicitly requested scheduled agent work. " +
+			'Use kind "todo" for durable Agenda items that require user or automation approval. ' +
+			'Use kind "scheduled" for one-time or recurring autonomous execution. ' +
+			"Todo available_at is not an execution timer; schedules use run_at or cron_pattern.",
+		inputSchema: zodToJsonSchema(TasksToolProviderInputSchema),
+		retryable: false,
+		maxRetries: 0,
+		execute: async (rawInput, context) => {
+			const parsed = TasksToolInputSchema.safeParse(rawInput);
+			if (!parsed.success) {
+				return {
+					ok: false,
+					kind:
+						typeof rawInput === "object" &&
+						rawInput !== null &&
+						"kind" in rawInput &&
+						(rawInput.kind === "todo" || rawInput.kind === "scheduled")
+							? rawInput.kind
+							: undefined,
+					error: {
+						code: "invalid_tasks_input",
+						message: parsed.error.issues[0]?.message ?? "Invalid tasks input",
+					},
+				};
+			}
+
+			if (parsed.data.kind === "todo") {
+				const result = await executeTodoTaskOperation(
+					options.todo,
+					parsed.data,
+					context,
+				);
+				return { kind: "todo", ...result };
+			}
+
+			const result = await executeScheduleOperation(
+				options.scheduled,
+				parsed.data,
+				context,
+			);
+			return { kind: "scheduled", ...result };
+		},
+	});
+}
+
+/** Adds selection and safety guidance only when the unified tool is enabled. */
+export function createTasksPromptExtension(): AgentExtension {
+	return {
+		name: "hub-task-guidance",
+		manifest: { capabilities: ["rules"] },
+		setup: (api) => {
+			api.registerRule({
+				id: "hub:task-guidance",
+				content: TASKS_SYSTEM_PROMPT_RULE,
+				whenToolAvailable: TASKS_TOOL_NAME,
+			});
+		},
+	};
+}
diff --git a/sdk/packages/core/vitest.config.ts b/sdk/packages/core/vitest.config.ts
index 11f1241803..98adf052ec 100644
--- a/sdk/packages/core/vitest.config.ts
+++ b/sdk/packages/core/vitest.config.ts
@@ -13,7 +13,13 @@ export default defineConfig({
 		hookTimeout: 15_000,
 		pool: "forks",
 		...(process.env.CI && process.platform === "win32"
-			? { maxWorkers: 2 }
+			? {
+					// The full core suite can exhaust a hosted Windows runner when two
+					// fork workers overlap process-heavy and SQLite-heavy test files.
+					// Run it serially there to prevent unexplained worker termination.
+					fileParallelism: false,
+					maxWorkers: 1,
+				}
 			: {}),
 	},
 });
diff --git a/sdk/packages/shared/src/extensions/contribution-registry.ts b/sdk/packages/shared/src/extensions/contribution-registry.ts
index d4adef7420..05d0b312c4 100644
--- a/sdk/packages/shared/src/extensions/contribution-registry.ts
+++ b/sdk/packages/shared/src/extensions/contribution-registry.ts
@@ -24,6 +24,11 @@ export interface AgentExtensionRule {
 	id: string;
 	content: string | (() => string | Promise<string>);
 	source?: string;
+	/**
+	 * Include this rule only while the named tool is available after host,
+	 * global-settings, and per-session policy filtering.
+	 */
+	whenToolAvailable?: string;
 }
 
 export interface AgentExtensionMessageBuilder<TMessage = unknown> {
diff --git a/sdk/packages/shared/src/hub.test.ts b/sdk/packages/shared/src/hub.test.ts
index a7db860ed9..b751d2c6be 100644
--- a/sdk/packages/shared/src/hub.test.ts
+++ b/sdk/packages/shared/src/hub.test.ts
@@ -1,5 +1,44 @@
-import { describe, expect, it } from "vitest";
-import { isHubProtocolCompatible, readHubScheduleMode } from "./hub";
+import { describe, expect, expectTypeOf, it } from "vitest";
+import type { HubCommandInput } from "./hub";
+import {
+	HUB_CAPABILITIES,
+	isHubProtocolCompatible,
+	readHubScheduleMode,
+} from "./hub";
+
+describe("HUB_CAPABILITIES", () => {
+	it("advertises the task queue command surface", () => {
+		expect(HUB_CAPABILITIES).toEqual(
+			expect.arrayContaining([
+				"task.create",
+				"task.list",
+				"task.get",
+				"task.update",
+				"task.approve",
+				"task.cancel",
+				"task.run",
+				"task.automation.get",
+				"task.automation.set",
+			]),
+		);
+	});
+
+	it("requires optimistic revisions on lifecycle commands", () => {
+		expectTypeOf<HubCommandInput<"task.approve">>().toEqualTypeOf<{
+			taskId: string;
+			expectedRevision: number;
+		}>();
+		expectTypeOf<HubCommandInput<"task.cancel">>().toEqualTypeOf<{
+			taskId: string;
+			expectedRevision: number;
+			reason?: string;
+		}>();
+		expectTypeOf<HubCommandInput<"task.run">>().toEqualTypeOf<{
+			taskId: string;
+			expectedRevision: number;
+		}>();
+	});
+});
 
 describe("isHubProtocolCompatible", () => {
 	it("accepts a hub whose supported client range includes the client protocol", () => {
diff --git a/sdk/packages/shared/src/hub.ts b/sdk/packages/shared/src/hub.ts
index 629470f441..951dedf840 100644
--- a/sdk/packages/shared/src/hub.ts
+++ b/sdk/packages/shared/src/hub.ts
@@ -2,6 +2,14 @@ import type { AgentMessage } from "./agent";
 import type { GatewayModelSelection, JsonValue } from "./llms/gateway";
 import type { ReasoningEffort } from "./llms/reasoning-options";
 import type { RuntimeConfigExtensionKind } from "./session/runtime-config";
+import type {
+	AgendaAutomationPolicy,
+	AgendaTaskCreateInput,
+	AgendaTaskListInput,
+	AgendaTaskRecord,
+	AgendaTaskRunRecord,
+	AgendaTaskUpdateInput,
+} from "./tasks";
 
 export type HubProtocolVersion = "v1";
 
@@ -19,6 +27,15 @@ export type HubCapabilityName =
 	| "session.abort"
 	| "schedule.create"
 	| "schedule.list"
+	| "task.create"
+	| "task.list"
+	| "task.get"
+	| "task.update"
+	| "task.approve"
+	| "task.cancel"
+	| "task.run"
+	| "task.automation.get"
+	| "task.automation.set"
 	| "settings.get"
 	| "settings.set"
 	| "connector.start"
@@ -35,6 +52,15 @@ export const HUB_CAPABILITIES: readonly HubCapabilityName[] = [
 	"session.abort",
 	"schedule.create",
 	"schedule.list",
+	"task.create",
+	"task.list",
+	"task.get",
+	"task.update",
+	"task.approve",
+	"task.cancel",
+	"task.run",
+	"task.automation.get",
+	"task.automation.set",
 	"settings.get",
 	"settings.set",
 	"connector.start",
@@ -116,6 +142,9 @@ export interface ClientCapability {
 	payloadSchema?: Record<string, unknown>;
 }
 
+/** Client capability advertised by a live user surface that can answer tool approvals. */
+export const HUB_CLIENT_TOOL_APPROVAL_CAPABILITY = "approval.respond";
+
 export interface HubClientRegistration {
 	clientId?: string;
 	clientType: string;
@@ -288,6 +317,7 @@ export interface ScheduleRecord {
 	scheduleId: string;
 	name: string;
 	cronPattern: string;
+	timezone?: string;
 	prompt: string;
 	workspaceRoot: string;
 	cwd?: string;
@@ -366,6 +396,7 @@ export function readHubScheduleMode(
 export interface HubScheduleCreateInput {
 	name: string;
 	cronPattern: string;
+	timezone?: string;
 	prompt: string;
 	workspaceRoot: string;
 	cwd?: string;
@@ -386,6 +417,7 @@ export interface HubScheduleUpdateInput {
 	scheduleId: string;
 	name?: string;
 	cronPattern?: string;
+	timezone?: string | null;
 	prompt?: string;
 	workspaceRoot?: string;
 	cwd?: string;
@@ -402,6 +434,61 @@ export interface HubScheduleUpdateInput {
 	metadata?: Record<string, JsonValue | undefined>;
 }
 
+export interface HubTaskIdInput {
+	taskId: string;
+}
+
+export type HubTaskCreateInput = Omit<AgendaTaskCreateInput, "createdBy">;
+export type HubTaskUpdateInput = Omit<AgendaTaskUpdateInput, "updatedBy">;
+
+export interface HubTaskRevisionInput extends HubTaskIdInput {
+	expectedRevision: number;
+}
+
+export interface HubTaskCancelInput extends HubTaskRevisionInput {
+	reason?: string;
+}
+
+export interface HubTaskAutomationSetInput {
+	policy: Omit<AgendaAutomationPolicy, "updatedAt">;
+}
+
+/**
+ * Strongly typed task command payloads. This map is intentionally extensible so
+ * other Hub command families can adopt typed payloads without changing the wire
+ * envelope.
+ */
+export interface HubCommandInputMap {
+	"task.create": HubTaskCreateInput;
+	"task.list": AgendaTaskListInput;
+	"task.get": HubTaskIdInput;
+	"task.update": HubTaskUpdateInput;
+	"task.approve": HubTaskRevisionInput;
+	"task.cancel": HubTaskCancelInput;
+	"task.run": HubTaskRevisionInput;
+	"task.automation.get": Record<string, never>;
+	"task.automation.set": HubTaskAutomationSetInput;
+}
+
+/** Typed task command results returned in {@link HubReplyEnvelope.payload}. */
+export interface HubCommandOutputMap {
+	"task.create": { task: AgendaTaskRecord };
+	"task.list": { tasks: AgendaTaskRecord[] };
+	"task.get": { task?: AgendaTaskRecord };
+	"task.update": { task: AgendaTaskRecord };
+	"task.approve": { task: AgendaTaskRecord };
+	"task.cancel": { task: AgendaTaskRecord };
+	"task.run": { task: AgendaTaskRecord; run?: AgendaTaskRunRecord };
+	"task.automation.get": { policy: AgendaAutomationPolicy };
+	"task.automation.set": { policy: AgendaAutomationPolicy };
+}
+
+export type HubTypedCommandName = keyof HubCommandInputMap & HubCommandName;
+export type HubCommandInput<TCommand extends HubTypedCommandName> =
+	HubCommandInputMap[TCommand];
+export type HubCommandOutput<TCommand extends HubTypedCommandName> =
+	HubCommandOutputMap[TCommand];
+
 export type HubCommandName =
 	| "client.register"
 	| "client.update"
@@ -455,6 +542,15 @@ export type HubCommandName =
 	| "schedule.stats"
 	| "schedule.active"
 	| "schedule.upcoming"
+	| "task.create"
+	| "task.list"
+	| "task.get"
+	| "task.update"
+	| "task.approve"
+	| "task.cancel"
+	| "task.run"
+	| "task.automation.get"
+	| "task.automation.set"
 	| "settings.list"
 	| "settings.get"
 	| "settings.patch"
@@ -564,6 +660,13 @@ export type HubEventName =
 	| "schedule.triggered"
 	| "schedule.execution_completed"
 	| "schedule.execution_failed"
+	| "task.created"
+	| "task.updated"
+	| "task.deleted"
+	| "task.run.started"
+	| "task.run.completed"
+	| "task.run.failed"
+	| "task.automation.updated"
 	| "settings.changed"
 	| "ui.notify"
 	| "ui.show_window"
diff --git a/sdk/packages/shared/src/index.browser.ts b/sdk/packages/shared/src/index.browser.ts
index cfebda4c13..ee9efa2aad 100644
--- a/sdk/packages/shared/src/index.browser.ts
+++ b/sdk/packages/shared/src/index.browser.ts
@@ -496,6 +496,7 @@ export {
 	CLINE_WORKSPACES_DIRECTORY_NAME,
 	isChatWorkspacePath,
 } from "./storage/chat-workspace-paths";
+export * from "./tasks";
 export * from "./team";
 export { createTool } from "./tools/create";
 export { AUTH_ERROR_PATTERNS, isLikelyAuthError } from "./types/auth";
diff --git a/sdk/packages/shared/src/index.ts b/sdk/packages/shared/src/index.ts
index c9050d1faf..c7e8cd1680 100644
--- a/sdk/packages/shared/src/index.ts
+++ b/sdk/packages/shared/src/index.ts
@@ -575,6 +575,7 @@ export {
 	CLINE_WORKSPACES_DIRECTORY_NAME,
 	isChatWorkspacePath,
 } from "./storage/chat-workspace-paths";
+export * from "./tasks";
 export * from "./team";
 export { createTool } from "./tools/create";
 export * from "./types";
diff --git a/sdk/packages/shared/src/storage/index.ts b/sdk/packages/shared/src/storage/index.ts
index f9530ba28d..716bc6dc1b 100644
--- a/sdk/packages/shared/src/storage/index.ts
+++ b/sdk/packages/shared/src/storage/index.ts
@@ -16,6 +16,7 @@ export {
 	isChatWorkspacePath,
 	isPluginModulePath,
 	type ResolveCronSpecsDirOptions,
+	type ResolveTaskSpecsDirOptions,
 	RULES_CONFIG_DIRECTORY_NAME,
 	resolveAgentConfigSearchPaths,
 	resolveAgentsConfigDirPath,
@@ -37,6 +38,7 @@ export {
 	resolveGlobalAgentsRulesPath,
 	resolveGlobalCronSpecsDir,
 	resolveGlobalSettingsPath,
+	resolveGlobalTaskSpecsDir,
 	resolveHooksConfigSearchPaths,
 	resolveMcpSettingsPath,
 	resolvePluginConfigSearchPaths,
@@ -45,13 +47,17 @@ export {
 	resolveRulesConfigSearchPaths,
 	resolveSessionDataDir,
 	resolveSkillsConfigSearchPaths,
+	resolveTaskSpecsDir,
+	resolveTasksDbPath,
 	resolveTeamDataDir,
 	resolveWorkflowsConfigSearchPaths,
 	resolveWorkspaceCronSpecsDir,
+	resolveWorkspaceTaskSpecsDir,
 	SKILLS_CONFIG_DIRECTORY_NAME,
 	setClineDir,
 	setClineDirIfUnset,
 	setHomeDir,
 	setHomeDirIfUnset,
+	type TaskSpecsScope,
 	WORKFLOWS_CONFIG_DIRECTORY_NAME,
 } from "./paths";
diff --git a/sdk/packages/shared/src/storage/paths.ts b/sdk/packages/shared/src/storage/paths.ts
index 37d69d2b48..2a269a9960 100644
--- a/sdk/packages/shared/src/storage/paths.ts
+++ b/sdk/packages/shared/src/storage/paths.ts
@@ -250,6 +250,52 @@ export function resolveCronDbPath(): string {
 	return join(resolveDbDataDir(), "cron.db");
 }
 
+/** Path to the dedicated agenda task queue database. */
+export function resolveTasksDbPath(): string {
+	const explicitPath = process.env.CLINE_TASKS_DB_PATH?.trim();
+	if (explicitPath) {
+		return explicitPath;
+	}
+	return join(resolveDbDataDir(), "tasks.db");
+}
+
+export type TaskSpecsScope = "global" | "workspace";
+
+export interface ResolveTaskSpecsDirOptions {
+	/** Explicit directory, primarily for tests and embedded hosts. */
+	taskSpecsDir?: string;
+	scope: TaskSpecsScope;
+	/** Required for workspace-scoped task specs. */
+	workspaceRoot?: string;
+}
+
+/** Global file-backed agenda tasks: `~/.cline/tasks/`. */
+export function resolveGlobalTaskSpecsDir(): string {
+	return join(resolveClineDir(), "tasks");
+}
+
+/** Workspace file-backed agenda tasks: `<workspace>/.cline/tasks/`. */
+export function resolveWorkspaceTaskSpecsDir(workspaceRoot: string): string {
+	const normalized = workspaceRoot.trim();
+	if (!normalized) {
+		throw new Error("workspaceRoot is required for workspace task scope");
+	}
+	return join(normalized, ".cline", "tasks");
+}
+
+export function resolveTaskSpecsDir(
+	options: ResolveTaskSpecsDirOptions,
+): string {
+	const explicit = options.taskSpecsDir?.trim();
+	if (explicit) {
+		return explicit;
+	}
+	if (options.scope === "workspace") {
+		return resolveWorkspaceTaskSpecsDir(options.workspaceRoot ?? "");
+	}
+	return resolveGlobalTaskSpecsDir();
+}
+
 export type CronSpecsScope = "global" | "workspace";
 
 export interface ResolveCronSpecsDirOptions {
diff --git a/sdk/packages/shared/src/storage/task-paths.test.ts b/sdk/packages/shared/src/storage/task-paths.test.ts
new file mode 100644
index 0000000000..e4e88a85b1
--- /dev/null
+++ b/sdk/packages/shared/src/storage/task-paths.test.ts
@@ -0,0 +1,29 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+	resolveClineDir,
+	resolveDbDataDir,
+	resolveGlobalTaskSpecsDir,
+	resolveTaskSpecsDir,
+	resolveTasksDbPath,
+	resolveWorkspaceTaskSpecsDir,
+} from "./paths";
+
+describe("agenda task storage paths", () => {
+	it("places task state in the shared db directory", () => {
+		expect(resolveTasksDbPath()).toBe(
+			process.env.CLINE_TASKS_DB_PATH?.trim() ||
+				join(resolveDbDataDir(), "tasks.db"),
+		);
+	});
+
+	it("resolves global and workspace file-backed task roots", () => {
+		expect(resolveGlobalTaskSpecsDir()).toBe(join(resolveClineDir(), "tasks"));
+		expect(resolveWorkspaceTaskSpecsDir("/workspace")).toBe(
+			join("/workspace", ".cline", "tasks"),
+		);
+		expect(
+			resolveTaskSpecsDir({ scope: "workspace", workspaceRoot: "/workspace" }),
+		).toBe(join("/workspace", ".cline", "tasks"));
+	});
+});
diff --git a/sdk/packages/shared/src/tasks.ts b/sdk/packages/shared/src/tasks.ts
new file mode 100644
index 0000000000..a26f5a29f1
--- /dev/null
+++ b/sdk/packages/shared/src/tasks.ts
@@ -0,0 +1,188 @@
+import type { GatewayModelSelection } from "./llms/gateway";
+
+/** Semantic labels used to group work on a user's agenda. */
+export type AgendaTaskType =
+	| "suggestion"
+	| "follow-up"
+	| "todo"
+	| "handoff"
+	| "idea"
+	| "reminder";
+
+export type AgendaTaskStatus =
+	| "pending_approval"
+	| "approved"
+	| "in_progress"
+	| "completed"
+	| "failed"
+	| "cancelled"
+	| "expired";
+
+/** Lower numbers are more urgent. P3 is the default priority. */
+export type AgendaTaskPriority = 0 | 1 | 2 | 3 | 4 | 5;
+
+export type AgendaTaskScope = "workspace" | "global";
+
+export interface AgendaTaskActor {
+	kind: "user" | "agent" | "system" | "automation_policy";
+	id?: string;
+	displayName?: string;
+	clientId?: string;
+	sessionId?: string;
+	agentId?: string;
+}
+
+export type AgendaTaskRunStatus =
+	| "starting"
+	| "running"
+	| "completed"
+	| "failed"
+	| "cancelled"
+	| "interrupted";
+
+export interface AgendaTaskRecord {
+	taskId: string;
+	type: AgendaTaskType;
+	status: AgendaTaskStatus;
+	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;
+	/** Task cannot be started before this ISO-8601 timestamp. */
+	availableAt: string;
+	/** Required latest-start timestamp. */
+	expiresAt: string;
+	automationEligible: boolean;
+	revision: number;
+	approvedRevision?: number;
+	createdBy: AgendaTaskActor;
+	updatedBy: AgendaTaskActor;
+	originSessionId?: string;
+	originTaskId?: string;
+	currentRunId?: string;
+	lastRunId?: string;
+	lastSessionId?: string;
+	/** Canonical Markdown source file backing this task. */
+	specPath?: string;
+	error?: string;
+	createdAt: string;
+	updatedAt: string;
+	completedAt?: string;
+	archivedAt?: string;
+}
+
+export interface AgendaTaskRunRecord {
+	runId: string;
+	taskId: string;
+	taskRevision: number;
+	attempt: number;
+	status: AgendaTaskRunStatus;
+	claimToken?: string;
+	claimUntilAt?: string;
+	requestedByClientId?: string;
+	sessionId?: string;
+	claimedAt: string;
+	startedAt?: string;
+	completedAt?: string;
+	resultSummary?: string;
+	error?: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+export interface AgendaTaskCreateInput {
+	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;
+	/** False only when a trusted interactive user directly authored the item. */
+	requiresApproval?: boolean;
+	createdBy: AgendaTaskActor;
+	originSessionId?: string;
+	originTaskId?: string;
+	/** Optional explicit source path; managers normally derive this. */
+	specPath?: string;
+}
+
+/** Editable task fields. Lifecycle transitions are owned by the task manager. */
+export interface AgendaTaskUpdateInput {
+	taskId: string;
+	expectedRevision: number;
+	type?: AgendaTaskType;
+	title?: string;
+	description?: string | null;
+	instructions?: string;
+	scope?: AgendaTaskScope;
+	workspaceRoot?: string | null;
+	cwd?: string | null;
+	resourcePaths?: string[];
+	priority?: AgendaTaskPriority;
+	assignee?: string | null;
+	modelSelection?: GatewayModelSelection | null;
+	mode?: "act" | "plan" | "yolo" | null;
+	systemPrompt?: string | null;
+	maxIterations?: number | null;
+	timeoutSeconds?: number | null;
+	availableAt?: string;
+	expiresAt?: string;
+	automationEligible?: boolean;
+	updatedBy: AgendaTaskActor;
+}
+
+export interface AgendaTaskListInput {
+	statuses?: AgendaTaskStatus[];
+	types?: AgendaTaskType[];
+	/** Explicit scope filtering. Omit to include global tasks with a workspace view. */
+	scope?: AgendaTaskScope;
+	/**
+	 * Selected workspace. With no explicit scope, results contain global tasks plus
+	 * tasks for this workspace. `scope: "workspace"` is workspace-only, while
+	 * `scope: "global"` ignores this value and remains global-only.
+	 */
+	workspaceRoot?: string;
+	priorities?: AgendaTaskPriority[];
+	automationEligible?: boolean;
+	availableBefore?: string;
+	includeArchived?: boolean;
+	limit?: number;
+}
+
+export type AgendaAutomationMode = "manual" | "auto_start" | "unattended";
+
+export interface AgendaAutomationPolicy {
+	/** `global` in v1; allows workspace/type-specific policies later. */
+	scopeKey: string;
+	mode: AgendaAutomationMode;
+	applyToAgentCreated: boolean;
+	maxConcurrentRuns: number;
+	maxChainDepth: number;
+	maxStartsPerHour: number;
+	enabledBy?: AgendaTaskActor;
+	enabledAt?: string;
+	updatedAt: string;
+}