@p4code/cli 0.1.24 → 0.1.26

package/dist/bin.mjs

@@ -236,7 +236,7 @@ const make$76 = () => {
 const layer$72 = Layer.sync(NetService, make$76);
 //#endregion
 //#region package.json
-var version = "0.1.24";
+var version = "0.1.26";
 //#endregion
 //#region src/config.ts
 /**
@@ -5881,7 +5881,6 @@ const SourceControlWritingStyleSettings = Schema$1.Struct({
 	followChangeRequestTemplates: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true)))
 });
 const DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL = Duration.seconds(30);
-const TaskBoardSource = Schema$1.Literals(["local", "hub"]);
 const ServerSettings = Schema$1.Struct({
 	enableAssistantStreaming: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false))),
 	enableProviderUpdateChecks: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
@@ -5956,23 +5955,19 @@ const ServerSettings = Schema$1.Struct({
 	sourceControlWritingStyle: SourceControlWritingStyleSettings.pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
 	sourceControlWriterModelSelection: Schema$1.NullOr(ModelSelection).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
 	/**
-	* Where this server's task board lives.
+	* The Linear team new issues are filed into, by name or id.
 	*
-	* `local` is this machine's own SQLite database, which is where every board
-	* has been until now. `hub` puts the board on the linked hub, so two servers
-	* read and write one board instead of two that silently diverge.
+	* Needed because Linear requires a team to create an issue and has no notion
+	* of a default one. Empty means unchosen, which is not an error until
+	* somebody tries to file a task on the Linear board - reading it works fine
+	* without one, and demanding the choice up front would block the common case
+	* of looking at what is already there.
 	*
-	* A setting rather than "hub if one is linked", because a hub can be linked
-	* for skills alone, and flipping a board's home is not something to have
-	* happen as a side effect of connecting. It is also the way back: the local
-	* rows are still there, untouched, when it is set to `local` again.
-	*
-	* **On `hub`, an unreachable hub means no board.** There is no local
-	* fallback by decision: answering from a stale local copy would recreate the
-	* per-machine divergence the hub exists to remove, and it would do it
-	* invisibly.
+	* A setting rather than a board control, unlike the board source itself: the
+	* team is a property of how this machine is set up, it is answered once, and
+	* changing it retroactively re-homes nothing.
 	*/
-	taskBoardSource: TaskBoardSource.pipe(Schema$1.withDecodingDefault(Effect.succeed("local"))),
+	linearTeam: Schema$1.String.pipe(Schema$1.withDecodingDefault(Effect.succeed(""))),
 	/**
 	* Skills the agents on this server must not see, by name.
 	*
@@ -6095,7 +6090,7 @@ const ServerSettingsPatch = Schema$1.Struct({
 	})),
 	sourceControlWriterModelSelection: Schema$1.optionalKey(Schema$1.NullOr(ModelSelection)),
 	disabledSkills: Schema$1.optionalKey(Schema$1.Array(TrimmedNonEmptyString)),
-	taskBoardSource: Schema$1.optionalKey(TaskBoardSource),
+	linearTeam: Schema$1.optionalKey(TrimmedString),
 	observability: Schema$1.optionalKey(Schema$1.Struct({
 		otlpTracesUrl: Schema$1.optionalKey(TrimmedString),
 		otlpMetricsUrl: Schema$1.optionalKey(TrimmedString)
@@ -7283,6 +7278,41 @@ const TaskPriority = Schema$1.Literals([
 	"urgent"
 ]);
 /**
+* Which board a call is about.
+*
+* `board` is p4code's own: this machine's rows, mirrored to the hub when one is
+* linked. It is one board rather than two because the local store is a replica
+* of the hub and not a rival copy of it, which is why there is no `hub` member
+* here — asking for "the hub board" and "the local board" separately would be
+* asking for the same rows twice.
+*
+* `linear` is the user's Linear workspace, read and written through the Linear
+* MCP server they already registered. p4code holds no Linear credential of its
+* own; see `mcp/TicketResolver` for why that is the only way in.
+*
+* A per-call parameter rather than a setting: a person switches boards to look
+* at something and switches back, and a server-wide mode would make that a
+* configuration change with a blast radius across every open client.
+*/
+const TaskSource = Schema$1.Literals(["board", "linear"]);
+/**
+* The board a call means when it does not say. Every existing caller predates
+* the parameter and means p4code's own board, so the default has to be `board`
+* for them to keep working unchanged.
+*/
+const DEFAULT_TASK_SOURCE = "board";
+const TaskSourceField = TaskSource.pipe(Schema$1.annotateEncoded({ description: "Which board to act on: 'board' for p4code's own (the default), 'linear' for the linked Linear workspace." }));
+/**
+* Mixed into the RPC payloads rather than into `TaskCreateInput` and friends.
+*
+* Those inputs are also the hub's wire format and the MCP tools' argument
+* schemas, and a source belongs to neither: the hub *is* the board, so a
+* `source` field on its create route would be a field it must reject, and an
+* agent picking a tracker per call is a capability to add deliberately rather
+* than one to leak in by inheritance.
+*/
+const TaskSourceSelector = Schema$1.Struct({ source: Schema$1.optional(TaskSourceField) });
+/**
 * A per-prefix sequence prefix, e.g. `T` or `P4`. Declared by a project in its
 * `p4.json` (`taskPrefix`); always stored and compared uppercase.
 */
@@ -7472,6 +7502,39 @@ const HubTaskCreateInput = Schema$1.Struct({
 	orderKey: Schema$1.optional(OrderKeyField)
 });
 /**
+* A whole row, written to the hub at an id the sending machine chose.
+*
+* Every field is present and nullable rather than optional, because this is a
+* replace and not a patch: a task whose assignee was cleared locally has to
+* arrive as an explicit `null`, and under an optional field it would arrive as
+* an absence indistinguishable from "unchanged" — so the clear would never
+* propagate and the two machines would disagree forever about who owns it.
+*
+* `readableId` and `updatedAt` are absent for the opposite reason: they are
+* the hub's to assign. The hub allocates the readable id the first time it
+* sees an id and preserves it afterwards, which is what lets a task created
+* on an offline machine get its `P4-12` on the first push and keep it.
+*
+* `createdAt` does come from the sender. It is a fact about when the person
+* filed the task, and the hub learning about it late does not make it newer.
+*/
+const HubTaskPutInput = Schema$1.Struct({
+	projectId: Schema$1.NullOr(ProjectIdField),
+	repositoryKey: Schema$1.NullOr(RepositoryKeyField),
+	threadId: Schema$1.NullOr(ThreadIdField),
+	externalRef: Schema$1.NullOr(ExternalRefField),
+	parentTaskId: Schema$1.NullOr(ParentTaskIdField),
+	title: TitleField,
+	body: BodyField,
+	status: StatusField,
+	priority: PriorityField,
+	assignee: Schema$1.NullOr(AssigneeField),
+	labels: LabelsField,
+	orderKey: Schema$1.NullOr(OrderKeyField),
+	createdAt: IsoDateTime,
+	readableIdPrefix: Schema$1.optional(TrimmedNonEmptyString)
+});
+/**
 * Every field is optional and an omitted field is left untouched. The nullable
 * fields accept an explicit `null` to clear them, which is why they are
 * `NullOr` inside `optional` rather than merely optional.
@@ -9213,23 +9276,44 @@ const WS_METHODS = {
 * client and useful only in the server log.
 */
 const TaskRpcError = Schema$1.Union([TaskStoreError, EnvironmentAuthorizationError]);
+/**
+* Every task method carries the board it means.
+*
+* Spread into each payload rather than declared once as a wrapper, because
+* these payloads are what the client sends verbatim and a nested `{ input,
+* source }` would rename every field at every call site for no gain. Absent
+* means `board`, which is what every caller written before this parameter
+* existed intends.
+*/
 const WsTasksListRpc = Rpc.make(WS_METHODS.tasksList, {
-	payload: TaskListFilter,
+	payload: Schema$1.Struct({
+		...TaskListFilter.fields,
+		...TaskSourceSelector.fields
+	}),
 	success: TaskListResult$1,
 	error: TaskRpcError
 });
 const WsTasksGetRpc = Rpc.make(WS_METHODS.tasksGet, {
-	payload: TaskGetInput,
+	payload: Schema$1.Struct({
+		...TaskGetInput.fields,
+		...TaskSourceSelector.fields
+	}),
 	success: TaskGetResult,
 	error: TaskRpcError
 });
 const WsTasksCreateRpc = Rpc.make(WS_METHODS.tasksCreate, {
-	payload: TaskCreateInput,
+	payload: Schema$1.Struct({
+		...TaskCreateInput.fields,
+		...TaskSourceSelector.fields
+	}),
 	success: TaskResult,
 	error: TaskRpcError
 });
 const WsTasksUpdateRpc = Rpc.make(WS_METHODS.tasksUpdate, {
-	payload: TaskUpdateInput,
+	payload: Schema$1.Struct({
+		...TaskUpdateInput.fields,
+		...TaskSourceSelector.fields
+	}),
 	success: TaskResult,
 	error: Schema$1.Union([
 		TaskNotFoundError,
@@ -9238,7 +9322,10 @@ const WsTasksUpdateRpc = Rpc.make(WS_METHODS.tasksUpdate, {
 	])
 });
 const WsTasksDeleteRpc = Rpc.make(WS_METHODS.tasksDelete, {
-	payload: TaskGetInput,
+	payload: Schema$1.Struct({
+		...TaskGetInput.fields,
+		...TaskSourceSelector.fields
+	}),
 	success: Schema$1.Struct({}),
 	error: TaskRpcError
 });
@@ -9256,7 +9343,10 @@ const WsTasksDeleteRpc = Rpc.make(WS_METHODS.tasksDelete, {
 * engine's own failure and already has a type.
 */
 const WsTasksStartThreadRpc = Rpc.make(WS_METHODS.tasksStartThread, {
-	payload: TaskStartThreadInput,
+	payload: Schema$1.Struct({
+		...TaskStartThreadInput.fields,
+		...TaskSourceSelector.fields
+	}),
 	success: TaskStartThreadResult,
 	error: Schema$1.Union([
 		TaskNotFoundError,
@@ -9487,7 +9577,7 @@ const WsTicketsResolveRpc = Rpc.make(WS_METHODS.ticketsResolve, {
 * a write can be missed.
 */
 const WsSubscribeTasksRpc = Rpc.make(WS_METHODS.subscribeTasks, {
-	payload: Schema$1.Struct({}),
+	payload: TaskSourceSelector,
 	success: TaskStreamEvent,
 	error: Schema$1.Union([TaskStoreError, EnvironmentAuthorizationError]),
 	stream: true
@@ -13037,6 +13127,62 @@ var _042_ProjectionThreadsUnpromptedSubagents_default = Effect.gen(function* ()
   `;
 });
 //#endregion
+//#region src/persistence/Migrations/043_TaskSync.ts
+/**
+* What the local board still owes the hub.
+*
+* The board is no longer either local or remote: local SQLite is a replica of
+* the hub, so every row needs to say whether the hub has seen its current
+* version. `sync_state` is that flag, and it only ever has two values —
+* `pending` (this machine has a version the hub has not acknowledged) and
+* `synced` (the hub returned this exact row). There is no third state for "in
+* flight": a push that dies mid-request leaves the row `pending`, which is
+* true, and the next pass retries it.
+*
+* Existing rows are marked `pending` rather than `synced`, which is what makes
+* this a migration and not just a column. Every task on this machine predates
+* the mirror and the hub has never seen any of them, so they upload on the
+* first pass after a hub is linked. That is the behaviour the column exists
+* for; defaulting them to `synced` would silently strand every task already on
+* the board.
+*
+* `task_tombstones` is the other half. A row deleted here while the hub was
+* unreachable is gone from `tasks`, so the next pull — which sees the hub
+* still holding it — would put it straight back. The tombstone is what says
+* "this absence is a decision, not a gap", and it is dropped once the hub has
+* accepted the delete.
+*
+* @module Migrations/043_TaskSync
+*/
+var _043_TaskSync_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`ALTER TABLE tasks ADD COLUMN sync_state TEXT NOT NULL DEFAULT 'pending'`;
+	yield* sql`ALTER TABLE tasks ADD COLUMN readable_id_prefix TEXT`;
+	yield* sql`
+    UPDATE tasks
+    SET readable_id_prefix = substr(readable_id, 1, instr(readable_id, '-') - 1)
+    WHERE readable_id IS NOT NULL AND instr(readable_id, '-') > 1
+  `;
+	yield* sql`
+    CREATE INDEX IF NOT EXISTS idx_tasks_sync_state
+    ON tasks(sync_state)
+  `;
+	yield* sql`
+    CREATE TABLE IF NOT EXISTS task_tombstones (
+      task_id TEXT PRIMARY KEY,
+      deleted_at TEXT NOT NULL
+    )
+  `;
+	yield* sql`
+    CREATE TABLE IF NOT EXISTS linear_task_links (
+      issue_id TEXT PRIMARY KEY,
+      thread_id TEXT,
+      project_id TEXT,
+      repository_key TEXT
+    )
+  `;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -13267,6 +13413,11 @@ const migrationEntries = [
 		42,
 		"ProjectionThreadsUnpromptedSubagents",
 		_042_ProjectionThreadsUnpromptedSubagents_default
+	],
+	[
+		43,
+		"TaskSync",
+		_043_TaskSync_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -14874,7 +15025,7 @@ const DeleteTaskInput = Schema$1.Struct({ taskId: TaskId });
 var TaskRepository = class extends Context.Service()("@p4code/cli/persistence/Services/Tasks/TaskRepository") {};
 //#endregion
 //#region src/persistence/Layers/Tasks.ts
-const TaskDbRow = Task.mapFields(Struct.assign({
+const TaskDbRow$1 = Task.mapFields(Struct.assign({
 	labels: Schema$1.fromJsonString(Schema$1.Array(TaskLabel)),
 	externalRef: Schema$1.NullOr(Schema$1.fromJsonString(TaskExternalRef))
 }));
@@ -14891,7 +15042,7 @@ const TaskListQuery = Schema$1.Struct({
 	status: Schema$1.NullOr(Schema$1.String),
 	assignee: Schema$1.NullOr(Schema$1.String)
 });
-const TASK_COLUMNS = `
+const TASK_COLUMNS$1 = `
   task_id AS "taskId",
   readable_id AS "readableId",
   project_id AS "projectId",
@@ -14973,13 +15124,13 @@ const makeTaskRepository = Effect.gen(function* () {
 	});
 	const getTaskRow = SqlSchema.findOneOption({
 		Request: GetTaskInput,
-		Result: TaskDbRow,
-		execute: ({ taskId }) => sql`SELECT ${sql.literal(TASK_COLUMNS)} FROM tasks WHERE task_id = ${taskId}`
+		Result: TaskDbRow$1,
+		execute: ({ taskId }) => sql`SELECT ${sql.literal(TASK_COLUMNS$1)} FROM tasks WHERE task_id = ${taskId}`
 	});
 	const getTaskRowByReadableId = SqlSchema.findOneOption({
 		Request: Schema$1.String,
-		Result: TaskDbRow,
-		execute: (readableId) => sql`SELECT ${sql.literal(TASK_COLUMNS)} FROM tasks WHERE readable_id = ${readableId}`
+		Result: TaskDbRow$1,
+		execute: (readableId) => sql`SELECT ${sql.literal(TASK_COLUMNS$1)} FROM tasks WHERE readable_id = ${readableId}`
 	});
 	/**
 	* Take the next number for a prefix, creating the sequence at 1 on first
@@ -14998,9 +15149,9 @@ const makeTaskRepository = Effect.gen(function* () {
 	});
 	const listTaskRows = SqlSchema.findAll({
 		Request: TaskListQuery,
-		Result: TaskDbRow,
+		Result: TaskDbRow$1,
 		execute: (query) => sql`
-        SELECT ${sql.literal(TASK_COLUMNS)}
+        SELECT ${sql.literal(TASK_COLUMNS$1)}
         FROM tasks
         WHERE (${query.projectId} IS NULL OR project_id = ${query.projectId})
           AND (${query.repositoryKey} IS NULL OR repository_key = ${query.repositoryKey})
@@ -15248,6 +15399,60 @@ const createTaskRoute = HttpRouter.add("POST", "/tasks", respondToHubFailures(Ef
 	const task = yield* tasks.create(row, input.readableIdPrefix ?? "T");
 	return HttpServerResponse.jsonUnsafe(task, { status: 201 });
 })));
+/**
+* Write a whole row at an id the calling server chose.
+*
+* This is what makes a local mirror possible. A server writes the row to its
+* own database first — so the board answers instantly and keeps answering with
+* the hub down — and only then pushes it here. By that point the id is already
+* referenced by a thread link, a parent link and anything else that names the
+* task, so the hub has to accept it rather than mint a competing one. Ids are
+* UUIDs, so accepting the caller's costs nothing: two servers cannot collide.
+*
+* The readable id stays the hub's. It is allocated the first time an id is
+* seen and preserved on every write after, which is the arrangement that lets
+* a task filed on an offline laptop pick up its `P4-12` on first contact and
+* keep it everywhere.
+*/
+const putTaskRoute = HttpRouter.add("PUT", "/tasks/:taskId", respondToHubFailures(Effect.gen(function* () {
+	yield* authenticateHubRequest();
+	const params = yield* HttpRouter.params;
+	const taskId = TaskId.make(params.taskId ?? "");
+	const input = yield* decodeOrInvalid(HubTaskPutInput, "Request body does not match HubTaskPutInput.")(yield* readJsonBody());
+	const tasks = yield* TaskRepository;
+	const timestamp = DateTime.formatIso(yield* DateTime.now);
+	const fields = {
+		projectId: input.projectId,
+		repositoryKey: input.repositoryKey,
+		threadId: input.threadId,
+		externalRef: input.externalRef,
+		parentTaskId: input.parentTaskId,
+		title: input.title,
+		body: input.body,
+		status: input.status,
+		priority: input.priority,
+		assignee: input.assignee,
+		labels: input.labels,
+		orderKey: input.orderKey
+	};
+	const existing = yield* tasks.getById({ taskId });
+	if (Option.isNone(existing)) {
+		const created = yield* tasks.create({
+			taskId,
+			...fields,
+			createdAt: input.createdAt,
+			updatedAt: timestamp
+		}, input.readableIdPrefix ?? "T");
+		return HttpServerResponse.jsonUnsafe(created, { status: 201 });
+	}
+	const replaced = {
+		...existing.value,
+		...fields,
+		updatedAt: timestamp
+	};
+	yield* tasks.upsert(replaced);
+	return HttpServerResponse.jsonUnsafe(replaced);
+})));
 const updateTaskRoute = HttpRouter.add("PATCH", "/tasks/:taskId", respondToHubFailures(Effect.gen(function* () {
 	yield* authenticateHubRequest();
 	const params = yield* HttpRouter.params;
@@ -15376,7 +15581,7 @@ const deleteAssetRoute = HttpRouter.add("DELETE", "/assets/:kind/:name", respond
 	const outcome = yield* (yield* AgentAssetRepository).deleteByName(requested);
 	return outcome._tag === "conflict" ? assetConflict(Option.getOrNull(outcome.current)) : HttpServerResponse.empty({ status: 204 });
 })));
-const layer$62 = Layer.mergeAll(healthRoute, listTasksRoute, getTaskRoute, createTaskRoute, updateTaskRoute, deleteTaskRoute, listAssetsRoute, getAssetRoute, putAssetRoute, deleteAssetRoute);
+const layer$62 = Layer.mergeAll(healthRoute, listTasksRoute, getTaskRoute, createTaskRoute, putTaskRoute, updateTaskRoute, deleteTaskRoute, listAssetsRoute, getAssetRoute, putAssetRoute, deleteAssetRoute);
 //#endregion
 //#region src/hub/Migrations/001_Tasks.ts
 /**
@@ -16158,6 +16363,36 @@ function buildSkillOverrides(disabled, discovered) {
 * @module provider/Drivers/ClaudeSkills
 */
 const FRONTMATTER_PATTERN$1 = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+/** The `true` spellings the CLI accepts for a boolean frontmatter field. */
+const TRUTHY_FRONTMATTER_VALUES = /* @__PURE__ */ new Set([
+	"true",
+	"yes",
+	"on",
+	"1"
+]);
+/**
+* A frontmatter boolean, spelled any of the ways the CLI allows.
+*
+* YAML already decodes an unquoted `true` to a boolean, but a quoted `"yes"`
+* arrives as a string, and the CLI accepts both. Reading only the boolean would
+* make a skill that works there silently model-invocable here.
+*/
+function readFrontmatterBoolean(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "number") return value === 1;
+	if (typeof value === "string") return TRUTHY_FRONTMATTER_VALUES.has(value.trim().toLowerCase());
+}
+/**
+* The document with its frontmatter block removed.
+*
+* The body is what a skill actually instructs; the header is metadata about
+* how it is selected. Exported for the expansion that inlines a skill into a
+* turn, which must send the instructions without the routing header.
+*/
+function stripMarkdownFrontmatter(contents) {
+	const match = FRONTMATTER_PATTERN$1.exec(contents);
+	return (match ? contents.slice(match[0].length) : contents).trim();
+}
 /**
 * The `name`/`description` header a skill and a subagent definition both carry.
 *
@@ -16179,10 +16414,12 @@ function parseMarkdownFrontmatter(contents) {
 	const record = parsed;
 	const name = typeof record.name === "string" ? record.name.trim() : "";
 	const description = typeof record.description === "string" ? record.description.trim() : "";
+	const disableModelInvocation = readFrontmatterBoolean(record["disable-model-invocation"]);
 	return {
 		kind: "parsed",
 		...name ? { name } : {},
-		...description ? { description } : {}
+		...description ? { description } : {},
+		...disableModelInvocation === void 0 ? {} : { disableModelInvocation }
 	};
 }
 /**
@@ -32523,7 +32760,7 @@ const NESTED_PAYLOAD_KEYS = [
 	"operations"
 ];
 const MAX_COLLECT_DEPTH = 4;
-function asRecord$4(value) {
+function asRecord$6(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
 }
 function pushChangedFilePath(target, value) {
@@ -32538,7 +32775,7 @@ function collectChangedFilePaths(value, target, depth) {
 		for (const entry of value) collectChangedFilePaths(entry, target, depth + 1);
 		return;
 	}
-	const record = asRecord$4(value);
+	const record = asRecord$6(value);
 	if (!record) return;
 	for (const field of CHANGED_FILE_FIELDS) pushChangedFilePath(target, record[field]);
 	for (const nestedKey of NESTED_PAYLOAD_KEYS) if (nestedKey in record) collectChangedFilePaths(record[nestedKey], target, depth + 1);
@@ -32549,7 +32786,7 @@ function collectChangedFilePaths(value, target, depth) {
 */
 function collectActivityChangedFilePaths(payload) {
 	const target = /* @__PURE__ */ new Set();
-	collectChangedFilePaths(asRecord$4(asRecord$4(payload)?.data), target, 0);
+	collectChangedFilePaths(asRecord$6(asRecord$6(payload)?.data), target, 0);
 	return target;
 }
 /**
@@ -35634,22 +35871,22 @@ function classifyToolCategory(input) {
 	if (normalized.includes("image")) return "image_view";
 	return "tool";
 }
-function asRecord$3(value) {
+function asRecord$5(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
 /** Classify from a runtime item payload's `data` (`{ toolName, input }`). */
 function classifyToolCategoryFromToolData(data) {
-	const record = asRecord$3(data);
+	const record = asRecord$5(data);
 	const toolName = record?.toolName;
 	if (typeof toolName !== "string" || toolName.trim().length === 0) return;
 	return classifyToolCategory({
 		toolName,
-		toolInput: asRecord$3(record?.input)
+		toolInput: asRecord$5(record?.input)
 	});
 }
 //#endregion
 //#region src/orchestration/ActivityPayloadProjection.ts
-function asRecord$2(value) {
+function asRecord$4(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
 function asTrimmedString$1(value) {
@@ -35672,7 +35909,7 @@ function collectChangedFiles(value, target, seen, depth) {
 		}
 		return;
 	}
-	const record = asRecord$2(value);
+	const record = asRecord$4(value);
 	if (!record) return;
 	pushChangedFile(target, seen, record.path);
 	pushChangedFile(target, seen, record.filePath);
@@ -35698,13 +35935,13 @@ function collectChangedFiles(value, target, seen, depth) {
 	}
 }
 function projectCommandData(data) {
-	const item = asRecord$2(data.item);
+	const item = asRecord$4(data.item);
 	if (!item) return;
 	const projectedItem = {};
 	if ("command" in item) projectedItem.command = item.command;
-	const input = asRecord$2(item.input);
+	const input = asRecord$4(item.input);
 	if (input && "command" in input) projectedItem.input = { command: input.command };
-	const result = asRecord$2(item.result);
+	const result = asRecord$4(item.result);
 	if (result && "command" in result) projectedItem.result = { command: result.command };
 	return Object.keys(projectedItem).length > 0 ? projectedItem : void 0;
 }
@@ -35720,7 +35957,7 @@ function summarizeToolTextOutput(value) {
 	return null;
 }
 function projectRawOutput(value) {
-	const rawOutput = asRecord$2(value);
+	const rawOutput = asRecord$4(value);
 	if (!rawOutput) return;
 	if (typeof rawOutput.totalFiles === "number" && Number.isFinite(rawOutput.totalFiles)) return {
 		totalFiles: rawOutput.totalFiles,
@@ -35742,14 +35979,14 @@ function projectRawOutput(value) {
 * the full payload in persistence and the event store.
 */
 function projectActivityPayload(activity) {
-	const payload = asRecord$2(activity.payload);
-	const data = asRecord$2(payload?.data);
+	const payload = asRecord$4(activity.payload);
+	const data = asRecord$4(payload?.data);
 	if (!payload || !data || payload.itemType === "mcp_tool_call") return activity;
 	const projectedData = {};
 	const item = projectCommandData(data);
 	if (item) projectedData.item = item;
 	if ("command" in data) projectedData.command = data.command;
-	const input = asRecord$2(data.input);
+	const input = asRecord$4(data.input);
 	if (input && "command" in input) projectedData.input = { command: input.command };
 	const changedFiles = [];
 	collectChangedFiles(data, changedFiles, /* @__PURE__ */ new Set(), 0);
@@ -35776,7 +36013,7 @@ function projectActivityPayload(activity) {
 */
 function isResolvableContextWindowActivity(activity) {
 	if (activity.kind !== "context-window.updated") return false;
-	const usedTokens = asRecord$2(activity.payload)?.usedTokens;
+	const usedTokens = asRecord$4(activity.payload)?.usedTokens;
 	return typeof usedTokens === "number" && Number.isFinite(usedTokens) && usedTokens >= 0;
 }
 /**
@@ -35792,7 +36029,7 @@ function isResolvableContextWindowActivity(activity) {
 * client.
 */
 function withoutContextWindowBreakdown$1(activity) {
-	const payload = asRecord$2(activity.payload);
+	const payload = asRecord$4(activity.payload);
 	if (!payload || payload.breakdown === void 0) return activity;
 	const { breakdown: _breakdown, ...rest } = payload;
 	return {
@@ -35807,7 +36044,7 @@ function dropStaleContextWindowActivities(activities) {
 	const retainedIndexes = new Set(latestIndexByTurn.values());
 	let breakdownIndex = null;
 	for (const index of retainedIndexes) {
-		if (asRecord$2(activities[index].payload)?.breakdown === void 0) continue;
+		if (asRecord$4(activities[index].payload)?.breakdown === void 0) continue;
 		if (breakdownIndex === null || index > breakdownIndex) breakdownIndex = index;
 	}
 	return activities.flatMap((activity, index) => {
@@ -35905,6 +36142,1283 @@ const normalizeDispatchCommand = (command) => Effect.gen(function* () {
 	};
 });
 //#endregion
+//#region src/mcp/McpToolClient.ts
+/**
+* Calling a tool on somebody else's MCP server.
+*
+* The rest of `apps/server/src/mcp` points the other way: it *exposes* p4code's
+* toolkit to an agent. This is the only place p4code is the client, and it
+* exists because one feature - recognizing a pasted ticket - needs an answer
+* before any agent turn runs, from a server the user has already registered.
+*
+* Deliberately not a general MCP client. There is no session reuse, no tool
+* listing, no notifications, no SSE stream held open: one request/response pair
+* per call, which is all streamable HTTP requires for a plain `tools/call`. A
+* real client belongs here only once something needs one.
+*
+* @module mcp/McpToolClient
+*/
+/**
+* The version p4code speaks. Sent on `initialize` and echoed back as a header
+* on the follow-up calls, which is what the spec asks of a client that has
+* already negotiated.
+*/
+const MCP_PROTOCOL_VERSION = "2025-06-18";
+const REQUEST_TIMEOUT_MS$1 = 15e3;
+var McpToolCallError = class extends Schema$1.TaggedErrorClass()("McpToolCallError", {
+	detail: Schema$1.String,
+	status: Schema$1.NullOr(Schema$1.Number)
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+const unauthorized$1 = (status) => status === 401 || status === 403;
+/**
+* Read a JSON-RPC envelope out of a response that may be either JSON or SSE.
+*
+* A streamable-http server picks the encoding, and both are legal answers to a
+* single call. The SSE branch keeps the last `data:` payload that parses: a
+* server is free to emit progress notifications ahead of the result, and the
+* result is what a caller of this asked for.
+*/
+const readEnvelope = (body) => {
+	const direct = parseJsonObject(body);
+	if (direct !== void 0) return direct;
+	let latest;
+	for (const line of body.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed.startsWith("data:")) continue;
+		const parsed = parseJsonObject(trimmed.slice(5).trim());
+		if (parsed !== void 0) latest = parsed;
+	}
+	return latest;
+};
+const parseJsonObject = (text) => {
+	if (text.length === 0) return void 0;
+	try {
+		const parsed = JSON.parse(text);
+		return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+	} catch {
+		return;
+	}
+};
+const textOf = (content) => {
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const block of content) {
+		if (typeof block !== "object" || block === null) continue;
+		const record = block;
+		if (record["type"] === "text" && typeof record["text"] === "string") parts.push(record["text"]);
+	}
+	return parts.join("\n");
+};
+/**
+* One `tools/call`, preceded by the `initialize` handshake the transport
+* requires.
+*
+* The handshake is not optional and not cacheable here: a server may hand out a
+* session id, and this holds no session state between calls. Two round trips
+* for one answer is the price of not keeping a connection open for a feature
+* that fires when somebody pastes something.
+*/
+const callMcpTool = Effect.fn("McpToolClient.callMcpTool")(function* (input) {
+	const http = yield* HttpClient$1.HttpClient;
+	const post = (body, extraHeaders) => http.execute(HttpClientRequest$1.bodyJsonUnsafe(HttpClientRequest$1.setHeaders(HttpClientRequest$1.post(input.url), {
+		...input.headers,
+		...extraHeaders,
+		accept: "application/json, text/event-stream"
+	}), body)).pipe(Effect.timeout(REQUEST_TIMEOUT_MS$1), Effect.catchCause((cause) => Effect.fail(new McpToolCallError({
+		detail: `Could not reach ${input.url}: ${String(cause)}`,
+		status: null
+	}))));
+	const initialize = yield* post({
+		jsonrpc: "2.0",
+		id: 1,
+		method: "initialize",
+		params: {
+			protocolVersion: MCP_PROTOCOL_VERSION,
+			capabilities: {},
+			clientInfo: {
+				name: "p4code",
+				version: "0.0.0"
+			}
+		}
+	}, {});
+	if (initialize.status >= 400) return yield* new McpToolCallError({
+		detail: unauthorized$1(initialize.status) ? "The server rejected p4code's credentials." : `The server answered ${initialize.status} to initialize.`,
+		status: initialize.status
+	});
+	const sessionId = initialize.headers["mcp-session-id"];
+	const sessionHeaders = {
+		"mcp-protocol-version": MCP_PROTOCOL_VERSION,
+		...sessionId === void 0 ? {} : { "mcp-session-id": sessionId }
+	};
+	yield* post({
+		jsonrpc: "2.0",
+		method: "notifications/initialized"
+	}, sessionHeaders).pipe(Effect.ignore);
+	const response = yield* post({
+		jsonrpc: "2.0",
+		id: 2,
+		method: "tools/call",
+		params: {
+			name: input.toolName,
+			arguments: input.arguments
+		}
+	}, sessionHeaders);
+	const body = yield* response.text.pipe(Effect.catchCause(() => Effect.succeed("")));
+	if (response.status >= 400) return yield* new McpToolCallError({
+		detail: unauthorized$1(response.status) ? "The server rejected p4code's credentials." : `The server answered ${response.status} to ${input.toolName}.`,
+		status: response.status
+	});
+	const envelope = readEnvelope(body);
+	if (envelope === void 0) return yield* new McpToolCallError({
+		detail: `The server's answer to ${input.toolName} was not JSON-RPC.`,
+		status: response.status
+	});
+	const error = envelope["error"];
+	if (typeof error === "object" && error !== null) {
+		const detail = error["message"];
+		return yield* new McpToolCallError({
+			detail: typeof detail === "string" ? detail : `${input.toolName} failed.`,
+			status: response.status
+		});
+	}
+	const result = envelope["result"];
+	if (typeof result !== "object" || result === null) return yield* new McpToolCallError({
+		detail: `${input.toolName} returned no result.`,
+		status: response.status
+	});
+	const resultRecord = result;
+	const text = textOf(resultRecord["content"]);
+	if (resultRecord["isError"] === true) return yield* new McpToolCallError({
+		detail: text.length > 0 ? text : `${input.toolName} reported an error.`,
+		status: response.status
+	});
+	return {
+		structuredContent: resultRecord["structuredContent"],
+		text
+	};
+});
+/** Why a Linear call could not be made, in terms a person can act on. */
+var LinearUnavailable = class extends Schema$1.TaggedErrorClass()("LinearUnavailable", {
+	reason: Schema$1.Literals([
+		"not_configured",
+		"not_authorized",
+		"failed"
+	]),
+	detail: Schema$1.String
+}) {
+	get message() {
+		return this.detail;
+	}
+};
+const asRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const asArray = (value) => Array.isArray(value) ? value : void 0;
+/**
+* Find the payload inside whatever the tool returned.
+*
+* MCP leaves a tool's result shape to the tool, so this accepts the three
+* arrangements seen in the wild - the structured payload itself, a text block
+* that happens to be JSON, or nothing usable - rather than assuming the one
+* Linear happens to send today. Same reasoning as `TicketResolver.readIssue`,
+* generalized because this one reads lists as well as single objects.
+*/
+const readPayload$1 = (result) => {
+	if (result.structuredContent !== void 0 && result.structuredContent !== null) return result.structuredContent;
+	try {
+		return JSON.parse(result.text);
+	} catch {
+		return;
+	}
+};
+/**
+* The rows out of a list result.
+*
+* A list tool may answer with a bare array or with the array under a key that
+* names the entity (`issues`, `teams`, `statuses`, `nodes`). Rather than
+* hard-coding each name, this takes the first array-valued property, which is
+* unambiguous in practice: these payloads carry one collection and some
+* pagination scalars beside it.
+*/
+const readRows = (payload) => {
+	const direct = asArray(payload);
+	if (direct !== void 0) return direct.map(asRecord$3).filter((row) => row !== void 0);
+	const record = asRecord$3(payload);
+	if (record === void 0) return [];
+	for (const value of Object.values(record)) {
+		const rows = asArray(value);
+		if (rows !== void 0) return rows.map(asRecord$3).filter((row) => row !== void 0);
+	}
+	return [];
+};
+/** The single object out of a result, unwrapping one level of nesting. */
+const readOne = (payload) => {
+	const record = asRecord$3(payload);
+	if (record === void 0) return;
+	if (record["id"] !== void 0 || record["identifier"] !== void 0) return record;
+	for (const value of Object.values(record)) {
+		const nested = asRecord$3(value);
+		if (nested?.["id"] !== void 0) return nested;
+	}
+};
+var LinearMcpClient = class extends Context.Service()("@p4code/cli/mcp/LinearMcpClient") {};
+const makeLinearMcpClient = Effect.gen(function* () {
+	const registry = yield* McpRegistry;
+	const oauth = yield* McpOAuth;
+	const http = yield* HttpClient$1.HttpClient;
+	/**
+	* The registration, already narrowed to one that can be reached over HTTP.
+	*
+	* A stdio Linear server is treated as absent rather than as an error: this
+	* client speaks streamable HTTP only, and a machine that registered Linear
+	* over stdio has no reachable Linear as far as the board is concerned.
+	*/
+	const findServer = registry.list.pipe(Effect.map((servers) => {
+		for (const candidate of servers) {
+			const registration = candidate.registration;
+			if (registration.name.toLowerCase() === "linear" && registration.enabled && registration.transport !== "stdio") return registration;
+		}
+	}), Effect.orElseSucceed(() => void 0));
+	const isConfigured = findServer.pipe(Effect.map((registration) => registration !== void 0));
+	const call = (toolName, args) => Effect.gen(function* () {
+		const registration = yield* findServer;
+		if (registration === void 0) return yield* new LinearUnavailable({
+			reason: "not_configured",
+			detail: "No Linear MCP server is registered on this machine. Add it in Settings to use the Linear board."
+		});
+		const token = yield* oauth.accessTokenFor(registration).pipe(Effect.orElseSucceed(() => Option.none()));
+		if (Option.isNone(token) && Object.keys(registration.headers ?? {}).length === 0) return yield* new LinearUnavailable({
+			reason: "not_authorized",
+			detail: "Linear is registered but not signed in on this machine. Sign in from Settings."
+		});
+		const headers = {
+			...registration.headers,
+			...Option.isSome(token) ? { authorization: `Bearer ${token.value}` } : {}
+		};
+		const result = yield* callMcpTool({
+			url: registration.url,
+			headers,
+			toolName,
+			arguments: args
+		}).pipe(Effect.provideService(HttpClient$1.HttpClient, http), Effect.mapError((error) => error.status === 401 || error.status === 403 ? new LinearUnavailable({
+			reason: "not_authorized",
+			detail: "Linear rejected p4code's sign-in. Sign in again from Settings."
+		}) : new LinearUnavailable({
+			reason: "failed",
+			detail: error.detail
+		})));
+		return readPayload$1(result);
+	});
+	return {
+		isConfigured,
+		call
+	};
+});
+const LinearMcpClientLive = Layer.effect(LinearMcpClient, makeLinearMcpClient);
+//#endregion
+//#region ../../packages/shared/src/ticketReference.ts
+/**
+* Recognizing a tracker reference in text somebody pasted.
+*
+* Shared because both ends need the same answer: the composer decides whether a
+* paste is worth a round trip, and the server decides what to ask the tracker.
+* Two copies of this rule would differ, and the difference would read as "it
+* works on my machine but the paste does nothing".
+*
+* @module ticketReference
+*/
+/**
+* A Linear issue URL, e.g.
+* `https://linear.app/omnicasa/issue/MOBILE-12262/haptic-feedback`.
+*
+* The workspace slug is what makes the URL unguessable from the identifier
+* alone, which is why a resolved ticket keeps the tracker's own URL rather than
+* rebuilding one.
+*/
+const LINEAR_ISSUE_URL_PATTERN = /https?:\/\/(?:www\.)?linear\.app\/[^/\s]+\/issue\/([A-Za-z][A-Za-z0-9]*-\d+)/;
+/**
+* A bare identifier, e.g. `MOBILE-12262`.
+*
+* Anchored: only a paste that is *nothing but* an identifier counts. Scanning
+* prose for this shape would claim things that are not tickets - a date range,
+* a version, a p4code readable id like `P4-40` - and each false positive costs
+* a request and, worse, a wrong link.
+*/
+const BARE_IDENTIFIER_PATTERN = /^([A-Za-z][A-Za-z0-9]*-\d+)$/;
+/**
+* The issue identifier a paste refers to, or `null` when it refers to none.
+*
+* Case is normalized up, the way every tracker prints it, so the same ticket
+* pasted two ways compares equal.
+*/
+function parseTicketReference(text) {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return null;
+	const url = LINEAR_ISSUE_URL_PATTERN.exec(trimmed);
+	if (url?.[1] !== void 0) return url[1].toUpperCase();
+	const bare = BARE_IDENTIFIER_PATTERN.exec(trimmed);
+	if (bare?.[1] !== void 0) return bare[1].toUpperCase();
+	return null;
+}
+//#endregion
+//#region src/persistence/Layers/linearTaskMapping.ts
+/**
+* Linear's issues and p4code's tasks, in both directions.
+*
+* Kept apart from the repository that calls it because this is the part with
+* the judgement calls in it - which Linear state a `todo` becomes, what an
+* issue with a state nobody anticipated reads as - and those are worth testing
+* without an MCP server in the room.
+*
+* The mapping is lossy in one direction and only one: p4code carries a thread,
+* a project and a repository key that Linear has nowhere to put, and those live
+* in the `linear_task_links` sidecar instead. Everything Linear carries has a
+* home here.
+*
+* @module persistence/Layers/linearTaskMapping
+*/
+/**
+* Linear's numeric priority, which is not p4code's ordering and not anyone's
+* intuition: 0 is none and 1 is the *most* urgent, so the scale runs backwards
+* from the number line.
+*/
+const PRIORITY_FROM_LINEAR = {
+	0: "none",
+	1: "urgent",
+	2: "high",
+	3: "medium",
+	4: "low"
+};
+const PRIORITY_TO_LINEAR = {
+	none: 0,
+	urgent: 1,
+	high: 2,
+	medium: 3,
+	low: 4
+};
+/**
+* The name p4code asks for when it wants a review column.
+*
+* Linear has no `in_review` state *type* - review states are ordinary
+* `started` states that a team happened to name - so this is the one status
+* that has to travel as a name and the one that can fail to apply. A team
+* without a state by this name gets Linear's own error, which says the state
+* was not found, rather than a silent landing in `in_progress`.
+*/
+const LINEAR_REVIEW_STATE_NAME = "In Review";
+/** How p4code names each Linear state type. */
+const STATUS_FROM_LINEAR_TYPE = {
+	triage: "backlog",
+	backlog: "backlog",
+	unstarted: "todo",
+	started: "in_progress",
+	completed: "done",
+	canceled: "cancelled"
+};
+const asRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+const text = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+/**
+* A person's name out of whatever Linear put in the field: an object when the
+* issue was read with expansions, a bare string when it was not.
+*/
+const personName = (value) => {
+	const direct = text(value);
+	if (direct !== void 0) return direct;
+	const record = asRecord$2(value);
+	if (record === void 0) return null;
+	return text(record["displayName"]) ?? text(record["name"]) ?? text(record["email"]) ?? null;
+};
+/** Label names, from either `["Bug"]` or `[{ name: "Bug" }]`. */
+const labelNames = (value) => {
+	if (!Array.isArray(value)) return [];
+	return value.map((entry) => text(entry) ?? text(asRecord$2(entry)?.["name"])).filter((name) => name !== void 0);
+};
+/**
+* The p4code status an issue is in.
+*
+* Read from the state *type* rather than its name, because a team can call its
+* started state anything at all and only the type is stable across workspaces.
+* The one exception is review, which has no type of its own and so is
+* recognized by name - a `started` state whose name mentions review is a review
+* state, and the alternative is a board where nothing ever reaches the review
+* column.
+*/
+const statusFromLinear = (statusType, statusName) => {
+	const type = text(statusType)?.toLowerCase();
+	const name = text(statusName);
+	if (type === "started" && name !== void 0 && /review/iu.test(name)) return "in_review";
+	if (type === void 0) return UNKNOWN_TASK_STATUS_FALLBACK;
+	return STATUS_FROM_LINEAR_TYPE[type] ?? "backlog";
+};
+/**
+* What to put in `save_issue`'s `state`, which accepts a type, a name or an id.
+*
+* Types are used wherever one exists, so the write lands in whatever the team
+* named its backlog rather than requiring p4code to know. Review is the
+* exception explained above.
+*/
+const statusToLinearState = (status) => {
+	switch (status) {
+		case "backlog": return "backlog";
+		case "todo": return "unstarted";
+		case "in_progress": return "started";
+		case "in_review": return LINEAR_REVIEW_STATE_NAME;
+		case "done": return "completed";
+		case "cancelled": return "canceled";
+	}
+};
+const priorityFromLinear = (value) => typeof value === "number" ? PRIORITY_FROM_LINEAR[value] ?? "none" : "none";
+const priorityToLinear = (priority) => PRIORITY_TO_LINEAR[priority];
+const EMPTY_LINEAR_TASK_LINK = {
+	threadId: null,
+	projectId: null,
+	repositoryKey: null
+};
+/**
+* One Linear issue as a board card.
+*
+* Returns `undefined` for an issue with no id or no title, which is not a
+* defensive flourish: `list_issues` takes a field selector, and a caller that
+* forgets to ask for `title` would otherwise fill the board with blank cards
+* rather than failing where the mistake is.
+*/
+const taskFromLinearIssue = (issue, link = EMPTY_LINEAR_TASK_LINK) => {
+	const id = text(issue["id"]);
+	const title = text(issue["title"]);
+	if (id === void 0 || title === void 0) return;
+	const url = text(issue["url"]);
+	const identifier = text(issue["identifier"]) ?? (url === void 0 ? void 0 : parseTicketReference(url) ?? void 0);
+	const createdAt = text(issue["createdAt"]);
+	const updatedAt = text(issue["updatedAt"]);
+	const parentId = text(issue["parentId"]);
+	return {
+		taskId: TaskId.make(id),
+		readableId: identifier ?? null,
+		orderKey: null,
+		projectId: link.projectId === null ? null : link.projectId,
+		repositoryKey: link.repositoryKey,
+		threadId: link.threadId === null ? null : link.threadId,
+		externalRef: identifier === void 0 || url === void 0 ? null : {
+			source: "linear",
+			identifier,
+			url
+		},
+		parentTaskId: parentId === void 0 ? null : TaskId.make(parentId),
+		title,
+		body: text(issue["description"]) ?? "",
+		status: statusFromLinear(issue["statusType"], issue["status"]),
+		priority: priorityFromLinear(issue["priority"]),
+		assignee: personName(issue["assignee"]),
+		labels: labelNames(issue["labels"]),
+		createdAt: createdAt ?? updatedAt ?? "1970-01-01T00:00:00.000Z",
+		updatedAt: updatedAt ?? createdAt ?? "1970-01-01T00:00:00.000Z"
+	};
+};
+/**
+* The fields `list_issues` has to return for a card to be complete.
+*
+* Named here rather than at the call site because `taskFromLinearIssue` reads
+* exactly these, and the two drifting apart is how a board quietly loses its
+* assignees.
+*/
+const LINEAR_ISSUE_FIELDS = [
+	"id",
+	"title",
+	"description",
+	"priority",
+	"url",
+	"createdAt",
+	"updatedAt",
+	"status",
+	"statusType",
+	"labels",
+	"assignee",
+	"parentId"
+];
+//#endregion
+//#region src/persistence/Layers/LinearTasks.ts
+/**
+* How often an open board asks Linear what changed.
+*
+* Slower than the hub's poll, because this is somebody else's rate limit and
+* a Linear workspace is edited by people at human speed rather than by agents
+* at machine speed.
+*/
+const POLL_INTERVAL$1 = Duration.seconds(30);
+/** Linear's cap on one page. Asking for more is an error, not a bigger page. */
+const LINEAR_PAGE_LIMIT = 250;
+const LINEAR_LIST_TOOL = "list_issues";
+const LINEAR_GET_TOOL = "get_issue";
+const LINEAR_SAVE_TOOL = "save_issue";
+const linearFailed = (operation, cause) => new PersistenceSqlError({
+	operation: `LinearTaskRepository.${operation}`,
+	detail: cause.detail,
+	cause: null
+});
+const makeLinearTaskRepository = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const linear = yield* LinearMcpClient;
+	const settings = yield* ServerSettingsService;
+	const changes = yield* PubSub.unbounded();
+	const publish = (event) => PubSub.publish(changes, event).pipe(Effect.asVoid);
+	const watchers = yield* Ref.make(0);
+	const lastSeen = yield* Ref.make(null);
+	const LinkRow = Schema$1.Struct({
+		issueId: Schema$1.String,
+		threadId: Schema$1.NullOr(Schema$1.String),
+		projectId: Schema$1.NullOr(Schema$1.String),
+		repositoryKey: Schema$1.NullOr(Schema$1.String)
+	});
+	const selectLinks = SqlSchema.findAll({
+		Request: Schema$1.Struct({}),
+		Result: LinkRow,
+		execute: () => sql`
+        SELECT issue_id AS "issueId",
+               thread_id AS "threadId",
+               project_id AS "projectId",
+               repository_key AS "repositoryKey"
+        FROM linear_task_links
+      `
+	});
+	const upsertLink = SqlSchema.void({
+		Request: LinkRow,
+		execute: (row) => sql`
+        INSERT INTO linear_task_links (issue_id, thread_id, project_id, repository_key)
+        VALUES (${row.issueId}, ${row.threadId}, ${row.projectId}, ${row.repositoryKey})
+        ON CONFLICT (issue_id) DO UPDATE SET
+          thread_id = excluded.thread_id,
+          project_id = excluded.project_id,
+          repository_key = excluded.repository_key
+      `
+	});
+	const readLinks = selectLinks({}).pipe(Effect.map((rows) => new Map(rows.map((row) => [row.issueId, {
+		threadId: row.threadId,
+		projectId: row.projectId,
+		repositoryKey: row.repositoryKey
+	}]))), Effect.mapError(toPersistenceSqlError("LinearTaskRepository.readLinks")));
+	/**
+	* Merge the p4code-only fields of a write into the sidecar.
+	*
+	* Absent means unchanged, matching every other patch in the codebase, which
+	* is why this reads the existing row instead of writing three nulls over it.
+	*/
+	const saveLink = (issueId, patch) => Effect.gen(function* () {
+		const current = (yield* readLinks).get(issueId) ?? EMPTY_LINEAR_TASK_LINK;
+		yield* upsertLink({
+			issueId,
+			threadId: patch.threadId === void 0 ? current.threadId : patch.threadId,
+			projectId: patch.projectId === void 0 ? current.projectId : patch.projectId,
+			repositoryKey: patch.repositoryKey === void 0 ? current.repositoryKey : patch.repositoryKey
+		}).pipe(Effect.mapError(toPersistenceSqlError("LinearTaskRepository.saveLink")));
+	});
+	const call = (operation, tool, args) => linear.call(tool, args).pipe(Effect.mapError((cause) => linearFailed(operation, cause)));
+	const configuredTeam = settings.getSettings.pipe(Effect.map((current) => current.linearTeam.trim()), Effect.orElseSucceed(() => ""));
+	const list = (filter) => Effect.gen(function* () {
+		const team = yield* configuredTeam;
+		const payload = yield* call("list", LINEAR_LIST_TOOL, {
+			includeArchived: false,
+			limit: LINEAR_PAGE_LIMIT,
+			fields: [...LINEAR_ISSUE_FIELDS],
+			...team === "" ? {} : { team },
+			...filter.status === void 0 ? {} : { state: statusToLinearState(filter.status) },
+			...filter.assignee === void 0 ? {} : { assignee: filter.assignee }
+		});
+		const links = yield* readLinks;
+		return readRows(payload).map((issue) => taskFromLinearIssue(issue, links.get(String(issue["id"])) ?? void 0)).filter((task) => task !== void 0).filter((task) => (filter.projectId === void 0 || task.projectId === filter.projectId) && (filter.repositoryKey === void 0 || task.repositoryKey === filter.repositoryKey) && (filter.threadId === void 0 || task.threadId === filter.threadId));
+	});
+	const readIssue = (operation, reference) => Effect.gen(function* () {
+		const issue = readOne(yield* call(operation, LINEAR_GET_TOOL, { id: reference }));
+		if (issue === void 0) return Option.none();
+		const task = taskFromLinearIssue(issue, (yield* readLinks).get(String(issue["id"])) ?? void 0);
+		return task === void 0 ? Option.none() : Option.some(task);
+	});
+	const getById = ({ taskId }) => readIssue("getById", taskId);
+	const getByReadableId = (readableId) => readIssue("getByReadableId", readableId);
+	/**
+	* The issue fields of a write, as `save_issue` wants them.
+	*
+	* Undefined entries are dropped rather than sent, because this tool treats
+	* an absent key as "leave alone" and an explicit null as "clear" - and the
+	* two are different answers for `assignee` and `parentId`.
+	*/
+	const issueFields = (input) => ({
+		...input.title === void 0 ? {} : { title: input.title },
+		...input.body === void 0 ? {} : { description: input.body },
+		...input.status === void 0 ? {} : { state: statusToLinearState(input.status) },
+		...input.priority === void 0 ? {} : { priority: priorityToLinear(input.priority) },
+		...input.assignee === void 0 ? {} : { assignee: input.assignee },
+		...input.labels === void 0 ? {} : { labels: [...input.labels] },
+		...input.parentTaskId === void 0 ? {} : { parentId: input.parentTaskId }
+	});
+	const saveIssue = (operation, args) => Effect.gen(function* () {
+		const issue = readOne(yield* call(operation, LINEAR_SAVE_TOOL, args));
+		if (issue === void 0) return yield* new PersistenceSqlError({
+			operation: `LinearTaskRepository.${operation}`,
+			detail: "Linear accepted the write but returned no issue.",
+			cause: null
+		});
+		const task = taskFromLinearIssue(issue, (yield* readLinks).get(String(issue["id"])) ?? void 0);
+		if (task === void 0) return yield* new PersistenceSqlError({
+			operation: `LinearTaskRepository.${operation}`,
+			detail: "Linear returned an issue with no id or title.",
+			cause: null
+		});
+		return task;
+	});
+	const create = (row) => Effect.gen(function* () {
+		const team = yield* configuredTeam;
+		if (team === "") return yield* new PersistenceSqlError({
+			operation: "LinearTaskRepository.create",
+			detail: "No Linear team is chosen, and Linear needs one to file an issue. Pick a team on the board.",
+			cause: null
+		});
+		const created = yield* saveIssue("create", {
+			team,
+			...issueFields({
+				title: row.title,
+				body: row.body,
+				status: row.status,
+				priority: row.priority,
+				assignee: row.assignee,
+				labels: row.labels,
+				parentTaskId: row.parentTaskId
+			})
+		});
+		yield* saveLink(created.taskId, {
+			threadId: row.threadId,
+			projectId: row.projectId,
+			repositoryKey: row.repositoryKey
+		});
+		const task = {
+			...created,
+			threadId: row.threadId,
+			projectId: row.projectId,
+			repositoryKey: row.repositoryKey
+		};
+		yield* publish({
+			type: "upserted",
+			task
+		});
+		return task;
+	});
+	const upsert = (row) => saveIssue("upsert", {
+		id: row.taskId,
+		...issueFields(row)
+	}).pipe(Effect.tap(() => saveLink(row.taskId, {
+		threadId: row.threadId,
+		projectId: row.projectId,
+		repositoryKey: row.repositoryKey
+	})), Effect.tap((task) => publish({
+		type: "upserted",
+		task: {
+			...task,
+			threadId: row.threadId
+		}
+	})), Effect.asVoid);
+	const patch = (input) => Effect.gen(function* () {
+		if (!(input.title !== void 0 || input.body !== void 0 || input.status !== void 0 || input.priority !== void 0 || input.assignee !== void 0 || input.labels !== void 0 || input.parentTaskId !== void 0)) {
+			yield* saveLink(input.taskId, {
+				...input.threadId === void 0 ? {} : { threadId: input.threadId },
+				...input.projectId === void 0 ? {} : { projectId: input.projectId },
+				...input.repositoryKey === void 0 ? {} : { repositoryKey: input.repositoryKey }
+			});
+			const reread = yield* getById({ taskId: input.taskId });
+			yield* Option.match(reread, {
+				onNone: () => Effect.void,
+				onSome: (task) => publish({
+					type: "upserted",
+					task
+				})
+			});
+			return reread;
+		}
+		const saved = yield* saveIssue("patch", {
+			id: input.taskId,
+			...issueFields(input)
+		});
+		yield* saveLink(input.taskId, {
+			...input.threadId === void 0 ? {} : { threadId: input.threadId },
+			...input.projectId === void 0 ? {} : { projectId: input.projectId },
+			...input.repositoryKey === void 0 ? {} : { repositoryKey: input.repositoryKey }
+		});
+		const links = yield* readLinks;
+		const task = {
+			...saved,
+			...links.get(input.taskId) ?? EMPTY_LINEAR_TASK_LINK
+		};
+		yield* publish({
+			type: "upserted",
+			task
+		});
+		return Option.some(task);
+	});
+	const patchIfStatus = (input, updatedAt) => Effect.gen(function* () {
+		const current = yield* getById({ taskId: input.patch.taskId });
+		if (Option.isNone(current)) return { outcome: "missing" };
+		if (current.value.status !== input.expectedStatus) return {
+			outcome: "conflict",
+			current: current.value
+		};
+		const updated = yield* patch(input.patch, updatedAt);
+		return Option.isNone(updated) ? { outcome: "missing" } : {
+			outcome: "updated",
+			task: updated.value
+		};
+	});
+	const deleteById = () => new PersistenceSqlError({
+		operation: "LinearTaskRepository.deleteById",
+		detail: "Linear issues cannot be deleted from p4code. Cancel the issue instead, or delete it in Linear.",
+		cause: null
+	});
+	/**
+	* One pass: read the board, publish what differs from last time.
+	*
+	* Compared on `updatedAt` for the same reason the hub's poll is - it is the
+	* field every write moves. A failed pass publishes nothing and keeps the old
+	* snapshot, so a Linear blip does not empty an open board.
+	*/
+	const pollOnce = Effect.gen(function* () {
+		if ((yield* Ref.get(watchers)) === 0) return;
+		const current = yield* list({});
+		const previous = yield* Ref.getAndSet(lastSeen, current);
+		if (previous === null) return;
+		const previousById = new Map(previous.map((task) => [task.taskId, task]));
+		for (const task of current) {
+			const before = previousById.get(task.taskId);
+			if (before === void 0 || before.updatedAt !== task.updatedAt) yield* publish({
+				type: "upserted",
+				task
+			});
+			previousById.delete(task.taskId);
+		}
+		for (const taskId of previousById.keys()) yield* publish({
+			type: "deleted",
+			taskId
+		});
+	}).pipe(Effect.ignoreCause({ log: true }));
+	yield* Effect.forever(pollOnce.pipe(Effect.andThen(Effect.sleep(POLL_INTERVAL$1)))).pipe(Effect.forkScoped);
+	return {
+		create,
+		upsert,
+		patch,
+		patchIfStatus,
+		getById,
+		getByReadableId,
+		list,
+		deleteById,
+		streamChanges: Stream.fromPubSub(changes),
+		streamWithSnapshot: Stream.unwrap(Effect.gen(function* () {
+			yield* Effect.acquireRelease(Ref.update(watchers, (count) => count + 1), () => Ref.update(watchers, (count) => Math.max(0, count - 1)));
+			const subscription = yield* PubSub.subscribe(changes);
+			const snapshot = yield* list({});
+			yield* Ref.set(lastSeen, snapshot);
+			return Stream.concat(Stream.succeed({
+				type: "snapshot",
+				tasks: snapshot
+			}), Stream.fromSubscription(subscription));
+		}))
+	};
+});
+//#endregion
+//#region src/persistence/Layers/RemoteTasks.ts
+/**
+* The hub's task API, as a client.
+*
+* This used to be a `TaskRepository` in its own right, and the board was
+* either this or the local database. It is now the transport underneath
+* `SyncedTaskRepository`: local SQLite is a replica of the hub, so nothing
+* reads from here directly and the board no longer goes dark when the hub is
+* unreachable. What changed with it is the failure story — an unreachable hub
+* used to mean no board, and now means a board that is behind.
+*
+* The four calls here are what a mirror needs and no more: read the hub's
+* rows, push a whole row, arbitrate a claim, and delete. There is no partial
+* patch, because a mirror always holds the full row it wants the hub to have
+* and sending a diff of it would only add a way for the two to disagree.
+*
+* @module persistence/Layers/RemoteTasks
+*/
+const HUB_REQUEST_TIMEOUT_MS = 15e3;
+const TaskListPage = Schema$1.Struct({ tasks: Schema$1.Array(Task) });
+const ConflictBody = Schema$1.Struct({ current: Task });
+const decodeTaskListPage = Schema$1.decodeUnknownEffect(TaskListPage);
+const decodeTask = Schema$1.decodeUnknownEffect(Task);
+const decodeConflictBody = Schema$1.decodeUnknownEffect(ConflictBody);
+/**
+* Every failure here is reported as the persistence error type.
+*
+* The mirror catches these and carries on — a failed push leaves the row
+* `pending` and the next pass retries it — so what matters is that the detail
+* says the hub was the store that would not answer, which is what shows up in
+* the log when someone asks why their two machines disagree.
+*/
+const hubUnavailable = (operation, detail) => new PersistenceSqlError({
+	operation: `HubTaskClient.${operation}`,
+	detail: `The hub board is unavailable: ${detail}`,
+	cause: null
+});
+var HubTaskClient = class extends Context.Service()("@p4code/cli/persistence/Layers/RemoteTasks/HubTaskClient") {};
+const makeHubTaskClient = Effect.gen(function* () {
+	const http = yield* HttpClient.HttpClient;
+	const link = yield* HubLink;
+	const isLinked = link.current.pipe(Effect.map((state) => Option.isSome(state.settings)));
+	const requireSettings = (operation) => Effect.gen(function* () {
+		const state = yield* link.current;
+		if (Option.isNone(state.settings)) return yield* hubUnavailable(operation, "no hub is configured on this server");
+		return state.settings.value;
+	});
+	const send = (operation, settings, request) => http.execute(request.pipe(HttpClientRequest.setHeader("authorization", `Bearer ${settings.token}`), HttpClientRequest.setHeader("accept", "application/json"))).pipe(Effect.timeout(HUB_REQUEST_TIMEOUT_MS), Effect.mapError((cause) => hubUnavailable(operation, `${cause._tag ?? "request failed"}`)));
+	const list = (filter) => Effect.gen(function* () {
+		const settings = yield* requireSettings("list");
+		const query = new URLSearchParams();
+		for (const key of [
+			"projectId",
+			"repositoryKey",
+			"threadId",
+			"status",
+			"assignee"
+		]) {
+			const value = filter[key];
+			if (value !== void 0) query.set(key, value);
+		}
+		const suffix = query.size === 0 ? "" : `?${query.toString()}`;
+		const response = yield* send("list", settings, HttpClientRequest.get(`${settings.baseUrl}/tasks${suffix}`));
+		if (response.status !== 200) return yield* hubUnavailable("list", `status ${response.status}`);
+		return (yield* response.json.pipe(Effect.flatMap(decodeTaskListPage), Effect.mapError(() => hubUnavailable("list", "the response did not match the contract")))).tasks;
+	});
+	const put = (row, readableIdPrefix) => Effect.gen(function* () {
+		const settings = yield* requireSettings("put");
+		const response = yield* send("put", settings, HttpClientRequest.bodyJsonUnsafe(HttpClientRequest.put(`${settings.baseUrl}/tasks/${encodeURIComponent(row.taskId)}`), {
+			projectId: row.projectId,
+			repositoryKey: row.repositoryKey,
+			threadId: row.threadId,
+			externalRef: row.externalRef,
+			parentTaskId: row.parentTaskId,
+			title: row.title,
+			body: row.body,
+			status: row.status,
+			priority: row.priority,
+			assignee: row.assignee,
+			labels: row.labels,
+			orderKey: row.orderKey,
+			createdAt: row.createdAt,
+			readableIdPrefix
+		}));
+		if (response.status !== 200 && response.status !== 201) return yield* hubUnavailable("put", `status ${response.status}`);
+		return yield* response.json.pipe(Effect.flatMap(decodeTask), Effect.mapError(() => hubUnavailable("put", "the response did not match the contract")));
+	});
+	const patchIfStatus = (input) => Effect.gen(function* () {
+		const settings = yield* requireSettings("patchIfStatus");
+		const { taskId, ...fields } = input.patch;
+		const response = yield* send("patchIfStatus", settings, HttpClientRequest.bodyJsonUnsafe(HttpClientRequest.patch(`${settings.baseUrl}/tasks/${encodeURIComponent(taskId)}`), {
+			...fields,
+			expectedStatus: input.expectedStatus
+		}));
+		if (response.status === 404) return { outcome: "missing" };
+		if (response.status === 409) return {
+			outcome: "conflict",
+			current: (yield* response.json.pipe(Effect.flatMap(decodeConflictBody), Effect.mapError(() => hubUnavailable("patchIfStatus", "the conflict response did not match the contract")))).current
+		};
+		if (response.status !== 200) return yield* hubUnavailable("patchIfStatus", `status ${response.status}`);
+		return {
+			outcome: "updated",
+			task: yield* response.json.pipe(Effect.flatMap(decodeTask), Effect.mapError(() => hubUnavailable("patchIfStatus", "the response did not match the contract")))
+		};
+	});
+	const remove = (taskId) => Effect.gen(function* () {
+		const settings = yield* requireSettings("remove");
+		const response = yield* send("remove", settings, HttpClientRequest.delete(`${settings.baseUrl}/tasks/${encodeURIComponent(taskId)}`));
+		if (response.status !== 200 && response.status !== 204 && response.status !== 404) return yield* hubUnavailable("remove", `status ${response.status}`);
+	});
+	return {
+		isLinked,
+		list,
+		put,
+		patchIfStatus,
+		remove
+	};
+});
+Layer.effect(HubTaskClient, makeHubTaskClient);
+//#endregion
+//#region src/persistence/Layers/TaskSyncStore.ts
+/**
+* The bookkeeping a mirror needs and a board does not.
+*
+* `TaskRepository` deliberately knows nothing about the hub: the same
+* interface backs the hub's own store, where "does the hub have this yet" is
+* not a question that can be asked. So the two extra facts the mirror needs —
+* which rows the hub has not acknowledged, and which absences are deletions
+* rather than gaps — live here, in their own small store over the same
+* database.
+*
+* Rows are pushed whole rather than as a queue of patches. Two edits to one
+* task while the hub was unreachable do not need to arrive as two writes; the
+* hub only ever needed the last one, and an ordered queue would buy replay
+* fidelity nobody reads at the cost of a table that can be half-drained.
+*
+* @module persistence/Layers/TaskSyncStore
+*/
+const TaskDbRow = Task.mapFields(Struct.assign({
+	labels: Schema$1.fromJsonString(Schema$1.Array(TaskLabel)),
+	externalRef: Schema$1.NullOr(Schema$1.fromJsonString(TaskExternalRef))
+}));
+const TASK_COLUMNS = `
+  task_id AS "taskId",
+  readable_id AS "readableId",
+  project_id AS "projectId",
+  repository_key AS "repositoryKey",
+  thread_id AS "threadId",
+  external_ref_json AS "externalRef",
+  parent_task_id AS "parentTaskId",
+  title,
+  body,
+  status,
+  priority,
+  assignee,
+  labels_json AS "labels",
+  order_key AS "orderKey",
+  created_at AS "createdAt",
+  updated_at AS "updatedAt"
+`;
+const makeTaskSyncStore = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const setState = SqlSchema.void({
+		Request: Schema$1.Struct({
+			taskId: TaskId,
+			state: Schema$1.String
+		}),
+		execute: ({ taskId, state }) => sql`UPDATE tasks SET sync_state = ${state} WHERE task_id = ${taskId}`
+	});
+	const PendingRow = Schema$1.Struct({
+		...TaskDbRow.fields,
+		readableIdPrefix: Schema$1.NullOr(Schema$1.String)
+	});
+	const selectPending = SqlSchema.findAll({
+		Request: Schema$1.Struct({}),
+		Result: PendingRow,
+		execute: () => sql`
+        SELECT ${sql.literal(TASK_COLUMNS)}, readable_id_prefix AS "readableIdPrefix"
+        FROM tasks WHERE sync_state = 'pending'
+      `
+	});
+	const advanceSequence = SqlSchema.void({
+		Request: Schema$1.Struct({
+			prefix: Schema$1.String,
+			seq: Schema$1.Int
+		}),
+		execute: ({ prefix, seq }) => sql`
+        INSERT INTO task_sequences (prefix, last_seq)
+        VALUES (${prefix}, ${seq})
+        ON CONFLICT (prefix) DO UPDATE SET last_seq = MAX(last_seq, excluded.last_seq)
+      `
+	});
+	const selectPrefix = SqlSchema.findAll({
+		Request: Schema$1.Struct({ taskId: TaskId }),
+		Result: Schema$1.Struct({ readableIdPrefix: Schema$1.NullOr(Schema$1.String) }),
+		execute: ({ taskId }) => sql`SELECT readable_id_prefix AS "readableIdPrefix" FROM tasks WHERE task_id = ${taskId}`
+	});
+	const setPrefix = SqlSchema.void({
+		Request: Schema$1.Struct({
+			taskId: TaskId,
+			prefix: Schema$1.String
+		}),
+		execute: ({ taskId, prefix }) => sql`UPDATE tasks SET readable_id_prefix = ${prefix} WHERE task_id = ${taskId}`
+	});
+	const selectSyncedIds = SqlSchema.findAll({
+		Request: Schema$1.Struct({}),
+		Result: Schema$1.Struct({ taskId: TaskId }),
+		execute: () => sql`SELECT task_id AS "taskId" FROM tasks WHERE sync_state = 'synced'`
+	});
+	const insertTombstone = SqlSchema.void({
+		Request: Schema$1.Struct({
+			taskId: TaskId,
+			deletedAt: Schema$1.String
+		}),
+		execute: ({ taskId, deletedAt }) => sql`
+        INSERT INTO task_tombstones (task_id, deleted_at)
+        VALUES (${taskId}, ${deletedAt})
+        ON CONFLICT (task_id) DO UPDATE SET deleted_at = excluded.deleted_at
+      `
+	});
+	const removeTombstone = SqlSchema.void({
+		Request: Schema$1.Struct({ taskId: TaskId }),
+		execute: ({ taskId }) => sql`DELETE FROM task_tombstones WHERE task_id = ${taskId}`
+	});
+	const selectTombstones = SqlSchema.findAll({
+		Request: Schema$1.Struct({}),
+		Result: Schema$1.Struct({ taskId: TaskId }),
+		execute: () => sql`SELECT task_id AS "taskId" FROM task_tombstones`
+	});
+	return {
+		/** Flag a row as owing the hub a push. Every local write calls this. */
+		markPending: (taskId) => setState({
+			taskId,
+			state: "pending"
+		}).pipe(Effect.mapError(toPersistenceSqlError("TaskSyncStore.markPending"))),
+		/** Record that the hub returned this exact row. */
+		markSynced: (taskId) => setState({
+			taskId,
+			state: "synced"
+		}).pipe(Effect.mapError(toPersistenceSqlError("TaskSyncStore.markSynced"))),
+		/**
+		* Remember which prefix this task should be numbered under, for a push
+		* that happens long after the create that knew it.
+		*/
+		rememberPrefix: (taskId, prefix) => setPrefix({
+			taskId,
+			prefix
+		}).pipe(Effect.mapError(toPersistenceSqlError("TaskSyncStore.rememberPrefix"))),
+		/**
+		* Move this machine's own sequence past a number the hub handed out.
+		*
+		* Without this the two counters drift apart in the one direction that
+		* hurts: the local sequence is only bumped by local creates, so a machine
+		* that has mirrored `P4-1` through `P4-40` from the hub still thinks its
+		* next number is 1 - and the moment the hub link goes away and it mints
+		* locally, the insert collides with a row it is already holding.
+		*
+		* Takes the maximum rather than assigning, so an out-of-order pull cannot
+		* wind the counter backwards.
+		*/
+		adoptSequence: (readableId) => {
+			if (readableId === null) return Effect.void;
+			const separator = readableId.lastIndexOf("-");
+			if (separator <= 0) return Effect.void;
+			const prefix = readableId.slice(0, separator).toUpperCase();
+			const seq = Number.parseInt(readableId.slice(separator + 1), 10);
+			if (!Number.isSafeInteger(seq) || seq <= 0) return Effect.void;
+			return advanceSequence({
+				prefix,
+				seq
+			}).pipe(Effect.mapError(toPersistenceSqlError("TaskSyncStore.adoptSequence")));
+		},
+		/** The remembered prefix, or `null` for a row that predates the column. */
+		readPrefix: (taskId) => selectPrefix({ taskId }).pipe(Effect.map((rows) => rows[0]?.readableIdPrefix ?? null), Effect.mapError(toPersistenceSqlError("TaskSyncStore.readPrefix"))),
+		/** Whole rows, because a push sends the row and not a diff of it. */
+		listPending: selectPending({}).pipe(Effect.mapError(toPersistenceSqlError("TaskSyncStore.listPending"))),
+		/**
+		* Ids the hub has confirmed. The pull compares against this rather than
+		* against every local row: a row the hub has never seen is missing from
+		* the hub's list for the obvious reason, and deleting it as "gone
+		* elsewhere" would throw away a task filed while offline.
+		*/
+		listSyncedIds: selectSyncedIds({}).pipe(Effect.map((rows) => rows.map((row) => row.taskId)), Effect.mapError(toPersistenceSqlError("TaskSyncStore.listSyncedIds"))),
+		recordTombstone: (taskId, deletedAt) => insertTombstone({
+			taskId,
+			deletedAt
+		}).pipe(Effect.mapError(toPersistenceSqlError("TaskSyncStore.recordTombstone"))),
+		clearTombstone: (taskId) => removeTombstone({ taskId }).pipe(Effect.mapError(toPersistenceSqlError("TaskSyncStore.clearTombstone"))),
+		listTombstones: selectTombstones({}).pipe(Effect.map((rows) => rows.map((row) => row.taskId)), Effect.mapError(toPersistenceSqlError("TaskSyncStore.listTombstones")))
+	};
+});
+//#endregion
+//#region src/persistence/Layers/SyncedTasks.ts
+/**
+* One board, replicated: local SQLite is the copy, the hub is the original.
+*
+* Every read is answered from this machine's database, so the board is instant
+* and keeps working with the hub unreachable. Every write lands locally first
+* and is then pushed; a push that fails leaves the row `pending` and the next
+* pass retries it. What a person sees is a board that never goes blank and
+* that agrees with the other machine within a poll interval.
+*
+* **This reverses the earlier decision, deliberately.** The hub board used to
+* fail loudly rather than answer from a local copy, on the grounds that a
+* stale answer recreates the per-machine divergence the hub exists to remove.
+* That argument was right about the risk and wrong about the cost: it traded a
+* working board for a guarantee that only holds while the network does. The
+* replacement keeps the guarantee where it actually matters — `patchIfStatus`,
+* the claim, still goes to the hub and still fails when the hub is unreachable,
+* because two machines each arbitrating against their own replica would both
+* win. Everything else is last-writer-wins, and a person retitling a task on
+* a plane is not a correctness problem.
+*
+* **With no hub linked this is just the local store**, plus rows marked as
+* owing a push that never comes. Linking a hub later uploads them.
+*
+* @module persistence/Layers/SyncedTasks
+*/
+/**
+* How stale another machine's write may look here.
+*
+* Short enough that a board left open follows along, long enough that two
+* servers idling all day are not a steady stream of requests at a hosted
+* service. Only changes made elsewhere wait for it; a write made here is
+* already on screen.
+*/
+const SYNC_INTERVAL = Duration.seconds(10);
+const makeSyncedTaskRepository = Effect.gen(function* () {
+	const local = yield* makeTaskRepository;
+	const sync = yield* makeTaskSyncStore;
+	const hub = yield* makeHubTaskClient;
+	const now = DateTime.now.pipe(Effect.map(DateTime.formatIso));
+	const prefixFor = (taskId) => sync.readPrefix(taskId).pipe(Effect.map((prefix) => prefix ?? "T"));
+	/**
+	* Send one row and adopt what came back.
+	*
+	* Adopting matters more than sending: the hub's answer carries the readable
+	* id it allocated and the timestamp it stamped, and a mirror that kept its
+	* own versions of those would disagree with the other machine about what the
+	* task is called.
+	*/
+	/**
+	* Take a row the hub confirmed: store it, mark it settled, and move this
+	* machine's own readable-id sequence past the number the hub used.
+	*
+	* The sequence step is not optional bookkeeping. Local minting only ever
+	* bumps the local counter, so a machine holding forty mirrored rows still
+	* believes its next number is 1 - and the first task it files with the hub
+	* gone would collide with a row it is already holding.
+	*/
+	const adopt = (stored) => local.upsert(stored).pipe(Effect.andThen(sync.markSynced(stored.taskId)), Effect.andThen(sync.adoptSequence(stored.readableId)));
+	const pushRow = (task, readableIdPrefix) => hub.put(task, readableIdPrefix).pipe(Effect.tap(adopt));
+	/** A push whose failure is not the caller's problem: the retry loop owns it. */
+	const pushInBackground = (task, readableIdPrefix) => pushRow(task, readableIdPrefix).pipe(Effect.ignoreCause({ log: true }), Effect.asVoid);
+	const create = (row, readableIdPrefix) => Effect.gen(function* () {
+		if (!(yield* hub.isLinked)) {
+			const task = yield* local.create(row, readableIdPrefix);
+			yield* sync.rememberPrefix(task.taskId, readableIdPrefix);
+			return task;
+		}
+		const draft = {
+			...row,
+			readableId: null
+		};
+		yield* local.upsert(draft);
+		yield* sync.rememberPrefix(draft.taskId, readableIdPrefix);
+		return yield* pushRow(draft, readableIdPrefix).pipe(Effect.catchCause((cause) => Effect.logDebug("task create could not reach the hub; queued", { cause }).pipe(Effect.as(draft))));
+	});
+	const upsert = (row) => Effect.gen(function* () {
+		yield* local.upsert(row);
+		yield* sync.markPending(row.taskId);
+		if (yield* hub.isLinked) yield* pushInBackground(row, yield* prefixFor(row.taskId));
+	});
+	const patch = (input, updatedAt) => Effect.gen(function* () {
+		const patched = yield* local.patch(input, updatedAt);
+		if (Option.isNone(patched)) return patched;
+		const task = patched.value;
+		yield* sync.markPending(task.taskId);
+		if (!(yield* hub.isLinked)) return patched;
+		const prefix = yield* prefixFor(task.taskId);
+		return yield* pushRow(task, prefix).pipe(Effect.map(Option.some), Effect.catchCause(() => Effect.succeed(patched)));
+	});
+	/**
+	* The one call that does not go local-first.
+	*
+	* A claim is a question about who gets the task, and a replica cannot answer
+	* it — both machines would compare against their own copy, both would see
+	* `todo`, and both would start. So this goes to the hub and only writes what
+	* the hub decided. With the hub unreachable it fails, which is the whole
+	* point: an agent that cannot establish it won the task must not run it.
+	*/
+	const patchIfStatus = (input, updatedAt) => Effect.gen(function* () {
+		if (!(yield* hub.isLinked)) return yield* local.patchIfStatus(input, updatedAt);
+		const outcome = yield* hub.patchIfStatus(input);
+		if (outcome.outcome === "updated") yield* adopt(outcome.task);
+		if (outcome.outcome === "conflict") yield* adopt(outcome.current);
+		return outcome;
+	});
+	const deleteById = ({ taskId }) => Effect.gen(function* () {
+		const linked = yield* hub.isLinked;
+		yield* local.deleteById({ taskId });
+		if (!linked) return;
+		yield* sync.recordTombstone(taskId, yield* now);
+		yield* hub.remove(taskId).pipe(Effect.andThen(sync.clearTombstone(taskId)), Effect.ignoreCause({ log: true }));
+	});
+	/**
+	* One pass: drain what is owed, then take what is new.
+	*
+	* Deletes go first, pushes second, the pull last, and the order is the whole
+	* correctness argument. A delete replayed after a push would re-upload a row
+	* that was just removed; a pull run before either would see this machine's
+	* own stale absence as the hub's opinion and undo local work.
+	*/
+	const syncOnce = Effect.gen(function* () {
+		if (!(yield* hub.isLinked)) return;
+		for (const taskId of yield* sync.listTombstones) yield* hub.remove(taskId).pipe(Effect.andThen(sync.clearTombstone(taskId)), Effect.ignoreCause({ log: true }));
+		for (const row of yield* sync.listPending) {
+			const { readableIdPrefix, ...task } = row;
+			yield* pushInBackground(task, readableIdPrefix ?? "T");
+		}
+		const remote = yield* hub.list({});
+		const stillPending = new Set((yield* sync.listPending).map((row) => row.taskId));
+		const tombstoned = new Set(yield* sync.listTombstones);
+		const syncedIds = yield* sync.listSyncedIds;
+		const held = new Map((yield* local.list({})).map((task) => [task.taskId, task]));
+		const seen = /* @__PURE__ */ new Set();
+		for (const task of remote) {
+			seen.add(task.taskId);
+			if (stillPending.has(task.taskId) || tombstoned.has(task.taskId)) continue;
+			const current = held.get(task.taskId);
+			if (current === void 0 || current.updatedAt !== task.updatedAt) yield* adopt(task);
+		}
+		for (const taskId of syncedIds) if (!seen.has(taskId)) yield* local.deleteById({ taskId });
+	}).pipe(Effect.ignoreCause({ log: true }));
+	yield* Effect.forever(syncOnce.pipe(Effect.andThen(Effect.sleep(SYNC_INTERVAL)))).pipe(Effect.forkScoped);
+	return {
+		create,
+		upsert,
+		patch,
+		patchIfStatus,
+		getById: local.getById,
+		getByReadableId: local.getByReadableId,
+		list: local.list,
+		deleteById,
+		streamChanges: local.streamChanges,
+		streamWithSnapshot: local.streamWithSnapshot
+	};
+});
+Layer.effect(TaskRepository, makeSyncedTaskRepository);
+//#endregion
+//#region src/persistence/Layers/TaskBoardSource.ts
+/**
+* Which board a call is about, resolved per call.
+*
+* This replaced a server-wide setting that chose between a local database and
+* the hub. Two things changed at once and each removed a reason for that
+* setting to exist: local and hub became one replicated board rather than two
+* rival ones, so there was nothing left to choose between; and a second real
+* board arrived - Linear - which a person switches to in order to look at
+* something and switches back a minute later. That is a control on the board,
+* not a configuration of the machine.
+*
+* Both repositories are built at startup and every call picks one. Building
+* lazily would mean the first call to a source paid for its construction, and
+* the Linear one starts a poll fiber that must exist before anyone subscribes.
+*
+* **A subscription keeps the source it opened with.** Switching boards in the
+* UI closes the stream and opens another, which is the honest implementation:
+* a stream that changed what it was a stream of would need a "your board
+* moved" event that no client knows how to render.
+*
+* @module persistence/Layers/TaskBoardSource
+*/
+var TaskRepositoryRegistry = class extends Context.Service()("@p4code/cli/persistence/Layers/TaskBoardSource/TaskRepositoryRegistry") {};
+const makeRegistry = Effect.gen(function* () {
+	const board = yield* makeSyncedTaskRepository;
+	const linear = yield* makeLinearTaskRepository;
+	return {
+		forSource: (source) => source === "linear" ? linear : board,
+		linearAvailable: (yield* LinearMcpClient).isConfigured
+	};
+});
+const TaskRepositoryRegistryLive = Layer.effect(TaskRepositoryRegistry, makeRegistry);
+/**
+* The default board, for everything that names no source.
+*
+* Every consumer that predates the source parameter - the orchestration
+* engine's task lookups, the startup reconciliation - goes through this, so
+* adding the parameter did not become a change to all of them. It is the same
+* instance the registry hands out for `board`, which matters: the repository
+* owns the change PubSub, and a second instance would mean a task filed by an
+* agent never reaching an open board.
+*/
+const RoutedTaskRepositoryLive = Layer.effect(TaskRepository, Effect.gen(function* () {
+	return (yield* TaskRepositoryRegistry).forSource(DEFAULT_TASK_SOURCE);
+})).pipe(Layer.provideMerge(TaskRepositoryRegistryLive));
+//#endregion
 //#region src/taskBoard.ts
 /**
 * Server-side helpers shared by the task board's two front doors: the MCP
@@ -36781,7 +38295,7 @@ function toAssetFilePath(repositoryPath, root) {
 const REGISTRY_SEARCH_URL = "https://www.skills.sh/api/search";
 const GITHUB_API_URL = "https://api.github.com";
 const GITHUB_RAW_URL = "https://raw.githubusercontent.com";
-const REQUEST_TIMEOUT_MS$1 = 15e3;
+const REQUEST_TIMEOUT_MS = 15e3;
 /** More than a person reads, few enough that the panel is a list and not a feed. */
 const MAX_SEARCH_RESULTS = 25;
 /**
@@ -36821,7 +38335,7 @@ const emptyFetch = (id, unavailable) => ({
 const make$37 = Effect.gen(function* () {
 	const http = yield* HttpClient.HttpClient;
 	const request = Effect.fn("SkillRegistry.request")(function* (url) {
-		return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.setHeader("accept", "application/json"), HttpClientRequest.setHeader("user-agent", "p4code"))).pipe(Effect.timeout(REQUEST_TIMEOUT_MS$1));
+		return yield* http.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.setHeader("accept", "application/json"), HttpClientRequest.setHeader("user-agent", "p4code"))).pipe(Effect.timeout(REQUEST_TIMEOUT_MS));
 	});
 	const search = (query) => Effect.gen(function* () {
 		const response = yield* request(`${REGISTRY_SEARCH_URL}?q=${encodeURIComponent(query)}`).pipe(Effect.orElseSucceed(() => null));
@@ -36891,211 +38405,6 @@ const make$37 = Effect.gen(function* () {
 });
 const layer$32 = Layer.effect(SkillRegistry, make$37);
 //#endregion
-//#region ../../packages/shared/src/ticketReference.ts
-/**
-* Recognizing a tracker reference in text somebody pasted.
-*
-* Shared because both ends need the same answer: the composer decides whether a
-* paste is worth a round trip, and the server decides what to ask the tracker.
-* Two copies of this rule would differ, and the difference would read as "it
-* works on my machine but the paste does nothing".
-*
-* @module ticketReference
-*/
-/**
-* A Linear issue URL, e.g.
-* `https://linear.app/omnicasa/issue/MOBILE-12262/haptic-feedback`.
-*
-* The workspace slug is what makes the URL unguessable from the identifier
-* alone, which is why a resolved ticket keeps the tracker's own URL rather than
-* rebuilding one.
-*/
-const LINEAR_ISSUE_URL_PATTERN = /https?:\/\/(?:www\.)?linear\.app\/[^/\s]+\/issue\/([A-Za-z][A-Za-z0-9]*-\d+)/;
-/**
-* A bare identifier, e.g. `MOBILE-12262`.
-*
-* Anchored: only a paste that is *nothing but* an identifier counts. Scanning
-* prose for this shape would claim things that are not tickets - a date range,
-* a version, a p4code readable id like `P4-40` - and each false positive costs
-* a request and, worse, a wrong link.
-*/
-const BARE_IDENTIFIER_PATTERN = /^([A-Za-z][A-Za-z0-9]*-\d+)$/;
-/**
-* The issue identifier a paste refers to, or `null` when it refers to none.
-*
-* Case is normalized up, the way every tracker prints it, so the same ticket
-* pasted two ways compares equal.
-*/
-function parseTicketReference(text) {
-	const trimmed = text.trim();
-	if (trimmed.length === 0) return null;
-	const url = LINEAR_ISSUE_URL_PATTERN.exec(trimmed);
-	if (url?.[1] !== void 0) return url[1].toUpperCase();
-	const bare = BARE_IDENTIFIER_PATTERN.exec(trimmed);
-	if (bare?.[1] !== void 0) return bare[1].toUpperCase();
-	return null;
-}
-//#endregion
-//#region src/mcp/McpToolClient.ts
-/**
-* Calling a tool on somebody else's MCP server.
-*
-* The rest of `apps/server/src/mcp` points the other way: it *exposes* p4code's
-* toolkit to an agent. This is the only place p4code is the client, and it
-* exists because one feature - recognizing a pasted ticket - needs an answer
-* before any agent turn runs, from a server the user has already registered.
-*
-* Deliberately not a general MCP client. There is no session reuse, no tool
-* listing, no notifications, no SSE stream held open: one request/response pair
-* per call, which is all streamable HTTP requires for a plain `tools/call`. A
-* real client belongs here only once something needs one.
-*
-* @module mcp/McpToolClient
-*/
-/**
-* The version p4code speaks. Sent on `initialize` and echoed back as a header
-* on the follow-up calls, which is what the spec asks of a client that has
-* already negotiated.
-*/
-const MCP_PROTOCOL_VERSION = "2025-06-18";
-const REQUEST_TIMEOUT_MS = 15e3;
-var McpToolCallError = class extends Schema$1.TaggedErrorClass()("McpToolCallError", {
-	detail: Schema$1.String,
-	status: Schema$1.NullOr(Schema$1.Number)
-}) {
-	get message() {
-		return this.detail;
-	}
-};
-const unauthorized$1 = (status) => status === 401 || status === 403;
-/**
-* Read a JSON-RPC envelope out of a response that may be either JSON or SSE.
-*
-* A streamable-http server picks the encoding, and both are legal answers to a
-* single call. The SSE branch keeps the last `data:` payload that parses: a
-* server is free to emit progress notifications ahead of the result, and the
-* result is what a caller of this asked for.
-*/
-const readEnvelope = (body) => {
-	const direct = parseJsonObject(body);
-	if (direct !== void 0) return direct;
-	let latest;
-	for (const line of body.split("\n")) {
-		const trimmed = line.trim();
-		if (!trimmed.startsWith("data:")) continue;
-		const parsed = parseJsonObject(trimmed.slice(5).trim());
-		if (parsed !== void 0) latest = parsed;
-	}
-	return latest;
-};
-const parseJsonObject = (text) => {
-	if (text.length === 0) return void 0;
-	try {
-		const parsed = JSON.parse(text);
-		return typeof parsed === "object" && parsed !== null ? parsed : void 0;
-	} catch {
-		return;
-	}
-};
-const textOf = (content) => {
-	if (!Array.isArray(content)) return "";
-	const parts = [];
-	for (const block of content) {
-		if (typeof block !== "object" || block === null) continue;
-		const record = block;
-		if (record["type"] === "text" && typeof record["text"] === "string") parts.push(record["text"]);
-	}
-	return parts.join("\n");
-};
-/**
-* One `tools/call`, preceded by the `initialize` handshake the transport
-* requires.
-*
-* The handshake is not optional and not cacheable here: a server may hand out a
-* session id, and this holds no session state between calls. Two round trips
-* for one answer is the price of not keeping a connection open for a feature
-* that fires when somebody pastes something.
-*/
-const callMcpTool = Effect.fn("McpToolClient.callMcpTool")(function* (input) {
-	const http = yield* HttpClient$1.HttpClient;
-	const post = (body, extraHeaders) => http.execute(HttpClientRequest$1.bodyJsonUnsafe(HttpClientRequest$1.setHeaders(HttpClientRequest$1.post(input.url), {
-		...input.headers,
-		...extraHeaders,
-		accept: "application/json, text/event-stream"
-	}), body)).pipe(Effect.timeout(REQUEST_TIMEOUT_MS), Effect.catchCause((cause) => Effect.fail(new McpToolCallError({
-		detail: `Could not reach ${input.url}: ${String(cause)}`,
-		status: null
-	}))));
-	const initialize = yield* post({
-		jsonrpc: "2.0",
-		id: 1,
-		method: "initialize",
-		params: {
-			protocolVersion: MCP_PROTOCOL_VERSION,
-			capabilities: {},
-			clientInfo: {
-				name: "p4code",
-				version: "0.0.0"
-			}
-		}
-	}, {});
-	if (initialize.status >= 400) return yield* new McpToolCallError({
-		detail: unauthorized$1(initialize.status) ? "The server rejected p4code's credentials." : `The server answered ${initialize.status} to initialize.`,
-		status: initialize.status
-	});
-	const sessionId = initialize.headers["mcp-session-id"];
-	const sessionHeaders = {
-		"mcp-protocol-version": MCP_PROTOCOL_VERSION,
-		...sessionId === void 0 ? {} : { "mcp-session-id": sessionId }
-	};
-	yield* post({
-		jsonrpc: "2.0",
-		method: "notifications/initialized"
-	}, sessionHeaders).pipe(Effect.ignore);
-	const response = yield* post({
-		jsonrpc: "2.0",
-		id: 2,
-		method: "tools/call",
-		params: {
-			name: input.toolName,
-			arguments: input.arguments
-		}
-	}, sessionHeaders);
-	const body = yield* response.text.pipe(Effect.catchCause(() => Effect.succeed("")));
-	if (response.status >= 400) return yield* new McpToolCallError({
-		detail: unauthorized$1(response.status) ? "The server rejected p4code's credentials." : `The server answered ${response.status} to ${input.toolName}.`,
-		status: response.status
-	});
-	const envelope = readEnvelope(body);
-	if (envelope === void 0) return yield* new McpToolCallError({
-		detail: `The server's answer to ${input.toolName} was not JSON-RPC.`,
-		status: response.status
-	});
-	const error = envelope["error"];
-	if (typeof error === "object" && error !== null) {
-		const detail = error["message"];
-		return yield* new McpToolCallError({
-			detail: typeof detail === "string" ? detail : `${input.toolName} failed.`,
-			status: response.status
-		});
-	}
-	const result = envelope["result"];
-	if (typeof result !== "object" || result === null) return yield* new McpToolCallError({
-		detail: `${input.toolName} returned no result.`,
-		status: response.status
-	});
-	const resultRecord = result;
-	const text = textOf(resultRecord["content"]);
-	if (resultRecord["isError"] === true) return yield* new McpToolCallError({
-		detail: text.length > 0 ? text : `${input.toolName} reported an error.`,
-		status: response.status
-	});
-	return {
-		structuredContent: resultRecord["structuredContent"],
-		text
-	};
-});
-//#endregion
 //#region src/mcp/TicketResolver.ts
 /**
 * The registered server name a Linear ticket is resolved through.
@@ -37409,7 +38718,7 @@ const COMMON_DEV_PORTS = Object.freeze([
 	8888,
 	9e3
 ]);
-const POLL_INTERVAL$1 = Duration.seconds(3);
+const POLL_INTERVAL = Duration.seconds(3);
 const LSOF_TIMEOUT_MS = 5e3;
 const WINDOWS_LISTENER_TIMEOUT_MS = 5e3;
 const terminalOwnerKey = (owner) => `${owner.threadId}\u0000${owner.terminalId}`;
@@ -37584,7 +38893,7 @@ const make$35 = Effect.gen(function* PortDiscoveryMake() {
 			lastSnapshot: next
 		}])) yield* broadcast(next);
 	}, Effect.catchCause((cause) => Effect.logWarning("preview port scan failed", Cause.pretty(cause))));
-	yield* Effect.forkScoped(pollTick().pipe(Effect.repeat(Schedule.spaced(POLL_INTERVAL$1))));
+	yield* Effect.forkScoped(pollTick().pipe(Effect.repeat(Schedule.spaced(POLL_INTERVAL))));
 	const acquireRetention = Effect.fn("PortDiscovery.retain")(function* () {
 		if (yield* Ref.modify(stateRef, (state) => [state.retainCount === 0, {
 			...state,
@@ -46517,7 +47826,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 	const orchestrationEngine = yield* OrchestrationEngineService;
 	const checkpointDiffQuery = yield* CheckpointDiffQuery;
 	const keybindings = yield* Keybindings;
-	const taskRepository = yield* TaskRepository;
+	const taskRepositories = yield* TaskRepositoryRegistry;
 	const projectionProjects = yield* ProjectionProjectRepository;
 	const externalLauncher = yield* ExternalLauncher;
 	const gitWorkflow = yield* GitWorkflowService;
@@ -47007,29 +48316,30 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 				issues: []
 			};
 		}), { "rpc.aggregate": "server" }),
-		[WS_METHODS.tasksList]: (filter) => observeRpcEffect$1(WS_METHODS.tasksList, taskRepository.list(filter).pipe(Effect.catch(toTaskStoreError("tasks.list")), Effect.map((tasks) => ({ tasks }))), { "rpc.aggregate": "tasks" }),
-		[WS_METHODS.tasksGet]: ({ taskId }) => observeRpcEffect$1(WS_METHODS.tasksGet, taskRepository.getById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.get")), Effect.map((found) => ({ task: Option.getOrNull(found) }))), { "rpc.aggregate": "tasks" }),
-		[WS_METHODS.tasksCreate]: (input) => observeRpcEffect$1(WS_METHODS.tasksCreate, Effect.gen(function* () {
+		[WS_METHODS.tasksList]: ({ source, ...filter }) => observeRpcEffect$1(WS_METHODS.tasksList, taskRepositories.forSource(source).list(filter).pipe(Effect.catch(toTaskStoreError("tasks.list")), Effect.map((tasks) => ({ tasks }))), { "rpc.aggregate": "tasks" }),
+		[WS_METHODS.tasksGet]: ({ taskId, source }) => observeRpcEffect$1(WS_METHODS.tasksGet, taskRepositories.forSource(source).getById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.get")), Effect.map((found) => ({ task: Option.getOrNull(found) }))), { "rpc.aggregate": "tasks" }),
+		[WS_METHODS.tasksCreate]: ({ source, ...input }) => observeRpcEffect$1(WS_METHODS.tasksCreate, Effect.gen(function* () {
 			const taskId = TaskId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
 			const timestamp = yield* nowIso$5;
 			const repositoryKey = yield* resolveTaskRepositoryKey(input.projectId);
 			const readableIdPrefix = yield* resolveTaskReadableIdPrefix(input.projectId);
 			const row = buildTaskRow(input, taskId, timestamp, repositoryKey);
-			return { task: yield* taskRepository.create(row, readableIdPrefix).pipe(Effect.catch(toTaskStoreError("tasks.create"))) };
+			return { task: yield* taskRepositories.forSource(source).create(row, readableIdPrefix).pipe(Effect.catch(toTaskStoreError("tasks.create"))) };
 		}), { "rpc.aggregate": "tasks" }),
-		[WS_METHODS.tasksUpdate]: (input) => observeRpcEffect$1(WS_METHODS.tasksUpdate, Effect.gen(function* () {
+		[WS_METHODS.tasksUpdate]: ({ source, ...input }) => observeRpcEffect$1(WS_METHODS.tasksUpdate, Effect.gen(function* () {
 			const timestamp = yield* nowIso$5;
 			const patch = input.projectId === void 0 ? input : {
 				...input,
 				repositoryKey: yield* resolveTaskRepositoryKey(input.projectId)
 			};
-			const patched = yield* taskRepository.patch(patch, timestamp).pipe(Effect.catch(toTaskStoreError("tasks.update")));
+			const patched = yield* taskRepositories.forSource(source).patch(patch, timestamp).pipe(Effect.catch(toTaskStoreError("tasks.update")));
 			if (Option.isNone(patched)) return yield* new TaskNotFoundError({ taskId: input.taskId });
 			return { task: patched.value };
 		}), { "rpc.aggregate": "tasks" }),
-		[WS_METHODS.tasksDelete]: ({ taskId }) => observeRpcEffect$1(WS_METHODS.tasksDelete, taskRepository.deleteById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.delete")), Effect.as({})), { "rpc.aggregate": "tasks" }),
-		[WS_METHODS.tasksStartThread]: ({ taskId }) => observeRpcEffect$1(WS_METHODS.tasksStartThread, Effect.gen(function* () {
-			const found = yield* taskRepository.getById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.startThread")));
+		[WS_METHODS.tasksDelete]: ({ taskId, source }) => observeRpcEffect$1(WS_METHODS.tasksDelete, taskRepositories.forSource(source).deleteById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.delete")), Effect.as({})), { "rpc.aggregate": "tasks" }),
+		[WS_METHODS.tasksStartThread]: ({ taskId, source }) => observeRpcEffect$1(WS_METHODS.tasksStartThread, Effect.gen(function* () {
+			const tasks = taskRepositories.forSource(source);
+			const found = yield* tasks.getById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.startThread")));
 			if (Option.isNone(found)) return yield* new TaskNotFoundError({ taskId });
 			const task = found.value;
 			const plan = resolveTaskStart(task, task.projectId === null ? Option.none() : yield* projectionProjects.getById({ projectId: task.projectId }).pipe(Effect.catch(toTaskStoreError("tasks.startThread.project"))));
@@ -47079,7 +48389,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 				createdAt
 			});
 			yield* dispatchNormalizedCommand(normalizedCommand);
-			const patched = yield* taskRepository.patch({
+			const patched = yield* tasks.patch({
 				taskId,
 				threadId,
 				status: "in_progress"
@@ -47097,7 +48407,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 		* becomes a task, so an accidental paste costs one request and no row.
 		*/
 		[WS_METHODS.ticketsResolve]: ({ reference }) => observeRpcEffect$1(WS_METHODS.ticketsResolve, ticketResolver.resolve(reference), { "rpc.aggregate": "tickets" }),
-		[WS_METHODS.subscribeTasks]: (_input) => observeRpcStreamEffect$1(WS_METHODS.subscribeTasks, Effect.succeed(taskRepository.streamWithSnapshot.pipe(Stream.catch((cause) => Stream.fromEffect(toTaskStoreError("tasks.subscribe")(cause))))), { "rpc.aggregate": "tasks" }),
+		[WS_METHODS.subscribeTasks]: ({ source }) => observeRpcStreamEffect$1(WS_METHODS.subscribeTasks, Effect.succeed(taskRepositories.forSource(source).streamWithSnapshot.pipe(Stream.catch((cause) => Stream.fromEffect(toTaskStoreError("tasks.subscribe")(cause))))), { "rpc.aggregate": "tasks" }),
 		[WS_METHODS.hubGetSyncStatus]: (_input) => observeRpcEffect$1(WS_METHODS.hubGetSyncStatus, assetSync.status, { "rpc.aggregate": "hub" }),
 		[WS_METHODS.hubConnect]: (input) => observeRpcEffect$1(WS_METHODS.hubConnect, hubLink.connect(input).pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(assetSync.status)), { "rpc.aggregate": "hub" }),
 		[WS_METHODS.hubDisconnect]: (_input) => observeRpcEffect$1(WS_METHODS.hubDisconnect, hubLink.disconnect.pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(assetSync.status)), { "rpc.aggregate": "hub" }),
@@ -47356,7 +48666,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 const websocketRpcRouteLayer = Layer.unwrap(Effect.gen(function* () {
 	const previewAutomationBroker = yield* PreviewAutomationBroker;
 	const serverSelfUpdate = yield* ServerSelfUpdate;
-	const taskRepository = yield* TaskRepository;
+	const taskRepositories = yield* TaskRepositoryRegistry;
 	const projectionProjects = yield* ProjectionProjectRepository;
 	const p4ProjectFileLoader = yield* P4ProjectFileLoader;
 	return HttpRouter.add("GET", "/ws", Effect.gen(function* () {
@@ -47364,7 +48674,7 @@ const websocketRpcRouteLayer = Layer.unwrap(Effect.gen(function* () {
 		const serverAuth = yield* EnvironmentAuth;
 		const sessions = yield* SessionStore;
 		const session = yield* serverAuth.authenticateWebSocketUpgrade(request).pipe(Effect.catchIf(isServerAuthCredentialError, (error) => failEnvironmentAuthInvalid(serverAuthCredentialReason(error))), Effect.catchIf(isServerAuthInternalError, (error) => failEnvironmentInternal("internal_error", error)));
-		const rpcWebSocketHttpEffect = yield* RpcServer.toHttpEffectWebsocket(WsRpcGroup, { disableTracing: true }).pipe(Effect.provide(makeWsRpcLayer(session, previewAutomationBroker).pipe(Layer.provideMerge(RpcSerialization.layerJson), Layer.provide(layer$34), Layer.provide(Layer.succeed(ServerSelfUpdate, serverSelfUpdate)), Layer.provide(Layer.succeed(TaskRepository, taskRepository)), Layer.provide(Layer.succeed(ProjectionProjectRepository, projectionProjects)), Layer.provide(Layer.succeed(P4ProjectFileLoader, p4ProjectFileLoader)), Layer.provide(layer$5.pipe(Layer.provide(layer$14.pipe(Layer.provide(Layer.mergeAll(layer$22, layer$20, layer$18, layer$16)), Layer.provideMerge(layer$39), Layer.provide(layer$37.pipe(Layer.provide(layer$38))))), Layer.provide(layer$40))))));
+		const rpcWebSocketHttpEffect = yield* RpcServer.toHttpEffectWebsocket(WsRpcGroup, { disableTracing: true }).pipe(Effect.provide(makeWsRpcLayer(session, previewAutomationBroker).pipe(Layer.provideMerge(RpcSerialization.layerJson), Layer.provide(layer$34), Layer.provide(Layer.succeed(ServerSelfUpdate, serverSelfUpdate)), Layer.provide(Layer.succeed(TaskRepositoryRegistry, taskRepositories)), Layer.provide(Layer.succeed(ProjectionProjectRepository, projectionProjects)), Layer.provide(Layer.succeed(P4ProjectFileLoader, p4ProjectFileLoader)), Layer.provide(layer$5.pipe(Layer.provide(layer$14.pipe(Layer.provide(Layer.mergeAll(layer$22, layer$20, layer$18, layer$16)), Layer.provideMerge(layer$39), Layer.provide(layer$37.pipe(Layer.provide(layer$38))))), Layer.provide(layer$40))))));
 		return yield* Effect.acquireUseRelease(sessions.markConnected(session.sessionId), () => rpcWebSocketHttpEffect, () => sessions.markDisconnected(session.sessionId));
 	}).pipe(Effect.catchTags({
 		EnvironmentAuthInvalidError: HttpServerRespondable.toResponse,
@@ -47372,296 +48682,6 @@ const websocketRpcRouteLayer = Layer.unwrap(Effect.gen(function* () {
 	})));
 }));
 //#endregion
-//#region src/persistence/Layers/RemoteTasks.ts
-/**
-* The board, kept on the hub instead of in this machine's database.
-*
-* A drop-in `TaskRepository`: same interface, same events, so the MCP toolkit,
-* the websocket RPCs and the board itself are unchanged and do not know which
-* one they are talking to. That was the point of making it an interface.
-*
-* **An unreachable hub fails loudly, by decision.** There is no local fallback
-* and no write queue. A server that answered from a local copy while the hub
-* was down would recreate exactly the divergence the hub exists to remove —
-* two Macs with two boards, silently — and the failure would be invisible until
-* someone noticed a task missing on the other machine. So a hub that cannot be
-* reached means the board says so and nothing is written. The cost is real and
-* is the point: no board while the hub is down.
-*
-* **Changes are polled, because the hub has no push.** The interface promises
-* a change stream, and the honest implementation of that against a plain HTTP
-* API is a poll with a diff. A write made through *this* server publishes
-* immediately, so the local board is live; the poll is what carries the other
-* machine's writes, at up to `POLL_INTERVAL` of lag.
-*
-* @module persistence/Layers/RemoteTasks
-*/
-const HUB_REQUEST_TIMEOUT_MS = 15e3;
-/**
-* How stale another machine's write may look here.
-*
-* Short enough that a board left open follows along, long enough that two
-* servers idling all day are not a steady stream of requests at a hosted
-* service. Only changes made elsewhere wait for it.
-*/
-const POLL_INTERVAL = Duration.seconds(10);
-const TaskListPage = Schema$1.Struct({ tasks: Schema$1.Array(Task) });
-const ConflictBody = Schema$1.Struct({ current: Task });
-const decodeTaskListPage = Schema$1.decodeUnknownEffect(TaskListPage);
-const decodeTask = Schema$1.decodeUnknownEffect(Task);
-const decodeConflictBody = Schema$1.decodeUnknownEffect(ConflictBody);
-/**
-* Every failure here is reported as the interface's own error type.
-*
-* `PersistenceSqlError` names a store that would not answer, which is exactly
-* what this is from a caller's point of view — the detail says the store is the
-* hub. Inventing a second error type would mean touching every call site to
-* handle a case they already handle.
-*/
-const hubUnavailable = (operation, detail) => new PersistenceSqlError({
-	operation: `RemoteTaskRepository.${operation}`,
-	detail: `The hub board is unavailable: ${detail}`,
-	cause: null
-});
-/**
-* @param isActive Whether this server is currently reading its board from the
-* hub. The poll asks before every pass rather than being started once: a
-* machine with the board set to `local` must not be sending a request to a
-* hosted service every ten seconds for a board nobody is reading, and the
-* setting can change while the server runs.
-*/
-const makeRemoteTaskRepository = Effect.fn("makeRemoteTaskRepository")(function* (isActive) {
-	const http = yield* HttpClient.HttpClient;
-	const link = yield* HubLink;
-	const changes = yield* PubSub.unbounded();
-	const publish = (event) => PubSub.publish(changes, event).pipe(Effect.asVoid);
-	/** The board as of the last poll, for diffing the next one against. */
-	const lastSeen = yield* Ref.make(null);
-	const requireSettings = (operation) => Effect.gen(function* () {
-		const state = yield* link.current;
-		if (Option.isNone(state.settings)) return yield* hubUnavailable(operation, "no hub is configured on this server");
-		return state.settings.value;
-	});
-	const send = (operation, settings, request) => http.execute(request.pipe(HttpClientRequest.setHeader("authorization", `Bearer ${settings.token}`), HttpClientRequest.setHeader("accept", "application/json"))).pipe(Effect.timeout(HUB_REQUEST_TIMEOUT_MS), Effect.mapError((cause) => hubUnavailable(operation, `${cause._tag ?? "request failed"}`)));
-	const list = (filter) => Effect.gen(function* () {
-		const settings = yield* requireSettings("list");
-		const query = new URLSearchParams();
-		for (const key of [
-			"projectId",
-			"repositoryKey",
-			"threadId",
-			"status",
-			"assignee"
-		]) {
-			const value = filter[key];
-			if (value !== void 0) query.set(key, value);
-		}
-		const suffix = query.size === 0 ? "" : `?${query.toString()}`;
-		const response = yield* send("list", settings, HttpClientRequest.get(`${settings.baseUrl}/tasks${suffix}`));
-		if (response.status !== 200) return yield* hubUnavailable("list", `status ${response.status}`);
-		return (yield* response.json.pipe(Effect.flatMap(decodeTaskListPage), Effect.mapError(() => hubUnavailable("list", "the response did not match the contract")))).tasks;
-	});
-	const getById = ({ taskId }) => Effect.gen(function* () {
-		const settings = yield* requireSettings("getById");
-		const response = yield* send("getById", settings, HttpClientRequest.get(`${settings.baseUrl}/tasks/${encodeURIComponent(taskId)}`));
-		if (response.status === 404) return Option.none();
-		if (response.status !== 200) return yield* hubUnavailable("getById", `status ${response.status}`);
-		return Option.some(yield* response.json.pipe(Effect.flatMap(decodeTask), Effect.mapError(() => hubUnavailable("getById", "the response did not match the contract"))));
-	});
-	/**
-	* Both writes here POST the hub's create route, and that is a real
-	* difference from the local store: the hub mints its own ids, timestamps and
-	* readable id, so a row written through this comes back with the hub's
-	* version of all three. The caller's `taskId` is not carried - honouring it
-	* would need a hub route that takes one, and inventing that quietly would
-	* let two servers mint colliding ids.
-	*/
-	const postCreate = (operation, row, readableIdPrefix) => Effect.gen(function* () {
-		const settings = yield* requireSettings(operation);
-		const response = yield* send(operation, settings, HttpClientRequest.bodyJsonUnsafe(HttpClientRequest.post(`${settings.baseUrl}/tasks`), {
-			...row.projectId === null ? {} : { projectId: row.projectId },
-			...row.repositoryKey === null ? {} : { repositoryKey: row.repositoryKey },
-			...row.threadId === null ? {} : { threadId: row.threadId },
-			...row.externalRef === null ? {} : { externalRef: row.externalRef },
-			...row.parentTaskId === null ? {} : { parentTaskId: row.parentTaskId },
-			title: row.title,
-			body: row.body,
-			status: row.status,
-			priority: row.priority,
-			...row.assignee === null ? {} : { assignee: row.assignee },
-			labels: row.labels,
-			...row.orderKey === null ? {} : { orderKey: row.orderKey },
-			...readableIdPrefix === void 0 ? {} : { readableIdPrefix }
-		}));
-		if (response.status !== 201 && response.status !== 200) return yield* hubUnavailable(operation, `status ${response.status}`);
-		const created = yield* response.json.pipe(Effect.flatMap(decodeTask), Effect.mapError(() => hubUnavailable(operation, "the response did not match the contract")));
-		yield* publish({
-			type: "upserted",
-			task: created
-		});
-		return created;
-	});
-	const create = (row, readableIdPrefix) => postCreate("create", row, readableIdPrefix);
-	const upsert = (row) => postCreate("upsert", row).pipe(Effect.asVoid);
-	/**
-	* Served by the same hub route as `getById`: readable ids and UUIDs are
-	* disjoint by shape, so the hub dispatches on what it is handed.
-	*/
-	const getByReadableId = (readableId) => getById({ taskId: TaskId.make(readableId) });
-	const patch = (input) => Effect.gen(function* () {
-		const settings = yield* requireSettings("patch");
-		const { taskId, ...fields } = input;
-		const response = yield* send("patch", settings, HttpClientRequest.bodyJsonUnsafe(HttpClientRequest.patch(`${settings.baseUrl}/tasks/${encodeURIComponent(taskId)}`), fields));
-		if (response.status === 404) return Option.none();
-		if (response.status !== 200) return yield* hubUnavailable("patch", `status ${response.status}`);
-		const updated = yield* response.json.pipe(Effect.flatMap(decodeTask), Effect.mapError(() => hubUnavailable("patch", "the response did not match the contract")));
-		yield* publish({
-			type: "upserted",
-			task: updated
-		});
-		return Option.some(updated);
-	});
-	const patchIfStatus = (input) => Effect.gen(function* () {
-		const settings = yield* requireSettings("patchIfStatus");
-		const { taskId, ...fields } = input.patch;
-		const response = yield* send("patchIfStatus", settings, HttpClientRequest.bodyJsonUnsafe(HttpClientRequest.patch(`${settings.baseUrl}/tasks/${encodeURIComponent(taskId)}`), {
-			...fields,
-			expectedStatus: input.expectedStatus
-		}));
-		if (response.status === 404) return { outcome: "missing" };
-		if (response.status === 409) return {
-			outcome: "conflict",
-			current: (yield* response.json.pipe(Effect.flatMap(decodeConflictBody), Effect.mapError(() => hubUnavailable("patchIfStatus", "the conflict response did not match the contract")))).current
-		};
-		if (response.status !== 200) return yield* hubUnavailable("patchIfStatus", `status ${response.status}`);
-		const updated = yield* response.json.pipe(Effect.flatMap(decodeTask), Effect.mapError(() => hubUnavailable("patchIfStatus", "the response did not match the contract")));
-		yield* publish({
-			type: "upserted",
-			task: updated
-		});
-		return {
-			outcome: "updated",
-			task: updated
-		};
-	});
-	const deleteById = ({ taskId }) => Effect.gen(function* () {
-		const settings = yield* requireSettings("deleteById");
-		const response = yield* send("deleteById", settings, HttpClientRequest.delete(`${settings.baseUrl}/tasks/${encodeURIComponent(taskId)}`));
-		if (response.status !== 200 && response.status !== 204 && response.status !== 404) return yield* hubUnavailable("deleteById", `status ${response.status}`);
-		yield* publish({
-			type: "deleted",
-			taskId
-		});
-	});
-	/**
-	* One poll: read the board, publish what differs from last time.
-	*
-	* Compared on `updatedAt` rather than deep equality, because that is the
-	* field every hub write moves and it makes the diff O(n) with no schema
-	* knowledge. A failed poll publishes nothing and leaves the last snapshot in
-	* place — a hub blip should not empty every open board.
-	*/
-	const pollOnce = Effect.gen(function* () {
-		if (!(yield* isActive)) return;
-		const current = yield* list({});
-		const previous = yield* Ref.getAndSet(lastSeen, current);
-		if (previous === null) return;
-		const previousById = new Map(previous.map((task) => [task.taskId, task]));
-		for (const task of current) {
-			const before = previousById.get(task.taskId);
-			if (before === void 0 || before.updatedAt !== task.updatedAt) yield* publish({
-				type: "upserted",
-				task
-			});
-			previousById.delete(task.taskId);
-		}
-		for (const taskId of previousById.keys()) yield* publish({
-			type: "deleted",
-			taskId
-		});
-	}).pipe(Effect.ignoreCause({ log: true }));
-	yield* Effect.forever(pollOnce.pipe(Effect.andThen(Effect.sleep(POLL_INTERVAL)))).pipe(Effect.forkScoped);
-	return {
-		create,
-		upsert,
-		patch,
-		patchIfStatus,
-		getById,
-		getByReadableId,
-		list,
-		deleteById,
-		streamChanges: Stream.fromPubSub(changes),
-		streamWithSnapshot: Stream.unwrap(Effect.gen(function* () {
-			const subscription = yield* PubSub.subscribe(changes);
-			const snapshot = yield* list({});
-			yield* Ref.set(lastSeen, snapshot);
-			return Stream.concat(Stream.succeed({
-				type: "snapshot",
-				tasks: snapshot
-			}), Stream.fromSubscription(subscription));
-		}))
-	};
-});
-Layer.effect(TaskRepository, makeRemoteTaskRepository(Effect.succeed(true)));
-//#endregion
-//#region src/persistence/Layers/TaskBoardSource.ts
-/**
-* Which board a call goes to: this machine's database, or the hub's.
-*
-* Both repositories are built, and every call reads the setting and delegates.
-* That is deliberate rather than picking one at startup: `taskBoardSource` is
-* an ordinary setting a person changes in a panel, and a setting that only
-* takes effect after a restart is the same hazard the hub link already
-* documents — you change it, nothing happens, and there is nothing on screen
-* saying why.
-*
-* **Subscriptions pick their source when they subscribe.** A stream cannot
-* change its mind mid-flight without inventing a "your board moved" event that
-* nothing knows how to render, so an open board keeps reading the source it
-* opened against and picks up the change when it reconnects. Switching is rare;
-* a wrong row on screen is not worth a new event type.
-*
-* @module persistence/Layers/TaskBoardSource
-*/
-const makeRoutedTaskRepository = Effect.gen(function* () {
-	const local = yield* makeTaskRepository;
-	const usingHub = (yield* ServerSettingsService).getSettings.pipe(Effect.map((current) => current.taskBoardSource === "hub"), Effect.orElseSucceed(() => false));
-	const remote = yield* makeRemoteTaskRepository(usingHub);
-	/**
-	* `local` on a settings read failure, and that direction is chosen.
-	*
-	* The alternative is refusing every board call because a settings file could
-	* not be read, which turns one broken file into a dead board. Falling back to
-	* the machine's own database is the answer that still works and cannot lose a
-	* hub write, because a write that never reached the hub was never accepted.
-	*/
-	const pick = usingHub.pipe(Effect.map((hub) => hub ? remote : local));
-	return {
-		create: (row, readableIdPrefix) => pick.pipe(Effect.flatMap((repository) => repository.create(row, readableIdPrefix))),
-		upsert: (row) => pick.pipe(Effect.flatMap((repository) => repository.upsert(row))),
-		patch: (input, updatedAt) => pick.pipe(Effect.flatMap((repository) => repository.patch(input, updatedAt))),
-		patchIfStatus: (input, updatedAt) => pick.pipe(Effect.flatMap((repository) => repository.patchIfStatus(input, updatedAt))),
-		getById: (input) => pick.pipe(Effect.flatMap((repository) => repository.getById(input))),
-		getByReadableId: (readableId) => pick.pipe(Effect.flatMap((repository) => repository.getByReadableId(readableId))),
-		list: (filter) => pick.pipe(Effect.flatMap((repository) => repository.list(filter))),
-		deleteById: (input) => pick.pipe(Effect.flatMap((repository) => repository.deleteById(input))),
-		get streamChanges() {
-			return Stream.unwrap(pick.pipe(Effect.map((repository) => repository.streamChanges)));
-		},
-		get streamWithSnapshot() {
-			return Stream.unwrap(pick.pipe(Effect.map((repository) => repository.streamWithSnapshot)));
-		}
-	};
-});
-/**
-* The board, wherever it lives.
-*
-* Replaces `TaskRepositoryLive` at the one place the route tree provides it, so
-* the MCP toolkit and the websocket handlers keep sharing a single instance —
-* which is what makes a task an agent files appear on an open board.
-*/
-const RoutedTaskRepositoryLive = Layer.effect(TaskRepository, makeRoutedTaskRepository);
-//#endregion
 //#region src/persistence/ProviderSessionRuntime.ts
 /**
 * ProviderSessionRuntimeRepository - Repository interface for provider runtime sessions.
@@ -89374,6 +90394,126 @@ const make$3 = Effect.gen(function* () {
 });
 const ProviderRuntimeIngestionLive = Layer.effect(ProviderRuntimeIngestionService, make$3).pipe(Layer.provide(ProjectionTurnRepositoryLive));
 //#endregion
+//#region src/provider/userInvokedSkills.ts
+/**
+* Running a skill the model is not allowed to reach.
+*
+* A skill carrying `disable-model-invocation: true` is withheld from the model
+* entirely — description included — so only a person typing `/name` can start
+* it. That works in the interactive CLI, which expands the slash command before
+* the model ever sees it. It does not work here: p4code drives the Agent SDK,
+* whose non-interactive path forwards the typed text verbatim, and p4code's own
+* fallback is to ask the model to call the `Skill` tool — which is the one door
+* this flag locks. The result is a skill that is unreachable from both sides,
+* with nothing in the transcript to say why.
+*
+* So the expansion happens here, server-side, before the turn leaves: the
+* skill's own instructions are inlined into the message the provider receives.
+* The transcript keeps what the person typed, the same split compression
+* already uses.
+*
+* **Only skills the model may not invoke are expanded.** Everything else is
+* left alone deliberately — those already work through the `Skill` tool, and
+* inlining them too would mean two mechanisms racing to run the same skill.
+*
+* @module provider/userInvokedSkills
+*/
+/**
+* A leading `/name`, with whatever followed it.
+*
+* Anchored at the start: a slash somewhere inside a sentence is a path, a date
+* or an "and/or", and treating those as commands would rewrite ordinary
+* messages. The name pattern matches what a skill directory can be called,
+* including the `plugin:skill` form.
+*/
+const SLASH_INVOCATION = /^\/([A-Za-z0-9][A-Za-z0-9_:-]*)[ \t]*([\s\S]*)$/;
+/** `SKILL.md` is the only file a skill is required to have. */
+const SKILL_FILENAME = "SKILL.md";
+const parseSlashInvocation = (text) => {
+	const match = SLASH_INVOCATION.exec(text.trim());
+	const name = match?.[1];
+	if (name === void 0) return void 0;
+	return {
+		name,
+		args: (match?.[2] ?? "").trim()
+	};
+};
+/**
+* The message the provider receives in place of `/name args`.
+*
+* Tagged rather than pasted bare so the instructions cannot be mistaken for the
+* person's own words, and attributed to its file so an agent that needs the
+* skill's siblings — a reference, a template — knows where to look.
+*/
+const buildUserInvokedSkillInput = (input) => [
+	`<skill name="${input.name}" path="${input.path}">`,
+	input.body,
+	"</skill>",
+	"",
+	`The user invoked the ${input.name} skill${input.args ? ` with: ${input.args}` : ""}. Follow the instructions above.`
+].join("\n");
+/**
+* The `SKILL.md` a typed name refers to, searched across the given roots.
+*
+* Both names a skill answers to are matched — the frontmatter `name` and the
+* directory it lives in — because either is what a person sees depending on the
+* surface they read it from, and matching one only would leave a skill whose
+* two names disagree quietly unreachable. Later roots win, which is how the
+* CLI resolves a project skill over a user one.
+*/
+const findSkillFile = Effect.fnUntraced(function* (input) {
+	const fileSystem = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	let found;
+	for (const root of input.roots) {
+		const entries = yield* fileSystem.readDirectory(root).pipe(Effect.orElseSucceed(() => []));
+		for (const entry of [...entries].sort()) {
+			const skillPath = path.join(root, entry, SKILL_FILENAME);
+			const contents = yield* fileSystem.readFileString(skillPath).pipe(Effect.orElseSucceed(() => void 0));
+			if (contents === void 0) continue;
+			const frontmatter = parseMarkdownFrontmatter(contents);
+			const frontmatterName = frontmatter.kind === "parsed" ? frontmatter.name : void 0;
+			if (entry !== input.name && frontmatterName !== input.name) continue;
+			found = {
+				path: skillPath,
+				contents
+			};
+		}
+	}
+	return found;
+});
+/**
+* The turn's text, with a user-invoked skill inlined when there is one.
+*
+* `undefined` means "nothing to do", which covers every ordinary message: no
+* leading slash, a name no skill answers to, a skill the model can invoke for
+* itself, or a body that is empty once the frontmatter comes off. Reading the
+* filesystem is best-effort throughout — an unreadable root or file leaves the
+* message exactly as it was typed, because failing a turn over a skill lookup
+* would be a worse answer than sending the text.
+*
+* @param roots - Skill directories, least specific first.
+*/
+const expandUserInvokedSkill = Effect.fnUntraced(function* (input) {
+	const invocation = parseSlashInvocation(input.text);
+	if (invocation === void 0) return void 0;
+	const skill = yield* findSkillFile({
+		name: invocation.name,
+		roots: input.roots
+	});
+	if (skill === void 0) return void 0;
+	const frontmatter = parseMarkdownFrontmatter(skill.contents);
+	if (frontmatter.kind !== "parsed" || frontmatter.disableModelInvocation !== true) return;
+	const body = stripMarkdownFrontmatter(skill.contents);
+	if (body.length === 0) return void 0;
+	return buildUserInvokedSkillInput({
+		name: invocation.name,
+		path: skill.path,
+		body,
+		args: invocation.args
+	});
+});
+//#endregion
 //#region src/orchestration/Layers/ProviderCommandReactor.ts
 const isProviderAdapterRequestError = Schema$1.is(ProviderAdapterRequestError);
 const isProviderDriverKind = Schema$1.is(ProviderDriverKind);
@@ -89570,6 +90710,25 @@ const make$2 = Effect.gen(function* () {
 	const resolveProject = Effect.fnUntraced(function* (projectId) {
 		return yield* projectionSnapshotQuery.getProjectShellById(projectId).pipe(Effect.map(Option.getOrUndefined));
 	});
+	/**
+	* Where a typed `/name` is looked up: the user's skills, then the
+	* workspace's.
+	*
+	* Project last so it wins, matching the CLI's most-specific-wins resolution.
+	* The user root is resolved with an empty `homePath` on purpose — this runs
+	* before a provider instance is chosen, and the config-dir override that a
+	* single Claude instance may carry is not a fact about the person's skills.
+	*/
+	const resolveUserInvokedSkillRoots = Effect.fnUntraced(function* (thread) {
+		const path = yield* Path.Path;
+		const userSkillsDir = yield* resolveClaudeUserSkillsDir({ homePath: "" });
+		const project = yield* resolveProject(thread.projectId);
+		const cwd = resolveThreadWorkspaceCwd({
+			thread,
+			projects: project ? [project] : []
+		});
+		return [userSkillsDir, ...cwd ? [path.join(cwd, ".claude", "skills")] : []];
+	});
 	const resolveThread = Effect.fnUntraced(function* (threadId) {
 		return yield* projectionSnapshotQuery.getThreadDetailById(threadId).pipe(Effect.map(Option.getOrUndefined));
 	});
@@ -89756,6 +90915,10 @@ const make$2 = Effect.gen(function* () {
 		});
 		if (input.modelSelection !== void 0) threadModelSelections.set(input.threadId, input.modelSelection);
 		const normalizedInput = toNonEmptyProviderInput(input.messageText);
+		const expandedInput = normalizedInput === void 0 ? void 0 : (yield* expandUserInvokedSkill({
+			text: normalizedInput,
+			roots: yield* resolveUserInvokedSkillRoots(thread)
+		})) ?? normalizedInput;
 		const normalizedAttachments = input.attachments ?? [];
 		const activeSession = yield* providerService.listSessions().pipe(Effect.map((sessions) => sessions.find((session) => session.threadId === input.threadId)));
 		const sessionModelSwitch = activeSession === void 0 ? "in-session" : activeSession.providerInstanceId === void 0 ? yield* new ProviderAdapterRequestError({
@@ -89776,7 +90939,7 @@ const make$2 = Effect.gen(function* () {
 			injectRuleset: !hadActiveSession && !hasSessionLevelRuleset,
 			staleRulesetMode: hadActiveSession && !rebuildsRulesetEachTurn ? threadSessionRulesetModes.get(input.threadId) : void 0
 		});
-		const inputWithCompressPrefix = normalizedInput !== void 0 && compressPrefix !== void 0 ? `${compressPrefix}\n\n${normalizedInput}` : normalizedInput;
+		const inputWithCompressPrefix = expandedInput !== void 0 && compressPrefix !== void 0 ? `${compressPrefix}\n\n${expandedInput}` : expandedInput;
 		return {
 			threadId: input.threadId,
 			...inputWithCompressPrefix ? { input: inputWithCompressPrefix } : {},
@@ -91338,7 +92501,7 @@ const WorkspaceLayerLive = Layer.mergeAll(layer$44, WorkspaceEntriesLayerLive, W
 const ProjectFaviconResolverLayerLive = layer$42.pipe(Layer.provide(layer$44), Layer.provide(layer$43));
 const AuthLayerLive = layer$64.pipe(Layer.provideMerge(PersistenceLayerLive), Layer.provide(layer$68));
 const ProviderRuntimeLayerLive = ProviderSessionReaperLive.pipe(Layer.provideMerge(ProviderLayerLive), Layer.provideMerge(OrchestrationLayerLive));
-const RuntimeDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(CheckpointingLayerLive), Layer.provideMerge(SourceControlProviderRegistryLayerLive), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderRuntimeLayerLive), Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive)), Layer.provideMerge(PersistenceLayerLive), Layer.provideMerge(layer$52), Layer.provideMerge(ProviderRegistryLive), Layer.provideMerge(ProviderInstanceRegistryHydrationLive), Layer.provideMerge(ProviderEventLoggersLive), Layer.provideMerge(OpenCodeRuntimeLive), Layer.provideMerge(layer$61.pipe(Layer.provide(layer$68))), Layer.provideMerge(WorkspaceLayerLive), Layer.provideMerge(ProjectFaviconResolverLayerLive), Layer.provideMerge(layer$53), Layer.provideMerge(layer$46), Layer.provideMerge(AuthLayerLive), Layer.provideMerge(layer$31.pipe(Layer.provideMerge(Layer.mergeAll(layer$58, layer$32).pipe(Layer.provideMerge(layer$59), Layer.provideMerge(layer$60))))), Layer.provideMerge(layer$68)).pipe(Layer.provideMerge(layer$8), Layer.provideMerge(layer$7), Layer.provideMerge(layer$6), Layer.provideMerge(layer$49), Layer.provideMerge(layer$51), Layer.provideMerge(layer$50), Layer.provide(layer$72));
+const RuntimeDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(CheckpointingLayerLive), Layer.provideMerge(SourceControlProviderRegistryLayerLive), Layer.provideMerge(GitLayerLive), Layer.provideMerge(VcsLayerLive), Layer.provideMerge(ProviderRuntimeLayerLive), Layer.provideMerge(Layer.mergeAll(TerminalLayerLive, PreviewLayerLive)), Layer.provideMerge(PersistenceLayerLive), Layer.provideMerge(layer$52), Layer.provideMerge(ProviderRegistryLive), Layer.provideMerge(ProviderInstanceRegistryHydrationLive), Layer.provideMerge(ProviderEventLoggersLive), Layer.provideMerge(OpenCodeRuntimeLive), Layer.provideMerge(layer$61.pipe(Layer.provide(layer$68))), Layer.provideMerge(WorkspaceLayerLive), Layer.provideMerge(ProjectFaviconResolverLayerLive), Layer.provideMerge(layer$53), Layer.provideMerge(layer$46), Layer.provideMerge(AuthLayerLive), Layer.provideMerge(Layer.mergeAll(layer$31, LinearMcpClientLive).pipe(Layer.provideMerge(Layer.mergeAll(layer$58, layer$32).pipe(Layer.provideMerge(layer$59), Layer.provideMerge(layer$60))))), Layer.provideMerge(layer$68)).pipe(Layer.provideMerge(layer$8), Layer.provideMerge(layer$7), Layer.provideMerge(layer$6), Layer.provideMerge(layer$49), Layer.provideMerge(layer$51), Layer.provideMerge(layer$50), Layer.provide(layer$72));
 /**
 * Hub asset sync.
 *