@p4code/cli 0.1.19 → 0.1.20

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.20";
 //#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),
@@ -7799,6 +7905,11 @@ var TicketResolveError = class extends Schema$1.TaggedErrorClass()("TicketResolv
 * 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." }) });
@@ -7825,6 +7936,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 +7981,43 @@ 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(" ")}`;
+	}
+};
 const ThreadControlToolError = Schema$1.Union([
 	ThreadToolUnavailableError,
 	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 +12821,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 +13088,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 +14729,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 +14754,7 @@ const makeTaskRepository = Effect.gen(function* () {
           repository_key,
           thread_id,
           external_ref_json,
+          parent_task_id,
           title,
           body,
           status,
@@ -14552,6 +14772,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 +14790,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 +14890,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 +14929,7 @@ 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.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 +15064,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 +15384,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 +15440,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 +16960,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 +16992,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 +17116,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 +17638,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 +17662,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 +18775,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.
@@ -19788,6 +20036,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 +20177,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 +20284,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 +20657,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 +20937,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 +21017,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 +21784,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 +22674,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           runtime_mode,
           interaction_mode,
           compress_mode,
+          unprompted_subagents,
           branch,
           worktree_path,
           latest_turn_id,
@@ -22415,6 +22699,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           ${row.runtimeMode},
           ${row.interactionMode},
           ${row.compressMode},
+          ${row.unpromptedSubagents},
           ${row.branch},
           ${row.worktreePath},
           ${row.latestTurnId},
@@ -22439,6 +22724,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 +22754,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 +22786,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 +23254,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 +23379,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 +24711,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 +24743,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 +24777,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 +25111,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 +25414,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 +25527,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 +25587,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 +25643,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 +25735,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 +25772,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 +29182,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 +35166,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",
@@ -45693,6 +46004,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 +46269,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 +46277,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 +46688,7 @@ 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.parentTaskId === null ? {} : { parentTaskId: row.parentTaskId },
 			title: row.title,
 			body: row.body,
 			status: row.status,
@@ -52502,7 +52817,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 +52916,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			startedAt,
 			basePermissionMode: permissionMode,
 			currentApiModelId: apiModelId,
+			currentUnpromptedSubagents: unpromptedSubagents,
 			resumeSessionId: sessionId,
 			pendingApprovals,
 			pendingUserInputs,
@@ -52672,7 +52988,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 +86267,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 +86316,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 +86329,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,6 +86346,242 @@ const TaskToolkitHandlersLive = TaskToolkit.toLayer({
 	})
 });
 //#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
@@ -86030,10 +86613,46 @@ 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(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");
 const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 	thread_rename: (input) => Effect.gen(function* () {
 		const invocation = yield* requireThreadCapability();
@@ -86083,6 +86702,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
@@ -87666,7 +88347,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 +88450,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) {