@p4code/cli 0.1.34 → 0.1.36

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.34";
+var version = "0.1.36";
 //#endregion
 //#region src/config.ts
 /**
@@ -5664,6 +5664,509 @@ var KeybindingsConfigError = class extends Schema$1.TaggedErrorClass()("Keybindi
 	}
 };
 //#endregion
+//#region ../../packages/contracts/src/task.ts
+const TASK_TITLE_MAX_LENGTH = 512;
+const TASK_LABEL_MAX_LENGTH = 64;
+const TASK_LABELS_MAX_COUNT = 32;
+const TASK_ASSIGNEE_MAX_LENGTH = 128;
+/**
+* Board columns, in board order. `backlog` is the default for newly created
+* tasks — an agent filing a task mid-session is recording work that exists, not
+* committing to doing it next.
+*
+* `cancelled` is the other way a task closes: decided against, superseded or
+* merged into another task. Marking such a task `done` is the workaround it
+* replaces, and it lies - a board that says five things finished when two of
+* them were dropped is not worth reading.
+*/
+const TaskStatus = Schema$1.Literals([
+	"backlog",
+	"todo",
+	"in_progress",
+	"in_review",
+	"done",
+	"cancelled"
+]);
+/**
+* What a status this build has never heard of decodes to when read back.
+*
+* `backlog` is the least dishonest guess: it says "recorded, nothing claimed
+* about it", which is true of a status we cannot interpret. Guessing `done` or
+* `cancelled` would claim the task is closed.
+*/
+const UNKNOWN_TASK_STATUS_FALLBACK = "backlog";
+const TaskPriority = Schema$1.Literals([
+	"none",
+	"low",
+	"medium",
+	"high",
+	"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 a source does not belong
+* there because the hub *is* the board. Client RPCs and the task toolkit mix
+* this selector into their own request schemas explicitly.
+*/
+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.
+*/
+const TASK_READABLE_ID_PREFIX_PATTERN = /^[A-Za-z][A-Za-z0-9]{0,9}$/;
+/** A validated task-id prefix such as `T`, `P4`, or `MOBILE`. */
+const TaskReadableIdPrefix = TrimmedNonEmptyString.check(Schema$1.isPattern(TASK_READABLE_ID_PREFIX_PATTERN));
+/**
+* The shape of a readable task id: prefix, dash, 1-based sequence number.
+* Deliberately disjoint from the UUID `taskId`, which is what lets a lookup
+* accept either and tell them apart by shape alone.
+*/
+const TASK_READABLE_ID_PATTERN = /^[A-Za-z][A-Za-z0-9]{0,9}-[1-9][0-9]*$/;
+/** Whether a task reference is a readable id (`P4-12`) rather than a UUID. */
+const isReadableTaskId = (reference) => TASK_READABLE_ID_PATTERN.test(reference);
+const TaskLabel = TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_LABEL_MAX_LENGTH));
+/**
+* Agent-facing field descriptions. These ride on the *encoded* side because
+* every one of these schemas is a brand or a check over a transformation, and
+* the JSON Schema an agent actually reads is generated from the encoded schema
+* — a plain `.annotate` on the decoded side is silently dropped.
+*/
+const ProjectIdField = ProjectId.pipe(Schema$1.annotateEncoded({ description: "Id of the project this task belongs to." }));
+const ThreadIdField = ThreadId.pipe(Schema$1.annotateEncoded({ description: "Id of the agent thread working this task." }));
+const TitleField = TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_TITLE_MAX_LENGTH)).pipe(Schema$1.annotateEncoded({ description: "One-line summary of the work. Required." }));
+const BodyField = Schema$1.String.pipe(Schema$1.annotateEncoded({ description: "Markdown detail: context, acceptance criteria, links." }));
+const StatusField = TaskStatus.pipe(Schema$1.annotateEncoded({ description: "Board column: backlog (recorded, not queued), todo (queued next), in_progress, in_review, done, cancelled (closed without doing the work)." }));
+/**
+* The status as read back from a store, tolerant of values this build predates.
+*
+* A board can be shared between machines running different versions, and a
+* newer peer may write a status added after this client shipped. A strict
+* literal would fail the decode of the whole page, so one unknown row would
+* blank the board behind a "hub is unavailable" error rather than degrade. An
+* unrecognized status therefore decodes to {@link UNKNOWN_TASK_STATUS_FALLBACK},
+* same spirit as the nullable `readableId` and `orderKey` below. Encoding stays
+* strict: this client can only ever write a status it knows.
+*/
+const StoredStatusField = TaskStatus.pipe(Schema$1.catchDecoding(() => Effect.succeedSome(UNKNOWN_TASK_STATUS_FALLBACK)));
+const PriorityField = TaskPriority.pipe(Schema$1.annotateEncoded({ description: "Relative urgency: none, low, medium, high or urgent." }));
+const AssigneeField = TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_ASSIGNEE_MAX_LENGTH)).pipe(Schema$1.annotateEncoded({ description: "Who owns the task — a person's handle or an agent name." }));
+/**
+* The portable half of "which repository is this task about".
+*
+* `projectId` cannot answer that across machines: it is a UUID minted when a
+* project is added, and the same checkout added on two servers gets two
+* different ids. A canonical repository key — the normalized primary git remote
+* — is the same string wherever the repo is cloned, so it survives the trip
+* through a shared board.
+*
+* Null for a task that is not about a repository, and also for a checkout with
+* no remote, where there is nothing stable to key on.
+*/
+const RepositoryKeyField = TrimmedNonEmptyString.pipe(Schema$1.annotateEncoded({ description: "Canonical repository key (normalized git remote, e.g. github.com/owner/repo). Portable across machines, unlike projectId." }));
+/**
+* Manual board position within a column, as a lexicographic fractional key.
+*
+* Compared as a plain string: smaller sorts higher. Keys are minted by the
+* board between the neighbours of a drop, so moving one card writes one row
+* rather than renumbering the column. `null` means the task has never been
+* placed by hand and falls back to the priority/recency order.
+*/
+const OrderKeyField = TrimmedNonEmptyString.pipe(Schema$1.annotateEncoded({ description: "Manual board position key. Lexicographic: smaller sorts higher in the column. Null means no manual position." }));
+/**
+* Which tracker issue a row *is*, for a row read out of a tracker.
+*
+* The identifier is the tracker's own, not ours: `MOBILE-12262` reads the same
+* in p4code as it does in Linear, in a commit message, and in conversation,
+* which is the whole point of carrying it. `url` is what the tracker itself
+* reported, never a guess assembled from the identifier - a Linear URL embeds
+* the workspace slug, so a constructed one would 404.
+*
+* Read-only, and only ever set by the `linear` source. p4code's own board does
+* not copy tracker issues into rows of its own: a ticket is read where it lives
+* and shown under the id its tracker gave it, which is why nothing here appears
+* in a create or update input.
+*/
+const TaskExternalRef = Schema$1.Struct({
+	source: Schema$1.Literals(["linear"]),
+	identifier: TrimmedNonEmptyString,
+	url: TrimmedNonEmptyString
+});
+/**
+* The task this one was split out of.
+*
+* Carried as a field rather than as a sentence in the body because the plan
+* phase writes it and the board reads it: a parent chip, a subtask list and
+* "does this still have unfinished children" are all questions about the graph,
+* and prose cannot be asked them. Stored as the parent's UUID, but accepted as
+* either a UUID or a readable id on the way in - a planning agent works in
+* `P4-12`, and making it look up a UUID first is a round trip for nothing.
+*
+* One level is all this promises. Nothing forbids a subtask of a subtask, and
+* nothing walks the chain either; the board renders the direct children of a
+* task and stops.
+*/
+const ParentTaskIdField = TaskId.pipe(Schema$1.annotateEncoded({ description: "The task this one is a subtask of - the parent's UUID or readable id (e.g. P4-12). Null for a task that is not part of a larger one." }));
+const LabelsField = Schema$1.Array(TaskLabel).check(Schema$1.isMaxLength(TASK_LABELS_MAX_COUNT)).pipe(Schema$1.annotateEncoded({ description: "Free-form tags used to group and filter tasks." }));
+const TaskIdField = TaskId.pipe(Schema$1.annotateEncoded({ description: "Id of the task to act on - the UUID or the readable id (e.g. P4-12)." }));
+const Task = Schema$1.Struct({
+	taskId: TaskId,
+	/**
+	* The human-readable id, e.g. `T-1` or `P4-12`: a per-prefix sequence
+	* allocated by the store that owns the row, never reused, with gaps where
+	* tasks were deleted. Nullable only for version skew - a row read from a
+	* store that has not run the backfill migration decodes to `null` rather
+	* than failing the whole board.
+	*/
+	readableId: Schema$1.NullOr(TrimmedNonEmptyString).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
+	/**
+	* Manual board position: a lexicographic fractional key, compared as a plain
+	* string, smaller first. Written only when a card is dragged to a position;
+	* `null` means "never placed by hand" and the board falls back to its
+	* priority/recency order. Nullable-with-default for the same version-skew
+	* reason as `readableId`: a row from a store without the migration decodes to
+	* `null` rather than failing the whole board.
+	*/
+	orderKey: Schema$1.NullOr(TrimmedNonEmptyString).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
+	/**
+	* The project this task belongs to, or `null` for a task that is not scoped
+	* to one. This references the existing workspace project registry rather than
+	* a task-board-private notion of a project.
+	*/
+	projectId: Schema$1.NullOr(ProjectId),
+	/**
+	* Canonical repository key, resolved server-side from `projectId` when the
+	* task is written. This is the field that survives a move to another machine;
+	* `projectId` above is a local pointer and is meaningless on a server that
+	* did not mint it. A board reading a shared task matches on this and looks up
+	* whatever local project shares the key.
+	*/
+	repositoryKey: Schema$1.NullOr(TrimmedNonEmptyString),
+	/**
+	* The thread currently working this task, or `null`. A task links to at most
+	* one thread at a time; re-running a task repoints this rather than appending
+	* to a history.
+	*/
+	threadId: Schema$1.NullOr(ThreadId),
+	/**
+	* The tracker issue this row is, for a row read from a tracker, and `null`
+	* for every row on p4code's own board. Nullable-with-default because the
+	* board's own store has no such column at all - a row read from SQLite
+	* decodes to `null` rather than failing the whole board.
+	*/
+	externalRef: Schema$1.NullOr(TaskExternalRef).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
+	/**
+	* The task this one was split out of, always as a UUID once stored - a
+	* readable id given on the way in is resolved before the row is written, so
+	* the link survives a board where readable ids were allocated elsewhere.
+	* Nullable-with-default for the same version-skew reason as `readableId`.
+	*/
+	parentTaskId: Schema$1.NullOr(TaskId).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
+	title: TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_TITLE_MAX_LENGTH)),
+	body: Schema$1.String,
+	status: StoredStatusField,
+	priority: TaskPriority,
+	assignee: Schema$1.NullOr(TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_ASSIGNEE_MAX_LENGTH))),
+	labels: Schema$1.Array(TaskLabel).check(Schema$1.isMaxLength(TASK_LABELS_MAX_COUNT)),
+	createdAt: IsoDateTime,
+	updatedAt: IsoDateTime
+});
+const TaskCreateInput = Schema$1.Struct({
+	projectId: Schema$1.optional(ProjectIdField),
+	repositoryKey: Schema$1.optional(RepositoryKeyField),
+	threadId: Schema$1.optional(ThreadIdField),
+	parentTaskId: Schema$1.optional(ParentTaskIdField),
+	title: TitleField,
+	body: Schema$1.optional(BodyField),
+	status: Schema$1.optional(StatusField),
+	priority: Schema$1.optional(PriorityField),
+	assignee: Schema$1.optional(AssigneeField),
+	labels: Schema$1.optional(LabelsField)
+});
+/**
+* What an environment server sends the hub to file a task.
+*
+* Extends the public create input with the readable-id prefix, because the two
+* halves of the answer live on different machines: the prefix comes from the
+* project's checked-in `p4.json`, which only the submitting server can read,
+* while the sequence number must be allocated by the hub, which is the only
+* party that sees every machine's writes. Deliberately not part of
+* `TaskCreateInput` itself so an agent filing over MCP cannot pick a prefix -
+* the prefix belongs to the project, not to the caller.
+*/
+const HubTaskCreateInput = Schema$1.Struct({
+	...TaskCreateInput.fields,
+	readableIdPrefix: Schema$1.optional(TrimmedNonEmptyString),
+	/**
+	* Carried on the hub's create route (but not the public one) so a server
+	* mirroring an already-placed row to the hub does not lose its position.
+	* An agent filing a new task has no business picking a slot.
+	*/
+	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),
+	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.
+*/
+const TaskUpdateInput = Schema$1.Struct({
+	taskId: TaskIdField,
+	projectId: Schema$1.optional(Schema$1.NullOr(ProjectIdField)),
+	repositoryKey: Schema$1.optional(Schema$1.NullOr(RepositoryKeyField)),
+	threadId: Schema$1.optional(Schema$1.NullOr(ThreadIdField)),
+	parentTaskId: Schema$1.optional(Schema$1.NullOr(ParentTaskIdField)),
+	title: Schema$1.optional(TitleField),
+	body: Schema$1.optional(BodyField),
+	status: Schema$1.optional(StatusField),
+	priority: Schema$1.optional(PriorityField),
+	assignee: Schema$1.optional(Schema$1.NullOr(AssigneeField)),
+	labels: Schema$1.optional(LabelsField),
+	orderKey: Schema$1.optional(Schema$1.NullOr(OrderKeyField))
+});
+/**
+* A task an agent has drafted but has not filed.
+*
+* Mirrors `TaskCreateInput` minus the fields the proposer has no business
+* setting. `status` is absent on purpose: a confirmed proposal always lands in
+* `backlog`, so an interviewing agent cannot queue its own work — the property
+* the board's pick-up relies on. `taskId`, `threadId` and `repositoryKey` are
+* absent because they are minted or derived when the proposal is accepted, not
+* offered by the model.
+*/
+const TaskProposeInput = Schema$1.Struct({
+	projectId: Schema$1.optional(ProjectIdField),
+	title: TitleField,
+	body: Schema$1.optional(BodyField),
+	priority: Schema$1.optional(PriorityField),
+	assignee: Schema$1.optional(AssigneeField),
+	labels: Schema$1.optional(LabelsField)
+});
+/**
+* What `task_propose` returns. The tool writes nothing; its only effect is the
+* card the client renders from the call itself, so the result exists to tell
+* the model that nothing has been filed yet and it should stop and wait.
+*/
+const TaskProposeResult = Schema$1.Struct({ awaitingConfirmation: Schema$1.Literal(true) });
+/**
+* Parameters for `task_current`. The thread defaults to the caller's own, which
+* is the point of the tool — an agent does not know its own thread id. It is
+* still a real parameter rather than an empty struct because an empty struct
+* generates a root `anyOf` JSON Schema that some providers reject outright.
+*/
+const TaskCurrentInput = Schema$1.Struct({ threadId: Schema$1.optional(ThreadId.pipe(Schema$1.annotateEncoded({ description: "Thread whose linked task to read. Defaults to this agent session's own thread." }))) });
+/** Parameters for reading or targeting a single task by id. */
+const TaskGetInput = Schema$1.Struct({ taskId: TaskIdField });
+const TaskListFilter = Schema$1.Struct({
+	projectId: Schema$1.optional(ProjectIdField),
+	repositoryKey: Schema$1.optional(RepositoryKeyField),
+	threadId: Schema$1.optional(ThreadIdField),
+	status: Schema$1.optional(StatusField),
+	assignee: Schema$1.optional(AssigneeField)
+});
+Schema$1.Union([Schema$1.Struct({
+	type: Schema$1.Literal("upserted"),
+	task: Task
+}), Schema$1.Struct({
+	type: Schema$1.Literal("deleted"),
+	taskId: TaskId
+})]);
+/**
+* What a board subscription carries: the current board, then every change.
+*
+* The snapshot rides on the stream rather than being fetched separately
+* because a list call followed by a subscribe has a gap — anything committed
+* between the two is lost, and the board then shows stale rows until something
+* else happens to touch them. The server takes the snapshot *after* it has
+* subscribed, so the worst case is an event the subscriber already has, which
+* is idempotent, rather than one it never sees.
+*/
+const TaskStreamEvent = Schema$1.Union([
+	Schema$1.Struct({
+		type: Schema$1.Literal("snapshot"),
+		tasks: Schema$1.Array(Task)
+	}),
+	Schema$1.Struct({
+		type: Schema$1.Literal("upserted"),
+		task: Task
+	}),
+	Schema$1.Struct({
+		type: Schema$1.Literal("deleted"),
+		taskId: TaskId
+	})
+]);
+Schema$1.Struct({
+	patch: TaskUpdateInput,
+	/** The status the caller believes the task is in. */
+	expectedStatus: TaskStatus
+});
+Schema$1.Union([
+	Schema$1.Struct({
+		outcome: Schema$1.Literal("updated"),
+		task: Task
+	}),
+	Schema$1.Struct({ outcome: Schema$1.Literal("missing") }),
+	Schema$1.Struct({
+		outcome: Schema$1.Literal("conflict"),
+		current: Task
+	})
+]);
+/**
+* Start an agent on a task.
+*
+* The input is only the task, deliberately. Everything else the thread needs —
+* which project, which model, what prompt — is resolved server-side from the
+* task's own project, because the caller that matters next is not a person
+* clicking a button but Phase 12's orchestrator, and a client that supplies the
+* model is a client that can start a task on a provider the user does not use.
+*
+* Worktrees are absent for a harder reason: `prepareWorktree` needs a base
+* branch, a task carries none, and nothing resolves one server-side. A thread
+* started from a task therefore runs in the project's own checkout.
+*/
+const TaskStartThreadInput = Schema$1.Struct({ taskId: TaskIdField });
+/**
+* The started thread and the task as it now stands.
+*
+* Both are returned because both changed: the caller navigates to the thread,
+* and the board would otherwise show the old status until the change event
+* arrived.
+*/
+const TaskStartThreadResult = Schema$1.Struct({
+	task: Task,
+	threadId: ThreadId
+});
+/**
+* A task cannot be started, and the reason is a property of the task or the
+* server rather than a failure.
+*
+* Each reason is a different thing for the user to fix, which is why this is a
+* union and not one message. `no-model` is the one worth explaining: a task
+* carries no model selection, so the thread runs on the project's default. The
+* server-side fallback that exists for first-run bootstrap is deliberately not
+* used here — it hardcodes a provider, so reaching for it would silently start
+* someone who works in Claude on Codex. Failing is the honest answer.
+*/
+const TaskNotStartableReason = Schema$1.Literals([
+	"no-project",
+	"project-missing",
+	"no-model"
+]);
+var TaskNotStartableError = class extends Schema$1.TaggedErrorClass()("TaskNotStartableError", {
+	taskId: TaskId,
+	reason: TaskNotStartableReason
+}) {
+	get message() {
+		switch (this.reason) {
+			case "no-project": return "This task has no project, so there is nowhere to run it. Set a project on the task first.";
+			case "project-missing": return "This task's project is not registered on this server. Point it at a project that is.";
+			case "no-model": return "This task's project has no default model. Choose one in the project's settings, then start the task again.";
+		}
+	}
+};
+/** Result shape for the board's list RPC. */
+const TaskListResult$1 = Schema$1.Struct({ tasks: Schema$1.Array(Task) });
+/** Result shape for every RPC that resolves to a single task. */
+const TaskResult = Schema$1.Struct({ task: Task });
+/** `get` distinguishes "no such task" from an error, so the task is nullable. */
+const TaskGetResult = Schema$1.Struct({ task: Schema$1.NullOr(Task) });
+var TaskToolUnavailableError = class extends Schema$1.TaggedErrorClass()("TaskToolUnavailableError", {
+	capability: Schema$1.Literal("tasks"),
+	environmentId: EnvironmentId,
+	threadId: ThreadId,
+	providerSessionId: TrimmedNonEmptyString,
+	providerInstanceId: ProviderInstanceId
+}) {
+	get message() {
+		return `MCP credential does not grant the ${this.capability} capability.`;
+	}
+};
+var TaskNotFoundError = class extends Schema$1.TaggedErrorClass()("TaskNotFoundError", { taskId: TaskId }) {
+	get message() {
+		return `No task exists with id ${this.taskId}.`;
+	}
+};
+/**
+* A task tool hit the store and the store failed. The underlying persistence
+* error is deliberately not surfaced to the agent — it carries SQL detail that
+* is noise in a tool result — but it is logged server-side.
+*/
+var TaskStoreError = class extends Schema$1.TaggedErrorClass()("TaskStoreError", { operation: TrimmedNonEmptyString }) {
+	get message() {
+		return `The task store failed during ${this.operation}.`;
+	}
+};
+/**
+* No task is linked to the calling agent's thread.
+*/
+var TaskNotLinkedError = class extends Schema$1.TaggedErrorClass()("TaskNotLinkedError", { threadId: ThreadId }) {
+	get message() {
+		return `No task is linked to thread ${this.threadId}.`;
+	}
+};
+const TaskToolError = Schema$1.Union([
+	TaskToolUnavailableError,
+	TaskNotFoundError,
+	TaskNotLinkedError,
+	TaskStoreError
+]);
+//#endregion
 //#region ../../packages/contracts/src/settings.ts
 const TimestampFormat = Schema$1.Literals([
 	"locale",
@@ -5978,6 +6481,12 @@ 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))),
+	/** Prefix used for tasks without a project or project-specific override. */
+	defaultTaskPrefix: TaskReadableIdPrefix.pipe(Schema$1.withDecodingDefault(Effect.succeed("T"))),
+	/** Linear issue identifier prefixes. Empty leaves Linear references unclaimed. */
+	linearTaskPrefixes: Schema$1.Array(TaskReadableIdPrefix).pipe(Schema$1.withDecodingDefault(Effect.succeed([]))),
+	/** Local task-id prefix overrides keyed by this environment's project id. */
+	projectTaskPrefixes: Schema$1.Record(ProjectId, TaskReadableIdPrefix).pipe(Schema$1.withDecodingDefault(Effect.succeed({}))),
 	/**
 	* The Linear team new issues are filed into, by name or id.
 	*
@@ -6113,6 +6622,9 @@ const ServerSettingsPatch = Schema$1.Struct({
 		followChangeRequestTemplates: Schema$1.optionalKey(Schema$1.Boolean)
 	})),
 	sourceControlWriterModelSelection: Schema$1.optionalKey(Schema$1.NullOr(ModelSelection)),
+	defaultTaskPrefix: Schema$1.optionalKey(TaskReadableIdPrefix),
+	linearTaskPrefixes: Schema$1.optionalKey(Schema$1.Array(TaskReadableIdPrefix)),
+	projectTaskPrefixes: Schema$1.optionalKey(Schema$1.Record(ProjectId, TaskReadableIdPrefix)),
 	disabledSkills: Schema$1.optionalKey(Schema$1.Array(TrimmedNonEmptyString)),
 	linearTeam: Schema$1.optionalKey(TrimmedString),
 	observability: Schema$1.optionalKey(Schema$1.Struct({
@@ -7263,509 +7775,6 @@ const GitActionProgressEvent = Schema$1.Union([
 	GitActionFailedEvent
 ]);
 //#endregion
-//#region ../../packages/contracts/src/task.ts
-const TASK_TITLE_MAX_LENGTH = 512;
-const TASK_LABEL_MAX_LENGTH = 64;
-const TASK_LABELS_MAX_COUNT = 32;
-const TASK_ASSIGNEE_MAX_LENGTH = 128;
-/**
-* Board columns, in board order. `backlog` is the default for newly created
-* tasks — an agent filing a task mid-session is recording work that exists, not
-* committing to doing it next.
-*
-* `cancelled` is the other way a task closes: decided against, superseded or
-* merged into another task. Marking such a task `done` is the workaround it
-* replaces, and it lies - a board that says five things finished when two of
-* them were dropped is not worth reading.
-*/
-const TaskStatus = Schema$1.Literals([
-	"backlog",
-	"todo",
-	"in_progress",
-	"in_review",
-	"done",
-	"cancelled"
-]);
-/**
-* What a status this build has never heard of decodes to when read back.
-*
-* `backlog` is the least dishonest guess: it says "recorded, nothing claimed
-* about it", which is true of a status we cannot interpret. Guessing `done` or
-* `cancelled` would claim the task is closed.
-*/
-const UNKNOWN_TASK_STATUS_FALLBACK = "backlog";
-const TaskPriority = Schema$1.Literals([
-	"none",
-	"low",
-	"medium",
-	"high",
-	"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.
-*/
-const TASK_READABLE_ID_PREFIX_PATTERN = /^[A-Za-z][A-Za-z0-9]{0,9}$/;
-/**
-* The shape of a readable task id: prefix, dash, 1-based sequence number.
-* Deliberately disjoint from the UUID `taskId`, which is what lets a lookup
-* accept either and tell them apart by shape alone.
-*/
-const TASK_READABLE_ID_PATTERN = /^[A-Za-z][A-Za-z0-9]{0,9}-[1-9][0-9]*$/;
-/** Whether a task reference is a readable id (`P4-12`) rather than a UUID. */
-const isReadableTaskId = (reference) => TASK_READABLE_ID_PATTERN.test(reference);
-const TaskLabel = TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_LABEL_MAX_LENGTH));
-/**
-* Agent-facing field descriptions. These ride on the *encoded* side because
-* every one of these schemas is a brand or a check over a transformation, and
-* the JSON Schema an agent actually reads is generated from the encoded schema
-* — a plain `.annotate` on the decoded side is silently dropped.
-*/
-const ProjectIdField = ProjectId.pipe(Schema$1.annotateEncoded({ description: "Id of the project this task belongs to." }));
-const ThreadIdField = ThreadId.pipe(Schema$1.annotateEncoded({ description: "Id of the agent thread working this task." }));
-const TitleField = TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_TITLE_MAX_LENGTH)).pipe(Schema$1.annotateEncoded({ description: "One-line summary of the work. Required." }));
-const BodyField = Schema$1.String.pipe(Schema$1.annotateEncoded({ description: "Markdown detail: context, acceptance criteria, links." }));
-const StatusField = TaskStatus.pipe(Schema$1.annotateEncoded({ description: "Board column: backlog (recorded, not queued), todo (queued next), in_progress, in_review, done, cancelled (closed without doing the work)." }));
-/**
-* The status as read back from a store, tolerant of values this build predates.
-*
-* A board can be shared between machines running different versions, and a
-* newer peer may write a status added after this client shipped. A strict
-* literal would fail the decode of the whole page, so one unknown row would
-* blank the board behind a "hub is unavailable" error rather than degrade. An
-* unrecognized status therefore decodes to {@link UNKNOWN_TASK_STATUS_FALLBACK},
-* same spirit as the nullable `readableId` and `orderKey` below. Encoding stays
-* strict: this client can only ever write a status it knows.
-*/
-const StoredStatusField = TaskStatus.pipe(Schema$1.catchDecoding(() => Effect.succeedSome(UNKNOWN_TASK_STATUS_FALLBACK)));
-const PriorityField = TaskPriority.pipe(Schema$1.annotateEncoded({ description: "Relative urgency: none, low, medium, high or urgent." }));
-const AssigneeField = TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_ASSIGNEE_MAX_LENGTH)).pipe(Schema$1.annotateEncoded({ description: "Who owns the task — a person's handle or an agent name." }));
-/**
-* The portable half of "which repository is this task about".
-*
-* `projectId` cannot answer that across machines: it is a UUID minted when a
-* project is added, and the same checkout added on two servers gets two
-* different ids. A canonical repository key — the normalized primary git remote
-* — is the same string wherever the repo is cloned, so it survives the trip
-* through a shared board.
-*
-* Null for a task that is not about a repository, and also for a checkout with
-* no remote, where there is nothing stable to key on.
-*/
-const RepositoryKeyField = TrimmedNonEmptyString.pipe(Schema$1.annotateEncoded({ description: "Canonical repository key (normalized git remote, e.g. github.com/owner/repo). Portable across machines, unlike projectId." }));
-/**
-* Manual board position within a column, as a lexicographic fractional key.
-*
-* Compared as a plain string: smaller sorts higher. Keys are minted by the
-* board between the neighbours of a drop, so moving one card writes one row
-* rather than renumbering the column. `null` means the task has never been
-* placed by hand and falls back to the priority/recency order.
-*/
-const OrderKeyField = TrimmedNonEmptyString.pipe(Schema$1.annotateEncoded({ description: "Manual board position key. Lexicographic: smaller sorts higher in the column. Null means no manual position." }));
-/**
-* Which tracker issue a row *is*, for a row read out of a tracker.
-*
-* The identifier is the tracker's own, not ours: `MOBILE-12262` reads the same
-* in p4code as it does in Linear, in a commit message, and in conversation,
-* which is the whole point of carrying it. `url` is what the tracker itself
-* reported, never a guess assembled from the identifier - a Linear URL embeds
-* the workspace slug, so a constructed one would 404.
-*
-* Read-only, and only ever set by the `linear` source. p4code's own board does
-* not copy tracker issues into rows of its own: a ticket is read where it lives
-* and shown under the id its tracker gave it, which is why nothing here appears
-* in a create or update input.
-*/
-const TaskExternalRef = Schema$1.Struct({
-	source: Schema$1.Literals(["linear"]),
-	identifier: TrimmedNonEmptyString,
-	url: TrimmedNonEmptyString
-});
-/**
-* The task this one was split out of.
-*
-* Carried as a field rather than as a sentence in the body because the plan
-* phase writes it and the board reads it: a parent chip, a subtask list and
-* "does this still have unfinished children" are all questions about the graph,
-* and prose cannot be asked them. Stored as the parent's UUID, but accepted as
-* either a UUID or a readable id on the way in - a planning agent works in
-* `P4-12`, and making it look up a UUID first is a round trip for nothing.
-*
-* One level is all this promises. Nothing forbids a subtask of a subtask, and
-* nothing walks the chain either; the board renders the direct children of a
-* task and stops.
-*/
-const ParentTaskIdField = TaskId.pipe(Schema$1.annotateEncoded({ description: "The task this one is a subtask of - the parent's UUID or readable id (e.g. P4-12). Null for a task that is not part of a larger one." }));
-const LabelsField = Schema$1.Array(TaskLabel).check(Schema$1.isMaxLength(TASK_LABELS_MAX_COUNT)).pipe(Schema$1.annotateEncoded({ description: "Free-form tags used to group and filter tasks." }));
-const TaskIdField = TaskId.pipe(Schema$1.annotateEncoded({ description: "Id of the task to act on - the UUID or the readable id (e.g. P4-12)." }));
-const Task = Schema$1.Struct({
-	taskId: TaskId,
-	/**
-	* The human-readable id, e.g. `T-1` or `P4-12`: a per-prefix sequence
-	* allocated by the store that owns the row, never reused, with gaps where
-	* tasks were deleted. Nullable only for version skew - a row read from a
-	* store that has not run the backfill migration decodes to `null` rather
-	* than failing the whole board.
-	*/
-	readableId: Schema$1.NullOr(TrimmedNonEmptyString).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
-	/**
-	* Manual board position: a lexicographic fractional key, compared as a plain
-	* string, smaller first. Written only when a card is dragged to a position;
-	* `null` means "never placed by hand" and the board falls back to its
-	* priority/recency order. Nullable-with-default for the same version-skew
-	* reason as `readableId`: a row from a store without the migration decodes to
-	* `null` rather than failing the whole board.
-	*/
-	orderKey: Schema$1.NullOr(TrimmedNonEmptyString).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
-	/**
-	* The project this task belongs to, or `null` for a task that is not scoped
-	* to one. This references the existing workspace project registry rather than
-	* a task-board-private notion of a project.
-	*/
-	projectId: Schema$1.NullOr(ProjectId),
-	/**
-	* Canonical repository key, resolved server-side from `projectId` when the
-	* task is written. This is the field that survives a move to another machine;
-	* `projectId` above is a local pointer and is meaningless on a server that
-	* did not mint it. A board reading a shared task matches on this and looks up
-	* whatever local project shares the key.
-	*/
-	repositoryKey: Schema$1.NullOr(TrimmedNonEmptyString),
-	/**
-	* The thread currently working this task, or `null`. A task links to at most
-	* one thread at a time; re-running a task repoints this rather than appending
-	* to a history.
-	*/
-	threadId: Schema$1.NullOr(ThreadId),
-	/**
-	* The tracker issue this row is, for a row read from a tracker, and `null`
-	* for every row on p4code's own board. Nullable-with-default because the
-	* board's own store has no such column at all - a row read from SQLite
-	* decodes to `null` rather than failing the whole board.
-	*/
-	externalRef: Schema$1.NullOr(TaskExternalRef).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
-	/**
-	* The task this one was split out of, always as a UUID once stored - a
-	* readable id given on the way in is resolved before the row is written, so
-	* the link survives a board where readable ids were allocated elsewhere.
-	* Nullable-with-default for the same version-skew reason as `readableId`.
-	*/
-	parentTaskId: Schema$1.NullOr(TaskId).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
-	title: TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_TITLE_MAX_LENGTH)),
-	body: Schema$1.String,
-	status: StoredStatusField,
-	priority: TaskPriority,
-	assignee: Schema$1.NullOr(TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_ASSIGNEE_MAX_LENGTH))),
-	labels: Schema$1.Array(TaskLabel).check(Schema$1.isMaxLength(TASK_LABELS_MAX_COUNT)),
-	createdAt: IsoDateTime,
-	updatedAt: IsoDateTime
-});
-const TaskCreateInput = Schema$1.Struct({
-	projectId: Schema$1.optional(ProjectIdField),
-	repositoryKey: Schema$1.optional(RepositoryKeyField),
-	threadId: Schema$1.optional(ThreadIdField),
-	parentTaskId: Schema$1.optional(ParentTaskIdField),
-	title: TitleField,
-	body: Schema$1.optional(BodyField),
-	status: Schema$1.optional(StatusField),
-	priority: Schema$1.optional(PriorityField),
-	assignee: Schema$1.optional(AssigneeField),
-	labels: Schema$1.optional(LabelsField)
-});
-/**
-* What an environment server sends the hub to file a task.
-*
-* Extends the public create input with the readable-id prefix, because the two
-* halves of the answer live on different machines: the prefix comes from the
-* project's checked-in `p4.json`, which only the submitting server can read,
-* while the sequence number must be allocated by the hub, which is the only
-* party that sees every machine's writes. Deliberately not part of
-* `TaskCreateInput` itself so an agent filing over MCP cannot pick a prefix -
-* the prefix belongs to the project, not to the caller.
-*/
-const HubTaskCreateInput = Schema$1.Struct({
-	...TaskCreateInput.fields,
-	readableIdPrefix: Schema$1.optional(TrimmedNonEmptyString),
-	/**
-	* Carried on the hub's create route (but not the public one) so a server
-	* mirroring an already-placed row to the hub does not lose its position.
-	* An agent filing a new task has no business picking a slot.
-	*/
-	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),
-	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.
-*/
-const TaskUpdateInput = Schema$1.Struct({
-	taskId: TaskIdField,
-	projectId: Schema$1.optional(Schema$1.NullOr(ProjectIdField)),
-	repositoryKey: Schema$1.optional(Schema$1.NullOr(RepositoryKeyField)),
-	threadId: Schema$1.optional(Schema$1.NullOr(ThreadIdField)),
-	parentTaskId: Schema$1.optional(Schema$1.NullOr(ParentTaskIdField)),
-	title: Schema$1.optional(TitleField),
-	body: Schema$1.optional(BodyField),
-	status: Schema$1.optional(StatusField),
-	priority: Schema$1.optional(PriorityField),
-	assignee: Schema$1.optional(Schema$1.NullOr(AssigneeField)),
-	labels: Schema$1.optional(LabelsField),
-	orderKey: Schema$1.optional(Schema$1.NullOr(OrderKeyField))
-});
-/**
-* A task an agent has drafted but has not filed.
-*
-* Mirrors `TaskCreateInput` minus the fields the proposer has no business
-* setting. `status` is absent on purpose: a confirmed proposal always lands in
-* `backlog`, so an interviewing agent cannot queue its own work — the property
-* the board's pick-up relies on. `taskId`, `threadId` and `repositoryKey` are
-* absent because they are minted or derived when the proposal is accepted, not
-* offered by the model.
-*/
-const TaskProposeInput = Schema$1.Struct({
-	projectId: Schema$1.optional(ProjectIdField),
-	title: TitleField,
-	body: Schema$1.optional(BodyField),
-	priority: Schema$1.optional(PriorityField),
-	assignee: Schema$1.optional(AssigneeField),
-	labels: Schema$1.optional(LabelsField)
-});
-/**
-* What `task_propose` returns. The tool writes nothing; its only effect is the
-* card the client renders from the call itself, so the result exists to tell
-* the model that nothing has been filed yet and it should stop and wait.
-*/
-const TaskProposeResult = Schema$1.Struct({ awaitingConfirmation: Schema$1.Literal(true) });
-/**
-* Parameters for `task_current`. The thread defaults to the caller's own, which
-* is the point of the tool — an agent does not know its own thread id. It is
-* still a real parameter rather than an empty struct because an empty struct
-* generates a root `anyOf` JSON Schema that some providers reject outright.
-*/
-const TaskCurrentInput = Schema$1.Struct({ threadId: Schema$1.optional(ThreadId.pipe(Schema$1.annotateEncoded({ description: "Thread whose linked task to read. Defaults to this agent session's own thread." }))) });
-/** Parameters for reading or targeting a single task by id. */
-const TaskGetInput = Schema$1.Struct({ taskId: TaskIdField });
-const TaskListFilter = Schema$1.Struct({
-	projectId: Schema$1.optional(ProjectIdField),
-	repositoryKey: Schema$1.optional(RepositoryKeyField),
-	threadId: Schema$1.optional(ThreadIdField),
-	status: Schema$1.optional(StatusField),
-	assignee: Schema$1.optional(AssigneeField)
-});
-Schema$1.Union([Schema$1.Struct({
-	type: Schema$1.Literal("upserted"),
-	task: Task
-}), Schema$1.Struct({
-	type: Schema$1.Literal("deleted"),
-	taskId: TaskId
-})]);
-/**
-* What a board subscription carries: the current board, then every change.
-*
-* The snapshot rides on the stream rather than being fetched separately
-* because a list call followed by a subscribe has a gap — anything committed
-* between the two is lost, and the board then shows stale rows until something
-* else happens to touch them. The server takes the snapshot *after* it has
-* subscribed, so the worst case is an event the subscriber already has, which
-* is idempotent, rather than one it never sees.
-*/
-const TaskStreamEvent = Schema$1.Union([
-	Schema$1.Struct({
-		type: Schema$1.Literal("snapshot"),
-		tasks: Schema$1.Array(Task)
-	}),
-	Schema$1.Struct({
-		type: Schema$1.Literal("upserted"),
-		task: Task
-	}),
-	Schema$1.Struct({
-		type: Schema$1.Literal("deleted"),
-		taskId: TaskId
-	})
-]);
-Schema$1.Struct({
-	patch: TaskUpdateInput,
-	/** The status the caller believes the task is in. */
-	expectedStatus: TaskStatus
-});
-Schema$1.Union([
-	Schema$1.Struct({
-		outcome: Schema$1.Literal("updated"),
-		task: Task
-	}),
-	Schema$1.Struct({ outcome: Schema$1.Literal("missing") }),
-	Schema$1.Struct({
-		outcome: Schema$1.Literal("conflict"),
-		current: Task
-	})
-]);
-/**
-* Start an agent on a task.
-*
-* The input is only the task, deliberately. Everything else the thread needs —
-* which project, which model, what prompt — is resolved server-side from the
-* task's own project, because the caller that matters next is not a person
-* clicking a button but Phase 12's orchestrator, and a client that supplies the
-* model is a client that can start a task on a provider the user does not use.
-*
-* Worktrees are absent for a harder reason: `prepareWorktree` needs a base
-* branch, a task carries none, and nothing resolves one server-side. A thread
-* started from a task therefore runs in the project's own checkout.
-*/
-const TaskStartThreadInput = Schema$1.Struct({ taskId: TaskIdField });
-/**
-* The started thread and the task as it now stands.
-*
-* Both are returned because both changed: the caller navigates to the thread,
-* and the board would otherwise show the old status until the change event
-* arrived.
-*/
-const TaskStartThreadResult = Schema$1.Struct({
-	task: Task,
-	threadId: ThreadId
-});
-/**
-* A task cannot be started, and the reason is a property of the task or the
-* server rather than a failure.
-*
-* Each reason is a different thing for the user to fix, which is why this is a
-* union and not one message. `no-model` is the one worth explaining: a task
-* carries no model selection, so the thread runs on the project's default. The
-* server-side fallback that exists for first-run bootstrap is deliberately not
-* used here — it hardcodes a provider, so reaching for it would silently start
-* someone who works in Claude on Codex. Failing is the honest answer.
-*/
-const TaskNotStartableReason = Schema$1.Literals([
-	"no-project",
-	"project-missing",
-	"no-model"
-]);
-var TaskNotStartableError = class extends Schema$1.TaggedErrorClass()("TaskNotStartableError", {
-	taskId: TaskId,
-	reason: TaskNotStartableReason
-}) {
-	get message() {
-		switch (this.reason) {
-			case "no-project": return "This task has no project, so there is nowhere to run it. Set a project on the task first.";
-			case "project-missing": return "This task's project is not registered on this server. Point it at a project that is.";
-			case "no-model": return "This task's project has no default model. Choose one in the project's settings, then start the task again.";
-		}
-	}
-};
-/** Result shape for the board's list RPC. */
-const TaskListResult$1 = Schema$1.Struct({ tasks: Schema$1.Array(Task) });
-/** Result shape for every RPC that resolves to a single task. */
-const TaskResult = Schema$1.Struct({ task: Task });
-/** `get` distinguishes "no such task" from an error, so the task is nullable. */
-const TaskGetResult = Schema$1.Struct({ task: Schema$1.NullOr(Task) });
-var TaskToolUnavailableError = class extends Schema$1.TaggedErrorClass()("TaskToolUnavailableError", {
-	capability: Schema$1.Literal("tasks"),
-	environmentId: EnvironmentId,
-	threadId: ThreadId,
-	providerSessionId: TrimmedNonEmptyString,
-	providerInstanceId: ProviderInstanceId
-}) {
-	get message() {
-		return `MCP credential does not grant the ${this.capability} capability.`;
-	}
-};
-var TaskNotFoundError = class extends Schema$1.TaggedErrorClass()("TaskNotFoundError", { taskId: TaskId }) {
-	get message() {
-		return `No task exists with id ${this.taskId}.`;
-	}
-};
-/**
-* A task tool hit the store and the store failed. The underlying persistence
-* error is deliberately not surfaced to the agent — it carries SQL detail that
-* is noise in a tool result — but it is logged server-side.
-*/
-var TaskStoreError = class extends Schema$1.TaggedErrorClass()("TaskStoreError", { operation: TrimmedNonEmptyString }) {
-	get message() {
-		return `The task store failed during ${this.operation}.`;
-	}
-};
-/**
-* No task is linked to the calling agent's thread.
-*/
-var TaskNotLinkedError = class extends Schema$1.TaggedErrorClass()("TaskNotLinkedError", { threadId: ThreadId }) {
-	get message() {
-		return `No task is linked to thread ${this.threadId}.`;
-	}
-};
-const TaskToolError = Schema$1.Union([
-	TaskToolUnavailableError,
-	TaskNotFoundError,
-	TaskNotLinkedError,
-	TaskStoreError
-]);
-//#endregion
 //#region ../../packages/contracts/src/p4ProjectFile.ts
 /** File name of the checked-in P4 project file, resolved at the workspace root. */
 const P4_PROJECT_FILE_NAME = "p4.json";
@@ -7790,7 +7799,7 @@ const P4ProjectFile = Schema$1.Struct({
 	$schema: Schema$1.optionalKey(Schema$1.String.annotate({ description: `URL of the JSON Schema for this file, typically "${P4_PROJECT_FILE_SCHEMA_URL}".` })),
 	iconPath: Schema$1.optionalKey(trimmedNonEmpty({ description: "Workspace-relative path to the project icon (e.g. \"assets/logo.svg\"). Checked before P4Code's built-in icon locations." }, P4_PROJECT_FILE_PATH_MAX_LENGTH)),
 	scripts: Schema$1.optionalKey(Schema$1.Array(P4ProjectFileScript).annotate({ description: "Project scripts shared with everyone who opens this repository in P4Code." }).check(Schema$1.isMaxLength(P4_PROJECT_FILE_MAX_SCRIPTS))),
-	taskPrefix: Schema$1.optionalKey(trimmedNonEmpty({ description: "Prefix for this project's readable task ids on the task board (e.g. \"P4\" numbers tasks P4-1, P4-2, ...). Letters and digits, starting with a letter, at most 10 characters; compared case-insensitively. Tasks without a project use \"T\"." }).check(Schema$1.isPattern(TASK_READABLE_ID_PREFIX_PATTERN)))
+	taskPrefix: Schema$1.optionalKey(trimmedNonEmpty({ description: "Checked-in prefix for this project's readable task ids on the task board (e.g. \"P4\" numbers tasks P4-1, P4-2, ...). Letters and digits, starting with a letter, at most 10 characters; compared case-insensitively. A project-specific Settings override takes precedence." }).check(Schema$1.isPattern(TASK_READABLE_ID_PREFIX_PATTERN)))
 }).annotate({
 	title: "P4 project file",
 	description: "Checked-in project configuration for P4Code (p4.json at the repository root). See https://p4.codes for documentation."
@@ -37552,22 +37561,36 @@ const resolveTaskRepositoryKey = Effect.fn("taskBoard.resolveRepositoryKey")(fun
 	if (Option.isNone(project)) return null;
 	return (yield* (yield* RepositoryIdentityResolver).resolve(project.value.workspaceRoot))?.canonicalKey ?? null;
 });
+/** Resolve configured prefix precedence without filesystem or store effects. */
+function selectTaskReadableIdPrefix(input) {
+	return (input.projectOverride ?? input.projectFilePrefix ?? input.defaultPrefix).toUpperCase();
+}
 /**
 * Resolve the readable-id prefix for a task's project.
 *
-* The prefix lives in the project's checked-in `p4.json` (`taskPrefix`), not in
-* this server's database: it is a property of the repository, agreed on by
-* everyone who clones it, exactly like the scripts beside it. A task with no
-* project, a removed project, or a `p4.json` without the field all fall back to
-* the default `T` - filing the task always beats refusing it over a label.
+* A server setting may override each project. Without one, the checked-in
+* `p4.json` value remains portable across clones. The configured default is
+* used when neither exists, including tasks with no project.
 */
 const resolveTaskReadableIdPrefix = Effect.fn("taskBoard.resolveReadableIdPrefix")(function* (projectId) {
-	if (projectId == null) return "T";
+	const current = yield* (yield* ServerSettingsService).getSettings.pipe(Effect.orElseSucceed(() => ({
+		defaultTaskPrefix: "T",
+		projectTaskPrefixes: {}
+	})));
+	if (projectId == null) return selectTaskReadableIdPrefix({ defaultPrefix: current.defaultTaskPrefix });
+	const override = current.projectTaskPrefixes[projectId];
+	if (override !== void 0) return selectTaskReadableIdPrefix({
+		defaultPrefix: current.defaultTaskPrefix,
+		projectOverride: override
+	});
 	const project = yield* (yield* ProjectionProjectRepository).getById({ projectId }).pipe(Effect.catchCause(() => Effect.succeed(Option.none())));
-	if (Option.isNone(project)) return "T";
+	if (Option.isNone(project)) return selectTaskReadableIdPrefix({ defaultPrefix: current.defaultTaskPrefix });
 	const file = yield* (yield* P4ProjectFileLoader).load(project.value.workspaceRoot);
-	if (Option.isNone(file) || file.value.taskPrefix === void 0) return "T";
-	return file.value.taskPrefix.toUpperCase();
+	if (Option.isNone(file) || file.value.taskPrefix === void 0) return selectTaskReadableIdPrefix({ defaultPrefix: current.defaultTaskPrefix });
+	return selectTaskReadableIdPrefix({
+		defaultPrefix: current.defaultTaskPrefix,
+		projectFilePrefix: file.value.taskPrefix
+	});
 });
 /** Project settings + live snapshots into the two lookups a start needs. */
 const buildTaskStartProviderDefaults = (input) => ({
@@ -88308,14 +88331,22 @@ const writeDependencies = [
 	RepositoryIdentityResolver
 ];
 /**
-* `task_create` also mints the task id (crypto) and resolves the readable-id
-* prefix from the project's checked-in `p4.json` (the file loader).
+* `task_create` also mints the task id, routes to the requested board, and
+* resolves the readable-id prefix from settings or `p4.json`.
 */
 const createDependencies = [
 	...writeDependencies,
 	Crypto.Crypto,
-	P4ProjectFileLoader
+	P4ProjectFileLoader,
+	ServerSettingsService,
+	TaskRepositoryRegistry,
+	ProjectionThreadRepository
 ];
+const TaskCreateToolInput = Schema$1.Struct({
+	...TaskCreateInput.fields,
+	...TaskSourceSelector.fields,
+	linkCurrentThread: Schema$1.optional(Schema$1.Boolean.annotate({ description: "Link the new task or ticket to this conversation. Use this when the user asks to capture the current chat as work." }))
+});
 const TaskListResult = Schema$1.Struct({ tasks: Schema$1.Array(Task) });
 const TaskListTool = Tool.make("task_list", {
 	description: "List tasks on the board, most recently updated first. Every filter is optional and they combine with AND; omit all of them to list every task. Use this to find work rather than guessing task ids.",
@@ -88339,8 +88370,8 @@ const TaskCurrentTool = Tool.make("task_current", {
 	dependencies
 }).annotate(Tool.Title, "Get the current task").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
 const TaskCreateTool = Tool.make("task_create", {
-	description: "File a new task on the board. Defaults to the 'backlog' status, so use this freely to record follow-up work you noticed but are not doing now. Set status to 'todo' only when the work is genuinely queued next.",
-	parameters: TaskCreateInput,
+	description: "File a new task on the p4code board, or a Linear ticket with source 'linear'. Defaults to the 'backlog' status. Set linkCurrentThread to true when the user asks to capture this conversation as a task or ticket; the new row then appears in this chat header. Set status to 'todo' only when the work is genuinely queued next.",
+	parameters: TaskCreateToolInput,
 	success: Task,
 	failure: TaskToolError,
 	dependencies: createDependencies
@@ -88449,16 +88480,25 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 		return current;
 	}),
 	task_create: (input) => Effect.gen(function* () {
-		yield* requireTaskCapability();
-		const tasks = yield* TaskRepository;
+		const invocation = yield* requireTaskCapability();
+		const taskRepositories = yield* TaskRepositoryRegistry;
+		const threads = yield* ProjectionThreadRepository;
+		const { source, linkCurrentThread, ...createInput } = input;
+		const tasks = taskRepositories.forSource(source);
+		const currentProjectId = linkCurrentThread === true && createInput.projectId === void 0 ? Option.getOrUndefined(yield* threads.getById({ threadId: invocation.threadId }).pipe(Effect.catch(toTaskStoreError("task_create:current_thread"))))?.projectId : void 0;
 		const crypto = yield* Crypto.Crypto;
 		const taskId = TaskId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
 		const timestamp = yield* nowIso$1;
-		const repositoryKey = yield* resolveTaskRepositoryKey(input.projectId);
-		const readableIdPrefix = yield* resolveTaskReadableIdPrefix(input.projectId);
-		const parentTaskId = yield* resolveParentTaskId(input.parentTaskId, "task_create");
-		const row = buildTaskRow(parentTaskId === void 0 || parentTaskId === null ? input : {
-			...input,
+		const linkedInput = linkCurrentThread === true ? {
+			...createInput,
+			...currentProjectId === void 0 ? {} : { projectId: currentProjectId },
+			threadId: invocation.threadId
+		} : createInput;
+		const repositoryKey = yield* resolveTaskRepositoryKey(linkedInput.projectId);
+		const readableIdPrefix = yield* resolveTaskReadableIdPrefix(linkedInput.projectId);
+		const parentTaskId = yield* resolveParentTaskId(linkedInput.parentTaskId, "task_create");
+		const row = buildTaskRow(parentTaskId === void 0 || parentTaskId === null ? linkedInput : {
+			...linkedInput,
 			parentTaskId
 		}, taskId, timestamp, repositoryKey);
 		return yield* tasks.create(row, readableIdPrefix).pipe(Effect.catch(toTaskStoreError("task_create")));