@p4code/cli 0.0.50 → 0.0.51

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$72 = () => {
 const layer$68 = Layer.sync(NetService, make$72);
 //#endregion
 //#region package.json
-var version = "0.0.50";
+var version = "0.0.51";
 //#endregion
 //#region src/config.ts
 /**
@@ -4819,6 +4819,87 @@ const ThreadMetadataUpdatedPayload = Schema$1.Struct({
 	name: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
 	metadata: Schema$1.optional(UnknownRecordSchema)
 });
+/**
+* Per-source attribution for what is occupying the context window, as reported
+* by a provider that can answer the question. Only the Claude adapter fills this
+* in today; every field is optional so a provider can report the parts it knows.
+*
+* `isDeferred` / `isLoaded` are the interesting half. Providers defer most tool
+* definitions behind tool search, so a deferred entry's tokens are what it
+* *would* cost rather than what it costs right now, and presenting the two as
+* one number overstates usage.
+*/
+const ContextWindowNamedCost = Schema$1.Struct({
+	name: TrimmedNonEmptyStringSchema$1,
+	tokens: NonNegativeInt
+});
+const ContextWindowDeferrableTool = Schema$1.Struct({
+	name: TrimmedNonEmptyStringSchema$1,
+	tokens: NonNegativeInt,
+	isLoaded: Schema$1.optional(Schema$1.Boolean)
+});
+const ContextWindowBreakdown = Schema$1.Struct({
+	/** The model the breakdown was measured against, which is not always the thread's current selection. */
+	model: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
+	/** Top-level buckets the provider itself divides the window into. */
+	categories: Schema$1.optional(Schema$1.Array(Schema$1.Struct({
+		name: TrimmedNonEmptyStringSchema$1,
+		tokens: NonNegativeInt,
+		isDeferred: Schema$1.optional(Schema$1.Boolean)
+	}))),
+	mcpTools: Schema$1.optional(Schema$1.Array(Schema$1.Struct({
+		name: TrimmedNonEmptyStringSchema$1,
+		serverName: TrimmedNonEmptyStringSchema$1,
+		tokens: NonNegativeInt,
+		isLoaded: Schema$1.optional(Schema$1.Boolean)
+	}))),
+	skills: Schema$1.optional(Schema$1.Struct({
+		totalSkills: NonNegativeInt,
+		includedSkills: NonNegativeInt,
+		tokens: NonNegativeInt,
+		entries: Schema$1.optional(Schema$1.Array(Schema$1.Struct({
+			name: TrimmedNonEmptyStringSchema$1,
+			source: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
+			tokens: NonNegativeInt
+		})))
+	})),
+	memoryFiles: Schema$1.optional(Schema$1.Array(Schema$1.Struct({
+		path: TrimmedNonEmptyStringSchema$1,
+		type: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
+		tokens: NonNegativeInt
+	}))),
+	agents: Schema$1.optional(Schema$1.Array(Schema$1.Struct({
+		agentType: TrimmedNonEmptyStringSchema$1,
+		source: Schema$1.optional(TrimmedNonEmptyStringSchema$1),
+		tokens: NonNegativeInt
+	}))),
+	systemTools: Schema$1.optional(Schema$1.Array(ContextWindowNamedCost)),
+	deferredBuiltinTools: Schema$1.optional(Schema$1.Array(ContextWindowDeferrableTool)),
+	systemPromptSections: Schema$1.optional(Schema$1.Array(ContextWindowNamedCost)),
+	slashCommands: Schema$1.optional(Schema$1.Struct({
+		totalCommands: NonNegativeInt,
+		includedCommands: NonNegativeInt,
+		tokens: NonNegativeInt
+	})),
+	/** How the conversation itself divides up, as opposed to the prompt scaffolding above. */
+	messages: Schema$1.optional(Schema$1.Struct({
+		toolCallTokens: NonNegativeInt,
+		toolResultTokens: NonNegativeInt,
+		attachmentTokens: NonNegativeInt,
+		assistantMessageTokens: NonNegativeInt,
+		userMessageTokens: NonNegativeInt,
+		redirectedContextTokens: NonNegativeInt,
+		unattributedTokens: NonNegativeInt,
+		toolCallsByType: Schema$1.optional(Schema$1.Array(Schema$1.Struct({
+			name: TrimmedNonEmptyStringSchema$1,
+			callTokens: NonNegativeInt,
+			resultTokens: NonNegativeInt
+		}))),
+		attachmentsByType: Schema$1.optional(Schema$1.Array(ContextWindowNamedCost))
+	})),
+	/** Token count at which the provider compacts on its own, when it does. */
+	autoCompactThreshold: Schema$1.optional(NonNegativeInt)
+});
 const ThreadTokenUsageSnapshot = Schema$1.Struct({
 	usedTokens: NonNegativeInt,
 	totalProcessedTokens: Schema$1.optional(NonNegativeInt),
@@ -4834,7 +4915,8 @@ const ThreadTokenUsageSnapshot = Schema$1.Struct({
 	lastReasoningOutputTokens: Schema$1.optional(NonNegativeInt),
 	toolUses: Schema$1.optional(NonNegativeInt),
 	durationMs: Schema$1.optional(NonNegativeInt),
-	compactsAutomatically: Schema$1.optional(Schema$1.Boolean)
+	compactsAutomatically: Schema$1.optional(Schema$1.Boolean),
+	breakdown: Schema$1.optional(ContextWindowBreakdown)
 });
 const ThreadTokenUsageUpdatedPayload = Schema$1.Struct({ usage: ThreadTokenUsageSnapshot });
 const ThreadRealtimeStartedPayload = Schema$1.Struct({ realtimeSessionId: Schema$1.optional(TrimmedNonEmptyStringSchema$1) });
@@ -7235,6 +7317,59 @@ const TaskStreamEvent = Schema$1.Union([
 		taskId: TaskId
 	})
 ]);
+/**
+* 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. */
@@ -8004,6 +8139,7 @@ const WS_METHODS = {
 	tasksCreate: "tasks.create",
 	tasksUpdate: "tasks.update",
 	tasksDelete: "tasks.delete",
+	tasksStartThread: "tasks.startThread",
 	hubGetSyncStatus: "hub.getSyncStatus",
 	hubConnect: "hub.connect",
 	hubDisconnect: "hub.disconnect",
@@ -8078,6 +8214,30 @@ const WsTasksDeleteRpc = Rpc.make(WS_METHODS.tasksDelete, {
 	error: TaskRpcError
 });
 /**
+* Start an agent on a task.
+*
+* This is the one task RPC that is not CRUD: it creates a thread, seeds it from
+* the task, and links the two. It lives in the `tasks.*` namespace because the
+* task is what it reads and writes — the thread is the side effect, not the
+* subject — and because the caller always names a task and never a thread.
+*
+* The error union is wider than the other task methods for the same reason. A
+* start can fail because the task is not startable, which is a property of the
+* row, or because the turn could not be dispatched, which is the orchestration
+* engine's own failure and already has a type.
+*/
+const WsTasksStartThreadRpc = Rpc.make(WS_METHODS.tasksStartThread, {
+	payload: TaskStartThreadInput,
+	success: TaskStartThreadResult,
+	error: Schema$1.Union([
+		TaskNotFoundError,
+		TaskNotStartableError,
+		TaskStoreError,
+		OrchestrationDispatchCommandError,
+		EnvironmentAuthorizationError
+	])
+});
+/**
 * Hub link and skill sync.
 *
 * Every one of these answers with the whole status rather than an
@@ -8590,7 +8750,7 @@ const WsSubscribeAuthAccessRpc = Rpc.make(WS_METHODS.subscribeAuthAccess, {
 	error: Schema$1.Union([AuthAccessStreamError, EnvironmentAuthorizationError]),
 	stream: true
 });
-const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
+const WsRpcGroup = RpcGroup.make(WsServerProbeRpc, WsServerGetConfigRpc, WsServerRefreshProvidersRpc, WsServerUpdateProviderRpc, WsServerUpdateServerRpc, WsServerUpsertKeybindingRpc, WsServerRemoveKeybindingRpc, WsServerGetSettingsRpc, WsServerUpdateSettingsRpc, WsServerDiscoverSourceControlRpc, WsServerGetTraceDiagnosticsRpc, WsServerGetProcessDiagnosticsRpc, WsServerGetProcessResourceHistoryRpc, WsServerSignalProcessRpc, WsSourceControlLookupRepositoryRpc, WsSourceControlCloneRepositoryRpc, WsSourceControlPublishRepositoryRpc, WsProjectsListEntriesRpc, WsProjectsReadFileRpc, WsProjectsSearchEntriesRpc, WsProjectsWriteFileRpc, WsShellOpenInEditorRpc, WsFilesystemBrowseRpc, WsAssetsCreateUrlRpc, WsSubscribeVcsStatusRpc, WsVcsPullRpc, WsVcsRefreshStatusRpc, WsGitRunStackedActionRpc, WsGitResolvePullRequestRpc, WsGitPreparePullRequestThreadRpc, WsVcsListRefsRpc, WsVcsCreateWorktreeRpc, WsVcsRemoveWorktreeRpc, WsVcsCreateRefRpc, WsVcsSwitchRefRpc, WsVcsInitRpc, WsReviewGetDiffPreviewRpc, WsTerminalOpenRpc, WsTerminalAttachRpc, WsTerminalWriteRpc, WsTerminalResizeRpc, WsTerminalClearRpc, WsTerminalRestartRpc, WsTerminalCloseRpc, WsSubscribeTerminalEventsRpc, WsSubscribeTerminalMetadataRpc, WsPreviewOpenRpc, WsPreviewNavigateRpc, WsPreviewResizeRpc, WsPreviewRefreshRpc, WsPreviewCloseRpc, WsPreviewListRpc, WsPreviewReportStatusRpc, WsPreviewAutomationConnectRpc, WsPreviewAutomationRespondRpc, WsPreviewAutomationFocusHostRpc, WsSubscribePreviewEventsRpc, WsSubscribeDiscoveredLocalServersRpc, WsSubscribeServerConfigRpc, WsSubscribeServerLifecycleRpc, WsSubscribeAuthAccessRpc, WsTasksListRpc, WsTasksGetRpc, WsTasksCreateRpc, WsTasksUpdateRpc, WsTasksDeleteRpc, WsTasksStartThreadRpc, WsSubscribeTasksRpc, WsHubGetSyncStatusRpc, WsHubConnectRpc, WsHubDisconnectRpc, WsHubSetSyncModeRpc, WsHubSetShareModeRpc, WsHubMintTokenRpc, WsSkillsSyncRpc, WsSkillsPublishRpc, WsSkillsPublishAllRpc, WsSkillsUnpublishRpc, WsAssetsReadRpc, WsAssetsSaveRpc, WsAssetsDeleteRpc, WsMcpListRpc, WsMcpSaveRpc, WsMcpRemoveRpc, WsMcpSetSecretRpc, WsOrchestrationDispatchCommandRpc, WsOrchestrationGetTurnDiffRpc, WsOrchestrationGetFullThreadDiffRpc, WsOrchestrationGetArchivedShellSnapshotRpc, WsOrchestrationSubscribeShellRpc, WsOrchestrationSubscribeThreadRpc);
 //#endregion
 //#region ../../packages/shared/src/oauthScope.ts
 const OAUTH_SCOPE_TOKEN = /^[\u0021\u0023-\u005b\u005d-\u007e]+$/u;
@@ -30964,11 +31124,25 @@ function isResolvableContextWindowActivity(activity) {
 * newer updates still stream through and supersede the retained rows on the
 * client.
 */
+function withoutContextWindowBreakdown$1(activity) {
+	const payload = asRecord$1(activity.payload);
+	if (!payload || payload.breakdown === void 0) return activity;
+	const { breakdown: _breakdown, ...rest } = payload;
+	return {
+		...activity,
+		payload: rest
+	};
+}
 function dropStaleContextWindowActivities(activities) {
 	const latestIndexByTurn = /* @__PURE__ */ new Map();
 	for (let index = 0; index < activities.length; index += 1) if (isResolvableContextWindowActivity(activities[index])) latestIndexByTurn.set(activities[index].turnId, index);
 	if (latestIndexByTurn.size === 0) return activities;
-	return activities.filter((activity, index) => !isResolvableContextWindowActivity(activity) || latestIndexByTurn.get(activity.turnId) === index);
+	const newestIndex = Math.max(...latestIndexByTurn.values());
+	return activities.flatMap((activity, index) => {
+		if (!isResolvableContextWindowActivity(activity)) return [activity];
+		if (latestIndexByTurn.get(activity.turnId) !== index) return [];
+		return [index === newestIndex ? activity : withoutContextWindowBreakdown$1(activity)];
+	});
 }
 function projectThreadDetailSnapshot(snapshot) {
 	return {
@@ -31116,6 +31290,39 @@ const resolveTaskRepositoryKey = Effect.fn("taskBoard.resolveRepositoryKey")(fun
 	return (yield* (yield* RepositoryIdentityResolver).resolve(project.value.workspaceRoot))?.canonicalKey ?? null;
 });
 /**
+* 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
+* interesting behaviour and each is a different thing for the user to fix,
+* while the handler around them is two store calls and a dispatch. Phase 12's
+* orchestrator has to make the same three decisions before it may claim a task,
+* and it should reach the same verdicts by calling this rather than by reading
+* the handler and reimplementing it.
+*
+* The project is passed in as the repository returns it — including soft-deleted
+* rows, which is why `deletedAt` is checked here rather than assumed away.
+*/
+const resolveTaskStart = (task, project) => {
+	if (task.projectId === null) return {
+		startable: false,
+		reason: "no-project"
+	};
+	if (Option.isNone(project) || project.value.deletedAt !== null) return {
+		startable: false,
+		reason: "project-missing"
+	};
+	const model = project.value.defaultModelSelection;
+	if (model === null) return {
+		startable: false,
+		reason: "no-model"
+	};
+	return {
+		startable: true,
+		projectId: task.projectId,
+		model
+	};
+};
+/**
 * Map a persistence failure to the caller-facing error.
 *
 * The underlying error carries SQL detail, which is noise to a client and, for
@@ -31127,6 +31334,54 @@ const toTaskStoreError = (operation) => (cause) => Effect.logWarning("task store
 	cause
 }).pipe(Effect.andThen(Effect.fail(new TaskStoreError({ operation }))));
 //#endregion
+//#region ../../packages/shared/src/taskExecution.ts
+/**
+* The `auto` rendering: here is the task, do it.
+*
+* Two instructions carry their weight. The agent is told its thread is already
+* linked to the task, because otherwise its first useful move is to guess which
+* board row it is on. And it is told to leave `status` alone: the server moved
+* the task to `in_progress` when it started the thread, and where the work goes
+* after that is the user's call — the same rule the scoping prompt follows, and
+* the reason the board's columns still mean something.
+*/
+const buildAutoPrompt = (task) => {
+	const body = task.body.trim();
+	return `You are picking up a task from the board. Do the work.
+
+## ${task.title}
+
+${body.length === 0 ? "_The task has no description. Read enough of the repository to work out what it means, and ask if it is genuinely ambiguous._" : body}
+
+This thread is linked to task \`${task.taskId}\`, which is now In progress. \`task_current\` re-reads it if you need the fields again.
+
+Record what you find with \`task_update\` as you go — a decision you made, a constraint you hit, something the task turned out to be wrong about. That is what makes the row worth reading afterwards. Leave \`status\` alone: moving work across the board is the user's call.
+
+Start by reading the code the task concerns. If it turns out to be specified too poorly to act on, say so and stop rather than guessing at what was meant.`;
+};
+/**
+* Render a task into the prompt that seeds its thread.
+*
+* Exhaustive over the mode on purpose: adding a member to [TaskExecutionMode]
+* without a rendering should fail to compile rather than fall through to `auto`.
+*/
+const buildTaskExecutionPrompt = (input) => {
+	switch (input.mode) {
+		case "auto": return buildAutoPrompt(input.task);
+	}
+};
+const TASK_THREAD_TITLE_MAX_LENGTH = 60;
+/**
+* The thread's title, which is the task's own — a thread started from a task is
+* that task, and a derived-from-the-prompt title would read as a sentence of
+* instructions in the sidebar.
+*/
+const buildTaskThreadTitle = (title) => {
+	const compact = title.trim().replace(/\s+/gu, " ");
+	if (compact.length === 0) return "Task";
+	return compact.length > TASK_THREAD_TITLE_MAX_LENGTH ? `${compact.slice(0, TASK_THREAD_TITLE_MAX_LENGTH - 1).trimEnd()}…` : compact;
+};
+//#endregion
 //#region src/observability/RpcInstrumentation.ts
 const RPC_SPAN_PREFIX = "ws.rpc";
 const DEFAULT_RPC_SPAN_ATTRIBUTES = {
@@ -40853,6 +41108,7 @@ const RPC_REQUIRED_SCOPE = /* @__PURE__ */ new Map([
 	[WS_METHODS.tasksCreate, AuthOrchestrationOperateScope],
 	[WS_METHODS.tasksUpdate, AuthOrchestrationOperateScope],
 	[WS_METHODS.tasksDelete, AuthOrchestrationOperateScope],
+	[WS_METHODS.tasksStartThread, AuthOrchestrationOperateScope],
 	[WS_METHODS.subscribeTasks, AuthOrchestrationReadScope],
 	[WS_METHODS.hubGetSyncStatus, AuthOrchestrationReadScope],
 	[WS_METHODS.hubConnect, AuthOrchestrationOperateScope],
@@ -40965,7 +41221,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 	const checkpointDiffQuery = yield* CheckpointDiffQuery;
 	const keybindings = yield* Keybindings;
 	const taskRepository = yield* TaskRepository;
-	yield* ProjectionProjectRepository;
+	const projectionProjects = yield* ProjectionProjectRepository;
 	const externalLauncher = yield* ExternalLauncher;
 	const gitWorkflow = yield* GitWorkflowService;
 	const review = yield* ReviewService;
@@ -41443,6 +41699,64 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 			return { task: patched.value };
 		}), { "rpc.aggregate": "tasks" }),
 		[WS_METHODS.tasksDelete]: ({ taskId }) => observeRpcEffect$1(WS_METHODS.tasksDelete, taskRepository.deleteById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.delete")), Effect.as({})), { "rpc.aggregate": "tasks" }),
+		[WS_METHODS.tasksStartThread]: ({ taskId }) => observeRpcEffect$1(WS_METHODS.tasksStartThread, Effect.gen(function* () {
+			const found = yield* taskRepository.getById({ taskId }).pipe(Effect.catch(toTaskStoreError("tasks.startThread")));
+			if (Option.isNone(found)) return yield* new TaskNotFoundError({ taskId });
+			const task = found.value;
+			const plan = resolveTaskStart(task, task.projectId === null ? Option.none() : yield* projectionProjects.getById({ projectId: task.projectId }).pipe(Effect.catch(toTaskStoreError("tasks.startThread.project"))));
+			if (!plan.startable) return yield* new TaskNotStartableError({
+				taskId,
+				reason: plan.reason
+			});
+			const modelSelection = plan.model;
+			const threadId = ThreadId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
+			const createdAt = yield* nowIso$5;
+			const threadTitle = buildTaskThreadTitle(task.title);
+			const normalizedCommand = yield* normalizeDispatchCommand({
+				type: "thread.turn.start",
+				commandId: yield* serverCommandId("task-start-thread"),
+				threadId,
+				message: {
+					messageId: MessageId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)),
+					role: "user",
+					text: buildTaskExecutionPrompt({
+						mode: "auto",
+						task: {
+							taskId,
+							title: task.title,
+							body: task.body
+						}
+					}),
+					attachments: []
+				},
+				modelSelection,
+				titleSeed: threadTitle,
+				runtimeMode: DEFAULT_RUNTIME_MODE$2,
+				interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+				bootstrap: { createThread: {
+					projectId: plan.projectId,
+					title: threadTitle,
+					modelSelection,
+					runtimeMode: DEFAULT_RUNTIME_MODE$2,
+					interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+					branch: null,
+					worktreePath: null,
+					createdAt
+				} },
+				createdAt
+			});
+			yield* dispatchNormalizedCommand(normalizedCommand);
+			const patched = yield* taskRepository.patch({
+				taskId,
+				threadId,
+				status: "in_progress"
+			}, yield* nowIso$5).pipe(Effect.catch(toTaskStoreError("tasks.startThread.link")));
+			if (Option.isNone(patched)) return yield* new TaskNotFoundError({ taskId });
+			return {
+				task: patched.value,
+				threadId
+			};
+		}), { "rpc.aggregate": "tasks" }),
 		[WS_METHODS.subscribeTasks]: (_input) => observeRpcStreamEffect$1(WS_METHODS.subscribeTasks, Effect.succeed(taskRepository.streamWithSnapshot.pipe(Stream.catch((cause) => Stream.fromEffect(toTaskStoreError("tasks.subscribe")(cause))))), { "rpc.aggregate": "tasks" }),
 		[WS_METHODS.hubGetSyncStatus]: (_input) => observeRpcEffect$1(WS_METHODS.hubGetSyncStatus, assetSync.status, { "rpc.aggregate": "hub" }),
 		[WS_METHODS.hubConnect]: (input) => observeRpcEffect$1(WS_METHODS.hubConnect, hubLink.connect(input).pipe(Effect.mapError((cause) => new HubLinkError({ detail: cause.message })), Effect.andThen(assetSync.status)), { "rpc.aggregate": "hub" }),
@@ -45240,13 +45554,178 @@ function normalizeClaudeActiveTokenUsage(value, contextWindow, totalProcessedTok
 		...totalProcessedTokens !== void 0 ? { totalProcessedTokens } : {}
 	});
 }
