@p4code/cli 0.1.6 → 0.1.8

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$73 = () => {
 const layer$69 = Layer.sync(NetService, make$73);
 //#endregion
 //#region package.json
-var version = "0.1.6";
+var version = "0.1.8";
 //#endregion
 //#region src/config.ts
 /**
@@ -5634,22 +5634,11 @@ const ClaudeSettings = makeProviderSettingsSchema({
 			placeholder: "e.g. --chrome",
 			clearWhenEmpty: "omit"
 		}
-	})),
-	/**
-	* The SDK preset system prompt omits the interactive CLI's terminal-tone
-	* sections, so the model tends to open a turn with a tool call instead of
-	* saying what it is about to do. This appends that instruction back.
-	*/
-	narrateBeforeTools: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true)), Schema$1.annotateKey({
-		title: "Explain before tool calls",
-		description: "Ask Claude to write one short sentence before its first tool call in a turn.",
-		providerSettingsForm: { control: "switch" }
 	}))
 }, { order: [
 	"binaryPath",
 	"homePath",
-	"launchArgs",
-	"narrateBeforeTools"
+	"launchArgs"
 ] });
 const CursorSettings = makeProviderSettingsSchema({
 	enabled: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(false)), Schema$1.annotateKey({ providerSettingsForm: { hidden: true } })),
@@ -5735,6 +5724,13 @@ 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))),
+	/**
+	* The Claude SDK preset system prompt omits the interactive CLI's
+	* terminal-tone sections, so the model tends to open a turn with a tool call
+	* instead of saying what it is about to do. This appends that instruction
+	* back for sessions started by the Claude provider.
+	*/
+	enableToolCallNarration: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	automaticGitFetchInterval: Schema$1.DurationFromMillis.pipe(Schema$1.withDecodingDefault(Effect.succeed(Duration.toMillis(DEFAULT_AUTOMATIC_GIT_FETCH_INTERVAL)))),
 	defaultThreadEnvMode: ThreadEnvMode.pipe(Schema$1.withDecodingDefault(Effect.succeed("local"))),
 	newWorktreesStartFromOrigin: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
