@p4code/cli 0.1.11 → 0.1.13

package/dist/bin.mjs

@@ -233,7 +233,7 @@ const make$73 = () => {
 const layer$69 = Layer.sync(NetService, make$73);
 //#endregion
 //#region package.json
-var version = "0.1.11";
+var version = "0.1.13";
 //#endregion
 //#region src/config.ts
 /**
@@ -1651,6 +1651,13 @@ const RuntimeMode = Schema$1.Literals([
 const DEFAULT_RUNTIME_MODE$2 = "full-access";
 const ProviderInteractionMode = Schema$1.Literals(["default", "plan"]);
 const DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+const CompressMode = Schema$1.Literals([
+	"off",
+	"lite",
+	"full",
+	"ultra"
+]);
+const DEFAULT_COMPRESS_MODE = "full";
 const ProviderRequestKind = Schema$1.Literals([
 	"command",
 	"file-read",
@@ -1827,6 +1834,7 @@ const OrchestrationThread = Schema$1.Struct({
 	modelSelection: ModelSelection,
 	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))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	latestTurn: Schema$1.NullOr(OrchestrationLatestTurn),
@@ -1867,6 +1875,7 @@ const OrchestrationThreadShell = Schema$1.Struct({
 	modelSelection: ModelSelection,
 	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))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	latestTurn: Schema$1.NullOr(OrchestrationLatestTurn),
@@ -1989,6 +1998,7 @@ const ThreadCreateCommand = Schema$1.Struct({
 	modelSelection: ModelSelection,
 	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))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime
@@ -2055,12 +2065,20 @@ const ThreadInteractionModeSetCommand = Schema$1.Struct({
 	interactionMode: ProviderInteractionMode,
 	createdAt: IsoDateTime
 });
+const ThreadCompressModeSetCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread.compress-mode.set"),
+	commandId: CommandId,
+	threadId: ThreadId,
+	compressMode: CompressMode,
+	createdAt: IsoDateTime
+});
 const ThreadTurnStartBootstrapCreateThread = Schema$1.Struct({
 	projectId: ProjectId,
 	title: TrimmedNonEmptyString,
 	modelSelection: ModelSelection,
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode,
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime
@@ -2090,6 +2108,7 @@ const ThreadTurnStartCommand = Schema$1.Struct({
 	titleSeed: Schema$1.optional(TrimmedNonEmptyString),
 	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))),
 	bootstrap: Schema$1.optional(ThreadTurnStartBootstrap),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
@@ -2108,6 +2127,7 @@ const ClientThreadTurnStartCommand = Schema$1.Struct({
 	titleSeed: Schema$1.optional(TrimmedNonEmptyString),
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode,
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	bootstrap: Schema$1.optional(ThreadTurnStartBootstrap),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
@@ -2163,6 +2183,7 @@ const DispatchableClientOrchestrationCommand = Schema$1.Union([
 	ThreadMetaUpdateCommand,
 	ThreadRuntimeModeSetCommand,
 	ThreadInteractionModeSetCommand,
+	ThreadCompressModeSetCommand,
 	ThreadTurnStartCommand,
 	ThreadTurnInterruptCommand,
 	ThreadApprovalRespondCommand,
@@ -2185,6 +2206,7 @@ const ClientOrchestrationCommand = Schema$1.Union([
 	ThreadMetaUpdateCommand,
 	ThreadRuntimeModeSetCommand,
 	ThreadInteractionModeSetCommand,
+	ThreadCompressModeSetCommand,
 	ClientThreadTurnStartCommand,
 	ThreadTurnInterruptCommand,
 	ThreadApprovalRespondCommand,
@@ -2275,6 +2297,7 @@ const OrchestrationEventType = Schema$1.Literals([
 	"thread.meta-updated",
 	"thread.runtime-mode-set",
 	"thread.interaction-mode-set",
+	"thread.compress-mode-set",
 	"thread.message-sent",
 	"thread.turn-start-requested",
 	"thread.turn-interrupt-requested",
@@ -2324,6 +2347,7 @@ const ThreadCreatedPayload$1 = Schema$1.Struct({
 	modelSelection: ModelSelection,
 	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))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime,
@@ -2381,6 +2405,11 @@ const ThreadInteractionModeSetPayload$1 = Schema$1.Struct({
 	interactionMode: ProviderInteractionMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_PROVIDER_INTERACTION_MODE))),
 	updatedAt: IsoDateTime
 });
+const ThreadCompressModeSetPayload$1 = Schema$1.Struct({
+	threadId: ThreadId,
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
+	updatedAt: IsoDateTime
+});
 const ThreadMessageSentPayload = Schema$1.Struct({
 	threadId: ThreadId,
 	messageId: MessageId,
@@ -2399,6 +2428,7 @@ const ThreadTurnStartRequestedPayload = Schema$1.Struct({
 	titleSeed: Schema$1.optional(TrimmedNonEmptyString),
 	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))),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
 });
@@ -2543,6 +2573,11 @@ const OrchestrationEvent = Schema$1.Union([
 		type: Schema$1.Literal("thread.interaction-mode-set"),
 		payload: ThreadInteractionModeSetPayload$1
 	}),
+	Schema$1.Struct({
+		...EventBaseFields,
+		type: Schema$1.Literal("thread.compress-mode-set"),
+		payload: ThreadCompressModeSetPayload$1
+	}),
 	Schema$1.Struct({
 		...EventBaseFields,
 		type: Schema$1.Literal("thread.message-sent"),
@@ -4518,14 +4553,16 @@ const ProviderSessionStartInput = Schema$1.Struct({
 	resumeCursor: Schema$1.optional(Schema$1.Unknown),
 	approvalPolicy: Schema$1.optional(ProviderApprovalPolicy),
 	sandboxMode: Schema$1.optional(ProviderSandboxMode),
-	runtimeMode: RuntimeMode
+	runtimeMode: RuntimeMode,
+	compressMode: Schema$1.optional(CompressMode)
 });
 const ProviderSendTurnInput = Schema$1.Struct({
 	threadId: ThreadId,
 	input: Schema$1.optional(TrimmedNonEmptyString.check(Schema$1.isMaxLength(PROVIDER_SEND_TURN_MAX_INPUT_CHARS))),
 	attachments: Schema$1.optional(Schema$1.Array(ChatAttachment).check(Schema$1.isMaxLength(8))),
 	modelSelection: Schema$1.optional(ModelSelection),
-	interactionMode: Schema$1.optional(ProviderInteractionMode)
+	interactionMode: Schema$1.optional(ProviderInteractionMode),
+	compressMode: Schema$1.optional(CompressMode)
 });
 Schema$1.Struct({
 	threadId: ThreadId,
@@ -7615,6 +7652,57 @@ const ThreadControlToolError = Schema$1.Union([
 	ThreadRenameRejectedError,
 	MemoryAppendFailedError
 ]);
+const ThreadWatchEventsInput = Schema$1.Struct({
+	threadId: ThreadId.annotate({ description: "The watched thread to read events from. Must be explicitly granted." }),
+	afterSequence: Schema$1.optional(NonNegativeInt.annotate({ description: "Exclusive sequence cursor. Events with a higher sequence are returned. Omit to read from the beginning." })),
+	limit: Schema$1.optional(NonNegativeInt.check(Schema$1.isLessThanOrEqualTo(200)).annotate({ description: `Maximum events to return (default 50, max 200).` }))
+});
+const ThreadWatchEventsResult = Schema$1.Struct({
+	threadId: ThreadId,
+	/** Ordered by sequence ascending; resume with the last event's sequence. */
+	events: Schema$1.Array(OrchestrationEvent),
+	/**
+	* The engine's latest persisted sequence at read time. Equal to the last
+	* returned event's sequence when the watcher is caught up.
+	*/
+	headSequence: NonNegativeInt,
+	/** True when more events for this thread exist past the returned page. */
+	hasMore: Schema$1.Boolean
+});
+var WatchToolUnavailableError = class extends Schema$1.TaggedErrorClass()("WatchToolUnavailableError", {
+	capability: Schema$1.Literal("watch"),
+	environmentId: EnvironmentId,
+	threadId: ThreadId,
+	providerSessionId: TrimmedNonEmptyString,
+	providerInstanceId: ProviderInstanceId
+}) {
+	get message() {
+		return `MCP credential does not grant the ${this.capability} capability.`;
+	}
+};
+/**
+* The capability is present but the requested thread is not in the granted
+* set. Separate from {@link WatchToolUnavailableError} so a watcher can tell
+* "you cannot watch at all" apart from "not this thread".
+*/
+var ThreadWatchNotPermittedError = class extends Schema$1.TaggedErrorClass()("ThreadWatchNotPermittedError", { threadId: ThreadId }) {
+	get message() {
+		return `This session was not granted watch access to thread ${this.threadId}.`;
+	}
+};
+var ThreadWatchFailedError = class extends Schema$1.TaggedErrorClass()("ThreadWatchFailedError", {
+	threadId: ThreadId,
+	detail: Schema$1.String
+}) {
+	get message() {
+		return `Reading events for thread ${this.threadId} failed: ${this.detail}`;
+	}
+};
+const ThreadWatchToolError = Schema$1.Union([
+	WatchToolUnavailableError,
+	ThreadWatchNotPermittedError,
+	ThreadWatchFailedError
+]);
 //#endregion
 //#region ../../packages/contracts/src/agentAsset.ts
 /**
@@ -12225,6 +12313,14 @@ var _038_TaskOrderKeys_default = Effect.gen(function* () {
 	yield* (yield* SqlClient.SqlClient)`ALTER TABLE tasks ADD COLUMN order_key TEXT`;
 });
 //#endregion
+//#region src/persistence/Migrations/039_ProjectionThreadsCompressMode.ts
+var _039_ProjectionThreadsCompressMode_default = Effect.gen(function* () {
+	yield* (yield* SqlClient.SqlClient)`
+    ALTER TABLE projection_threads
+    ADD COLUMN compress_mode TEXT NOT NULL DEFAULT 'off'
+  `;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -12435,6 +12531,11 @@ const migrationEntries = [
 		38,
 		"TaskOrderKeys",
 		_038_TaskOrderKeys_default
+	],
+	[
+		39,
+		"ProjectionThreadsCompressMode",
+		_039_ProjectionThreadsCompressMode_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -18131,6 +18232,7 @@ const ThreadSettledPayload = ThreadSettledPayload$1;
 const ThreadMetaUpdatedPayload = ThreadMetaUpdatedPayload$1;
 const ThreadRuntimeModeSetPayload = ThreadRuntimeModeSetPayload$1;
 const ThreadInteractionModeSetPayload = ThreadInteractionModeSetPayload$1;
+const ThreadCompressModeSetPayload = ThreadCompressModeSetPayload$1;
 const ThreadDeletedPayload = ThreadDeletedPayload$1;
 const ThreadUnarchivedPayload = ThreadUnarchivedPayload$1;
 const ThreadUnsettledPayload = ThreadUnsettledPayload$1;
@@ -18270,6 +18372,7 @@ function projectEvent(model, event) {
 				modelSelection: payload.modelSelection,
 				runtimeMode: payload.runtimeMode,
 				interactionMode: payload.interactionMode,
+				compressMode: payload.compressMode,
 				branch: payload.branch,
 				worktreePath: payload.worktreePath,
 				latestTurn: null,
@@ -18369,6 +18472,13 @@ function projectEvent(model, event) {
 				updatedAt: payload.updatedAt
 			})
 		})));
+		case "thread.compress-mode-set": return decodeForEvent(ThreadCompressModeSetPayload, event.payload, event.type, "payload").pipe(Effect.map((payload) => ({
+			...nextBase,
+			threads: updateThread(nextBase.threads, payload.threadId, {
+				compressMode: payload.compressMode,
+				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);
@@ -18734,6 +18844,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 					modelSelection: command.modelSelection,
 					runtimeMode: command.runtimeMode,
 					interactionMode: command.interactionMode,
+					compressMode: command.compressMode,
 					branch: command.branch,
 					worktreePath: command.worktreePath,
 					createdAt: command.createdAt,
@@ -18991,6 +19102,28 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				}
 			};
 		}
+		case "thread.compress-mode.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.compress-mode-set",
+				payload: {
+					threadId: command.threadId,
+					compressMode: command.compressMode,
+					updatedAt: occurredAt
+				}
+			};
+		}
 		case "thread.turn.start": {
 			const targetThread = yield* requireThread({
 				readModel,
@@ -19048,6 +19181,7 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 					...command.titleSeed !== void 0 ? { titleSeed: command.titleSeed } : {},
 					runtimeMode: targetThread.runtimeMode,
 					interactionMode: targetThread.interactionMode,
+					compressMode: targetThread.compressMode,
 					...sourceProposedPlan !== void 0 ? { sourceProposedPlan } : {},
 					createdAt: command.createdAt
 				}
@@ -19813,6 +19947,7 @@ const ProjectionThread = Schema$1.Struct({
 	modelSelection: ModelSelection,
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode,
+	compressMode: CompressMode,
 	branch: Schema$1.NullOr(Schema$1.String),
 	worktreePath: Schema$1.NullOr(Schema$1.String),
 	latestTurnId: Schema$1.NullOr(TurnId),
@@ -20700,6 +20835,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           model_selection_json,
           runtime_mode,
           interaction_mode,
+          compress_mode,
           branch,
           worktree_path,
           latest_turn_id,
@@ -20723,6 +20859,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           ${JSON.stringify(row.modelSelection)},
           ${row.runtimeMode},
           ${row.interactionMode},
+          ${row.compressMode},
           ${row.branch},
           ${row.worktreePath},
           ${row.latestTurnId},
@@ -20746,6 +20883,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           model_selection_json = excluded.model_selection_json,
           runtime_mode = excluded.runtime_mode,
           interaction_mode = excluded.interaction_mode,
+          compress_mode = excluded.compress_mode,
           branch = excluded.branch,
           worktree_path = excluded.worktree_path,
           latest_turn_id = excluded.latest_turn_id,
@@ -20774,6 +20912,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           model_selection_json AS "modelSelection",
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
+          compress_mode AS "compressMode",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -20804,6 +20943,7 @@ const makeProjectionThreadRepository = Effect.gen(function* () {
           model_selection_json AS "modelSelection",
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
+          compress_mode AS "compressMode",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -21270,6 +21410,7 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 					modelSelection: event.payload.modelSelection,
 					runtimeMode: event.payload.runtimeMode,
 					interactionMode: event.payload.interactionMode,
+					compressMode: event.payload.compressMode,
 					branch: event.payload.branch,
 					worktreePath: event.payload.worktreePath,
 					latestTurnId: null,
@@ -21384,6 +21525,16 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
 				});
 				return;
 			}
+			case "thread.compress-mode-set": {
+				const existingRow = yield* projectionThreadRepository.getById({ threadId: event.payload.threadId });
+				if (Option.isNone(existingRow)) return;
+				yield* projectionThreadRepository.upsert({
+					...existingRow.value,
+					compressMode: event.payload.compressMode,
+					updatedAt: event.payload.updatedAt
+				});
+				return;
+			}
 			case "thread.deleted": {
 				attachmentSideEffects.deletedThreadIds.add(event.payload.threadId);
 				const existingRow = yield* projectionThreadRepository.getById({ threadId: event.payload.threadId });
@@ -22705,6 +22856,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           model_selection_json AS "modelSelection",
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
+          compress_mode AS "compressMode",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -22735,6 +22887,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           model_selection_json AS "modelSelection",
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
+          compress_mode AS "compressMode",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -22767,6 +22920,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           model_selection_json AS "modelSelection",
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
+          compress_mode AS "compressMode",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -23099,6 +23253,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           model_selection_json AS "modelSelection",
           runtime_mode AS "runtimeMode",
           interaction_mode AS "interactionMode",
+          compress_mode AS "compressMode",
           branch,
           worktree_path AS "worktreePath",
           latest_turn_id AS "latestTurnId",
@@ -23400,6 +23555,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			modelSelection: row.modelSelection,
 			runtimeMode: row.runtimeMode,
 			interactionMode: row.interactionMode,
+			compressMode: row.compressMode,
 			branch: row.branch,
 			worktreePath: row.worktreePath,
 			latestTurn: latestTurnByThread.get(row.threadId) ?? null,
@@ -23511,6 +23667,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				modelSelection: row.modelSelection,
 				runtimeMode: row.runtimeMode,
 				interactionMode: row.interactionMode,
+				compressMode: row.compressMode,
 				branch: row.branch,
 				worktreePath: row.worktreePath,
 				latestTurn: latestTurnByThread.get(row.threadId) ?? null,
@@ -23569,6 +23726,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				modelSelection: row.modelSelection,
 				runtimeMode: row.runtimeMode,
 				interactionMode: row.interactionMode,
+				compressMode: row.compressMode,
 				branch: row.branch,
 				worktreePath: row.worktreePath,
 				latestTurn: latestTurnByThread.get(row.threadId) ?? null,
@@ -23623,6 +23781,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 				modelSelection: row.modelSelection,
 				runtimeMode: row.runtimeMode,
 				interactionMode: row.interactionMode,
+				compressMode: row.compressMode,
 				branch: row.branch,
 				worktreePath: row.worktreePath,
 				latestTurn: latestTurnByThread.get(row.threadId) ?? null,
@@ -23713,6 +23872,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			modelSelection: threadRow.value.modelSelection,
 			runtimeMode: threadRow.value.runtimeMode,
 			interactionMode: threadRow.value.interactionMode,
+			compressMode: threadRow.value.compressMode,
 			branch: threadRow.value.branch,
 			worktreePath: threadRow.value.worktreePath,
 			latestTurn: Option.isSome(latestTurnRow) ? mapLatestTurn(latestTurnRow.value) : null,
@@ -23748,6 +23908,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			modelSelection: threadRow.value.modelSelection,
 			runtimeMode: threadRow.value.runtimeMode,
 			interactionMode: threadRow.value.interactionMode,
+			compressMode: threadRow.value.compressMode,
 			branch: threadRow.value.branch,
 			worktreePath: threadRow.value.worktreePath,
 			latestTurn: Option.isSome(latestTurnRow) ? mapLatestTurn(latestTurnRow.value) : null,
@@ -23827,11 +23988,66 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 });
 const OrchestrationProjectionSnapshotQueryLive = Layer.effect(ProjectionSnapshotQuery, makeProjectionSnapshotQuery);
 //#endregion
+//#region src/orchestration/Services/ThreadEventStream.ts
+var ThreadEventStreamService = class extends Context.Service()("@p4code/cli/orchestration/Services/ThreadEventStream/ThreadEventStreamService") {};
+//#endregion
+//#region src/orchestration/Layers/ThreadEventStream.ts
+const makeThreadEventStream = Effect.gen(function* () {
+	const engine = yield* OrchestrationEngineService;
+	const isThreadEvent = (threadId) => (event) => event.aggregateKind === "thread" && event.aggregateId === threadId;
+	const watch = (input) => Stream.unwrap(Effect.gen(function* () {
+		const matchesThread = isThreadEvent(input.threadId);
+		const liveBuffer = yield* Queue.unbounded();
+		yield* Effect.forkScoped(engine.streamDomainEvents.pipe(Stream.filter(matchesThread), Stream.runForEach((event) => Queue.offer(liveBuffer, event))), { startImmediately: true });
+		const afterSequence = input.afterSequence ?? 0;
+		const headSequence = yield* engine.latestSequence;
+		const replayGap = headSequence - afterSequence;
+		const catchUp = replayGap > 0 ? engine.readEvents(afterSequence, replayGap).pipe(Stream.filter(matchesThread)) : Stream.empty;
+		const caughtUp = Stream.make({
+			kind: "caught-up",
+			headSequence
+		});
+		const live = Stream.fromQueue(liveBuffer).pipe(Stream.filter((event) => event.sequence > headSequence));
+		return Stream.concat(catchUp.pipe(Stream.map((event) => ({
+			kind: "event",
+			event
+		}))), Stream.concat(caughtUp, live.pipe(Stream.map((event) => ({
+			kind: "event",
+			event
+		})))));
+	}));
+	const read = (input) => Effect.gen(function* () {
+		const matchesThread = isThreadEvent(input.threadId);
+		const afterSequence = input.afterSequence ?? 0;
+		const headSequence = yield* engine.latestSequence;
+		const replayGap = headSequence - afterSequence;
+		if (replayGap <= 0) return {
+			events: [],
+			headSequence,
+			hasMore: false
+		};
+		const collected = yield* engine.readEvents(afterSequence, replayGap).pipe(Stream.filter(matchesThread), Stream.take(input.limit + 1), Stream.runCollect);
+		const events = Array.from(collected);
+		const hasMore = events.length > input.limit;
+		return {
+			events: hasMore ? events.slice(0, input.limit) : events,
+			headSequence,
+			hasMore
+		};
+	});
+	return ThreadEventStreamService.of({
+		watch,
+		read
+	});
+});
+const ThreadEventStreamLive = Layer.effect(ThreadEventStreamService, makeThreadEventStream);
+//#endregion
 //#region src/orchestration/runtimeLayer.ts
 const OrchestrationEventInfrastructureLayerLive = Layer.mergeAll(OrchestrationEventStoreLive, OrchestrationCommandReceiptRepositoryLive);
 const OrchestrationProjectionPipelineLayerLive = OrchestrationProjectionPipelineLive.pipe(Layer.provide(OrchestrationEventStoreLive));
 const OrchestrationInfrastructureLayerLive = Layer.mergeAll(OrchestrationProjectionSnapshotQueryLive, OrchestrationEventInfrastructureLayerLive, OrchestrationProjectionPipelineLayerLive);
-const OrchestrationLayerLive = Layer.mergeAll(OrchestrationInfrastructureLayerLive, OrchestrationEngineLive.pipe(Layer.provide(OrchestrationInfrastructureLayerLive)));
+const OrchestrationEngineLayerLive = OrchestrationEngineLive.pipe(Layer.provide(OrchestrationInfrastructureLayerLive));
+const OrchestrationLayerLive = Layer.mergeAll(OrchestrationInfrastructureLayerLive, OrchestrationEngineLayerLive, ThreadEventStreamLive.pipe(Layer.provide(OrchestrationEngineLayerLive)));
 //#endregion
 //#region ../../packages/shared/src/keybindings.ts
 const DEFAULT_KEYBINDINGS = [
@@ -27101,6 +27317,7 @@ const resolveAutoBootstrapWelcomeTargets = Effect.gen(function* () {
 				title: "New thread",
 				modelSelection: nextProjectDefaultModelSelection,
 				interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+				compressMode: DEFAULT_COMPRESS_MODE,
 				runtimeMode: "full-access",
 				branch: null,
 				worktreePath: null,
@@ -33144,6 +33361,12 @@ const toTaskStoreError = (operation) => (cause) => Effect.logWarning("task store
 /**
 * The `auto` rendering: here is the task, do it.
 *
+* The prompt carries a reference to the task, not a copy of it. Inlining the
+* body flattened the row into plain text: labels, project and priority were
+* lost, and an edit made after the thread started was invisible to an agent
+* still reading its stale snapshot. The row stays the single source of truth
+* and the agent reads it live over MCP.
+*
 * Two instructions carry their weight. The agent is told its thread is already
 * linked to the task, because otherwise its first useful move is to guess which
 * board row it is on. And it is told to leave `status` alone: the server moved
@@ -33152,18 +33375,16 @@ const toTaskStoreError = (operation) => (cause) => Effect.logWarning("task store
 * the reason the board's columns still mean something.
 */
 const buildAutoPrompt = (task) => {
-	const body = task.body.trim();
-	return `You are picking up a task from the board. Do the work.
-
-## ${task.title}
+	const reference = task.readableId ?? task.taskId;
+	return `You are picking up task \`${reference}\` from the board: ${task.title}
 
-${body.length === 0 ? "_The task has no description. Read enough of the repository to work out what it means, and ask if it is genuinely ambiguous._" : body}
+Start by reading the task itself with \`task_current\` (or \`task_get\` with \`${reference}\`). The body, labels, project and priority live on the row, not in this message, and the row may have been edited since this thread started — what it says now is the source of truth. Re-read it the same way whenever you need the fields again.
 
-This thread is linked to task \`${task.taskId}\`, which is now In progress. \`task_current\` re-reads it if you need the fields again.
+This thread is already linked to the task, which is now In progress. Do the work.
 
 Record what you find with \`task_update\` as you go — a decision you made, a constraint you hit, something the task turned out to be wrong about. That is what makes the row worth reading afterwards. Leave \`status\` alone: moving work across the board is the user's call.
 
-Start by reading the code the task concerns. If it turns out to be specified too poorly to act on, say so and stop rather than guessing at what was meant.`;
+After reading the task, read the code it concerns. If it turns out to be specified too poorly to act on, say so and stop rather than guessing at what was meant.`;
 };
 /**
 * Render a task into the prompt that seeds its thread.
@@ -36118,6 +36339,24 @@ const requireTaskCapability = Effect.fn("mcp.requireTaskCapability")(function* (
 	});
 	return invocation;
 });
+/**
+* The watch capability's guard is two checks, not one: the capability must be
+* present AND the requested thread must be in the explicit grant set. The two
+* failures are distinct errors so a watcher can tell "this session cannot
+* watch at all" apart from "not this thread".
+*/
+const requireWatchCapability = Effect.fn("mcp.requireWatchCapability")(function* (watchedThreadId) {
+	const invocation = yield* McpInvocationContext;
+	if (!invocation.capabilities.has("watch")) return yield* new WatchToolUnavailableError({
+		capability: "watch",
+		environmentId: invocation.environmentId,
+		threadId: invocation.threadId,
+		providerSessionId: invocation.providerSessionId,
+		providerInstanceId: invocation.providerInstanceId
+	});
+	if (!invocation.watchThreadIds?.has(watchedThreadId)) return yield* new ThreadWatchNotPermittedError({ threadId: watchedThreadId });
+	return invocation;
+});
 /** Third of the trio, for the same reason the second exists. */
 const requireThreadCapability = Effect.fn("mcp.requireThreadCapability")(function* () {
 	const invocation = yield* McpInvocationContext;
@@ -43521,6 +43760,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 					modelSelection: bootstrap.createThread.modelSelection,
 					runtimeMode: bootstrap.createThread.runtimeMode,
 					interactionMode: bootstrap.createThread.interactionMode,
+					compressMode: bootstrap.createThread.compressMode,
 					branch: bootstrap.createThread.branch,
 					worktreePath: bootstrap.createThread.worktreePath,
 					createdAt: bootstrap.createThread.createdAt
@@ -43774,8 +44014,8 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 						mode: "auto",
 						task: {
 							taskId,
-							title: task.title,
-							body: task.body
+							readableId: task.readableId,
+							title: task.title
 						}
 					}),
 					attachments: []
@@ -43784,12 +44024,14 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 				titleSeed: threadTitle,
 				runtimeMode: DEFAULT_RUNTIME_MODE$2,
 				interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+				compressMode: DEFAULT_COMPRESS_MODE,
 				bootstrap: { createThread: {
 					projectId: plan.projectId,
 					title: threadTitle,
 					modelSelection,
 					runtimeMode: DEFAULT_RUNTIME_MODE$2,
 					interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
+					compressMode: DEFAULT_COMPRESS_MODE,
 					branch: null,
 					worktreePath: null,
 					createdAt
@@ -45073,16 +45315,20 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 		const providerSessionId = yield* crypto.randomUUIDv4.pipe(Effect.orDie);
 		const rawToken = yield* crypto.randomBytes(32).pipe(Effect.map(tokenFromBytes), Effect.orDie);
 		const tokenHash = yield* hashToken(rawToken);
+		const watchThreadIds = new Set((request.watchThreadIds ?? []).map((threadId) => ThreadId.make(threadId)));
+		const capabilities = /* @__PURE__ */ new Set([
+			"preview",
+			"tasks",
+			"threads"
+		]);
+		if (watchThreadIds.size > 0) capabilities.add("watch");
 		const scope = {
 			environmentId,
 			threadId: ThreadId.make(request.threadId),
 			providerSessionId,
 			providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
-			capabilities: /* @__PURE__ */ new Set([
-				"preview",
-				"tasks",
-				"threads"
-			]),
+			capabilities,
+			...watchThreadIds.size > 0 ? { watchThreadIds } : {},
 			issuedAt
 		};
 		yield* SynchronizedRef.update(state, ({ records }) => {
@@ -47857,6 +48103,88 @@ function formatAskUserQuestionAnswers(answers) {
 	return formatted;
 }
 //#endregion
+//#region src/provider/CompressPrompts.ts
+/**
+* Caveman-style response compression rulesets, adapted from the caveman
+* plugin's SKILL.md. Pre-baked per level so injection is a lookup, not a
+* runtime template. Applies to assistant prose only: code blocks, commits,
+* PRs, error strings, and safety-critical text stay uncompressed.
+*/
+const COMPRESS_SHARED_RULES = `Respond terse. All technical substance stays. Only fluff dies.
+
+## Persistence
+
+Active every response. No revert after many turns. No filler drift. Still active if unsure.
+
+## Rules
+
+Drop filler (just/really/basically/actually/simply), pleasantries (sure/certainly/of course/happy to), hedging. Short synonyms (big not extensive, fix not "implement a solution for"). No tool-call narration, no decorative tables/emoji, no dumping long raw error logs unless asked - quote shortest decisive line. Standard well-known tech acronyms OK (DB/API/HTTP); never invent new abbreviations (cfg/impl/req/res/fn) - tokenizers split them same as the full word: zero tokens saved, reader still decodes. No causal arrows (->) in prose. Technical terms exact. Code blocks unchanged. Errors quoted exact.
+
+Preserve the user's dominant language: compress the style, not the language. 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.
+
+No self-reference. Never name or announce the style. No compressed answer plus normal recap - compressed output only. Exception: user explicitly asks what the mode is.
+
+## Auto-Clarity
+
+Drop compression and write normally when:
+- Security warnings
+- Irreversible action confirmations
+- Multi-step sequences where fragment order or omitted conjunctions risk misread
+- Compression itself creates technical ambiguity
+- User asks to clarify or repeats a question
+
+Resume compression after the clear part is done.
+
+## Boundaries
+
+Code, commit messages, and PR descriptions: write normal, uncompressed.`;
+const COMPRESS_RULESETS = {
+	lite: `## Response compression: lite
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: lite
+
+No filler or hedging. Keep articles and full sentences. Professional but tight.
+
+Example - "Why does my React component re-render?"
+"Your component re-renders because you create a new object reference each render. Wrap it in \`useMemo\`."`,
+	full: `## Response compression: full
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: full
+
+Drop articles (a/an/the), fragments OK, short synonyms. Pattern: [thing] [action] [reason]. [next step].
+
+Not: "Sure! I'd be happy to help you with that. The issue you're experiencing is likely caused by..."
+Yes: "Bug in auth middleware. Token expiry check use \`<\` not \`<=\`. Fix:"
+
+Example - "Why does my React component re-render?"
+"New object ref each render. Inline object prop = new ref = re-render. Wrap in \`useMemo\`."`,
+	ultra: `## Response compression: ultra
+
+${COMPRESS_SHARED_RULES}
+
+## Intensity: ultra
+
+Drop articles, fragments OK, short synonyms. Also strip conjunctions when cause-then-effect stays unambiguous. One word when one word is enough. State each fact once. Code symbols, function names, API names, error strings: never touch.
+
+Example - "Why does my React component re-render?"
+"Inline object prop, new ref, re-render. \`useMemo\`."`
+};
+const COMPRESS_TURN_REMINDERS = {
+	lite: "[response style: compressed lite - no filler/hedging, full sentences; code/commits/security text normal]",
+	full: "[response style: compressed full - terse fragments, drop articles/filler; code/commits/security text normal]",
+	ultra: "[response style: compressed ultra - maximum terseness, one word when enough; code/commits/security text normal]"
+};
+function compressRulesetFor(mode) {
+	return mode === "off" ? void 0 : COMPRESS_RULESETS[mode];
+}
+function compressTurnReminderFor(mode) {
+	return mode === "off" ? void 0 : COMPRESS_TURN_REMINDERS[mode];
+}
+//#endregion
 //#region src/provider/Layers/ClaudeAdapter.ts
 /**
 * ClaudeAdapterLive - Scoped live implementation for the Claude Agent provider adapter.
@@ -50246,6 +50574,8 @@ 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 compressRuleset = compressRulesetFor(input.compressMode ?? "off");
+		const systemPromptAppend = [...narrateBeforeTools ? [NARRATE_BEFORE_TOOLS_PROMPT] : [], ...compressRuleset !== void 0 ? [compressRuleset] : []].join("\n\n");
 		const queryOptions = {
 			...input.cwd ? { cwd: input.cwd } : {},
 			...apiModelId ? { model: apiModelId } : {},
@@ -50253,7 +50583,7 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			systemPrompt: {
 				type: "preset",
 				preset: "claude_code",
-				...narrateBeforeTools ? { append: NARRATE_BEFORE_TOOLS_PROMPT } : {}
+				...systemPromptAppend.length > 0 ? { append: systemPromptAppend } : {}
 			},
 			settingSources: [...CLAUDE_SETTING_SOURCES],
 			...effectiveEffort ? { effort: effectiveEffort } : {},
@@ -69563,8 +69893,12 @@ ${P4_CODE_BROWSER_TOOL_INSTRUCTIONS}
 function toSingleLine(value) {
 	return value.replaceAll(/\s+/g, " ").trim();
 }
-function buildCodexDeveloperInstructions(interactionMode, runtime) {
-	return `${interactionMode === "plan" ? CODEX_PLAN_MODE_DEVELOPER_INSTRUCTIONS : CODEX_DEFAULT_MODE_DEVELOPER_INSTRUCTIONS}
+function buildCodexDeveloperInstructions(interactionMode, runtime, compressMode) {
+	const base = interactionMode === "plan" ? CODEX_PLAN_MODE_DEVELOPER_INSTRUCTIONS : CODEX_DEFAULT_MODE_DEVELOPER_INSTRUCTIONS;
+	const compressRuleset = compressRulesetFor(compressMode ?? "off");
+	return `${base}${compressRuleset === void 0 ? "" : `
+
+<response_style>${compressRuleset}</response_style>`}
 
 <runtime_info>In case you're asked: you are running in P4Code through the Codex harness, as ${toSingleLine(runtime.model)} with ${toSingleLine(runtime.reasoningEffort)} reasoning effort. No need to mention this otherwise.</runtime_info>`;
 }
@@ -69682,7 +70016,7 @@ function buildCodexCollaborationMode(input) {
 			developer_instructions: buildCodexDeveloperInstructions(input.interactionMode, {
 				model,
 				reasoningEffort
-			})
+			}, input.compressMode)
 		}
 	};
 }