+/**
+* The contract's string fields are non-empty, and this payload is decoded on the
+* way out, so an entry the SDK reports with a blank name would fail the whole
+* event rather than lose one row. Drop those instead.
+*/
+function trimmedName(value) {
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function mapNamedCosts(entries) {
+	if (!entries || entries.length === 0) return;
+	const mapped = entries.flatMap((entry) => {
+		const name = trimmedName(entry.name);
+		const tokens = finiteNonNegativeInteger(entry.tokens);
+		return name !== void 0 && tokens !== void 0 ? [{
+			name,
+			tokens
+		}] : [];
+	});
+	return mapped.length > 0 ? mapped : void 0;
+}
+/**
+* Keeps the per-source attribution the SDK already computes on every turn. The
+* `gridRows` and `color` fields are dropped: they describe how the vendor CLI
+* paints its own meter, and this UI has its own.
+*/
+function claudeContextWindowBreakdown(value) {
+	const model = trimmedName(value.model);
+	const categories = value.categories.flatMap((category) => {
+		const name = trimmedName(category.name);
+		const tokens = finiteNonNegativeInteger(category.tokens);
+		if (name === void 0 || tokens === void 0) return [];
+		return [{
+			name,
+			tokens,
+			...category.isDeferred !== void 0 ? { isDeferred: category.isDeferred } : {}
+		}];
+	});
+	const mcpTools = value.mcpTools.flatMap((tool) => {
+		const name = trimmedName(tool.name);
+		const serverName = trimmedName(tool.serverName);
+		const tokens = finiteNonNegativeInteger(tool.tokens);
+		if (name === void 0 || serverName === void 0 || tokens === void 0) return [];
+		return [{
+			name,
+			serverName,
+			tokens,
+			...tool.isLoaded !== void 0 ? { isLoaded: tool.isLoaded } : {}
+		}];
+	});
+	const memoryFiles = value.memoryFiles.flatMap((file) => {
+		const path = trimmedName(file.path);
+		const tokens = finiteNonNegativeInteger(file.tokens);
+		if (path === void 0 || tokens === void 0) return [];
+		const type = trimmedName(file.type);
+		return [{
+			path,
+			tokens,
+			...type !== void 0 ? { type } : {}
+		}];
+	});
+	const agents = value.agents.flatMap((agent) => {
+		const agentType = trimmedName(agent.agentType);
+		const tokens = finiteNonNegativeInteger(agent.tokens);
+		if (agentType === void 0 || tokens === void 0) return [];
+		const source = trimmedName(agent.source);
+		return [{
+			agentType,
+			tokens,
+			...source !== void 0 ? { source } : {}
+		}];
+	});
+	const deferredBuiltinTools = value.deferredBuiltinTools?.flatMap((tool) => {
+		const name = trimmedName(tool.name);
+		const tokens = finiteNonNegativeInteger(tool.tokens);
+		return name !== void 0 && tokens !== void 0 ? [{
+			name,
+			tokens,
+			isLoaded: tool.isLoaded
+		}] : [];
+	});
+	const skillsSource = value.skills;
+	const skillEntries = skillsSource?.skillFrontmatter.flatMap((skill) => {
+		const name = trimmedName(skill.name);
+		const tokens = finiteNonNegativeInteger(skill.tokens);
+		if (name === void 0 || tokens === void 0) return [];
+		const source = trimmedName(skill.source);
+		return [{
+			name,
+			tokens,
+			...source !== void 0 ? { source } : {}
+		}];
+	});
+	const skills = skillsSource === void 0 ? void 0 : {
+		totalSkills: finiteNonNegativeInteger(skillsSource.totalSkills) ?? 0,
+		includedSkills: finiteNonNegativeInteger(skillsSource.includedSkills) ?? 0,
+		tokens: finiteNonNegativeInteger(skillsSource.tokens) ?? 0,
+		...skillEntries && skillEntries.length > 0 ? { entries: skillEntries } : {}
+	};
+	const slashCommandsSource = value.slashCommands;
+	const slashCommands = slashCommandsSource === void 0 ? void 0 : {
+		totalCommands: finiteNonNegativeInteger(slashCommandsSource.totalCommands) ?? 0,
+		includedCommands: finiteNonNegativeInteger(slashCommandsSource.includedCommands) ?? 0,
+		tokens: finiteNonNegativeInteger(slashCommandsSource.tokens) ?? 0
+	};
+	const messagesSource = value.messageBreakdown;
+	const toolCallsByType = messagesSource?.toolCallsByType.flatMap((entry) => {
+		const name = trimmedName(entry.name);
+		const callTokens = finiteNonNegativeInteger(entry.callTokens);
+		const resultTokens = finiteNonNegativeInteger(entry.resultTokens);
+		return name !== void 0 && callTokens !== void 0 && resultTokens !== void 0 ? [{
+			name,
+			callTokens,
+			resultTokens
+		}] : [];
+	});
+	const attachmentsByType = mapNamedCosts(messagesSource?.attachmentsByType);
+	const messages = messagesSource === void 0 ? void 0 : {
+		toolCallTokens: finiteNonNegativeInteger(messagesSource.toolCallTokens) ?? 0,
+		toolResultTokens: finiteNonNegativeInteger(messagesSource.toolResultTokens) ?? 0,
+		attachmentTokens: finiteNonNegativeInteger(messagesSource.attachmentTokens) ?? 0,
+		assistantMessageTokens: finiteNonNegativeInteger(messagesSource.assistantMessageTokens) ?? 0,
+		userMessageTokens: finiteNonNegativeInteger(messagesSource.userMessageTokens) ?? 0,
+		redirectedContextTokens: finiteNonNegativeInteger(messagesSource.redirectedContextTokens) ?? 0,
+		unattributedTokens: finiteNonNegativeInteger(messagesSource.unattributedTokens) ?? 0,
+		...toolCallsByType && toolCallsByType.length > 0 ? { toolCallsByType } : {},
+		...attachmentsByType !== void 0 ? { attachmentsByType } : {}
+	};
+	const systemTools = mapNamedCosts(value.systemTools);
+	const systemPromptSections = mapNamedCosts(value.systemPromptSections);
+	const autoCompactThreshold = finiteNonNegativeInteger(value.autoCompactThreshold);
+	const breakdown = {
+		...model !== void 0 ? { model } : {},
+		...categories.length > 0 ? { categories } : {},
+		...mcpTools.length > 0 ? { mcpTools } : {},
+		...skills !== void 0 ? { skills } : {},
+		...memoryFiles.length > 0 ? { memoryFiles } : {},
+		...agents.length > 0 ? { agents } : {},
+		...systemTools !== void 0 ? { systemTools } : {},
+		...deferredBuiltinTools && deferredBuiltinTools.length > 0 ? { deferredBuiltinTools } : {},
+		...systemPromptSections !== void 0 ? { systemPromptSections } : {},
+		...slashCommands !== void 0 ? { slashCommands } : {},
+		...messages !== void 0 ? { messages } : {},
+		...autoCompactThreshold !== void 0 ? { autoCompactThreshold } : {}
+	};
+	return Object.keys(breakdown).length > 0 ? breakdown : void 0;
+}
+/**
+* Drops the attribution from a snapshot that is being carried forward. The token
+* counts still describe the thread, but the breakdown was measured against a
+* turn that has since moved on. A stale breakdown presented as the current one
+* is worse than none, because nothing about it looks stale.
+*/
+function withoutContextWindowBreakdown(usage) {
+	if (!usage || usage.breakdown === void 0) return usage;
+	const { breakdown: _breakdown, ...rest } = usage;
+	return rest;
+}
 function normalizeClaudeContextUsageApiSnapshot(value, totalProcessedTokens) {
-	return makeClaudeTokenUsageSnapshot({
+	const snapshot = makeClaudeTokenUsageSnapshot({
 		activeTokens: value.totalTokens,
 		contextWindow: value.maxTokens,
 		...totalProcessedTokens !== void 0 ? { totalProcessedTokens } : {},
 		compactsAutomatically: value.isAutoCompactEnabled
 	});
+	if (!snapshot) return;
+	const breakdown = claudeContextWindowBreakdown(value);
+	return breakdown !== void 0 ? {
+		...snapshot,
+		breakdown
+	} : snapshot;
 }
 function compactBoundaryTokenUsageSnapshot(message, contextWindow, totalProcessedTokens) {
 	const metadata = message.compact_metadata;
@@ -46039,7 +46518,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const resultHasActiveUsage = resultUsageRecord !== void 0 && (hasResultUsageIteration || claudeUsageInputTokens(resultUsageRecord) + claudeUsageOutputTokens(resultUsageRecord) > 0);
 		const resultTotalOnly = resultUsageRecord !== void 0 && !resultHasActiveUsage && claudeTotalProcessedTokens(resultUsageRecord) !== void 0;
 		const resultIterationSnapshot = resultUsageRecord ? normalizeClaudeActiveTokenUsage(resultUsageRecord, maxTokens, accumulatedTotalProcessedTokens ?? context.lastKnownTotalProcessedTokens) : void 0;
-		const lastGoodUsage = context.lastKnownTokenUsage;
+		const lastGoodUsage = withoutContextWindowBreakdown(context.lastKnownTokenUsage);
 		const usageSnapshot = contextUsageSnapshot ?? (resultTotalOnly && lastGoodUsage ? {
 			...lastGoodUsage,
 			...typeof maxTokens === "number" && Number.isFinite(maxTokens) && maxTokens > 0 ? { maxTokens } : {},