@@ -5838,8 +5834,7 @@ const ClaudeSettingsPatch = Schema$1.Struct({
 	binaryPath: Schema$1.optionalKey(TrimmedString),
 	homePath: Schema$1.optionalKey(TrimmedString),
 	customModels: Schema$1.optionalKey(Schema$1.Array(Schema$1.String)),
-	launchArgs: Schema$1.optionalKey(TrimmedString),
-	narrateBeforeTools: Schema$1.optionalKey(Schema$1.Boolean)
+	launchArgs: Schema$1.optionalKey(TrimmedString)
 });
 const CursorSettingsPatch = Schema$1.Struct({
 	enabled: Schema$1.optionalKey(Schema$1.Boolean),
@@ -5862,6 +5857,7 @@ const OpenCodeSettingsPatch = Schema$1.Struct({
 const ServerSettingsPatch = Schema$1.Struct({
 	enableAssistantStreaming: Schema$1.optionalKey(Schema$1.Boolean),
 	enableProviderUpdateChecks: Schema$1.optionalKey(Schema$1.Boolean),
+	enableToolCallNarration: Schema$1.optionalKey(Schema$1.Boolean),
 	automaticGitFetchInterval: Schema$1.optionalKey(Schema$1.DurationFromMillis),
 	defaultThreadEnvMode: Schema$1.optionalKey(ThreadEnvMode),
 	newWorktreesStartFromOrigin: Schema$1.optionalKey(Schema$1.Boolean),
@@ -7016,6 +7012,341 @@ 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.
+*/
+const TaskStatus = Schema$1.Literals([
+	"backlog",
+	"todo",
+	"in_progress",
+	"in_review",
+	"done"
+]);
+const TaskPriority = Schema$1.Literals([
+	"none",
+	"low",
+	"medium",
+	"high",
+	"urgent"
+]);
+/**
+* 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." }));
+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." }));
+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))),
+	/**
+	* 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),
+	title: TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_TITLE_MAX_LENGTH)),
+	body: Schema$1.String,
+	status: TaskStatus,
+	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),
+	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)
+});
+/**
+* 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)),
+	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)
+});
+/**
+* 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";
@@ -7039,7 +7370,8 @@ const P4ProjectFileScript = Schema$1.Struct({
 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)))
+	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)))
 }).annotate({
 	title: "P4 project file",
 	description: "Checked-in project configuration for P4Code (p4.json at the repository root). See https://p4.codes for documentation."
@@ -7185,305 +7517,6 @@ var ProjectWriteFileError = class extends Schema$1.TaggedErrorClass()("ProjectWr
 	}
 };
 //#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.
-*/
-const TaskStatus = Schema$1.Literals([
-	"backlog",
-	"todo",
-	"in_progress",
-	"in_review",
-	"done"
-]);
-const TaskPriority = Schema$1.Literals([
-	"none",
-	"low",
-	"medium",
-	"high",
-	"urgent"
-]);
-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." }));
-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." }));
-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." }));
-const Task = Schema$1.Struct({
-	taskId: TaskId,
-	/**
-	* 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),
-	title: TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_TITLE_MAX_LENGTH)),
-	body: Schema$1.String,
-	status: TaskStatus,
-	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),
-	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)
-});
-/**
-* 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)),
-	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)
-});
-/**
-* 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/agentAsset.ts
 /**
 * User-scope agent assets — the things that make an agent behave the same on
@@ -12034,6 +12067,51 @@ var _036_TaskRepositoryKey_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/persistence/Migrations/037_TaskReadableIds.ts
+/**
+* Human-readable task ids (`T-1`, `P4-12`).
+*
+* `task_sequences` holds one row per prefix with the highest number ever
+* handed out. It only grows: deleting a task does not return its number, so a
+* readable id, once uttered, never comes to mean a different task.
+*
+* Existing rows are backfilled with the default `T` prefix in creation order.
+* Their projects' prefixes are deliberately not consulted — a prefix lives in
+* the project's checked-in `p4.json`, and a migration that shells out to read
+* workspaces (which may no longer be on disk) is exactly what a migration
+* should not be. New tasks pick up their project's prefix from creation on.
+*/
+var _037_TaskReadableIds_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`
+    CREATE TABLE IF NOT EXISTS task_sequences (
+      prefix TEXT PRIMARY KEY,
+      last_seq INTEGER NOT NULL
+    )
+  `;
+	yield* sql`ALTER TABLE tasks ADD COLUMN readable_id TEXT`;
+	yield* sql`
+    UPDATE tasks
+    SET readable_id = 'T-' || (
+      SELECT COUNT(*)
+      FROM tasks AS earlier
+      WHERE earlier.created_at < tasks.created_at
+        OR (earlier.created_at = tasks.created_at AND earlier.task_id <= tasks.task_id)
+    )
+    WHERE readable_id IS NULL
+  `;
+	yield* sql`
+    INSERT INTO task_sequences (prefix, last_seq)
+    SELECT 'T', COUNT(*) FROM tasks
+    WHERE true
+    ON CONFLICT (prefix) DO UPDATE SET last_seq = MAX(last_seq, excluded.last_seq)
+  `;
+	yield* sql`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_readable_id
+    ON tasks(readable_id)
+  `;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -12234,6 +12312,11 @@ const migrationEntries = [
 		36,
 		"TaskRepositoryKey",
 		_036_TaskRepositoryKey_default
+	],
+	[
+		37,
+		"TaskReadableIds",
+		_037_TaskReadableIds_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -13857,6 +13940,7 @@ const TaskListQuery = Schema$1.Struct({
 });
 const TASK_COLUMNS = `
   task_id AS "taskId",
+  readable_id AS "readableId",
   project_id AS "projectId",
   repository_key AS "repositoryKey",
   thread_id AS "threadId",
@@ -13878,6 +13962,7 @@ const makeTaskRepository = Effect.gen(function* () {
 		execute: (row) => sql`
         INSERT INTO tasks (
           task_id,
+          readable_id,
           project_id,
           repository_key,
           thread_id,
@@ -13892,6 +13977,7 @@ const makeTaskRepository = Effect.gen(function* () {
         )
         VALUES (
           ${row.taskId},
+          ${row.readableId},
           ${row.projectId},
           ${row.repositoryKey},
           ${row.threadId},
@@ -13906,6 +13992,7 @@ const makeTaskRepository = Effect.gen(function* () {
         )
         ON CONFLICT (task_id)
         DO UPDATE SET
+          readable_id = excluded.readable_id,
           project_id = excluded.project_id,
           repository_key = excluded.repository_key,
           thread_id = excluded.thread_id,
@@ -13924,6 +14011,26 @@ const makeTaskRepository = Effect.gen(function* () {
 		Result: TaskDbRow,
 		execute: ({ taskId }) => sql`SELECT ${sql.literal(TASK_COLUMNS)} 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}`
+	});
+	/**
+	* Take the next number for a prefix, creating the sequence at 1 on first
+	* use. The row is never reset or decremented - a deleted task's number is
+	* gone - which is what makes a readable id safe to say out loud.
+	*/
+	const allocateReadableIdSeq = SqlSchema.findAll({
+		Request: Schema$1.Struct({ prefix: Schema$1.String }),
+		Result: Schema$1.Struct({ lastSeq: Schema$1.Int }),
+		execute: ({ prefix }) => sql`
+        INSERT INTO task_sequences (prefix, last_seq)
+        VALUES (${prefix}, 1)
+        ON CONFLICT (prefix) DO UPDATE SET last_seq = last_seq + 1
+        RETURNING last_seq AS "lastSeq"
+      `
+	});
 	const listTaskRows = SqlSchema.findAll({
 		Request: TaskListQuery,
 		Result: TaskDbRow,
@@ -13946,7 +14053,31 @@ const makeTaskRepository = Effect.gen(function* () {
 		type: "upserted",
 		task: row
 	})));
+	/**
+	* The allocation and the insert share one transaction on purpose: a number
+	* taken outside it would either be lost on a failed insert (a gap nobody
+	* caused) or, worse, handed to two concurrent creates.
+	*/
+	const create = (row, readableIdPrefix) => sql.withTransaction(Effect.gen(function* () {
+		const prefix = readableIdPrefix.toUpperCase();
+		const seq = (yield* allocateReadableIdSeq({ prefix }))[0]?.lastSeq;
+		if (seq === void 0) return yield* new PersistenceSqlError({
+			operation: "TaskRepository.create:allocate",
+			detail: "the sequence upsert returned no row",
+			cause: null
+		});
+		const task = {
+			...row,
+			readableId: `${prefix}-${seq}`
+		};
+		yield* upsertTaskRow(task);
+		return task;
+	})).pipe(Effect.mapError(toPersistenceSqlError("TaskRepository.create:query")), Effect.tap((task) => publish({
+		type: "upserted",
+		task
+	})));
 	const getById = (input) => getTaskRow(input).pipe(Effect.mapError(toPersistenceSqlError("TaskRepository.getById:query")));
+	const getByReadableId = (readableId) => getTaskRowByReadableId(readableId.toUpperCase()).pipe(Effect.mapError(toPersistenceSqlError("TaskRepository.getByReadableId:query")));
 	const list = (filter) => listTaskRows({
 		projectId: filter.projectId ?? null,
 		repositoryKey: filter.repositoryKey ?? null,
@@ -14021,10 +14152,12 @@ const makeTaskRepository = Effect.gen(function* () {
 		taskId: input.taskId
 	})));
 	return {
+		create,
 		upsert,
 		patch,
 		patchIfStatus,
 		getById,
+		getByReadableId,
 		list,
 		deleteById,
 		streamChanges: Stream.fromPubSub(changes),
@@ -14113,12 +14246,13 @@ const getTaskRoute = HttpRouter.add("GET", "/tasks/:taskId", respondToHubFailure
 	yield* authenticateHubRequest();
 	const params = yield* HttpRouter.params;
 	const taskId = TaskId.make(params.taskId ?? "");
-	const found = yield* (yield* TaskRepository).getById({ taskId });
+	const tasks = yield* TaskRepository;
+	const found = isReadableTaskId(taskId) ? yield* tasks.getByReadableId(taskId) : yield* tasks.getById({ taskId });
 	return Option.isNone(found) ? notFound(taskId) : HttpServerResponse.jsonUnsafe(found.value);
 })));
 const createTaskRoute = HttpRouter.add("POST", "/tasks", respondToHubFailures(Effect.gen(function* () {
 	yield* authenticateHubRequest();
-	const input = yield* decodeOrInvalid(TaskCreateInput, "Request body does not match TaskCreateInput.")(yield* readJsonBody());
+	const input = yield* decodeOrInvalid(HubTaskCreateInput, "Request body does not match HubTaskCreateInput.")(yield* readJsonBody());
 	const tasks = yield* TaskRepository;
 	const crypto = yield* Crypto.Crypto;
 	const taskId = TaskId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
@@ -14137,8 +14271,8 @@ const createTaskRoute = HttpRouter.add("POST", "/tasks", respondToHubFailures(Ef
 		createdAt: timestamp,
 		updatedAt: timestamp
 	};
-	yield* tasks.upsert(row);
-	return HttpServerResponse.jsonUnsafe(row, { status: 201 });
+	const task = yield* tasks.create(row, input.readableIdPrefix ?? "T");
+	return HttpServerResponse.jsonUnsafe(task, { status: 201 });
 })));
 const updateTaskRoute = HttpRouter.add("PATCH", "/tasks/:taskId", respondToHubFailures(Effect.gen(function* () {
 	yield* authenticateHubRequest();
@@ -14376,6 +14510,50 @@ var _003_AgentAssets_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/hub/Migrations/004_TaskReadableIds.ts
+/**
+* Human-readable task ids (`T-1`, `P4-12`).
+*
+* `task_sequences` holds one row per prefix with the highest number ever
+* handed out. It only grows: deleting a task does not return its number, so a
+* readable id, once uttered, never comes to mean a different task.
+*
+* Existing rows are backfilled with the default `T` prefix in creation order.
+* Prefixes cannot be consulted here at all: they live in each project's
+* checked-in `p4.json`, and the hub has no checkouts. New tasks arrive with a
+* prefix resolved by the submitting environment server.
+*/
+var _004_TaskReadableIds_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`
+    CREATE TABLE IF NOT EXISTS task_sequences (
+      prefix TEXT PRIMARY KEY,
+      last_seq INTEGER NOT NULL
+    )
+  `;
+	yield* sql`ALTER TABLE tasks ADD COLUMN readable_id TEXT`;
+	yield* sql`
+    UPDATE tasks
+    SET readable_id = 'T-' || (
+      SELECT COUNT(*)
+      FROM tasks AS earlier
+      WHERE earlier.created_at < tasks.created_at
+        OR (earlier.created_at = tasks.created_at AND earlier.task_id <= tasks.task_id)
+    )
+    WHERE readable_id IS NULL
+  `;
+	yield* sql`
+    INSERT INTO task_sequences (prefix, last_seq)
+    SELECT 'T', COUNT(*) FROM tasks
+    WHERE true
+    ON CONFLICT (prefix) DO UPDATE SET last_seq = MAX(last_seq, excluded.last_seq)
+  `;
+	yield* sql`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_tasks_readable_id
+    ON tasks(readable_id)
+  `;
+});
+//#endregion
 //#region src/hub/Migrations.ts
 /**
 * Hub migrations.
@@ -14401,6 +14579,11 @@ const hubMigrationEntries = [
 		3,
 		"AgentAssets",
 		_003_AgentAssets_default
+	],
+	[
+		4,
+		"TaskReadableIds",
+		_004_TaskReadableIds_default
 	]
 ];
 const hubMigrationLoader = Migrator.fromRecord(Object.fromEntries(hubMigrationEntries.map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -31482,6 +31665,287 @@ const make$39 = Effect.gen(function* () {
 });
 const layer$34 = Layer.effect(CheckpointDiffQuery, make$39);
 //#endregion
+//#region ../../packages/shared/src/toolCategory.ts
+const TOOL_CATEGORY_TITLES = {
+	file_read: "File read",
+	file_search: "File search",
+	file_change: "File change",
+	command: "Command run",
+	version_control: "Version control",
+	build_test: "Build or test",
+	mcp_tool: "MCP tool call",
+	subagent: "Subagent task",
+	web_search: "Web search",
+	web_fetch: "Web fetch",
+	task_plan: "Task or plan",
+	image_view: "Image view",
+	tool: "Tool call"
+};
+new Set(Object.keys(TOOL_CATEGORY_TITLES));
+/** Exact tool names, lowercased, matched before the substring heuristics below. */
+const FILE_READ_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"read",
+	"readfile",
+	"read_file",
+	"view",
+	"viewfile",
+	"view_file",
+	"notebookread",
+	"notebook_read",
+	"openfile",
+	"open_file"
+]);
+const FILE_SEARCH_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"grep",
+	"glob",
+	"search",
+	"filesearch",
+	"file_search",
+	"codebasesearch",
+	"codebase_search",
+	"listdir",
+	"list_dir",
+	"list_directory",
+	"ls"
+]);
+const FILE_CHANGE_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"edit",
+	"write",
+	"multiedit",
+	"multi_edit",
+	"notebookedit",
+	"notebook_edit",
+	"applypatch",
+	"apply_patch",
+	"patch",
+	"createfile",
+	"create_file",
+	"strreplace",
+	"str_replace",
+	"deletefile",
+	"delete_file"
+]);
+const COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"bash",
+	"shell",
+	"terminal",
+	"exec",
+	"execute",
+	"execcommand",
+	"exec_command",
+	"runcommand",
+	"run_command",
+	"local_shell"
+]);
+const SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"task",
+	"agent",
+	"subagent",
+	"sub_agent"
+]);
+const WEB_FETCH_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"webfetch",
+	"web_fetch",
+	"fetch",
+	"fetchurl",
+	"fetch_url",
+	"browse",
+	"openurl",
+	"open_url"
+]);
+/**
+* Matched before the subagent rules, so `task_create` is a board write while the
+* bare `Task` tool stays a subagent.
+*/
+const TASK_PLAN_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"todowrite",
+	"todo_write",
+	"todoread",
+	"todo_read",
+	"exitplanmode",
+	"exit_plan_mode",
+	"updateplan",
+	"update_plan",
+	"task_create",
+	"task_update",
+	"task_list",
+	"task_get",
+	"task_current",
+	"task_propose",
+	"taskcreate",
+	"taskupdate",
+	"tasklist",
+	"taskget"
+]);
+/** Shell builtins that say nothing about what the command as a whole does. */
+const NEUTRAL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"cd",
+	"echo",
+	"printf",
+	"pwd",
+	"true",
+	"false",
+	"time"
+]);
+/** `sed`/`awk` are stream editors (`sed -i` rewrites files), so they stay commands. */
+const FILE_READ_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"cat",
+	"head",
+	"tail",
+	"less",
+	"more",
+	"bat",
+	"nl",
+	"jq",
+	"wc"
+]);
+const FILE_SEARCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"grep",
+	"egrep",
+	"fgrep",
+	"rg",
+	"ag",
+	"ack",
+	"find",
+	"fd",
+	"ls",
+	"tree",
+	"which"
+]);
+/** `git status` and `git diff` sort here too: the verb is what a reader scans for. */
+const VERSION_CONTROL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"git",
+	"gh",
+	"jj",
+	"hg",
+	"svn",
+	"glab"
+]);
+/**
+* Builds, tests, type checks, lint and install share one category: a test run is
+* what a person scans for when a turn goes long, and the rest is the same noise.
+*/
+const BUILD_TEST_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"pnpm",
+	"npm",
+	"npx",
+	"yarn",
+	"bun",
+	"bunx",
+	"vitest",
+	"jest",
+	"vp",
+	"tsc",
+	"tsgo",
+	"eslint",
+	"oxlint",
+	"biome",
+	"prettier",
+	"ruff",
+	"pytest",
+	"make",
+	"cargo",
+	"gradle",
+	"mvn",
+	"xcodebuild",
+	"swift",
+	"pip",
+	"uv",
+	"poetry"
+]);
+const WEB_FETCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
+	"curl",
+	"wget",
+	"http",
+	"httpie"
+]);
+const SHELL_SEGMENT_SEPARATOR = /\|\||&&|;|\||\n/u;
+const LEADING_ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/u;
+const REDIRECT_TARGET = /\d?>>?\s*(?<target>[^\s|;&]+)/gu;
+/** Redirect targets that discard output instead of writing a file. */
+const DISCARDED_REDIRECT_TARGETS = /* @__PURE__ */ new Set([
+	"/dev/null",
+	"&1",
+	"&2"
+]);
+function toolCategoryTitle(category) {
+	return TOOL_CATEGORY_TITLES[category];
+}
+function readCommandInput(toolInput) {
+	const raw = toolInput?.command ?? toolInput?.cmd;
+	if (typeof raw !== "string") return;
+	const trimmed = raw.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+/** `cat x > y` reads and writes; only the write matters for the row heading. */
+function redirectsToFile(segment) {
+	for (const match of segment.matchAll(REDIRECT_TARGET)) {
+		const target = match.groups?.target;
+		if (target && !DISCARDED_REDIRECT_TARGETS.has(target)) return true;
+	}
+	return false;
+}
+function classifyShellSegment(segment) {
+	if (redirectsToFile(segment)) return "command";
+	const head = segment.trim().replace(LEADING_ENV_ASSIGNMENT, "").split(/\s+/u)[0]?.replace(/^.*\//u, "").toLowerCase();
+	if (!head || NEUTRAL_SHELL_COMMANDS.has(head)) return;
+	if (FILE_READ_SHELL_COMMANDS.has(head)) return "file_read";
+	if (FILE_SEARCH_SHELL_COMMANDS.has(head)) return "file_search";
+	if (VERSION_CONTROL_SHELL_COMMANDS.has(head)) return "version_control";
+	if (BUILD_TEST_SHELL_COMMANDS.has(head)) return "build_test";
+	if (WEB_FETCH_SHELL_COMMANDS.has(head)) return "web_fetch";
+	return "command";
+}
+/**
+* A shell call only counts as anything narrower than a command when every
+* non-neutral segment agrees; anything unrecognized (or write-ish) keeps the
+* whole call a command, and so does a pipeline that mixes two categories — the
+* one exception being a read piped into a search, which is still a search.
+* Quoted separators split segments too, which can only downgrade to "command".
+*/
+function classifyShellCommand(command) {
+	const categories = new Set(command.split(SHELL_SEGMENT_SEPARATOR).map(classifyShellSegment).filter((category) => category !== void 0));
+	if (categories.size === 0 || categories.has("command")) return "command";
+	const [only] = categories;
+	if (categories.size === 1 && only) return only;
+	return [...categories].every((category) => category === "file_read" || category === "file_search") ? "file_search" : "command";
+}
+function classifyToolCategory(input) {
+	const normalized = input.toolName.trim().toLowerCase();
+	if (normalized.startsWith("mcp__") || normalized.includes("mcp")) return "mcp_tool";
+	if (TASK_PLAN_TOOL_NAMES.has(normalized)) return "task_plan";
+	if (WEB_FETCH_TOOL_NAMES.has(normalized)) return "web_fetch";
+	if (SUBAGENT_TOOL_NAMES.has(normalized) || normalized.includes("agent")) return "subagent";
+	if (FILE_READ_TOOL_NAMES.has(normalized)) return "file_read";
+	if (FILE_SEARCH_TOOL_NAMES.has(normalized)) return "file_search";
+	if (FILE_CHANGE_TOOL_NAMES.has(normalized)) return "file_change";
+	if (COMMAND_TOOL_NAMES.has(normalized) || normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) {
+		const command = readCommandInput(input.toolInput);
+		return command ? classifyShellCommand(command) : "command";
+	}
+	if (normalized.includes("websearch") || normalized.includes("web_search")) return "web_search";
+	if (normalized.includes("webfetch") || normalized.includes("web_fetch")) return "web_fetch";
+	if (normalized.includes("todo") || normalized.includes("plan")) return "task_plan";
+	if (normalized.includes("edit") || normalized.includes("write") || normalized.includes("patch") || normalized.includes("replace") || normalized.includes("create") || normalized.includes("delete")) return "file_change";
+	if (normalized.includes("read") || normalized.includes("view")) return "file_read";
+	if (normalized.includes("grep") || normalized.includes("glob")) return "file_search";
+	if (normalized.includes("image")) return "image_view";
+	return "tool";
+}
+function asRecord$2(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$2(data);
+	const toolName = record?.toolName;
+	if (typeof toolName !== "string" || toolName.trim().length === 0) return;
+	return classifyToolCategory({
+		toolName,
+		toolInput: asRecord$2(record?.input)
+	});
+}
+//#endregion
 //#region src/orchestration/ActivityPayloadProjection.ts
 function asRecord$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -31583,9 +32047,13 @@ function projectActivityPayload(activity) {
 	const item = projectCommandData(data);
 	if (item) projectedData.item = item;
 	if ("command" in data) projectedData.command = data.command;
+	const input = asRecord$1(data.input);
+	if (input && "command" in input) projectedData.input = { command: input.command };
 	const changedFiles = [];
 	collectChangedFiles(data, changedFiles, /* @__PURE__ */ new Set(), 0);
 	if (changedFiles.length > 0) projectedData.files = changedFiles.map((path) => ({ path }));
+	const toolCategory = classifyToolCategoryFromToolData(data);
+	if (toolCategory) projectedData.toolCategory = toolCategory;
 	if ("toolCallId" in data) projectedData.toolCallId = data.toolCallId;
 	if ("kind" in data) projectedData.kind = data.kind;
 	const rawOutput = projectRawOutput(data.rawOutput);
@@ -31757,6 +32225,8 @@ const normalizeDispatchCommand = (command) => Effect.gen(function* () {
 * presentation and is not.
 *
 * The id and timestamp are passed in so this stays pure and holds no clock.
+* The readable id is absent on purpose: the store allocates it at insert time,
+* inside the same transaction as the sequence bump.
 */
 const buildTaskRow = (input, taskId, timestamp, repositoryKey = null) => ({
 	taskId,
@@ -31792,6 +32262,23 @@ const resolveTaskRepositoryKey = Effect.fn("taskBoard.resolveRepositoryKey")(fun
 	return (yield* (yield* RepositoryIdentityResolver).resolve(project.value.workspaceRoot))?.canonicalKey ?? null;
 });
 /**
+* 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.
+*/
+const resolveTaskReadableIdPrefix = Effect.fn("taskBoard.resolveReadableIdPrefix")(function* (projectId) {
+	if (projectId == null) return "T";
+	const project = yield* (yield* ProjectionProjectRepository).getById({ projectId }).pipe(Effect.catchCause(() => Effect.succeed(Option.none())));
+	if (Option.isNone(project)) return "T";
+	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();
+});
+/**
 * Everything that decides whether a task can be started, as one pure function.
 *
 * Kept out of the RPC handler because the three refusals are the whole of the
@@ -42416,9 +42903,12 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 		[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* () {
-			const row = buildTaskRow(input, TaskId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)), yield* nowIso$5, yield* resolveTaskRepositoryKey(input.projectId));
-			yield* taskRepository.upsert(row).pipe(Effect.catch(toTaskStoreError("tasks.create")));
-			return { task: row };
+			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"))) };
 		}), { "rpc.aggregate": "tasks" }),
 		[WS_METHODS.tasksUpdate]: (input) => observeRpcEffect$1(WS_METHODS.tasksUpdate, Effect.gen(function* () {
 			const timestamp = yield* nowIso$5;
@@ -42729,12 +43219,13 @@ const websocketRpcRouteLayer = Layer.unwrap(Effect.gen(function* () {
 	const serverSelfUpdate = yield* ServerSelfUpdate;
 	const taskRepository = yield* TaskRepository;
 	const projectionProjects = yield* ProjectionProjectRepository;
+	const p4ProjectFileLoader = yield* P4ProjectFileLoader;
 	return HttpRouter.add("GET", "/ws", Effect.gen(function* () {
 		const request = yield* HttpServerRequest.HttpServerRequest;
 		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$33), Layer.provide(Layer.succeed(ServerSelfUpdate, serverSelfUpdate)), Layer.provide(Layer.succeed(TaskRepository, taskRepository)), Layer.provide(Layer.succeed(ProjectionProjectRepository, projectionProjects)), 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$38), Layer.provide(layer$36.pipe(Layer.provide(layer$37))))), Layer.provide(layer$39))))));
+		const rpcWebSocketHttpEffect = yield* RpcServer.toHttpEffectWebsocket(WsRpcGroup, { disableTracing: true }).pipe(Effect.provide(makeWsRpcLayer(session, previewAutomationBroker).pipe(Layer.provideMerge(RpcSerialization.layerJson), Layer.provide(layer$33), 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$38), Layer.provide(layer$36.pipe(Layer.provide(layer$37))))), Layer.provide(layer$39))))));
 		return yield* Effect.acquireUseRelease(sessions.markConnected(session.sessionId), () => rpcWebSocketHttpEffect, () => sessions.markDisconnected(session.sessionId));
 	}).pipe(Effect.catchTags({
 		EnvironmentAuthInvalidError: HttpServerRespondable.toResponse,
@@ -42839,17 +43330,16 @@ const makeRemoteTaskRepository = Effect.fn("makeRemoteTaskRepository")(function*
 		return Option.some(yield* response.json.pipe(Effect.flatMap(decodeTask), Effect.mapError(() => hubUnavailable("getById", "the response did not match the contract"))));
 	});
 	/**
-	* Upsert is a create here, and that is a real difference from the local
-	* store.
-	*
-	* The hub mints its own ids and timestamps, so a row written through this
-	* comes back with the hub's version of both. 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.
+	* 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 upsert = (row) => Effect.gen(function* () {
-		const settings = yield* requireSettings("upsert");
-		const response = yield* send("upsert", settings, HttpClientRequest.bodyJsonUnsafe(HttpClientRequest.post(`${settings.baseUrl}/tasks`), {
+	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 },
@@ -42858,15 +43348,24 @@ const makeRemoteTaskRepository = Effect.fn("makeRemoteTaskRepository")(function*
 			status: row.status,
 			priority: row.priority,
 			...row.assignee === null ? {} : { assignee: row.assignee },
-			labels: row.labels
+			labels: row.labels,
+			...readableIdPrefix === void 0 ? {} : { readableIdPrefix }
 		}));
-		if (response.status !== 201 && response.status !== 200) return yield* hubUnavailable("upsert", `status ${response.status}`);
-		const created = yield* response.json.pipe(Effect.flatMap(decodeTask), Effect.mapError(() => hubUnavailable("upsert", "the response did not match the contract")));
+		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;
@@ -42941,10 +43440,12 @@ const makeRemoteTaskRepository = Effect.fn("makeRemoteTaskRepository")(function*
 	}).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),
@@ -42994,10 +43495,12 @@ const makeRoutedTaskRepository = Effect.gen(function* () {
 	*/
 	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() {
@@ -46483,177 +46986,6 @@ function parseCliArgs(args, options) {
 	};
 }
 //#endregion
-//#region ../../packages/shared/src/toolCategory.ts
-const TOOL_CATEGORY_TITLES = {
-	file_read: "File read",
-	file_search: "File search",
-	file_change: "File change",
-	command: "Command run",
-	mcp_tool: "MCP tool call",
-	subagent: "Subagent task",
-	web_search: "Web search",
-	image_view: "Image view",
-	tool: "Tool call"
-};
-/** Exact tool names, lowercased, matched before the substring heuristics below. */
-const FILE_READ_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"read",
-	"readfile",
-	"read_file",
-	"view",
-	"viewfile",
-	"view_file",
-	"notebookread",
-	"notebook_read",
-	"openfile",
-	"open_file"
-]);
-const FILE_SEARCH_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"grep",
-	"glob",
-	"search",
-	"filesearch",
-	"file_search",
-	"codebasesearch",
-	"codebase_search",
-	"listdir",
-	"list_dir",
-	"list_directory",
-	"ls"
-]);
-const FILE_CHANGE_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"edit",
-	"write",
-	"multiedit",
-	"multi_edit",
-	"notebookedit",
-	"notebook_edit",
-	"applypatch",
-	"apply_patch",
-	"patch",
-	"createfile",
-	"create_file",
-	"strreplace",
-	"str_replace",
-	"deletefile",
-	"delete_file"
-]);
-const COMMAND_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"bash",
-	"shell",
-	"terminal",
-	"exec",
-	"execute",
-	"execcommand",
-	"exec_command",
-	"runcommand",
-	"run_command",
-	"local_shell"
-]);
-const SUBAGENT_TOOL_NAMES = /* @__PURE__ */ new Set([
-	"task",
-	"agent",
-	"subagent",
-	"sub_agent"
-]);
-/** Shell builtins that say nothing about what the command as a whole does. */
-const NEUTRAL_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"cd",
-	"echo",
-	"printf",
-	"pwd",
-	"true",
-	"false",
-	"time"
-]);
-/** `sed`/`awk` are stream editors (`sed -i` rewrites files), so they stay commands. */
-const FILE_READ_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"cat",
-	"head",
-	"tail",
-	"less",
-	"more",
-	"bat",
-	"nl",
-	"jq",
-	"wc"
-]);
-const FILE_SEARCH_SHELL_COMMANDS = /* @__PURE__ */ new Set([
-	"grep",
-	"egrep",
-	"fgrep",
-	"rg",
-	"ag",
-	"ack",
-	"find",
-	"fd",
-	"ls",
-	"tree",
-	"which"
-]);
-const SHELL_SEGMENT_SEPARATOR = /\|\||&&|;|\||\n/u;
-const LEADING_ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=\S*\s+/u;
-const REDIRECT_TARGET = /\d?>>?\s*(?<target>[^\s|;&]+)/gu;
-/** Redirect targets that discard output instead of writing a file. */
-const DISCARDED_REDIRECT_TARGETS = /* @__PURE__ */ new Set([
-	"/dev/null",
-	"&1",
-	"&2"
-]);
-function toolCategoryTitle(category) {
-	return TOOL_CATEGORY_TITLES[category];
-}
-function readCommandInput(toolInput) {
-	const raw = toolInput?.command ?? toolInput?.cmd;
-	if (typeof raw !== "string") return;
-	const trimmed = raw.trim();
-	return trimmed.length > 0 ? trimmed : void 0;
-}
-/** `cat x > y` reads and writes; only the write matters for the row heading. */
-function redirectsToFile(segment) {
-	for (const match of segment.matchAll(REDIRECT_TARGET)) {
-		const target = match.groups?.target;
-		if (target && !DISCARDED_REDIRECT_TARGETS.has(target)) return true;
-	}
-	return false;
-}
-function classifyShellSegment(segment) {
-	if (redirectsToFile(segment)) return "command";
-	const head = segment.trim().replace(LEADING_ENV_ASSIGNMENT, "").split(/\s+/u)[0]?.replace(/^.*\//u, "").toLowerCase();
-	if (!head || NEUTRAL_SHELL_COMMANDS.has(head)) return;
-	if (FILE_READ_SHELL_COMMANDS.has(head)) return "file_read";
-	if (FILE_SEARCH_SHELL_COMMANDS.has(head)) return "file_search";
-	return "command";
-}
-/**
-* A shell call only counts as a read or a search when every non-neutral segment
-* agrees; anything unrecognized (or write-ish) keeps the whole call a command.
-* Quoted separators split segments too, which can only downgrade to "command".
-*/
-function classifyShellCommand(command) {
-	const categories = command.split(SHELL_SEGMENT_SEPARATOR).map(classifyShellSegment).filter((category) => category !== void 0);
-	if (categories.length === 0 || categories.includes("command")) return "command";
-	return categories.includes("file_search") ? "file_search" : "file_read";
-}
-function classifyToolCategory(input) {
-	const normalized = input.toolName.trim().toLowerCase();
-	if (normalized.startsWith("mcp__") || normalized.includes("mcp")) return "mcp_tool";
-	if (SUBAGENT_TOOL_NAMES.has(normalized) || normalized.includes("agent")) return "subagent";
-	if (FILE_READ_TOOL_NAMES.has(normalized)) return "file_read";
-	if (FILE_SEARCH_TOOL_NAMES.has(normalized)) return "file_search";
-	if (FILE_CHANGE_TOOL_NAMES.has(normalized)) return "file_change";
-	if (COMMAND_TOOL_NAMES.has(normalized) || normalized.includes("bash") || normalized.includes("shell") || normalized.includes("terminal") || normalized.includes("command")) {
-		const command = readCommandInput(input.toolInput);
-		return command ? classifyShellCommand(command) : "command";
-	}
-	if (normalized.includes("websearch") || normalized.includes("web_search")) return "web_search";
-	if (normalized.includes("edit") || normalized.includes("write") || normalized.includes("patch") || normalized.includes("replace") || normalized.includes("create") || normalized.includes("delete")) return "file_change";
-	if (normalized.includes("read") || normalized.includes("view")) return "file_read";
-	if (normalized.includes("grep") || normalized.includes("glob")) return "file_search";
-	if (normalized.includes("image")) return "image_view";
-	return "tool";
-}
-//#endregion
 //#region src/provider/askUserQuestionAnswers.ts
 /**
 * What separates the options of one multi-select answer.
@@ -47249,6 +47581,8 @@ const SUPPORTED_CLAUDE_IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
 * preset drops the interactive CLI's terminal-tone sections, so without this the
 * model opens a turn with a tool call rather than a line saying what it is doing.
 */
+/** Emitted by the CLI but absent from the SDK's `SDKMessage` union. */
+const UNTYPED_COMMAND_LIFECYCLE_MESSAGE = "command_lifecycle";
 const NARRATE_BEFORE_TOOLS_PROMPT = "Before your first tool call in a turn, write one short sentence saying what you are about to do. Keep it to a single line and skip it when you are answering without tools.";
 const CLAUDE_SETTING_SOURCES = [
 	"user",
@@ -48694,6 +49028,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 	const handleSdkMessage = Effect.fn("handleSdkMessage")(function* (context, message) {
 		yield* logNativeSdkMessage(context, message);
 		yield* ensureThreadId(context, message);
+		if (message.type === UNTYPED_COMMAND_LIFECYCLE_MESSAGE) return;
 		switch (message.type) {
 			case "stream_event":
 				yield* handleStreamEvent(context, message);
@@ -49076,6 +49411,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		};
 		const mcpSession = readMcpProviderSession(input.threadId);
 		const externalMcpServers = options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers;
+		const narrateBeforeTools = options?.resolveToolCallNarration === void 0 ? DEFAULT_SERVER_SETTINGS.enableToolCallNarration : yield* options.resolveToolCallNarration;
 		const queryOptions = {
 			...input.cwd ? { cwd: input.cwd } : {},
 			...apiModelId ? { model: apiModelId } : {},
@@ -49083,7 +49419,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			systemPrompt: {
 				type: "preset",
 				preset: "claude_code",
-				...claudeSettings.narrateBeforeTools ? { append: NARRATE_BEFORE_TOOLS_PROMPT } : {}
+				...narrateBeforeTools ? { append: NARRATE_BEFORE_TOOLS_PROMPT } : {}
 			},
 			settingSources: [...CLAUDE_SETTING_SOURCES],
 			...effectiveEffort ? { effort: effectiveEffort } : {},
@@ -49125,7 +49461,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			"claude.query.include_partial_messages": true,
 			"claude.query.additional_directories": input.cwd ? [input.cwd] : [],
 			"claude.query.setting_sources": [...CLAUDE_SETTING_SOURCES],
-			"claude.query.narrate_before_tools": claudeSettings.narrateBeforeTools,
+			"claude.query.narrate_before_tools": narrateBeforeTools,
 			"claude.query.settings_json": encodeJsonStringForDiagnostics$2(settings) ?? "",
 			"claude.query.extra_args_json": encodeJsonStringForDiagnostics$2(extraArgs) ?? "",
 			"claude.query.path_to_executable": claudeBinaryPath
@@ -49536,11 +49872,13 @@ const ClaudeDriver = {
 		});
 		const mcpRegistry = yield* McpRegistry;
 		const resolveDisabledSkills = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => []));
+		const resolveToolCallNarration = serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableToolCallNarration), Effect.orElseSucceed(() => DEFAULT_SERVER_SETTINGS.enableToolCallNarration));
 		const adapter = yield* makeClaudeAdapter(effectiveConfig, {
 			instanceId,
 			environment: processEnv,
 			resolveMcpServers: mcpRegistry.resolveForSession,
 			resolveDisabledSkills,
+			resolveToolCallNarration,
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 		});
 		const textGeneration = yield* makeClaudeTextGeneration(effectiveConfig, processEnv);
