@p4code/cli 0.1.19 → 0.1.21

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$76 = () => {
 const layer$72 = Layer.sync(NetService, make$76);
 //#endregion
 //#region package.json
-var version = "0.1.19";
+var version = "0.1.21";
 //#endregion
 //#region src/config.ts
 /**
@@ -1838,6 +1838,7 @@ const OrchestrationThread = Schema$1.Struct({
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_PROVIDER_INTERACTION_MODE))),
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	latestTurn: Schema$1.NullOr(OrchestrationLatestTurn),
@@ -1879,6 +1880,7 @@ const OrchestrationThreadShell = Schema$1.Struct({
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_PROVIDER_INTERACTION_MODE))),
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	latestTurn: Schema$1.NullOr(OrchestrationLatestTurn),
@@ -2002,6 +2004,7 @@ const ThreadCreateCommand = Schema$1.Struct({
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_PROVIDER_INTERACTION_MODE))),
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime
@@ -2075,6 +2078,18 @@ const ThreadCompressModeSetCommand = Schema$1.Struct({
 	compressMode: CompressMode,
 	createdAt: IsoDateTime
 });
+/**
+* No decoding default on the value, matching the compress command beside it: a
+* command is an instruction someone issued, and defaulting the very field it
+* exists to carry would turn a malformed dispatch into a silent write.
+*/
+const ThreadUnpromptedSubagentsSetCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread.unprompted-subagents.set"),
+	commandId: CommandId,
+	threadId: ThreadId,
+	unpromptedSubagents: Schema$1.Boolean,
+	createdAt: IsoDateTime
+});
 const ThreadTurnStartBootstrapCreateThread = Schema$1.Struct({
 	projectId: ProjectId,
 	title: TrimmedNonEmptyString,
@@ -2082,6 +2097,7 @@ const ThreadTurnStartBootstrapCreateThread = Schema$1.Struct({
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode,
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime
@@ -2112,6 +2128,7 @@ const ThreadTurnStartCommand = Schema$1.Struct({
 	runtimeMode: RuntimeMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_RUNTIME_MODE$2))),
 	interactionMode: ProviderInteractionMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_PROVIDER_INTERACTION_MODE))),
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	bootstrap: Schema$1.optional(ThreadTurnStartBootstrap),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
@@ -2131,6 +2148,7 @@ const ClientThreadTurnStartCommand = Schema$1.Struct({
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode,
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	bootstrap: Schema$1.optional(ThreadTurnStartBootstrap),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
@@ -2187,6 +2205,7 @@ const DispatchableClientOrchestrationCommand = Schema$1.Union([
 	ThreadRuntimeModeSetCommand,
 	ThreadInteractionModeSetCommand,
 	ThreadCompressModeSetCommand,
+	ThreadUnpromptedSubagentsSetCommand,
 	ThreadTurnStartCommand,
 	ThreadTurnInterruptCommand,
 	ThreadApprovalRespondCommand,
@@ -2210,6 +2229,7 @@ const ClientOrchestrationCommand = Schema$1.Union([
 	ThreadRuntimeModeSetCommand,
 	ThreadInteractionModeSetCommand,
 	ThreadCompressModeSetCommand,
+	ThreadUnpromptedSubagentsSetCommand,
 	ClientThreadTurnStartCommand,
 	ThreadTurnInterruptCommand,
 	ThreadApprovalRespondCommand,
@@ -2301,6 +2321,7 @@ const OrchestrationEventType = Schema$1.Literals([
 	"thread.runtime-mode-set",
 	"thread.interaction-mode-set",
 	"thread.compress-mode-set",
+	"thread.unprompted-subagents-set",
 	"thread.message-sent",
 	"thread.turn-start-requested",
 	"thread.turn-interrupt-requested",
@@ -2351,6 +2372,7 @@ const ThreadCreatedPayload$1 = Schema$1.Struct({
 	runtimeMode: RuntimeMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_RUNTIME_MODE$2))),
 	interactionMode: ProviderInteractionMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_PROVIDER_INTERACTION_MODE))),
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime,
@@ -2413,6 +2435,16 @@ const ThreadCompressModeSetPayload$1 = Schema$1.Struct({
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	updatedAt: IsoDateTime
 });
+/**
+* One thread's subagent policy changed. Its own event rather than a field on
+* the compress one, for the reason every event here is narrow: replaying a
+* combined event would rewrite whichever half the user did not touch.
+*/
+const ThreadUnpromptedSubagentsSetPayload$1 = Schema$1.Struct({
+	threadId: ThreadId,
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	updatedAt: IsoDateTime
+});
 const ThreadMessageSentPayload = Schema$1.Struct({
 	threadId: ThreadId,
 	messageId: MessageId,
@@ -2432,6 +2464,7 @@ const ThreadTurnStartRequestedPayload = Schema$1.Struct({
 	runtimeMode: RuntimeMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_RUNTIME_MODE$2))),
 	interactionMode: ProviderInteractionMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_PROVIDER_INTERACTION_MODE))),
 	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	unpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
 });
@@ -2581,6 +2614,11 @@ const OrchestrationEvent = Schema$1.Union([
 		type: Schema$1.Literal("thread.compress-mode-set"),
 		payload: ThreadCompressModeSetPayload$1
 	}),