@@ -69696,6 +70030,7 @@ function buildTurnStartParams(input) {
 	const config = runtimeModeToThreadConfig(input.runtimeMode);
 	const collaborationMode = buildCodexCollaborationMode({
 		...input.interactionMode ? { interactionMode: input.interactionMode } : {},
+		...input.compressMode ? { compressMode: input.compressMode } : {},
 		...input.model ? { model: input.model } : {},
 		...input.effort ? { effort: input.effort } : {}
 	});
@@ -70234,7 +70569,8 @@ const makeCodexSessionRuntime = (options) => Effect.gen(function* () {
 				...normalizedModel ? { model: normalizedModel } : {},
 				...input.serviceTier ? { serviceTier: input.serviceTier } : {},
 				...input.effort ? { effort: input.effort } : {},
-				...input.interactionMode ? { interactionMode: input.interactionMode } : {}
+				...input.interactionMode ? { interactionMode: input.interactionMode } : {},
+				...input.compressMode ? { compressMode: input.compressMode } : {}
 			});
 			const rawResponse = yield* client.raw.request("turn/start", params);
 			const response = yield* decodeV2TurnStartResponse(rawResponse).pipe(Effect.mapError((error) => CodexAppServerProtocolParseError.fromSchemaError("decode-response-payload", error, { method: "turn/start" })));
@@ -71226,6 +71562,7 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 			...reasoningEffort ? { effort: reasoningEffort } : {},
 			...serviceTier ? { serviceTier } : {},
 			...input.interactionMode !== void 0 ? { interactionMode: input.interactionMode } : {},
+			...input.compressMode !== void 0 ? { compressMode: input.compressMode } : {},
 			...codexAttachments.length > 0 ? { attachments: codexAttachments } : {}
 		}).pipe(Effect.mapError((cause) => mapCodexRuntimeError(input.threadId, "turn/start", cause)));
 	});