@@ -80967,8 +81305,15 @@ const writeDependencies = [
 	ProjectionProjectRepository,
 	RepositoryIdentityResolver
 ];
-/** `task_create` also mints the task id, so it needs the crypto service. */
-const createDependencies = [...writeDependencies, Crypto.Crypto];
+/**
+* `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).
+*/
+const createDependencies = [
+	...writeDependencies,
+	Crypto.Crypto,
+	P4ProjectFileLoader
+];
 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.",
@@ -80978,7 +81323,7 @@ const TaskListTool = Tool.make("task_list", {
 	dependencies
 }).annotate(Tool.Title, "List tasks").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
 const TaskGetTool = Tool.make("task_get", {
-	description: "Read a single task by id, including its body, labels and linked thread.",
+	description: "Read a single task by id, including its body, labels and linked thread. Accepts either the UUID or the readable id (e.g. T-3, P4-12).",
 	parameters: TaskGetInput,
 	success: Task,
 	failure: TaskToolError,
@@ -81028,6 +81373,15 @@ const TaskToolkit = Toolkit.make(TaskListTool, TaskGetTool, TaskCurrentTool, Tas
 //#endregion
 //#region src/mcp/toolkits/tasks/handlers.ts
 const nowIso$1 = Effect.map(DateTime.now, DateTime.formatIso);
+/**
+* Agents reference tasks by whichever id they have seen, so any `taskId`
+* parameter accepts the readable id (`P4-12`) as well as the UUID. The two are
+* disjoint by shape, which is what makes the dispatch safe.
+*/
+const findTask = (taskId) => Effect.gen(function* () {
+	const tasks = yield* TaskRepository;
+	return isReadableTaskId(taskId) ? yield* tasks.getByReadableId(taskId) : yield* tasks.getById({ taskId });
+});
 const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 	task_list: (input) => Effect.gen(function* () {
 		yield* requireTaskCapability();
@@ -81035,7 +81389,7 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 	}),
 	task_get: (input) => Effect.gen(function* () {
 		yield* requireTaskCapability();
-		const found = yield* (yield* TaskRepository).getById({ taskId: input.taskId }).pipe(Effect.catch(toTaskStoreError("task_get")));
+		const found = yield* findTask(input.taskId).pipe(Effect.catch(toTaskStoreError("task_get")));
 		if (Option.isNone(found)) return yield* new TaskNotFoundError({ taskId: input.taskId });
 		return found.value;
 	}),
@@ -81051,16 +81405,25 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 		yield* requireTaskCapability();
 		const tasks = yield* TaskRepository;
 		const crypto = yield* Crypto.Crypto;
-		const row = buildTaskRow(input, TaskId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)), yield* nowIso$1, yield* resolveTaskRepositoryKey(input.projectId));
-		yield* tasks.upsert(row).pipe(Effect.catch(toTaskStoreError("task_create")));
-		return row;
+		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 row = buildTaskRow(input, taskId, timestamp, repositoryKey);
+		return yield* tasks.create(row, readableIdPrefix).pipe(Effect.catch(toTaskStoreError("task_create")));
 	}),
 	task_update: (input) => Effect.gen(function* () {
 		yield* requireTaskCapability();
 		const tasks = yield* TaskRepository;
 		const timestamp = yield* nowIso$1;
-		const patch = input.projectId === void 0 ? input : {
+		const taskId = isReadableTaskId(input.taskId) ? Option.getOrNull(yield* findTask(input.taskId).pipe(Effect.catch(toTaskStoreError("task_update"))))?.taskId : input.taskId;
+		if (taskId === void 0) return yield* new TaskNotFoundError({ taskId: input.taskId });
+		const patch = input.projectId === void 0 ? {
+			...input,
+			taskId
+		} : {
 			...input,
+			taskId,
 			repositoryKey: yield* resolveTaskRepositoryKey(input.projectId)
 		};
 		const patched = yield* tasks.patch(patch, timestamp).pipe(Effect.catch(toTaskStoreError("task_update")));
@@ -82429,6 +82792,31 @@ const make$2 = Effect.gen(function* () {
 		},
 		createdAt: input.createdAt
 	})));