+	Schema$1.Struct({
+		...EventBaseFields,
+		type: Schema$1.Literal("thread.unprompted-subagents-set"),
+		payload: ThreadUnpromptedSubagentsSetPayload$1
+	}),
 	Schema$1.Struct({
 		...EventBaseFields,
 		type: Schema$1.Literal("thread.message-sent"),
@@ -4587,7 +4625,8 @@ const ProviderSessionStartInput = Schema$1.Struct({
 	approvalPolicy: Schema$1.optional(ProviderApprovalPolicy),
 	sandboxMode: Schema$1.optional(ProviderSandboxMode),
 	runtimeMode: RuntimeMode,
-	compressMode: Schema$1.optional(CompressMode)
+	compressMode: Schema$1.optional(CompressMode),
+	unpromptedSubagents: Schema$1.optional(Schema$1.Boolean)
 });
 const ProviderSendTurnInput = Schema$1.Struct({
 	threadId: ThreadId,
@@ -4595,7 +4634,8 @@ const ProviderSendTurnInput = Schema$1.Struct({
 	attachments: Schema$1.optional(Schema$1.Array(ChatAttachment).check(Schema$1.isMaxLength(8))),
 	modelSelection: Schema$1.optional(ModelSelection),
 	interactionMode: Schema$1.optional(ProviderInteractionMode),
-	compressMode: Schema$1.optional(CompressMode)
+	compressMode: Schema$1.optional(CompressMode),
+	unpromptedSubagents: Schema$1.optional(Schema$1.Boolean)
 });
 Schema$1.Struct({
 	threadId: ThreadId,
@@ -5853,6 +5893,45 @@ const ServerSettings = Schema$1.Struct({
 	* instruction can override an earlier general one.
 	*/
 	enableUnpromptedSubagents: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	/**
+	* Whether the board offers the scoping agent: the Scope action on a task and
+	* the panel that drafts a new one by interview.
+	*
+	* A switch rather than a permanent fixture because the discipline it imposes
+	* — one question at a time, no file edits, a task body with verifiable
+	* criteria — is a way of working, not a fact about the product. Someone who
+	* writes their own tasks wants the button gone, not ignored.
+	*
+	* Off hides the entry points. It does not delete the skill file already
+	* written into a repository, and it does not stop anyone invoking the same
+	* discipline by name from an ordinary chat: that is what {@link disabledSkills}
+	* is for.
+	*/
+	enableScopingAgent: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	/**
+	* Whether the board offers the plan phase: splitting one scoped task into
+	* ordered subtasks. Separate from {@link enableScopingAgent} because the two
+	* are useful apart — scoping a task by interview says nothing about wanting
+	* it decomposed, and a board that plans everything into five rows is a board
+	* nobody reads.
+	*/
+	enablePlanPhase: Schema$1.Boolean.pipe(Schema$1.withDecodingDefault(Effect.succeed(true))),
+	/**
+	* Whether the scoping and planning flows write their generated `SKILL.md`
+	* into the repository they run in.
+	*
+	* Its own switch because it is the only one of the three with a side effect
+	* outside p4code: the file lands in the working tree and shows up in
+	* `git status`, which is unwelcome in a repo whose `.claude/` is checked in
+	* and shared. Off does not cost the discipline — the thread seed carries the
+	* rules inline instead, exactly as the create flow already does for providers
+	* with no notion of a skill — it costs only invoking it by name later from an
+	* ordinary chat.
+	*
+	* Files already written are left alone. Nothing here deletes anything from a
+	* user's repository.
+	*/
+	writeGeneratedSkillsToRepo: 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))),
@@ -5988,6 +6067,9 @@ const ServerSettingsPatch = Schema$1.Struct({
 	enableProviderUpdateChecks: Schema$1.optionalKey(Schema$1.Boolean),
 	enableToolCallNarration: Schema$1.optionalKey(Schema$1.Boolean),
 	enableUnpromptedSubagents: Schema$1.optionalKey(Schema$1.Boolean),
+	enableScopingAgent: Schema$1.optionalKey(Schema$1.Boolean),
+	enablePlanPhase: Schema$1.optionalKey(Schema$1.Boolean),
+	writeGeneratedSkillsToRepo: 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),
@@ -7263,6 +7345,21 @@ const TaskExternalRef = Schema$1.Struct({
 	url: TrimmedNonEmptyString
 });
 const ExternalRefField = TaskExternalRef.pipe(Schema$1.annotateEncoded({ description: "The tracker issue this task mirrors, e.g. a Linear ticket. Null for a task that originated on this board." }));
+/**
+* The task this one was split out of.
+*
+* Carried as a field rather than as a sentence in the body because the plan
+* phase writes it and the board reads it: a parent chip, a subtask list and
+* "does this still have unfinished children" are all questions about the graph,
+* and prose cannot be asked them. Stored as the parent's UUID, but accepted as
+* either a UUID or a readable id on the way in - a planning agent works in
+* `P4-12`, and making it look up a UUID first is a round trip for nothing.
+*
+* One level is all this promises. Nothing forbids a subtask of a subtask, and
+* nothing walks the chain either; the board renders the direct children of a
+* task and stops.
+*/
+const ParentTaskIdField = TaskId.pipe(Schema$1.annotateEncoded({ description: "The task this one is a subtask of - the parent's UUID or readable id (e.g. P4-12). Null for a task that is not part of a larger one." }));
 const LabelsField = Schema$1.Array(TaskLabel).check(Schema$1.isMaxLength(TASK_LABELS_MAX_COUNT)).pipe(Schema$1.annotateEncoded({ description: "Free-form tags used to group and filter tasks." }));
 const TaskIdField = TaskId.pipe(Schema$1.annotateEncoded({ description: "Id of the task to act on - the UUID or the readable id (e.g. P4-12)." }));
 const Task = Schema$1.Struct({
@@ -7311,6 +7408,13 @@ const Task = Schema$1.Struct({
 	* `null` rather than failing the whole board.
 	*/
 	externalRef: Schema$1.NullOr(TaskExternalRef).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
+	/**
+	* The task this one was split out of, always as a UUID once stored - a
+	* readable id given on the way in is resolved before the row is written, so
+	* the link survives a board where readable ids were allocated elsewhere.
+	* Nullable-with-default for the same version-skew reason as `readableId`.
+	*/
+	parentTaskId: Schema$1.NullOr(TaskId).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
 	title: TrimmedNonEmptyString.check(Schema$1.isMaxLength(TASK_TITLE_MAX_LENGTH)),
 	body: Schema$1.String,
 	status: StoredStatusField,
@@ -7325,6 +7429,7 @@ const TaskCreateInput = Schema$1.Struct({
 	repositoryKey: Schema$1.optional(RepositoryKeyField),
 	threadId: Schema$1.optional(ThreadIdField),
 	externalRef: Schema$1.optional(ExternalRefField),
+	parentTaskId: Schema$1.optional(ParentTaskIdField),
 	title: TitleField,
 	body: Schema$1.optional(BodyField),
 	status: Schema$1.optional(StatusField),
@@ -7364,6 +7469,7 @@ const TaskUpdateInput = Schema$1.Struct({
 	repositoryKey: Schema$1.optional(Schema$1.NullOr(RepositoryKeyField)),
 	threadId: Schema$1.optional(Schema$1.NullOr(ThreadIdField)),
 	externalRef: Schema$1.optional(Schema$1.NullOr(ExternalRefField)),
+	parentTaskId: Schema$1.optional(Schema$1.NullOr(ParentTaskIdField)),
 	title: Schema$1.optional(TitleField),
 	body: Schema$1.optional(BodyField),
 	status: Schema$1.optional(StatusField),
@@ -7783,22 +7889,44 @@ var TicketResolveError = class extends Schema$1.TaggedErrorClass()("TicketResolv
 //#endregion
 //#region ../../packages/contracts/src/threadControl.ts
 /**
-* Thread control over MCP - the self-scoped toolkit an agent uses to act on
-* the thread it is running in.
-*
-* Deliberately narrow. The reported need was an agent renaming its own thread;
-* that needs no cross-thread reach, and the per-session bearer token is the
-* only thing guarding `/mcp` on a remote-reachable server, so a capability
-* that could rename arbitrary threads would be a capability to vandalise the
-* workspace from one leaked token. Delete and create are withheld outright,
-* the same answer the task toolkit gave. Settle is absent for a structural
-* reason rather than a policy one: the decider refuses `thread.settle` while
-* the thread's session is starting or running, and a self-scoped MCP call
-* always arrives from its own live session, so the call could never succeed.
+* Thread control over MCP - the toolkit an agent uses to act on its own thread
+* and on the threads it started.
+*
+* **The scope rule.** A per-session bearer token is the only thing guarding
+* `/mcp` on a remote-reachable server, so reach is granted, never assumed. A
+* session may address its own thread and the threads it created through
+* `thread_spawn`, and nothing else. A leaked token therefore still reaches only
+* work that token itself began. The grant is held on the credential rather than
+* derived from the board, so it cannot widen because someone edited a task.
+*
+* **Delete is not exposed, and that is the decision rather than an omission.**
+* It is the one irreversible action here and a thread carries its whole
+* transcript. The task toolkit gave the same answer for the same reason, and a
+* thread is the more expensive thing to lose. An agent that wants a thread gone
+* settles it and says so; a person deletes it.
+*
+* **Spawning is one level deep.** `thread_spawn` seeds a first message and
+* starts the turn, because a create that cannot say anything is not the feature
+* anyone asked for. A thread that was itself spawned may not spawn: the depth
+* cap is what a runaway loop runs into, and one level is enough for "split this
+* task and start the pieces" while still being a structural bound rather than a
+* prompt asking nicely.
+*
+* **Settle is queued rather than refused.** The decider refuses `thread.settle`
+* while the target's session is starting or running, and an MCP call from a
+* thread's own session always arrives while that session is alive - so the
+* self-addressed case could never succeed as an immediate command. It is
+* recorded instead and applied when the session stops, which is what an agent
+* settling its own thread means anyway: finish, then close.
 *
 * Quick-append to memory lives here too: it is the other thing an agent wants
 * to do *from* a thread, and it shares the toolkit's capability and scope.
 *
+* Compressing an asset joins them for a different reason. It is a write the
+* agent could perform with its ordinary file tools, and the point of routing it
+* through a tool instead is that the server gets to check the rewrite before it
+* lands - and to keep the original somewhere the rewrite cannot reach.
+*
 * @module contracts/threadControl
 */
 const ThreadRenameInput = Schema$1.Struct({ title: TrimmedNonEmptyString.annotate({ description: "The new thread title. Replaces the current one." }) });
@@ -7807,6 +7935,64 @@ const ThreadRenameResult = Schema$1.Struct({
 	title: TrimmedNonEmptyString
 });
 /**
+* Which thread a control tool acts on.
+*
+* Optional, and absent means the caller's own thread. That default is what
+* keeps the common case honest: an agent adjusting itself never has to name an
+* id, so it cannot name the wrong one, and every tool below reads the same way
+* whether or not it is addressed elsewhere.
+*/
+const ControlTargetThreadId = Schema$1.optional(ThreadId.annotate({ description: "The thread to act on. Omit for this session's own thread. Only threads this session started with thread_spawn can be named here; any other id is refused." }));
+const ThreadSpawnInput = Schema$1.Struct({
+	title: TrimmedNonEmptyString.annotate({ description: "Title for the new thread. Shown on the board and in the sidebar." }),
+	prompt: TrimmedNonEmptyString.annotate({ description: "The first message to send. The thread starts its turn immediately, so this is the whole brief the new agent gets." }),
+	projectId: Schema$1.optional(ProjectId.annotate({ description: "Project to start the thread in. Defaults to this session's own project." })),
+	runtimeMode: Schema$1.optional(RuntimeMode.annotate({ description: "Permission mode for the new thread. Defaults to this session's own." })),
+	interactionMode: Schema$1.optional(ProviderInteractionMode),
+	compressMode: Schema$1.optional(CompressMode),
+	unpromptedSubagents: Schema$1.optional(Schema$1.Boolean)
+});
+const ThreadSpawnResult = Schema$1.Struct({
+	/** Watchable with `thread_watch_events`, and addressable by every tool here. */
+	threadId: ThreadId,
+	projectId: ProjectId,
+	title: TrimmedNonEmptyString
+});
+const ThreadConfigureInput = Schema$1.Struct({
+	threadId: ControlTargetThreadId,
+	title: Schema$1.optional(TrimmedNonEmptyString),
+	modelSelection: Schema$1.optional(ModelSelection),
+	runtimeMode: Schema$1.optional(RuntimeMode),
+	interactionMode: Schema$1.optional(ProviderInteractionMode),
+	compressMode: Schema$1.optional(CompressMode),
+	unpromptedSubagents: Schema$1.optional(Schema$1.Boolean)
+});
+const ThreadConfigureResult = Schema$1.Struct({
+	threadId: ThreadId,
+	/** The settings that were actually changed, in the order they were applied. */
+	applied: Schema$1.Array(Schema$1.String)
+});
+const ThreadSettleInput = Schema$1.Struct({ threadId: ControlTargetThreadId });
+/**
+* Settled now, or recorded to settle when the session stops.
+*
+* Two outcomes rather than one because the difference is the agent's to know: a
+* queued settle has not happened yet, and a thread that goes on to do more work
+* still settles at the end of it.
+*/
+const ThreadSettleResult = Schema$1.Struct({
+	threadId: ThreadId,
+	outcome: Schema$1.Literals(["settled", "queued"])
+});
+const ThreadSnoozeInput = Schema$1.Struct({
+	threadId: ControlTargetThreadId,
+	snoozedUntil: IsoDateTime.annotate({ description: "When the thread should come back, as an ISO 8601 timestamp." })
+});
+const ThreadSnoozeResult = Schema$1.Struct({
+	threadId: ThreadId,
+	snoozedUntil: IsoDateTime
+});
+/**
 * Which memory file an append lands in.
 *
 * A closed union rather than a filename, because the target directory also
@@ -7825,6 +8011,23 @@ const MemoryAppendResult = Schema$1.Struct({
 	/** Absolute path the append landed in, so the agent can cite or inspect it. */
 	path: Schema$1.String
 });
+const AssetCompressInput = Schema$1.Struct({
+	path: TrimmedNonEmptyString.annotate({ description: "Absolute path of the asset file to overwrite. Must sit inside one of this machine's agent asset directories: user skills, the provider config directory that holds the memory files, or the subagent definitions directory." }),
+	content: Schema$1.String.check(Schema$1.isNonEmpty()).annotate({ description: "The compressed file, whole. Headings, fenced code blocks, inline code, URLs, paths and any YAML frontmatter must come back unchanged; only the prose around them may be rewritten." })
+});
+const AssetCompressResult = Schema$1.Struct({
+	/** Absolute path that was rewritten. */
+	path: Schema$1.String,
+	/** Where the pre-compression original was kept, outside every synced directory. */
+	backupPath: Schema$1.String,
+	charsBefore: Schema$1.Number,
+	charsAfter: Schema$1.Number,
+	/** Estimated at four characters per token, not measured by a provider tokenizer. */
+	estimatedTokensBefore: Schema$1.Number,
+	estimatedTokensAfter: Schema$1.Number,
+	/** Differences worth reporting that were not worth refusing the write over. */
+	warnings: Schema$1.Array(Schema$1.String)
+});
 var ThreadToolUnavailableError = class extends Schema$1.TaggedErrorClass()("ThreadToolUnavailableError", {
 	capability: Schema$1.Literal("threads"),
 	environmentId: EnvironmentId,
@@ -7853,10 +8056,77 @@ var MemoryAppendFailedError = class extends Schema$1.TaggedErrorClass()("MemoryA
 		return `Appending to ${this.file} failed: ${this.detail}`;
 	}
 };
+/**
+* The compression will not be attempted, or the file could not be read.
+*
+* Separate from the validation failure below because they want opposite
+* responses. A refusal is final - the path is not an asset, the name looks like
+* a credential, the file is not there - and retrying it produces the same
+* answer. A validation failure is a rewrite that can be corrected.
+*/
+var AssetCompressRefusedError = class extends Schema$1.TaggedErrorClass()("AssetCompressRefusedError", {
+	path: Schema$1.String,
+	detail: Schema$1.String
+}) {
+	get message() {
+		return `Compressing ${this.path} was refused: ${this.detail}`;
+	}
+};
+/**
+* The rewrite lost something, and nothing was written.
+*
+* Carries the checks that failed rather than a summary, because the agent's
+* next move is to restore exactly those things from the original and call
+* again. The file on disk is untouched, so a second failure costs nothing more.
+*/
+var AssetCompressValidationFailedError = class extends Schema$1.TaggedErrorClass()("AssetCompressValidationFailedError", {
+	path: Schema$1.String,
+	errors: Schema$1.Array(Schema$1.String)
+}) {
+	get message() {
+		return `The compressed ${this.path} did not validate, so nothing was written: ${this.errors.join(" ")}`;
+	}
+};
+/**
+* The named thread is outside this session's grant.
+*
+* Deliberately the same answer whether the thread does not exist or exists and
+* belongs to someone else: a caller that could tell those apart could map the
+* whole board one id at a time.
+*/
+var ThreadControlNotPermittedError = class extends Schema$1.TaggedErrorClass()("ThreadControlNotPermittedError", { threadId: ThreadId }) {
+	get message() {
+		return `This session cannot act on thread ${this.threadId}. A session may act on its own thread and on threads it started with thread_spawn.`;
+	}
+};
+/** A spawned thread asked to spawn. One level is the whole allowance. */
+var ThreadSpawnNotPermittedError = class extends Schema$1.TaggedErrorClass()("ThreadSpawnNotPermittedError", {
+	threadId: ThreadId,
+	detail: Schema$1.String
+}) {
+	get message() {
+		return `Thread ${this.threadId} cannot start another thread: ${this.detail}`;
+	}
+};
+/** The orchestration engine declined or failed a thread control command. */
+var ThreadControlRejectedError = class extends Schema$1.TaggedErrorClass()("ThreadControlRejectedError", {
+	threadId: ThreadId,
+	commandType: Schema$1.String,
+	detail: Schema$1.String
+}) {
+	get message() {
+		return `${this.commandType} on thread ${this.threadId} failed: ${this.detail}`;
+	}
+};
 const ThreadControlToolError = Schema$1.Union([
 	ThreadToolUnavailableError,
+	ThreadControlNotPermittedError,
+	ThreadSpawnNotPermittedError,
+	ThreadControlRejectedError,
 	ThreadRenameRejectedError,
-	MemoryAppendFailedError
+	MemoryAppendFailedError,
+	AssetCompressRefusedError,
+	AssetCompressValidationFailedError
 ]);
 const ThreadWatchEventsInput = Schema$1.Struct({
 	threadId: ThreadId.annotate({ description: "The watched thread to read events from. Must be explicitly granted." }),
@@ -12660,6 +12930,53 @@ var _040_TaskExternalRef_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/persistence/Migrations/041_TaskParentTaskId.ts
+/**
+* The task a task was split out of, for the plan phase's subtasks.
+*
+* A plain column rather than a join table: a task has at most one parent, and
+* the question asked of it is always "children of this row", which one indexed
+* column answers.
+*
+* No foreign key. Tasks are synced between machines and a child can arrive
+* before its parent does, or outlive it - a constraint would reject the write
+* rather than leave a link that resolves later. The board treats a parent it
+* cannot find as no parent at all.
+*
+* The index is non-unique and partial: many children per parent, and the many
+* rows that are nobody's child stay out of it.
+*/
+var _041_TaskParentTaskId_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`;
+	yield* sql`
+    CREATE INDEX IF NOT EXISTS idx_tasks_parent_task_id
+    ON tasks(parent_task_id)
+    WHERE parent_task_id IS NOT NULL
+  `;
+});
+//#endregion
+//#region src/persistence/Migrations/042_ProjectionThreadsUnpromptedSubagents.ts
+/**
+* Whether a thread lets the model spawn subagents without being asked, moved
+* from a machine-wide setting onto the thread itself.
+*
+* Stored as an integer beside `has_actionable_proposed_plan` rather than as a
+* SQLite boolean, which does not exist; the projection reads it back as
+* `> 0`.
+*
+* The default is `1` — subagents allowed — because that is what every existing
+* thread has been doing under the old server setting. Anything else would
+* change the behaviour of live threads on upgrade, which is not a migration's
+* business.
+*/
+var _042_ProjectionThreadsUnpromptedSubagents_default = Effect.gen(function* () {
+	yield* (yield* SqlClient.SqlClient)`
+    ALTER TABLE projection_threads
+    ADD COLUMN unprompted_subagents INTEGER NOT NULL DEFAULT 1
+  `;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -12880,6 +13197,16 @@ const migrationEntries = [
 		40,
 		"TaskExternalRef",
 		_040_TaskExternalRef_default
+	],
+	[
+		41,
+		"TaskParentTaskId",
+		_041_TaskParentTaskId_default
+	],
+	[
+		42,
+		"ProjectionThreadsUnpromptedSubagents",
+		_042_ProjectionThreadsUnpromptedSubagents_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -14511,6 +14838,7 @@ const TASK_COLUMNS = `
   repository_key AS "repositoryKey",
   thread_id AS "threadId",
   external_ref_json AS "externalRef",
+  parent_task_id AS "parentTaskId",
   title,
   body,
   status,
@@ -14535,6 +14863,7 @@ const makeTaskRepository = Effect.gen(function* () {
           repository_key,
           thread_id,
           external_ref_json,
+          parent_task_id,
           title,
           body,
           status,
@@ -14552,6 +14881,7 @@ const makeTaskRepository = Effect.gen(function* () {
           ${row.repositoryKey},
           ${row.threadId},
           ${row.externalRef === null ? null : JSON.stringify(row.externalRef)},
+          ${row.parentTaskId},
           ${row.title},
           ${row.body},
           ${row.status},
@@ -14569,6 +14899,7 @@ const makeTaskRepository = Effect.gen(function* () {
           repository_key = excluded.repository_key,
           thread_id = excluded.thread_id,
           external_ref_json = excluded.external_ref_json,
+          parent_task_id = excluded.parent_task_id,
           title = excluded.title,
           body = excluded.body,
           status = excluded.status,
@@ -14668,6 +14999,7 @@ const makeTaskRepository = Effect.gen(function* () {
 			...input.repositoryKey !== void 0 ? { repositoryKey: input.repositoryKey } : {},
 			...input.threadId !== void 0 ? { threadId: input.threadId } : {},
 			...input.externalRef !== void 0 ? { externalRef: input.externalRef } : {},
+			...input.parentTaskId !== void 0 ? { parentTaskId: input.parentTaskId } : {},
 			...input.title !== void 0 ? { title: input.title } : {},
 			...input.body !== void 0 ? { body: input.body } : {},
 			...input.status !== void 0 ? { status: input.status } : {},
@@ -14706,6 +15038,8 @@ const makeTaskRepository = Effect.gen(function* () {
 			...input.patch.projectId !== void 0 ? { projectId: input.patch.projectId } : {},
 			...input.patch.repositoryKey !== void 0 ? { repositoryKey: input.patch.repositoryKey } : {},
 			...input.patch.threadId !== void 0 ? { threadId: input.patch.threadId } : {},
+			...input.patch.externalRef !== void 0 ? { externalRef: input.patch.externalRef } : {},
+			...input.patch.parentTaskId !== void 0 ? { parentTaskId: input.patch.parentTaskId } : {},
 			...input.patch.title !== void 0 ? { title: input.patch.title } : {},
 			...input.patch.body !== void 0 ? { body: input.patch.body } : {},
 			...input.patch.status !== void 0 ? { status: input.patch.status } : {},
@@ -14840,6 +15174,7 @@ const createTaskRoute = HttpRouter.add("POST", "/tasks", respondToHubFailures(Ef
 		repositoryKey: input.repositoryKey ?? null,
 		threadId: input.threadId ?? null,
 		externalRef: input.externalRef ?? null,
+		parentTaskId: input.parentTaskId ?? null,
 		title: input.title,
 		body: input.body ?? "",
 		status: input.status ?? "backlog",
@@ -15159,6 +15494,22 @@ var _006_TaskExternalRef_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/hub/Migrations/007_TaskParentTaskId.ts
+/**
+* The task a task was split out of, mirroring the environment server's
+* migration 041. The hub carries the column so a plan filed on one machine
+* still reads as a plan on another, rather than as a handful of loose tasks.
+*/
+var _007_TaskParentTaskId_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`;
+	yield* sql`
+    CREATE INDEX IF NOT EXISTS idx_tasks_parent_task_id
+    ON tasks(parent_task_id)
+    WHERE parent_task_id IS NOT NULL
+  `;
+});
+//#endregion
 //#region src/hub/Migrations.ts
 /**
 * Hub migrations.
@@ -15199,6 +15550,11 @@ const hubMigrationEntries = [
 		6,
 		"TaskExternalRef",
 		_006_TaskExternalRef_default
+	],
+	[
+		7,
+		"TaskParentTaskId",
+		_007_TaskParentTaskId_default
 	]
 ];
 const hubMigrationLoader = Migrator.fromRecord(Object.fromEntries(hubMigrationEntries.map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -16714,7 +17070,7 @@ const isIgnoredEntry = (entry) => IGNORED_ENTRIES.has(entry) || entry.startsWith
 * Exported so the single-file kinds ask it the same way this one does, rather
 * than each keeping a copy that could drift into a different answer.
 */
-const looksBinary$1 = (content) => content.includes("\0");
+const looksBinary$2 = (content) => content.includes("\0");
 /**
 * Read one directory as an asset's files, or say why it cannot be one.
 *
@@ -16746,7 +17102,7 @@ const readSkillFiles = Effect.fn("skillDirectory.readSkillFiles")(function* (roo
 			if (files.length >= 512) return "too-many-files";
 			const content = yield* fileSystem.readFileString(absolute).pipe(Effect.orElseSucceed(() => void 0));
 			if (content === void 0) return "unreadable";
-			if (looksBinary$1(content)) return "binary-file";
+			if (looksBinary$2(content)) return "binary-file";
 			if (content.length > 524288) return "file-too-large";
 			files.push({
 				path: relative,
@@ -16870,7 +17226,7 @@ const readAgentDefinitions = Effect.fn("agentDefinitionFiles.read")(function* (a
 			});
 			continue;
 		}
-		if (looksBinary$1(content)) {
+		if (looksBinary$2(content)) {
 			refused.push({
 				name: entry,
 				reason: "binary-file"
@@ -17392,7 +17748,7 @@ const isMemoryDirectoryName = (name) => MEMORY_DIRECTORY_NAMES.includes(name);
 */
 const isMemoryAssetName = (name) => isMemoryFileName(name) || isMemoryDirectoryName(name);
 /** The same test the skill reader uses: a NUL is what breaks a JSON text column. */
-const looksBinary = (content) => content.includes("\0");
+const looksBinary$1 = (content) => content.includes("\0");
 /**
 * Read whichever memory files exist in this machine's config directory.
 *
@@ -17416,7 +17772,7 @@ const readMemoryFiles = Effect.fn("memoryFile.readMemoryFiles")(function* (memor
 			});
 			continue;
 		}
-		if (looksBinary(content)) {
+		if (looksBinary$1(content)) {
 			refused.push({
 				name,
 				reason: "binary-file"
@@ -18529,6 +18885,8 @@ Never drop not/never/no/only/except: flipping the meaning costs more than any to
 
 Tool calls: fire direct. No plan, no progress note between calls, never announce the next call. If the harness asks for a short lead-in before tool calls, write that one line and nothing more. Otherwise text before a call only to clarify, warn about a security or irreversible action, or resolve ambiguity.
 
+Subagent and tool output is raw material, not the answer. Never relay a subagent report, a file listing, or command output verbatim - state the conclusion it supports and cite the file and line that back it. Its length is its own and is never a licence to answer at that length. Quote from it only where the exact wording is the point.
+
 Preserve the user's dominant language: reply in the language the user writes, whatever language the examples or the surrounding context use. Compress the style, not the language. Every emitted line in that language, lead-in lines included, not just the final reply. Always keep technical terms, code, API names, CLI commands, commit-type keywords (feat/fix/...), and exact error strings verbatim unless the user explicitly asks for translation.
 
 Dropping articles applies to article languages only. Where small markers carry case or role (particles, postpositions), keep them: grammar, not filler. Compress politeness and filler instead.
@@ -18622,6 +18980,16 @@ function compressTurnReminderFor(mode) {
 */
 const PRESET_MAX_RESULT_ROWS = 20;
 /**
+* The tool calls a preset run is allowed.
+*
+* Fifteen because a located answer typically takes six to ten, and the runs
+* that overshoot do not overshoot slightly: measured against real transcripts,
+* the long tail sits between sixty and a hundred and thirty calls and carries
+* nearly all of the cost. A cap that a good run never reaches is a cap that only
+* ever bites the runs that had stopped making progress.
+*/
+const PRESET_MAX_TOOL_CALLS = 15;
+/**
 * Named `p4-*` on purpose.
 *
 * The directory is shared with whatever the user has written by hand, and
@@ -18651,6 +19019,34 @@ names a path that is not there, answer with the BLOCKED line below. Guessing at
 the missing half of a request produces an answer that reads as confident and is
 not checkable, which is worse than no answer.`;
 /**
+* What every preset says about the run in between.
+*
+* Three rules, each aimed at a measured failure. The cap bounds the quadratic.
+* The ban on nesting stops a bounded run from spawning an unbounded one, which
+* is the same bill again with nothing watching it. The stop-at-the-cap clause is
+* what makes the number safe to enforce: without somewhere to put a partial
+* answer, a capped subagent either grinds past the cap or throws away what it
+* had, and both are worse than a short table with a named gap.
+*/
+const WORK_BUDGET = `## What the run costs
+
+At most ${PRESET_MAX_TOOL_CALLS} tool calls. Most answers of this kind take six
+to ten, so treat the cap as the point where something has gone wrong rather than
+as a target to spend.
+
+Spend them on calls that can fail usefully: before each one, know what a hit and
+a miss would each tell you. Batch searches into one call separated by echoed
+markers rather than issuing them one at a time, bound every output with a head
+or a line count, and read a file only after a search has told you which lines
+matter, and read those lines. Never repeat a call you have already made.
+
+Do not spawn a subagent of your own. You are the bounded run; one that starts
+another has spent the budget twice with nothing watching the second half.
+
+Reaching the cap ends the run. Return the rows you have verified, and add a
+final line naming the search you would have run next. With no verified rows at
+all, that is the BLOCKED line.`;
+/**
 * What every preset says about the answer.
 *
 * The two sentinels matter as much as the table. Without `NONE` a clean run
@@ -18669,7 +19065,8 @@ const outputContract = (row, extra) => [
 	`    ${row}`,
 	"",
 	"Nothing to report: the single word NONE.",
-	"Request insufficient: BLOCKED - <what is missing>, on one line.",
+	"Request insufficient, or the budget spent before anything was verified:",
+	"BLOCKED - <what is missing>, on one line.",
 	"",
 	"Paths are repository-relative and carry a line number. A row without one is",
 	"a row you have not verified: open the file and get it.",
@@ -18681,6 +19078,11 @@ const outputContract = (row, extra) => [
 * The compression ruleset goes last so the contract above it is read first.
 * Both are instructions to the same model and neither overrides the other:
 * the contract fixes the shape, the ruleset fixes the prose inside it.
+*
+* `model` is optional, and omitting it inherits the session's. Naming a cheaper
+* tier is worth it only where the job is mechanical enough that the tier is not
+* what makes the answer right, which is true of locating a symbol and is not
+* true of deciding whether a line is a bug.
 */
 const buildPreset = (input) => {
 	const name = `${PRESET_NAME_PREFIX}${input.name}`;
@@ -18689,6 +19091,7 @@ const buildPreset = (input) => {
 		`name: ${name}`,
 		`description: ${JSON.stringify(input.description)}`,
 		`tools: ${input.tools}`,
+		...input.model === void 0 ? [] : [`model: ${input.model}`],
 		"---",
 		"",
 		input.body.trim(),
@@ -18711,12 +19114,15 @@ const AGENT_PRESETS = [buildPreset({
 	name: "investigator",
 	description: "Find where something lives in the codebase. Use when the answer is a set of locations rather than a change. Returns a fixed table of path:line rows and nothing else.",
 	tools: "Read, Grep, Glob, Bash",
+	model: "sonnet",
 	summary: "Locates code and answers with a path:line table.",
 	body: `You locate code. You do not change it, and you say no more about any location
 than the one clause that explains why it is in the list.
 
 ${INPUT_CONTRACT}
 
+${WORK_BUDGET}
+
 ${outputContract("path:line - symbol - one clause on why it matters", [
 		"",
 		"Symbol is the function, type or constant the line belongs to, not a paraphrase",
@@ -18734,6 +19140,8 @@ approval is a list that has to be re-read to find the three rows that matter.
 
 ${INPUT_CONTRACT}
 
+${WORK_BUDGET}
+
 ${outputContract("path:line - severity - what is wrong, and what it breaks", [
 		"",
 		"Severity is one of three words:",
@@ -19788,6 +20196,7 @@ const ThreadMetaUpdatedPayload = ThreadMetaUpdatedPayload$1;
 const ThreadRuntimeModeSetPayload = ThreadRuntimeModeSetPayload$1;
 const ThreadInteractionModeSetPayload = ThreadInteractionModeSetPayload$1;
 const ThreadCompressModeSetPayload = ThreadCompressModeSetPayload$1;
+const ThreadUnpromptedSubagentsSetPayload = ThreadUnpromptedSubagentsSetPayload$1;
 const ThreadDeletedPayload = ThreadDeletedPayload$1;
 const ThreadUnarchivedPayload = ThreadUnarchivedPayload$1;
 const ThreadUnsettledPayload = ThreadUnsettledPayload$1;
@@ -19928,6 +20337,7 @@ function projectEvent(model, event) {
 				runtimeMode: payload.runtimeMode,
 				interactionMode: payload.interactionMode,
 				compressMode: payload.compressMode,
+				unpromptedSubagents: payload.unpromptedSubagents,
 				branch: payload.branch,
 				worktreePath: payload.worktreePath,
 				latestTurn: null,
@@ -20034,6 +20444,13 @@ function projectEvent(model, event) {
 				updatedAt: payload.updatedAt
 			})
 		})));
+		case "thread.unprompted-subagents-set": return decodeForEvent(ThreadUnpromptedSubagentsSetPayload, event.payload, event.type, "payload").pipe(Effect.map((payload) => ({
+			...nextBase,
+			threads: updateThread(nextBase.threads, payload.threadId, {
+				unpromptedSubagents: payload.unpromptedSubagents,
+				updatedAt: payload.updatedAt
+			})
+		})));
 		case "thread.message-sent": return Effect.gen(function* () {
 			const payload = yield* decodeForEvent(MessageSentPayloadSchema, event.payload, event.type, "payload");
 			const thread = nextBase.threads.find((entry) => entry.id === payload.threadId);
@@ -20400,6 +20817,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 					runtimeMode: command.runtimeMode,
 					interactionMode: command.interactionMode,
 					compressMode: command.compressMode,
+					unpromptedSubagents: command.unpromptedSubagents,
 					branch: command.branch,
 					worktreePath: command.worktreePath,
 					createdAt: command.createdAt,
@@ -20679,6 +21097,28 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				}
 			};
 		}
+		case "thread.unprompted-subagents.set": {
+			yield* requireThread({
+				readModel,
+				command,
+				threadId: command.threadId
+			});
+			const occurredAt = yield* nowIso$8;
+			return {
+				...yield* withEventBase({
+					aggregateKind: "thread",
+					aggregateId: command.threadId,
+					occurredAt,
+					commandId: command.commandId
+				}),
+				type: "thread.unprompted-subagents-set",
+				payload: {
+					threadId: command.threadId,
+					unpromptedSubagents: command.unpromptedSubagents,
+					updatedAt: occurredAt
+				}
+			};
+		}
 		case "thread.turn.start": {
 			const targetThread = yield* requireThread({
 				readModel,
@@ -20737,6 +21177,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 					runtimeMode: targetThread.runtimeMode,
 					interactionMode: targetThread.interactionMode,
 					compressMode: targetThread.compressMode,
+					unpromptedSubagents: targetThread.unpromptedSubagents,
 					...sourceProposedPlan !== void 0 ? { sourceProposedPlan } : {},
 					createdAt: command.createdAt
 				}
@@ -21503,6 +21944,8 @@ const ProjectionThread = Schema$1.Struct({
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode,
 	compressMode: CompressMode,
+	/** 0 or 1: SQLite has no boolean, matching `hasActionableProposedPlan`. */
+	unpromptedSubagents: NonNegativeInt,
 	branch: Schema$1.NullOr(Schema$1.String),
 	worktreePath: Schema$1.NullOr(Schema$1.String),
 	latestTurnId: Schema$1.NullOr(TurnId),
@@ -22391,6 +22834,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           runtime_mode,
           interaction_mode,
           compress_mode,
+          unprompted_subagents,
           branch,
           worktree_path,
           latest_turn_id,
@@ -22415,6 +22859,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           ${row.runtimeMode},
           ${row.interactionMode},
           ${row.compressMode},
+          ${row.unpromptedSubagents},
           ${row.branch},
           ${row.worktreePath},
           ${row.latestTurnId},
@@ -22439,6 +22884,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           runtime_mode = excluded.runtime_mode,
           interaction_mode = excluded.interaction_mode,
           compress_mode = excluded.compress_mode,
+          unprompted_subagents = excluded.unprompted_subagents,
           branch = excluded.branch,
           worktree_path = excluded.worktree_path,
           latest_turn_id = excluded.latest_turn_id,
@@ -22468,6 +22914,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
           compress_mode AS "compressMode",
+          unprompted_subagents AS "unpromptedSubagents",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -22499,6 +22946,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
           compress_mode AS "compressMode",
+          unprompted_subagents AS "unpromptedSubagents",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -22966,6 +23414,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 					runtimeMode: event.payload.runtimeMode,
 					interactionMode: event.payload.interactionMode,
 					compressMode: event.payload.compressMode,
+					unpromptedSubagents: event.payload.unpromptedSubagents ? 1 : 0,
 					branch: event.payload.branch,
 					worktreePath: event.payload.worktreePath,
 					latestTurnId: null,
@@ -23090,6 +23539,16 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				});
 				return;
 			}
+			case "thread.unprompted-subagents-set": {
+				const existingRow = yield* projectionThreadRepository.getById({ threadId: event.payload.threadId });
+				if (Option.isNone(existingRow)) return;
+				yield* projectionThreadRepository.upsert({
+					...existingRow.value,
+					unpromptedSubagents: event.payload.unpromptedSubagents ? 1 : 0,
+					updatedAt: event.payload.updatedAt
+				});
+				return;
+			}
 			case "thread.deleted": {
 				attachmentSideEffects.deletedThreadIds.add(event.payload.threadId);
 				const existingRow = yield* projectionThreadRepository.getById({ threadId: event.payload.threadId });
@@ -24412,6 +24871,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
           compress_mode AS "compressMode",
+          unprompted_subagents AS "unpromptedSubagents",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -24443,6 +24903,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
           compress_mode AS "compressMode",
+          unprompted_subagents AS "unpromptedSubagents",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -24476,6 +24937,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
           compress_mode AS "compressMode",
+          unprompted_subagents AS "unpromptedSubagents",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -24809,6 +25271,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
           compress_mode AS "compressMode",
+          unprompted_subagents AS "unpromptedSubagents",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -25111,6 +25574,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			runtimeMode: row.runtimeMode,
 			interactionMode: row.interactionMode,
 			compressMode: row.compressMode,
+			unpromptedSubagents: row.unpromptedSubagents > 0,
 			branch: row.branch,
 			worktreePath: row.worktreePath,
 			latestTurn: latestTurnByThread.get(row.threadId) ?? null,
@@ -25223,6 +25687,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				runtimeMode: row.runtimeMode,
 				interactionMode: row.interactionMode,
 				compressMode: row.compressMode,
+				unpromptedSubagents: row.unpromptedSubagents > 0,
 				branch: row.branch,
 				worktreePath: row.worktreePath,
 				latestTurn: latestTurnByThread.get(row.threadId) ?? null,
@@ -25282,6 +25747,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				runtimeMode: row.runtimeMode,
 				interactionMode: row.interactionMode,
 				compressMode: row.compressMode,
+				unpromptedSubagents: row.unpromptedSubagents > 0,
 				branch: row.branch,
 				worktreePath: row.worktreePath,
 				latestTurn: latestTurnByThread.get(row.threadId) ?? null,
@@ -25337,6 +25803,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				runtimeMode: row.runtimeMode,
 				interactionMode: row.interactionMode,
 				compressMode: row.compressMode,
+				unpromptedSubagents: row.unpromptedSubagents > 0,
 				branch: row.branch,
 				worktreePath: row.worktreePath,
 				latestTurn: latestTurnByThread.get(row.threadId) ?? null,
@@ -25428,6 +25895,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			runtimeMode: threadRow.value.runtimeMode,
 			interactionMode: threadRow.value.interactionMode,
 			compressMode: threadRow.value.compressMode,
+			unpromptedSubagents: threadRow.value.unpromptedSubagents > 0,
 			branch: threadRow.value.branch,
 			worktreePath: threadRow.value.worktreePath,
 			latestTurn: Option.isSome(latestTurnRow) ? mapLatestTurn(latestTurnRow.value) : null,
@@ -25464,6 +25932,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			runtimeMode: threadRow.value.runtimeMode,
 			interactionMode: threadRow.value.interactionMode,
 			compressMode: threadRow.value.compressMode,
+			unpromptedSubagents: threadRow.value.unpromptedSubagents > 0,
 			branch: threadRow.value.branch,
 			worktreePath: threadRow.value.worktreePath,
 			latestTurn: Option.isSome(latestTurnRow) ? mapLatestTurn(latestTurnRow.value) : null,
@@ -28873,6 +29342,7 @@ const resolveAutoBootstrapWelcomeTargets = Effect.gen(function* () {
 				modelSelection: nextProjectDefaultModelSelection,
 				interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
 				compressMode: DEFAULT_COMPRESS_MODE,
+				unpromptedSubagents: true,
 				runtimeMode: "full-access",
 				branch: null,
 				worktreePath: null,
@@ -34856,6 +35326,7 @@ const buildTaskRow = (input, taskId, timestamp, repositoryKey = null) => ({
 	repositoryKey: repositoryKey ?? input.repositoryKey ?? null,
 	threadId: input.threadId ?? null,
 	externalRef: input.externalRef ?? null,
+	parentTaskId: input.parentTaskId ?? null,
 	title: input.title,
 	body: input.body ?? "",
 	status: input.status ?? "backlog",
@@ -38261,6 +38732,38 @@ const requireThreadCapability = Effect.fn("mcp.requireThreadCapability")(functio
 	});
 	return invocation;
 });
+/**
+* The thread a control tool may act on, given what it was asked to act on.
+*
+* Two checks like `requireWatchCapability`, and for the same reason: the
+* capability says this session controls threads at all, the grant says which.
+* An omitted id resolves to the session's own thread, which is always in the
+* grant and is why the common call needs no id and so cannot name a wrong one.
+*/
+const requireThreadControlTarget = Effect.fn("mcp.requireThreadControlTarget")(function* (requested) {
+	const invocation = yield* requireThreadCapability();
+	if (requested === void 0 || requested === invocation.threadId) return {
+		invocation,
+		threadId: invocation.threadId
+	};
+	if (!invocation.controlThreadIds?.has(requested)) return yield* new ThreadControlNotPermittedError({ threadId: requested });
+	return {
+		invocation,
+		threadId: requested
+	};
+});
+/**
+* The guard on starting a thread, which is a different question from acting on
+* one: it is not "which thread" but "may this session make more of them".
+*/
+const requireThreadSpawn = Effect.fn("mcp.requireThreadSpawn")(function* () {
+	const invocation = yield* requireThreadCapability();
+	if (invocation.mayCreateThreads !== true) return yield* new ThreadSpawnNotPermittedError({
+		threadId: invocation.threadId,
+		detail: "this thread was itself started by an agent, and spawning goes one level deep so a runaway loop has a bound"
+	});
+	return invocation;
+});
 //#endregion
 //#region src/mcp/PreviewAutomationBroker.ts
 var PreviewAutomationBroker = class extends Context.Service()("@p4code/cli/mcp/PreviewAutomationBroker") {};
@@ -45693,6 +46196,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 					runtimeMode: bootstrap.createThread.runtimeMode,
 					interactionMode: bootstrap.createThread.interactionMode,
 					compressMode: bootstrap.createThread.compressMode,
+					unpromptedSubagents: bootstrap.createThread.unpromptedSubagents,
 					branch: bootstrap.createThread.branch,
 					worktreePath: bootstrap.createThread.worktreePath,
 					createdAt: bootstrap.createThread.createdAt
@@ -45957,6 +46461,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 				runtimeMode: DEFAULT_RUNTIME_MODE$2,
 				interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
 				compressMode: DEFAULT_COMPRESS_MODE,
+				unpromptedSubagents: true,
 				bootstrap: { createThread: {
 					projectId: plan.projectId,
 					title: threadTitle,
@@ -45964,6 +46469,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 					runtimeMode: DEFAULT_RUNTIME_MODE$2,
 					interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
 					compressMode: DEFAULT_COMPRESS_MODE,
+					unpromptedSubagents: true,
 					branch: null,
 					worktreePath: null,
 					createdAt
@@ -46374,6 +46880,8 @@ const makeRemoteTaskRepository = Effect.fn("makeRemoteTaskRepository")(function*
 			...row.projectId === null ? {} : { projectId: row.projectId },
 			...row.repositoryKey === null ? {} : { repositoryKey: row.repositoryKey },
 			...row.threadId === null ? {} : { threadId: row.threadId },
+			...row.externalRef === null ? {} : { externalRef: row.externalRef },
+			...row.parentTaskId === null ? {} : { parentTaskId: row.parentTaskId },
 			title: row.title,
 			body: row.body,
 			status: row.status,
@@ -47261,7 +47769,10 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 	const crypto = yield* Crypto.Crypto;
 	const environmentId = yield* (yield* ServerEnvironment).getEnvironmentId;
 	const httpServer = yield* HttpServer.HttpServer;
-	const state = yield* SynchronizedRef.make({ records: /* @__PURE__ */ new Map() });
+	const state = yield* SynchronizedRef.make({
+		records: /* @__PURE__ */ new Map(),
+		spawnedThreadIds: /* @__PURE__ */ new Set()
+	});
 	const currentTimeMillis = options.now ? Effect.sync(options.now) : Clock.currentTimeMillis;
 	const livenessWindowMs = options.livenessWindowMs ?? DEFAULT_LIVENESS_WINDOW_MS;
 	const endpoint = httpServer.address._tag === "TcpAddress" ? `http://${getHttpMcpEndpointHost(httpServer.address.hostname)}:${httpServer.address.port}/mcp` : "http://127.0.0.1/mcp";
@@ -47282,29 +47793,35 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			"threads"
 		]);
 		if (watchThreadIds.size > 0) capabilities.add("watch");
-		const scope = {
+		const threadId = ThreadId.make(request.threadId);
+		const scopeWith = (mayCreateThreads) => ({
 			environmentId,
-			threadId: ThreadId.make(request.threadId),
+			threadId,
 			providerSessionId,
 			providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
 			capabilities,
 			...watchThreadIds.size > 0 ? { watchThreadIds } : {},
+			mayCreateThreads,
 			issuedAt
-		};
-		yield* SynchronizedRef.update(state, ({ records }) => {
+		});
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
 			const next = new Map(pruneDead(records, issuedAt));
 			next.set(tokenHash, {
 				tokenHash,
-				scope,
+				scope: scopeWith(!spawnedThreadIds.has(threadId)),
+				controlThreadIds: /* @__PURE__ */ new Set(),
 				lastAliveAt: issuedAt
 			});
-			return { records: next };
+			return {
+				records: next,
+				spawnedThreadIds
+			};
 		});
 		return { config: {
 			environmentId,
-			threadId: scope.threadId,
+			threadId,
 			providerSessionId,
-			providerInstanceId: scope.providerInstanceId,
+			providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
 			endpoint,
 			authorizationHeader: `Bearer ${rawToken}`
 		} };
@@ -47313,42 +47830,76 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 		if (rawToken.length === 0) return void 0;
 		const tokenHash = yield* hashToken(rawToken);
 		const timestamp = yield* currentTimeMillis;
-		return yield* SynchronizedRef.modify(state, ({ records }) => {
+		return yield* SynchronizedRef.modify(state, ({ records, spawnedThreadIds }) => {
 			const current = pruneDead(records, timestamp);
 			const record = current.get(tokenHash);
-			if (!record) return [void 0, { records: current }];
+			if (!record) return [void 0, {
+				records: current,
+				spawnedThreadIds
+			}];
 			const next = new Map(current);
 			next.set(tokenHash, {
 				...record,
 				lastAliveAt: timestamp
 			});
-			return [record.scope, { records: next }];
+			return [record.controlThreadIds.size === 0 ? record.scope : {
+				...record.scope,
+				capabilities: /* @__PURE__ */ new Set([...record.scope.capabilities, "watch"]),
+				controlThreadIds: record.controlThreadIds,
+				watchThreadIds: /* @__PURE__ */ new Set([...record.scope.watchThreadIds ?? [], ...record.controlThreadIds])
+			}, {
+				records: next,
+				spawnedThreadIds
+			}];
 		});
 	});
 	const touch = Effect.fn("McpSessionRegistry.touch")(function* (threadId) {
 		const timestamp = yield* currentTimeMillis;
-		yield* SynchronizedRef.update(state, ({ records }) => {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
 			const current = pruneDead(records, timestamp);
 			const next = new Map(current);
 			for (const [tokenHash, record] of current) if (record.scope.threadId === threadId) next.set(tokenHash, {
 				...record,
 				lastAliveAt: timestamp
 			});
-			return { records: next };
+			return {
+				records: next,
+				spawnedThreadIds
+			};
+		});
+	});
+	const recordSpawnedThread = Effect.fn("McpSessionRegistry.recordSpawnedThread")(function* (input) {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+			const next = new Map(records);
+			for (const [tokenHash, record] of records) if (record.scope.providerSessionId === input.providerSessionId) next.set(tokenHash, {
+				...record,
+				controlThreadIds: /* @__PURE__ */ new Set([...record.controlThreadIds, input.threadId])
+			});
+			return {
+				records: next,
+				spawnedThreadIds: /* @__PURE__ */ new Set([...spawnedThreadIds, input.threadId])
+			};
 		});
 	});
-	const revokeWhere = (predicate) => SynchronizedRef.update(state, ({ records }) => ({ records: new Map(Array.from(records).filter(([, record]) => !predicate(record))) }));
+	const revokeWhere = (predicate) => SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => ({
+		records: new Map(Array.from(records).filter(([, record]) => !predicate(record))),
+		spawnedThreadIds
+	}));
 	return McpSessionRegistry.of({
 		issue,
 		resolve,
 		touch,
+		recordSpawnedThread,
 		revokeProviderSession: Effect.fn("McpSessionRegistry.revokeProviderSession")(function* (providerSessionId) {
 			yield* revokeWhere((record) => record.scope.providerSessionId === providerSessionId);
 		}),
 		revokeThread: Effect.fn("McpSessionRegistry.revokeThread")(function* (threadId) {
 			yield* revokeWhere((record) => record.scope.threadId === threadId);
 		}),
-		revokeAll: SynchronizedRef.set(state, { records: /* @__PURE__ */ new Map() })
+		revokeAll: SynchronizedRef.update(state, ({ spawnedThreadIds }) => ({
+			records: /* @__PURE__ */ new Map(),
+			spawnedThreadIds
+		}))
 	});
 });
 let activeMcpSessionRegistry;
@@ -52502,7 +53053,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 unpromptedSubagents = options?.resolveUnpromptedSubagents === void 0 ? DEFAULT_SERVER_SETTINGS.enableUnpromptedSubagents : yield* options.resolveUnpromptedSubagents;
+		const unpromptedSubagents = input.unpromptedSubagents !== void 0 ? input.unpromptedSubagents : options?.resolveUnpromptedSubagents === void 0 ? DEFAULT_SERVER_SETTINGS.enableUnpromptedSubagents : yield* options.resolveUnpromptedSubagents;
 		const compressRuleset = compressRulesetFor(input.compressMode ?? "off");
 		const systemPromptAppend = [
 			...narrateBeforeTools ? [NARRATE_BEFORE_TOOLS_PROMPT] : [],
@@ -52601,6 +53152,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			startedAt,
 			basePermissionMode: permissionMode,
 			currentApiModelId: apiModelId,
+			currentUnpromptedSubagents: unpromptedSubagents,
 			resumeSessionId: sessionId,
 			pendingApprovals,
 			pendingUserInputs,
@@ -52672,7 +53224,13 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 		const context = yield* requireSession(input.threadId);
 		const modelSelection = input.modelSelection !== void 0 && input.modelSelection.instanceId === boundInstanceId ? input.modelSelection : void 0;
 		if (context.turnState?.synthetic === true) yield* completeTurn(context, "completed");
-		const message = yield* buildUserMessageEffect(input, {
+		const turnSubagentsPrompt = input.unpromptedSubagents !== void 0 && input.unpromptedSubagents !== context.currentUnpromptedSubagents ? input.unpromptedSubagents ? SUBAGENTS_ALLOWED_PROMPT : SUBAGENTS_ON_REQUEST_PROMPT : void 0;
+		if (input.unpromptedSubagents !== void 0) context.currentUnpromptedSubagents = input.unpromptedSubagents;
+		const turnInput = turnSubagentsPrompt === void 0 ? input : {
+			...input,
+			input: input.input === void 0 ? turnSubagentsPrompt : `${turnSubagentsPrompt}\n\n${input.input}`
+		};
+		const message = yield* buildUserMessageEffect(turnInput, {
 			fileSystem,
 			attachmentsDir: serverConfig.attachmentsDir,
 			boundInstanceId
@@ -85945,6 +86503,28 @@ const findTask = (taskId) => Effect.gen(function* () {
 	const tasks = yield* TaskRepository;
 	return isReadableTaskId(taskId) ? yield* tasks.getByReadableId(taskId) : yield* tasks.getById({ taskId });
 });
+/**
+* Resolve a parent reference to the UUID the column stores.
+*
+* A planning agent works in readable ids - it has just read `P4-12` off the
+* board - but the link is stored as the row key, because readable ids are
+* allocated per store and the one it quotes may have been minted on another
+* machine. Absent stays absent and an explicit null stays null: those mean
+* "leave it" and "clear it", neither of which is a reference to resolve.
+*
+* A readable id that names no task fails rather than being stored raw. The
+* opposite would file a subtask whose parent link can never resolve, which
+* reads on the board as a task that is part of nothing. A UUID is taken on
+* trust, matching the column's lack of a foreign key: a parent may legitimately
+* arrive after its child on a board synced from elsewhere.
+*/
+const resolveParentTaskId = (parentTaskId, operation) => Effect.gen(function* () {
+	if (parentTaskId === void 0 || parentTaskId === null) return parentTaskId;
+	if (!isReadableTaskId(parentTaskId)) return parentTaskId;
+	const parent = yield* findTask(parentTaskId).pipe(Effect.catch(toTaskStoreError(operation)));
+	if (Option.isNone(parent)) return yield* new TaskNotFoundError({ taskId: parentTaskId });
+	return parent.value.taskId;
+});
 const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 	task_list: (input) => Effect.gen(function* () {
 		yield* requireTaskCapability();
@@ -85972,7 +86552,11 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 		const timestamp = yield* nowIso$1;
 		const repositoryKey = yield* resolveTaskRepositoryKey(input.projectId);
 		const readableIdPrefix = yield* resolveTaskReadableIdPrefix(input.projectId);
-		const row = buildTaskRow(input, taskId, timestamp, repositoryKey);
+		const parentTaskId = yield* resolveParentTaskId(input.parentTaskId, "task_create");
+		const row = buildTaskRow(parentTaskId === void 0 || parentTaskId === null ? input : {
+			...input,
+			parentTaskId
+		}, taskId, timestamp, repositoryKey);
 		return yield* tasks.create(row, readableIdPrefix).pipe(Effect.catch(toTaskStoreError("task_create")));
 	}),
 	task_update: (input) => Effect.gen(function* () {
@@ -85981,13 +86565,12 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 		const timestamp = yield* nowIso$1;
 		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
-		} : {
+		const parentTaskId = yield* resolveParentTaskId(input.parentTaskId, "task_update");
+		const patch = {
 			...input,
 			taskId,
-			repositoryKey: yield* resolveTaskRepositoryKey(input.projectId)
+			...parentTaskId === void 0 ? {} : { parentTaskId },
+			...input.projectId === void 0 ? {} : { repositoryKey: yield* resolveTaskRepositoryKey(input.projectId) }
 		};
 		const patched = yield* tasks.patch(patch, timestamp).pipe(Effect.catch(toTaskStoreError("task_update")));
 		if (Option.isNone(patched)) return yield* new TaskNotFoundError({ taskId: input.taskId });
@@ -85999,14 +86582,295 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 	})
 });
 //#endregion
+//#region src/orchestration/pendingThreadSettles.ts
+/**
+* Threads that asked to settle while their session was still running.
+*
+* The decider refuses `thread.settle` for a thread whose session is starting or
+* running, and an agent settling its own thread always calls from inside that
+* session - so the command it wants can never be the command it sends. The
+* intent is recorded here instead and replayed when the session stops, which is
+* what "settle this thread" meant from the agent's side anyway: finish, then
+* close.
+*
+* A module-level set rather than a service because it has to be reachable from
+* two layer trees that do not otherwise meet - an MCP tool handler on one side,
+* the provider command reactor on the other - and threading a new service
+* through both to hold a set of ids is more wiring than the thing is worth.
+* `McpProviderSession` and the active-registry handle are the same shape for
+* the same reason. It is intentionally not durable: a queued settle belongs to
+* a session, and a server restart has already ended every session there was.
+*/
+const pending = /* @__PURE__ */ new Set();
+const queueThreadSettle = (threadId) => {
+	pending.add(threadId);
+};
+/**
+* Removes the intent and reports whether there was one, so a caller cannot
+* settle the same thread twice by reading and then forgetting to clear.
+*/
+const takeQueuedThreadSettle = (threadId) => pending.delete(threadId);
+//#endregion
+//#region src/sync/assetCompression.ts
+/**
+* Checking that a compressed asset still says what the original said.
+*
+* Compression here is a rewrite of prose an agent reads before it does anything
+* else: a skill, a memory file, a subagent definition. Rewriting that prose is
+* cheap to get almost right and expensive to get slightly wrong, because the
+* damage is silent. A dropped URL, a mangled command, a heading that no longer
+* matches the sentence pointing at it - none of that fails loudly. It just makes
+* the agent behave a little differently on every machine that syncs the file.
+*
+* So the write is gated on a comparison rather than on the model's word for it.
+* The rules are ported from caveman's `validate.py`, with the ones this task
+* calls out - headings, code blocks, URLs, paths, bullet counts - promoted to
+* refusals rather than warnings. A refusal costs one retry; a bad write costs
+* whatever the agent does next, on every machine, until someone notices.
+*
+* Pure on purpose. Everything here is a string comparison, so every rule can be
+* tested without a filesystem, a provider or a thread, and the tool that calls
+* it is left with only the parts that genuinely touch disk.
+*
+* @module sync/assetCompression
+*/
+/**
+* How far the bullet count may move before the rewrite stops being compression.
+*
+* Not zero. Compression legitimately folds a two-line bullet into one, and a
+* rule that forbade that would forbid the feature. Caveman's own threshold,
+* kept because it is the one their receipts were measured against.
+*/
+const BULLET_COUNT_TOLERANCE = .15;
+/**
+* Characters per token, for the before/after figures.
+*
+* An estimate, and labelled as one everywhere it surfaces. The exact count
+* belongs to whichever provider tokenizer will read the file, and asking one
+* would mean a network call inside a validation path that is otherwise pure.
+* Four is the usual English-prose approximation and is good enough to answer
+* the only question anyone asks here: did this get meaningfully smaller.
+*/
+const CHARS_PER_TOKEN_ESTIMATE = 4;
+const URL_REGEX = /https?:\/\/[^\s)]+/gu;
+/**
+* Sentence punctuation swept up by the URL match.
+*
+* `See https://svgl.app for the catalogue.` and `Catalogue: https://svgl.app.`
+* name the same URL, and a comparison that disagreed would refuse every rewrite
+* that moved a link to the end of a sentence - which is most of them.
+*/
+const URL_TRAILING_PUNCTUATION_REGEX = /[.,;:!?'"\])]+$/u;
+const FENCE_LINE_REGEX = /^(\s{0,3})(`{3,}|~{3,})(.*)$/u;
+const HEADING_REGEX = /^(#{1,6})\s+(.*)$/gmu;
+const BULLET_REGEX = /^\s*[-*+]\s+/gmu;
+const INLINE_CODE_REGEX = /`([^`]+)`/gu;
+/**
+* Crude, and deliberately so.
+*
+* Either a path prefix (`./`, `../`, `/`, a drive letter) or a separator inside
+* the match. It over-matches - `and/or` is a "path" by this rule - and the
+* over-match is the safe direction: a false positive refuses a rewrite that
+* dropped the phrase, and a false negative lets a real path go missing.
+*/
+const PATH_REGEX = /(?:\.\/|\.\.\/|\/|[A-Za-z]:\\)[\w\-/\\.]+|[\w\-.]+[/\\][\w\-/\\.]+/gu;
+/** YAML frontmatter: `---` on the first line, `---` on a line of its own after. */
+const FRONTMATTER_REGEX = /^---\r?\n[\s\S]*?\r?\n---\r?\n/u;
+/**
+* Filenames that almost certainly hold secrets, and the directories that do.
+*
+* Compressing a file means handing its bytes to a model, so this is checked
+* before the read rather than after it. The asset roots should never contain
+* any of these, which is exactly why the check is cheap to keep: it costs
+* nothing in the ordinary case and is the only thing standing between a
+* misplaced `credentials.md` and a provider's API.
+*/
+const SENSITIVE_BASENAME_REGEX = /^(\.env(\..+)?|\.netrc|credentials(\..+)?|secrets?(\..+)?|passwords?(\..+)?|id_(rsa|dsa|ecdsa|ed25519)(\.pub)?|authorized_keys|known_hosts|.*\.(pem|key|p12|pfx|crt|cer|jks|keystore|asc|gpg))$/iu;
+const SENSITIVE_PATH_SEGMENTS = /* @__PURE__ */ new Set([
+	".ssh",
+	".aws",
+	".gnupg",
+	".kube",
+	".docker"
+]);
+const SENSITIVE_NAME_TOKENS = [
+	"secret",
+	"credential",
+	"password",
+	"passwd",
+	"apikey",
+	"accesskey",
+	"token",
+	"privatekey"
+];
+const segmentsOf = (filePath) => filePath.split(/[/\\]/u).filter((segment) => segment.length > 0);
+/**
+* Whether this path looks like something that must not be sent to a model.
+*
+* Name-based, because that is all that is knowable before the read. Separators
+* inside the name are normalized away first so `api-key.md` and `api_key.md`
+* are the same answer.
+*/
+const isSensitiveAssetPath = (filePath) => {
+	const segments = segmentsOf(filePath);
+	const name = segments.at(-1) ?? "";
+	if (SENSITIVE_BASENAME_REGEX.test(name)) return true;
+	if (segments.some((segment) => SENSITIVE_PATH_SEGMENTS.has(segment.toLowerCase()))) return true;
+	const flattened = name.toLowerCase().replace(/[_\-\s.]/gu, "");
+	return SENSITIVE_NAME_TOKENS.some((token) => flattened.includes(token));
+};
+/** The frontmatter block including its delimiters, or the empty string. */
+const frontmatterOf = (text) => FRONTMATTER_REGEX.exec(text)?.[0] ?? "";
+const headingsOf = (text) => [...text.matchAll(HEADING_REGEX)].map((match) => `${match[1] ?? ""} ${(match[2] ?? "").trim()}`);
+/**
+* Fenced code blocks, as whole strings, fences included.
+*
+* Line-based rather than one regex, so a closing fence is only a closing fence
+* when CommonMark says it is: same character, at least as long as the opener,
+* nothing after it. That is what lets a four-backtick block wrap three-backtick
+* content without the extractor stopping in the middle of it.
+*
+* An unclosed fence is skipped rather than reported. It means the markdown was
+* already malformed, and including it would fail every compression of a file
+* that was broken before anyone touched it.
+*/
+const codeBlocksOf = (text) => {
+	const lines = text.split("\n");
+	const blocks = [];
+	let index = 0;
+	while (index < lines.length) {
+		const opening = FENCE_LINE_REGEX.exec(lines[index] ?? "");
+		if (opening === null) {
+			index += 1;
+			continue;
+		}
+		const fence = opening[2] ?? "";
+		const collected = [lines[index] ?? ""];
+		index += 1;
+		let closed = false;
+		while (index < lines.length) {
+			const line = lines[index] ?? "";
+			const closing = FENCE_LINE_REGEX.exec(line);
+			const closingFence = closing?.[2] ?? "";
+			if (closing !== null && closingFence[0] === fence[0] && closingFence.length >= fence.length && (closing[3] ?? "").trim().length === 0) {
+				collected.push(line);
+				closed = true;
+				index += 1;
+				break;
+			}
+			collected.push(line);
+			index += 1;
+		}
+		if (closed) blocks.push(collected.join("\n"));
+	}
+	return blocks;
+};
+const withoutCodeBlocks = (text) => codeBlocksOf(text).reduce((rest, block) => rest.replace(block, ""), text);
+const inlineCodeCounts = (text) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const match of withoutCodeBlocks(text).matchAll(INLINE_CODE_REGEX)) {
+		const span = match[1] ?? "";
+		counts.set(span, (counts.get(span) ?? 0) + 1);
+	}
+	return counts;
+};
+const urlsOf = (text) => new Set([...text.matchAll(URL_REGEX)].map((match) => match[0].replace(URL_TRAILING_PUNCTUATION_REGEX, "")));
+/**
+* Paths, with URLs taken out of the text first.
+*
+* `//svgl.app` inside `https://svgl.app` is a path by the pattern's reckoning,
+* so leaving the URLs in would have every link contribute a phantom path whose
+* spelling changes with the punctuation after it.
+*/
+const pathsOf = (text) => new Set([...text.replace(URL_REGEX, " ").matchAll(PATH_REGEX)].map((match) => match[0]));
+const countOf = (text, pattern) => [...text.matchAll(pattern)].length;
+const missingFrom = (original, compressed) => [...original].filter((value) => !compressed.has(value));
+const addedTo = (original, compressed) => [...compressed].filter((value) => !original.has(value));
+const quoteList = (values) => values.map((value) => `'${value}'`).join(", ");
+/**
+* Compare a compressed rewrite against the original it came from.
+*
+* Errors are the things whose loss changes what the file instructs: a code
+* block, a URL, a path, an inline span, a heading, the frontmatter. Additions
+* are warnings rather than errors throughout, because a rewrite that names one
+* more path than the original is doing something odd but is not losing
+* anything, and a refusal there would be a refusal nobody can act on.
+*/
+const validateCompression = (original, compressed) => {
+	const errors = [];
+	const warnings = [];
+	if (frontmatterOf(original) !== frontmatterOf(compressed)) errors.push("The YAML frontmatter changed. It is metadata the provider parses, not prose; return it byte-identical.");
+	const originalHeadings = headingsOf(original);
+	const compressedHeadings = headingsOf(compressed);
+	if (originalHeadings.length !== compressedHeadings.length || originalHeadings.some((heading, at) => heading !== compressedHeadings[at])) errors.push(`Headings changed: ${originalHeadings.length} in the original, ${compressedHeadings.length} in the rewrite. Keep every heading, in order, with its exact text.`);
+	const originalBlocks = codeBlocksOf(original);
+	const compressedBlocks = codeBlocksOf(compressed);
+	if (originalBlocks.length !== compressedBlocks.length || originalBlocks.some((block, at) => block !== compressedBlocks[at])) errors.push(`Code blocks are not byte-identical: ${originalBlocks.length} in the original, ${compressedBlocks.length} in the rewrite. Copy them through unchanged.`);
+	const originalUrls = urlsOf(original);
+	const compressedUrls = urlsOf(compressed);
+	const lostUrls = missingFrom(originalUrls, compressedUrls);
+	if (lostUrls.length > 0) errors.push(`URLs missing from the rewrite: ${quoteList(lostUrls)}.`);
+	const addedUrls = addedTo(originalUrls, compressedUrls);
+	if (addedUrls.length > 0) warnings.push(`URLs the original did not have: ${quoteList(addedUrls)}.`);
+	const originalPaths = pathsOf(original);
+	const compressedPaths = pathsOf(compressed);
+	const lostPaths = missingFrom(originalPaths, compressedPaths);
+	if (lostPaths.length > 0) errors.push(`Paths missing from the rewrite: ${quoteList(lostPaths)}.`);
+	const addedPaths = addedTo(originalPaths, compressedPaths);
+	if (addedPaths.length > 0) warnings.push(`Paths the original did not have: ${quoteList(addedPaths)}.`);
+	const originalInline = inlineCodeCounts(original);
+	const compressedInline = inlineCodeCounts(compressed);
+	const lostInline = [...originalInline].filter(([span, count]) => (compressedInline.get(span) ?? 0) < count);
+	if (lostInline.length > 0) errors.push(`Inline code spans missing from the rewrite: ${quoteList(lostInline.map(([span]) => span))}.`);
+	const originalBullets = countOf(original, BULLET_REGEX);
+	const compressedBullets = countOf(compressed, BULLET_REGEX);
+	if (originalBullets > 0) {
+		if (Math.abs(originalBullets - compressedBullets) / originalBullets > BULLET_COUNT_TOLERANCE) errors.push(`Bullet count moved from ${originalBullets} to ${compressedBullets}, past the ${Math.round(BULLET_COUNT_TOLERANCE * 100)}% tolerance. Compress the wording of each bullet rather than merging or dropping bullets.`);
+	}
+	return {
+		errors,
+		warnings
+	};
+};
+/** Roughly how many tokens this text costs to read. Estimated, never measured. */
+const estimateTokens = (text) => Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
+/**
+* The name a backup of this file is kept under.
+*
+* Timestamped rather than fixed. Caveman refuses to compress when a backup
+* already exists, which protects the first original at the cost of blocking
+* every later compression; keeping one backup per write protects every version
+* instead, including the edits someone made between two compressions.
+*
+* The parent directory's name is carried in the path rather than the file name
+* so that `global-memory/feedback_svgl.md` and `svgl/SKILL.md` cannot collide.
+*/
+const backupFileName = (input) => `${input.fileName}.${input.atIso.replace(/[:.]/gu, "-")}.original`;
+//#endregion
 //#region src/mcp/toolkits/threads/tools.ts
 /**
-* Self-scoped on purpose: neither tool takes a thread id. The thread acted on
-* is always the one in `McpInvocationScope`, exactly as `task_current` resolves
-* it, so a leaked per-session token cannot reach any other thread. Delete,
-* create and archive are deliberately not exposed; settle could never succeed
-* from here because the decider refuses it while the calling session is alive.
+* Scoped to what this session started, on purpose.
+*
+* A control tool may name a thread, but only one this session created with
+* `thread_spawn`; omitting the id means the session's own thread, which is the
+* common case and the one that cannot be got wrong. The grant lives on the
+* credential in `McpSessionRegistry`, so a leaked per-session token still
+* reaches only the work that token itself began, and its reach cannot widen
+* because something changed on the board.
+*
+* Delete and archive stay unexposed. Deletion is the one irreversible action in
+* this file and a thread carries its whole transcript, which is a worse thing
+* to lose than the task row the task toolkit withheld delete for.
+*
+* `thread_spawn` goes one level: a thread that was itself spawned is issued a
+* credential that cannot spawn, so a loop meets a bound rather than a request
+* not to loop. `thread_settle` on a live session is queued and applied when the
+* session stops, because the decider refuses an immediate settle there and a
+* call from a thread's own session always arrives while it is alive.
+*
+* @module mcp/toolkits/threads/tools
 */
+/** Self-only, and staying that way: `thread_configure` is where a title on another thread is set. */
 const ThreadRenameTool = Tool.make("thread_rename", {
 	description: "Rename this agent session's own thread. Use it when the seeded title no longer matches what the thread turned out to be about. Only the current thread can be renamed; no other thread is reachable.",
 	parameters: ThreadRenameInput,
@@ -86018,6 +86882,54 @@ const ThreadRenameTool = Tool.make("thread_rename", {
 		Crypto.Crypto
 	]
 }).annotate(Tool.Title, "Rename this thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
+const ThreadSpawnTool = Tool.make("thread_spawn", {
+	description: "Start a new agent thread and send it a first message, then return its id. Use it to hand a piece of work to a fresh thread - a subtask you just planned, a job that wants its own transcript. The new thread inherits this one's project, model and permission mode unless you say otherwise, and can then be watched with thread_watch_events and adjusted with thread_configure. A thread that was itself started this way cannot start another.",
+	parameters: ThreadSpawnInput,
+	success: ThreadSpawnResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		McpSessionRegistry,
+		OrchestrationEngineService,
+		ProjectionThreadRepository,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Start a thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
+const ThreadConfigureTool = Tool.make("thread_configure", {
+	description: "Change a thread's settings: title, model, permission mode, interaction mode, compression, and whether it may use subagents without asking. Omit threadId to configure this session's own thread; name one only if this session started it. Every field is optional and an omitted field is left alone; the settings actually changed come back in the result.",
+	parameters: ThreadConfigureInput,
+	success: ThreadConfigureResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Configure a thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
+const ThreadSettleTool = Tool.make("thread_settle", {
+	description: "Settle a thread, marking its work finished so it drops out of the active list. Omit threadId for this session's own thread; name one only if this session started it. A thread whose session is still running cannot be settled on the spot, so the request is recorded and applied when that session stops - the result says which of the two happened.",
+	parameters: ThreadSettleInput,
+	success: ThreadSettleResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		ProjectionThreadRepository,
+		ProjectionThreadSessionRepository,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Settle a thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
+const ThreadSnoozeTool = Tool.make("thread_snooze", {
+	description: "Snooze a thread until a given time, hiding it from the active list until then. Omit threadId for this session's own thread; name one only if this session started it.",
+	parameters: ThreadSnoozeInput,
+	success: ThreadSnoozeResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Snooze a thread").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
 const MemoryAppendTool = Tool.make("memory_append", {
 	description: "Append a block of markdown to the user-scope memory file (CLAUDE.md by default, AGENTS.md on request). Use it to record a durable preference or fact the user asked to remember. Appends only - it never rewrites or removes existing memory.",
 	parameters: MemoryAppendInput,
@@ -86030,11 +86942,221 @@ const MemoryAppendTool = Tool.make("memory_append", {
 		Path.Path
 	]
 }).annotate(Tool.Title, "Append to memory").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
-const ThreadToolkit = Toolkit.make(ThreadRenameTool, MemoryAppendTool);
+/**
+* Overwrite an asset with a compressed version of itself, if it survives the
+* comparison.
+*
+* A tool rather than an instruction to use `Edit` because the guarantee is the
+* point: the original is copied out of every synced directory first, the
+* rewrite is compared against it, and a rewrite that lost a URL or a code block
+* is refused with the list of what it lost. An agent editing the file directly
+* can be asked to preserve those things but cannot be prevented from not.
+*/
+const AssetCompressTool = Tool.make("asset_compress", {
+	description: "Overwrite one agent asset file - a skill, a memory file, a subagent definition - with a compressed rewrite of it, after checking the rewrite kept everything that carries meaning. Headings, fenced code blocks, inline code, URLs, paths and YAML frontmatter must come back unchanged; only the prose may be rewritten. The original is backed up outside every synced directory first. If the check fails nothing is written and the failed checks are returned, so a corrected rewrite can be sent as a second call.",
+	parameters: AssetCompressInput,
+	success: AssetCompressResult,
+	failure: ThreadControlToolError,
+	dependencies: [
+		McpInvocationContext,
+		ServerConfig$1,
+		ServerSettingsService,
+		FileSystem.FileSystem,
+		Path.Path
+	]
+}).annotate(Tool.Title, "Compress an asset").annotate(Tool.Readonly, false).annotate(Tool.Destructive, true).annotate(Tool.Idempotent, false);
+const ThreadToolkit = Toolkit.make(ThreadSpawnTool, ThreadConfigureTool, ThreadSettleTool, ThreadSnoozeTool, ThreadRenameTool, MemoryAppendTool, AssetCompressTool);
 //#endregion
 //#region src/mcp/toolkits/threads/handlers.ts
 const DEFAULT_MEMORY_APPEND_TARGET = "CLAUDE.md";
+/**
+* Where originals are kept.
+*
+* Under the server's state directory, which is the one place on this machine
+* that is neither an asset root nor inside one. A backup next to the file would
+* be published by the next sync and re-read by the next agent turn, which is
+* the opposite of what compressing the file was for.
+*/
+const COMPRESS_BACKUP_DIRNAME = "asset-compress-backups";
+/** Prose only. A skill may ship scripts, and a rewritten script is a broken one. */
+const COMPRESSIBLE_EXTENSION = ".md";
+/** The same test the asset readers use: a NUL is what breaks a JSON text column. */
+const looksBinary = (content) => content.includes("\0");
+/**
+* Every control command shares this: mint an id, dispatch, and turn a decider
+* refusal into one error the agent can read.
+*/
+const dispatchControl = Effect.fn("mcp.threads.dispatchControl")(function* (command, threadId) {
+	yield* (yield* OrchestrationEngineService).dispatch(command).pipe(Effect.mapError((cause) => new ThreadControlRejectedError({
+		threadId,
+		commandType: command.type,
+		detail: cause.message
+	})));
+});
+const newCommandId = Effect.gen(function* () {
+	const crypto = yield* Crypto.Crypto;
+	return CommandId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
+});
 const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
+	thread_spawn: (input) => Effect.gen(function* () {
+		const invocation = yield* requireThreadSpawn();
+		const registry = yield* McpSessionRegistry;
+		const threads = yield* ProjectionThreadRepository;
+		const crypto = yield* Crypto.Crypto;
+		const parent = yield* threads.getById({ threadId: invocation.threadId }).pipe(Effect.mapError((cause) => new ThreadSpawnNotPermittedError({
+			threadId: invocation.threadId,
+			detail: `this thread could not be read to take its defaults from: ${cause.message}`
+		})));
+		if (Option.isNone(parent)) return yield* new ThreadSpawnNotPermittedError({
+			threadId: invocation.threadId,
+			detail: "this thread is not on the board, so there is nothing to start a thread beside"
+		});
+		const template = parent.value;
+		const projectId = input.projectId ?? template.projectId;
+		const runtimeMode = input.runtimeMode ?? template.runtimeMode;
+		const interactionMode = input.interactionMode ?? template.interactionMode;
+		const compressMode = input.compressMode ?? template.compressMode;
+		const unpromptedSubagents = input.unpromptedSubagents ?? template.unpromptedSubagents === 1;
+		const threadId = ThreadId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie));
+		const createdAt = DateTime.formatIso(yield* DateTime.now);
+		yield* dispatchControl({
+			type: "thread.create",
+			commandId: yield* newCommandId,
+			threadId,
+			projectId,
+			title: input.title,
+			modelSelection: template.modelSelection,
+			runtimeMode,
+			interactionMode,
+			compressMode,
+			unpromptedSubagents,
+			branch: null,
+			worktreePath: null,
+			createdAt
+		}, threadId);
+		yield* registry.recordSpawnedThread({
+			providerSessionId: invocation.providerSessionId,
+			threadId
+		});
+		yield* dispatchControl({
+			type: "thread.turn.start",
+			commandId: yield* newCommandId,
+			threadId,
+			message: {
+				messageId: MessageId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)),
+				role: "user",
+				text: input.prompt,
+				attachments: []
+			},
+			modelSelection: template.modelSelection,
+			titleSeed: input.title,
+			runtimeMode,
+			interactionMode,
+			compressMode,
+			unpromptedSubagents,
+			createdAt
+		}, threadId);
+		return {
+			threadId,
+			projectId,
+			title: input.title
+		};
+	}),
+	thread_configure: (input) => Effect.gen(function* () {
+		const { threadId } = yield* requireThreadControlTarget(input.threadId);
+		const createdAt = DateTime.formatIso(yield* DateTime.now);
+		const applied = [];
+		if (input.title !== void 0 || input.modelSelection !== void 0) {
+			yield* dispatchControl({
+				type: "thread.meta.update",
+				commandId: yield* newCommandId,
+				threadId,
+				...input.title !== void 0 ? { title: input.title } : {},
+				...input.modelSelection !== void 0 ? { modelSelection: input.modelSelection } : {}
+			}, threadId);
+			if (input.title !== void 0) applied.push("title");
+			if (input.modelSelection !== void 0) applied.push("modelSelection");
+		}
+		if (input.runtimeMode !== void 0) {
+			yield* dispatchControl({
+				type: "thread.runtime-mode.set",
+				commandId: yield* newCommandId,
+				threadId,
+				runtimeMode: input.runtimeMode,
+				createdAt
+			}, threadId);
+			applied.push("runtimeMode");
+		}
+		if (input.interactionMode !== void 0) {
+			yield* dispatchControl({
+				type: "thread.interaction-mode.set",
+				commandId: yield* newCommandId,
+				threadId,
+				interactionMode: input.interactionMode,
+				createdAt
+			}, threadId);
+			applied.push("interactionMode");
+		}
+		if (input.compressMode !== void 0) {
+			yield* dispatchControl({
+				type: "thread.compress-mode.set",
+				commandId: yield* newCommandId,
+				threadId,
+				compressMode: input.compressMode,
+				createdAt
+			}, threadId);
+			applied.push("compressMode");
+		}
+		if (input.unpromptedSubagents !== void 0) {
+			yield* dispatchControl({
+				type: "thread.unprompted-subagents.set",
+				commandId: yield* newCommandId,
+				threadId,
+				unpromptedSubagents: input.unpromptedSubagents,
+				createdAt
+			}, threadId);
+			applied.push("unpromptedSubagents");
+		}
+		return {
+			threadId,
+			applied
+		};
+	}),
+	thread_settle: (input) => Effect.gen(function* () {
+		const { threadId } = yield* requireThreadControlTarget(input.threadId);
+		const threads = yield* ProjectionThreadRepository;
+		const session = yield* (yield* ProjectionThreadSessionRepository).getByThreadId({ threadId }).pipe(Effect.catchCause(() => Effect.succeed(Option.none())));
+		if (!(Option.isSome(session) && (session.value.status === "starting" || session.value.status === "running"))) {
+			yield* dispatchControl({
+				type: "thread.settle",
+				commandId: yield* newCommandId,
+				threadId
+			}, threadId);
+			return {
+				threadId,
+				outcome: "settled"
+			};
+		}
+		queueThreadSettle(threadId);
+		yield* threads.getById({ threadId }).pipe(Effect.orDie);
+		return {
+			threadId,
+			outcome: "queued"
+		};
+	}),
+	thread_snooze: (input) => Effect.gen(function* () {
+		const { threadId } = yield* requireThreadControlTarget(input.threadId);
+		yield* dispatchControl({
+			type: "thread.snooze",
+			commandId: yield* newCommandId,
+			threadId,
+			snoozedUntil: input.snoozedUntil
+		}, threadId);
+		return {
+			threadId,
+			snoozedUntil: input.snoozedUntil
+		};
+	}),
 	thread_rename: (input) => Effect.gen(function* () {
 		const invocation = yield* requireThreadCapability();
 		const engine = yield* OrchestrationEngineService;
@@ -86083,6 +87205,68 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 			file,
 			path: filePath
 		};
+	}),
+	asset_compress: (input) => Effect.gen(function* () {
+		yield* requireThreadCapability();
+		const path = yield* Path.Path;
+		const fileSystem = yield* FileSystem.FileSystem;
+		const config = yield* ServerConfig$1;
+		const claudeHome = { homePath: (yield* (yield* ServerSettingsService).getSettings.pipe(Effect.orElseSucceed(() => void 0)))?.providers.claudeAgent.homePath ?? "" };
+		const refuse = (target, detail) => new AssetCompressRefusedError({
+			path: target,
+			detail
+		});
+		if (!path.isAbsolute(input.path)) return yield* refuse(input.path, "The path must be absolute.");
+		const filePath = path.resolve(input.path);
+		const fileName = path.basename(filePath);
+		if (path.extname(fileName).toLowerCase() !== COMPRESSIBLE_EXTENSION) return yield* refuse(filePath, `Only ${COMPRESSIBLE_EXTENSION} files are compressed. Scripts and data files an asset ships alongside its prose are left alone.`);
+		if (isSensitiveAssetPath(filePath)) return yield* refuse(filePath, "The name looks like credentials, keys or secrets, and compressing sends the file's contents to a model.");
+		const configDir = yield* resolveClaudeConfigDirPath(claudeHome, process.env);
+		const skillsDir = yield* resolveClaudeUserSkillsDir(claudeHome);
+		const agentsDir = yield* resolveClaudeUserAgentsDir(claudeHome);
+		const within = (root) => {
+			const relative = path.relative(root, filePath);
+			return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
+		};
+		const memoryDirectoryName = path.relative(configDir, filePath).split(path.sep)[0] ?? "";
+		if (!(within(skillsDir) || within(agentsDir) || path.dirname(filePath) === configDir && isMemoryFileName(fileName) || within(configDir) && isMemoryDirectoryName(memoryDirectoryName))) return yield* refuse(filePath, `Not an agent asset. Compressible files live under '${skillsDir}', under '${agentsDir}', or in '${configDir}' as a memory file or inside ${MEMORY_DIRECTORY_NAMES.join(" or ")}.`);
+		const original = yield* fileSystem.readFileString(filePath).pipe(Effect.orElseSucceed(() => void 0));
+		if (original === void 0) return yield* refuse(filePath, "The file could not be read.");
+		if (looksBinary(original)) return yield* refuse(filePath, "The file is not text.");
+		if (original.trim().length === 0) return yield* refuse(filePath, "The file is empty.");
+		const compressed = input.content;
+		if (compressed.trim().length === 0) return yield* refuse(filePath, "The rewrite is blank.");
+		if (compressed.trim() === original.trim()) return yield* refuse(filePath, "The rewrite is the file that is already there. Nothing was written.");
+		if (compressed.length >= original.length) return yield* refuse(filePath, `The rewrite is not smaller: ${original.length} characters became ${compressed.length}. Send the file's contents alone, with no commentary or wrapping fence.`);
+		const validation = validateCompression(original, compressed);
+		if (validation.errors.length > 0) return yield* new AssetCompressValidationFailedError({
+			path: filePath,
+			errors: validation.errors
+		});
+		const backupPath = path.join(config.stateDir, COMPRESS_BACKUP_DIRNAME, path.basename(path.dirname(filePath)), backupFileName({
+			fileName,
+			atIso: DateTime.formatIso(yield* DateTime.now)
+		}));
+		if (((yield* writeFileStringAtomically({
+			filePath: backupPath,
+			contents: original
+		}).pipe(Effect.as(true), Effect.orElseSucceed(() => false))) ? yield* fileSystem.readFileString(backupPath).pipe(Effect.orElseSucceed(() => void 0)) : void 0) !== original) {
+			yield* fileSystem.remove(backupPath, { force: true }).pipe(Effect.ignore);
+			return yield* refuse(filePath, `The original could not be backed up to '${backupPath}', so it was left as it is.`);
+		}
+		yield* writeFileStringAtomically({
+			filePath,
+			contents: compressed
+		}).pipe(Effect.mapError((cause) => refuse(filePath, `The write failed: ${cause.message}. The original is at '${backupPath}'.`)));
+		return {
+			path: filePath,
+			backupPath,
+			charsBefore: original.length,
+			charsAfter: compressed.length,
+			estimatedTokensBefore: estimateTokens(original),
+			estimatedTokensAfter: estimateTokens(compressed),
+			warnings: validation.warnings
+		};
 	})
 });
 //#endregion
@@ -87533,13 +88717,34 @@ const make$2 = Effect.gen(function* () {
 		if (providerError) return providerError.detail;
 		return Cause.pretty(cause);
 	};
+	/**
+	* Applies a settle an agent asked for while its session was still running.
+	*
+	* The decider refuses `thread.settle` for a live session, so `thread_settle`
+	* over MCP records the intent instead of failing. This is the moment it
+	* becomes legal: the session has just been written as stopped, so the same
+	* command the agent could not send now succeeds. Taken from the queue rather
+	* than read, so a second stop cannot settle the thread twice.
+	*/
+	const flushQueuedSettle = Effect.fnUntraced(function* (threadId) {
+		if (!takeQueuedThreadSettle(threadId)) return;
+		const commandId = yield* serverCommandId("queued-thread-settle");
+		yield* orchestrationEngine.dispatch({
+			type: "thread.settle",
+			commandId,
+			threadId
+		}).pipe(Effect.catchCause((cause) => Effect.logDebug("queued thread settle did not apply", {
+			threadId,
+			cause
+		})));
+	});
 	const setThreadSession = (input) => serverCommandId("provider-session-set").pipe(Effect.flatMap((commandId) => orchestrationEngine.dispatch({
 		type: "thread.session.set",
 		commandId,
 		threadId: input.threadId,
 		session: input.session,
 		createdAt: input.createdAt
-	})));
+	})), Effect.tap(() => input.session.status === "stopped" || input.session.status === "error" ? flushQueuedSettle(input.threadId) : Effect.void));
 	const setThreadSessionErrorOnTurnStartFailure = Effect.fnUntraced(function* (input) {
 		const thread = yield* resolveThread(input.threadId);
 		if (!thread) return;
@@ -87666,7 +88871,8 @@ const make$2 = Effect.gen(function* () {
 			modelSelection: desiredModelSelection,
 			...input?.resumeCursor !== void 0 ? { resumeCursor: input.resumeCursor } : {},
 			runtimeMode: desiredRuntimeMode,
-			compressMode: thread.compressMode
+			compressMode: thread.compressMode,
+			unpromptedSubagents: thread.unpromptedSubagents
 		});
 		const bindSessionToThread = (session) => Effect.gen(function* () {
 			if (session.providerInstanceId === void 0) return yield* new ProviderAdapterRequestError({
@@ -87768,7 +88974,8 @@ const make$2 = Effect.gen(function* () {
 			...normalizedAttachments.length > 0 ? { attachments: normalizedAttachments } : {},
 			...modelForTurn !== void 0 ? { modelSelection: modelForTurn } : {},
 			...input.interactionMode !== void 0 ? { interactionMode: input.interactionMode } : {},
-			compressMode
+			compressMode,
+			unpromptedSubagents: thread.unpromptedSubagents
 		};
 	});
 	const maybeGenerateAndRenameWorktreeBranchForFirstTurn = Effect.fn("maybeGenerateAndRenameWorktreeBranchForFirstTurn")(function* (input) {