@@ -82105,7 +82442,7 @@ const invokeTargeted = (operation, input, timeoutMs) => {
 	const { tabId, ...operationInput } = input;
 	return invoke(operation, operationInput, timeoutMs, tabId);
 };
-const handlers$2 = {
+const handlers$3 = {
 	preview_status: (input) => invokeTargeted("status", input ?? {}),
 	preview_open: (input) => invokeTargeted("open", normalizePreviewOpenInput(input)),
 	preview_navigate: (input) => invokeTargeted("navigate", input, input.timeoutMs),
@@ -82121,10 +82458,10 @@ const handlers$2 = {
 	preview_recording_start: (input) => invokeTargeted("recordingStart", input ?? {}),
 	preview_recording_stop: (input) => invokeTargeted("recordingStop", input ?? {})
 };
-const { preview_snapshot, ...standardHandlers } = handlers$2;
+const { preview_snapshot, ...standardHandlers } = handlers$3;
 const PreviewStandardToolkitHandlersLive = PreviewStandardToolkit.toLayer(standardHandlers);
 const PreviewSnapshotToolkitHandlersLive = PreviewSnapshotToolkit.toLayer({ preview_snapshot });
-PreviewToolkit.toLayer(handlers$2);
+PreviewToolkit.toLayer(handlers$3);
 //#endregion
 //#region src/mcp/toolkits/tasks/tools.ts
 const dependencies = [McpInvocationContext, TaskRepository];
@@ -82357,6 +82694,41 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 	})
 });
 //#endregion