+	/**
+	* A successful interrupt otherwise leaves nothing behind: the only row the
+	* timeline ever got was the failure case above, and the turn fold's "You
+	* stopped after Xs" is invisible while the fold is open and says nothing in
+	* the work log. The turn id comes from the request rather than the provider
+	* because orchestration turn ids are not provider turn ids.
+	*/
+	const appendTurnInterruptedActivity = (input) => Effect.all({
+		commandId: serverCommandId("provider-interrupt-activity"),
+		eventId: serverEventId()
+	}).pipe(Effect.flatMap(({ commandId, eventId }) => orchestrationEngine.dispatch({
+		type: "thread.activity.append",
+		commandId,
+		threadId: input.threadId,
+		activity: {
+			id: eventId,
+			tone: "info",
+			kind: "provider.turn.interrupted",
+			summary: "Interrupted by user",
+			payload: {},
+			turnId: input.turnId,
+			createdAt: input.createdAt
+		},
+		createdAt: input.createdAt
+	})));
 	const formatFailureDetail = (cause) => {
 		const failReason = cause.reasons.find(Cause.isFailReason);
 		const providerError = isProviderAdapterRequestError(failReason?.error) ? failReason.error : void 0;
@@ -82815,6 +83203,11 @@ const make$2 = Effect.gen(function* () {
 			createdAt: event.payload.createdAt
 		});
 		yield* providerService.interruptTurn({ threadId: event.payload.threadId });
+		yield* appendTurnInterruptedActivity({
+			threadId: event.payload.threadId,
+			turnId: event.payload.turnId ?? null,
+			createdAt: event.payload.createdAt
+		});
 	});
 	const processApprovalResponseRequested = Effect.fn("processApprovalResponseRequested")(function* (event) {
 		const thread = yield* resolveThread(event.payload.threadId);
@@ -84744,7 +85137,7 @@ const RuntimeDependenciesLive = ReactorLayerLive.pipe(Layer.provideMerge(Checkpo
 */
 const AssetSyncLive = layer$54.pipe(Layer.provideMerge(layer$55), Layer.provideMerge(layer$56));
 const RuntimeServicesLive = layer$44.pipe(Layer.provideMerge(AssetSyncLive), Layer.provideMerge(RuntimeDependenciesLive));
-const makeRoutesLayer = Layer.mergeAll(Layer.mergeAll(HttpApiBuilder.layer(EnvironmentHttpApi).pipe(Layer.provide(authHttpApiLayer), Layer.provide(orchestrationHttpApiLayer), Layer.provide(serverEnvironmentHttpApiLayer), Layer.provide(environmentAuthenticatedAuthLayer)), otlpTracesProxyRouteLayer, assetRouteLayer, staticAndDevRouteLayer, websocketRpcRouteLayer), layer.pipe(Layer.provide(layer$2))).pipe(Layer.provide(RoutedTaskRepositoryLive.pipe(Layer.provide(PersistenceLayerLive))), Layer.provide(ProjectionProjectRepositoryLive.pipe(Layer.provide(PersistenceLayerLive))), Layer.provide(layer$28), Layer.provide(layer$46), Layer.provide(browserApiCorsLayer), Layer.provide(httpCompressionLayer));
+const makeRoutesLayer = Layer.mergeAll(Layer.mergeAll(HttpApiBuilder.layer(EnvironmentHttpApi).pipe(Layer.provide(authHttpApiLayer), Layer.provide(orchestrationHttpApiLayer), Layer.provide(serverEnvironmentHttpApiLayer), Layer.provide(environmentAuthenticatedAuthLayer)), otlpTracesProxyRouteLayer, assetRouteLayer, staticAndDevRouteLayer, websocketRpcRouteLayer), layer.pipe(Layer.provide(layer$2))).pipe(Layer.provide(RoutedTaskRepositoryLive.pipe(Layer.provide(PersistenceLayerLive))), Layer.provide(ProjectionProjectRepositoryLive.pipe(Layer.provide(PersistenceLayerLive))), Layer.provide(layer$42), Layer.provide(layer$28), Layer.provide(layer$46), Layer.provide(browserApiCorsLayer), Layer.provide(httpCompressionLayer));
 const makeServerLayer = Layer.unwrap(Effect.gen(function* () {
 	const config = yield* ServerConfig$1;
 	yield* fixPath();