@p4code/cli 0.1.12 → 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.12";
+var version = "0.1.13";
 //#endregion
 //#region src/config.ts
 /**
@@ -1657,6 +1657,7 @@ const CompressMode = Schema$1.Literals([
 	"full",
 	"ultra"
 ]);
+const DEFAULT_COMPRESS_MODE = "full";
 const ProviderRequestKind = Schema$1.Literals([
 	"command",
 	"file-read",
@@ -1833,7 +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("off"))),
+	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),
@@ -1874,7 +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("off"))),
+	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),
@@ -1997,7 +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("off"))),
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime
@@ -2077,7 +2078,7 @@ const ThreadTurnStartBootstrapCreateThread = Schema$1.Struct({
 	modelSelection: ModelSelection,
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode,
-	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed("off"))),
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime
@@ -2107,7 +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("off"))),
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	bootstrap: Schema$1.optional(ThreadTurnStartBootstrap),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
@@ -2126,7 +2127,7 @@ const ClientThreadTurnStartCommand = Schema$1.Struct({
 	titleSeed: Schema$1.optional(TrimmedNonEmptyString),
 	runtimeMode: RuntimeMode,
 	interactionMode: ProviderInteractionMode,
-	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed("off"))),
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	bootstrap: Schema$1.optional(ThreadTurnStartBootstrap),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
@@ -2346,7 +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("off"))),
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	branch: Schema$1.NullOr(TrimmedNonEmptyString),
 	worktreePath: Schema$1.NullOr(TrimmedNonEmptyString),
 	createdAt: IsoDateTime,
@@ -2406,7 +2407,7 @@ const ThreadInteractionModeSetPayload$1 = Schema$1.Struct({
 });
 const ThreadCompressModeSetPayload$1 = Schema$1.Struct({
 	threadId: ThreadId,
-	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed("off"))),
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	updatedAt: IsoDateTime
 });
 const ThreadMessageSentPayload = Schema$1.Struct({
@@ -2427,7 +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("off"))),
+	compressMode: CompressMode.pipe(Schema$1.withDecodingDefault(Effect.succeed(DEFAULT_COMPRESS_MODE))),
 	sourceProposedPlan: Schema$1.optional(SourceProposedPlanReference),
 	createdAt: IsoDateTime
 });
@@ -7651,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
 /**
@@ -23936,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 = [
@@ -27210,7 +27317,7 @@ const resolveAutoBootstrapWelcomeTargets = Effect.gen(function* () {
 				title: "New thread",
 				modelSelection: nextProjectDefaultModelSelection,
 				interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
-				compressMode: "off",
+				compressMode: DEFAULT_COMPRESS_MODE,
 				runtimeMode: "full-access",
 				branch: null,
 				worktreePath: null,
@@ -33254,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
@@ -33262,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.
+	const reference = task.readableId ?? task.taskId;
+	return `You are picking up task \`${reference}\` from the board: ${task.title}
 
-## ${task.title}
+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.
 
-${body.length === 0 ? "_The task has no description. Read enough of the repository to work out what it means, and ask if it is genuinely ambiguous._" : body}
-
-This thread is linked to task \`${task.taskId}\`, which is now In progress. \`task_current\` re-reads it if you need the fields again.
+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.
@@ -36228,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;
@@ -43885,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: []
@@ -43895,14 +44024,14 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 				titleSeed: threadTitle,
 				runtimeMode: DEFAULT_RUNTIME_MODE$2,
 				interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
-				compressMode: "off",
+				compressMode: DEFAULT_COMPRESS_MODE,
 				bootstrap: { createThread: {
 					projectId: plan.projectId,
 					title: threadTitle,
 					modelSelection,
 					runtimeMode: DEFAULT_RUNTIME_MODE$2,
 					interactionMode: DEFAULT_PROVIDER_INTERACTION_MODE,
-					compressMode: "off",
+					compressMode: DEFAULT_COMPRESS_MODE,
 					branch: null,
 					worktreePath: null,
 					createdAt
@@ -45186,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 }) => {
@@ -82309,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),
@@ -82325,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];
@@ -82561,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",
@@ -82665,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
 /**