+//#region src/mcp/toolkits/watch/tools.ts
+/**
+* Cross-thread by design, which is exactly why it is the most guarded tool in
+* the registry: the handler admits only threads in the session's explicit
+* `watchThreadIds` grant, never the token's whole reach. The read is a cursor
+* poll because MCP tools are request/response; a watcher advances
+* `afterSequence` with each page and knows it is caught up when `hasMore` is
+* false and the last sequence equals `headSequence`.
+*/
+const ThreadWatchEventsTool = Tool.make("thread_watch_events", {
+	description: "Read a watched thread's orchestration events after a sequence cursor. Returns an ordered page plus the head sequence; pass the last event's sequence back as afterSequence to poll forward. Only threads this session was explicitly granted are readable.",
+	parameters: ThreadWatchEventsInput,
+	success: ThreadWatchEventsResult,
+	failure: ThreadWatchToolError,
+	dependencies: [McpInvocationContext, ThreadEventStreamService]
+}).annotate(Tool.Title, "Read watched thread events").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
+const WatchToolkit = Toolkit.make(ThreadWatchEventsTool);
+const WatchToolkitHandlersLive = WatchToolkit.toLayer({ thread_watch_events: (input) => Effect.gen(function* () {
+	yield* requireWatchCapability(input.threadId);
+	const page = yield* (yield* ThreadEventStreamService).read({
+		threadId: input.threadId,
+		...input.afterSequence !== void 0 ? { afterSequence: input.afterSequence } : {},
+		limit: input.limit ?? 50
+	}).pipe(Effect.mapError((cause) => new ThreadWatchFailedError({
+		threadId: input.threadId,
+		detail: cause.message
+	})));
+	return {
+		threadId: input.threadId,
+		events: page.events,
+		headSequence: page.headSequence,
+		hasMore: page.hasMore
+	};
+}) });
+//#endregion
 //#region src/mcp/McpHttpServer.ts
 const unauthorized = HttpServerResponse.jsonUnsafe({
 	error: "invalid_mcp_credential",
@@ -82461,12 +82833,13 @@ const PreviewSnapshotRegistrationLive = Layer.effectDiscard(registerPreviewSnaps
 const PreviewToolkitRegistrationLive = Layer.mergeAll(PreviewStandardToolkitRegistrationLive, PreviewSnapshotRegistrationLive);
 const TaskToolkitRegistrationLive = McpServer.toolkit(TaskToolkit).pipe(Layer.provide(TaskToolkitHandlersLive));
 const ThreadToolkitRegistrationLive = McpServer.toolkit(ThreadToolkit).pipe(Layer.provide(ThreadToolkitHandlersLive));
+const WatchToolkitRegistrationLive = McpServer.toolkit(WatchToolkit).pipe(Layer.provide(WatchToolkitHandlersLive));
 const McpTransportLive = McpServer.layerHttp({
 	name: "P4Code",
 	version,
 	path: "/mcp"
 }).pipe(Layer.provide(McpAuthMiddlewareLive));
-const layer = Layer.mergeAll(PreviewToolkitRegistrationLive, TaskToolkitRegistrationLive, ThreadToolkitRegistrationLive).pipe(Layer.provideMerge(McpTransportLive));
+const layer = Layer.mergeAll(PreviewToolkitRegistrationLive, TaskToolkitRegistrationLive, ThreadToolkitRegistrationLive, WatchToolkitRegistrationLive).pipe(Layer.provideMerge(McpTransportLive));
 //#endregion
 //#region src/orchestration/Services/CheckpointReactor.ts
 /**
@@ -83877,7 +84250,8 @@ const make$2 = Effect.gen(function* () {
 			...effectiveCwd ? { cwd: effectiveCwd } : {},
 			modelSelection: desiredModelSelection,
 			...input?.resumeCursor !== void 0 ? { resumeCursor: input.resumeCursor } : {},
-			runtimeMode: desiredRuntimeMode
+			runtimeMode: desiredRuntimeMode,
+			compressMode: thread.compressMode
 		});
 		const bindSessionToThread = (session) => Effect.gen(function* () {
 			if (session.providerInstanceId === void 0) return yield* new ProviderAdapterRequestError({
@@ -83950,6 +84324,7 @@ const make$2 = Effect.gen(function* () {
 	const buildSendTurnRequestForThread = Effect.fnUntraced(function* (input) {
 		const thread = yield* resolveThread(input.threadId);
 		if (!thread) return yield* Effect.die(/* @__PURE__ */ new Error(`Thread '${input.threadId}' was not found in read model.`));
+		const hadActiveSession = thread.session !== null && thread.session.status !== "stopped";
 		yield* ensureSessionForThread(input.threadId, input.createdAt, {
 			...input.modelSelection !== void 0 ? { modelSelection: input.modelSelection } : {},
 			pendingTurnStart: true
@@ -83968,12 +84343,17 @@ const make$2 = Effect.gen(function* () {
 			...requestedModelSelection,
 			model: activeSession.model
 		} : requestedModelSelection : input.modelSelection;
+		const compressMode = thread.compressMode;
+		const hasSessionLevelRuleset = activeSession?.provider === "claudeAgent" || activeSession?.provider === "codex";
+		const compressPrefix = !hadActiveSession && !hasSessionLevelRuleset ? compressRulesetFor(compressMode) : compressTurnReminderFor(compressMode);
+		const inputWithCompressPrefix = normalizedInput !== void 0 && compressPrefix !== void 0 ? `${compressPrefix}\n\n${normalizedInput}` : normalizedInput;
 		return {
 			threadId: input.threadId,
-			...normalizedInput ? { input: normalizedInput } : {},
+			...inputWithCompressPrefix ? { input: inputWithCompressPrefix } : {},
 			...normalizedAttachments.length > 0 ? { attachments: normalizedAttachments } : {},
 			...modelForTurn !== void 0 ? { modelSelection: modelForTurn } : {},
-			...input.interactionMode !== void 0 ? { interactionMode: input.interactionMode } : {}
+			...input.interactionMode !== void 0 ? { interactionMode: input.interactionMode } : {},
+			compressMode
 		};
 	});
 	const maybeGenerateAndRenameWorktreeBranchForFirstTurn = Effect.fn("maybeGenerateAndRenameWorktreeBranchForFirstTurn")(function* (input) {