@p4code/cli 0.2.11 → 0.2.12

package/dist/bin.mjs

@@ -237,7 +237,7 @@ const make$89 = () => {
 const layer$80 = Layer.sync(NetService, make$89);
 //#endregion
 //#region package.json
-var version = "0.2.11";
+var version = "0.2.12";
 //#endregion
 //#region src/config.ts
 /**
@@ -1833,6 +1833,10 @@ const OrchestrationMessage = Schema$1.Struct({
 });
 const FUSION_REVIEW_PROMPT_PREFIX = "[fusion-review]";
 const FUSION_NO_OBJECTION_TEXT = "[fusion-no-objection]";
+const FUSION_ADVICE_PROMPT_PREFIX = "[fusion-advice]";
+const FUSION_GATE_PROMPT_PREFIX = "[fusion-gate]";
+const FUSION_GATE_UNWATCHED_SUMMARY = "Gate passed unwatched";
+const FUSION_GATE_DEFAULT_TIMEOUT_MS = 12e4;
 const OrchestrationProposedPlanId = TrimmedNonEmptyString;
 const OrchestrationProposedPlan = Schema$1.Struct({
 	id: OrchestrationProposedPlanId,
@@ -1950,12 +1954,57 @@ const OrchestrationThread = Schema$1.Struct({
 	checkpoints: Schema$1.Array(OrchestrationCheckpointSummary),
 	session: Schema$1.NullOr(OrchestrationSession)
 });
+const ThreadPairGateKind = Schema$1.Literals([
+	"plan",
+	"command-approval",
+	"repeated-failure"
+]);
+/**
+* Where an open gate stands. `awaiting-watcher` is the only state the fail-open
+* timeout runs against: a watcher that never answers must not brick the run,
+* while an implementer revising or a human deciding may take as long as needed.
+*/
+const ThreadPairGateState = Schema$1.Literals([
+	"awaiting-watcher",
+	"awaiting-implementer",
+	"escalated"
+]);
+const ThreadPairGateId = TrimmedNonEmptyString;
+const ThreadPairGateOutcome = Schema$1.Literals([
+	"approved",
+	"unwatched",
+	"human",
+	"cancelled"
+]);
+const ThreadPairGateResolver = Schema$1.Literals([
+	"watcher",
+	"timeout",
+	"human",
+	"system"
+]);
+const OrchestrationThreadPairGate = Schema$1.Struct({
+	id: ThreadPairGateId,
+	kind: ThreadPairGateKind,
+	state: ThreadPairGateState,
+	/** Watcher objections spent so far. The pair's roundCap bounds this. */
+	round: NonNegativeInt,
+	requestId: Schema$1.NullOr(ApprovalRequestId),
+	planId: Schema$1.NullOr(OrchestrationProposedPlanId),
+	commandTitle: Schema$1.NullOr(TrimmedNonEmptyString),
+	openedAt: IsoDateTime,
+	/** Set whenever the gate is waiting on the watcher; the timeout base. */
+	awaitingWatcherSince: Schema$1.NullOr(IsoDateTime),
+	updatedAt: IsoDateTime
+});
 /** Persisted relationship between two otherwise ordinary threads. */
 const OrchestrationThreadPair = Schema$1.Struct({
 	id: ThreadPairId,
 	implementerThreadId: ThreadId,
 	watcherThreadId: ThreadId,
 	lastReviewedImplementerSequence: NonNegativeInt,
+	roundCap: NonNegativeInt.pipe(Schema$1.withDecodingDefault(Effect.succeed(2))),
+	gateTimeoutMs: NonNegativeInt.pipe(Schema$1.withDecodingDefault(Effect.succeed(FUSION_GATE_DEFAULT_TIMEOUT_MS))),
+	activeGate: Schema$1.NullOr(OrchestrationThreadPairGate).pipe(Schema$1.withDecodingDefault(Effect.succeed(null))),
 	createdAt: IsoDateTime,
 	detachedAt: Schema$1.NullOr(IsoDateTime)
 });
@@ -2312,6 +2361,8 @@ const ThreadPairCreateCommand = Schema$1.Struct({
 	pairId: ThreadPairId,
 	implementerThreadId: ThreadId,
 	watcherThreadId: ThreadId,
+	roundCap: Schema$1.optional(NonNegativeInt),
+	gateTimeoutMs: Schema$1.optional(NonNegativeInt),
 	createdAt: IsoDateTime
 });
 const ThreadPairDetachCommand = Schema$1.Struct({
@@ -2320,6 +2371,20 @@ const ThreadPairDetachCommand = Schema$1.Struct({
 	pairId: ThreadPairId,
 	createdAt: IsoDateTime
 });
+/**
+* Resolves the pair's open gate. Client-dispatchable because "Skip the gate"
+* and "Answer it yourself" are human overrides; the watcher's own resolutions
+* arrive through the advise toolkit, which dispatches this same command.
+*/
+const ThreadPairGateResolveCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread-pair.gate.resolve"),
+	commandId: CommandId,
+	pairId: ThreadPairId,
+	gateId: ThreadPairGateId,
+	outcome: ThreadPairGateOutcome,
+	resolvedBy: ThreadPairGateResolver,
+	resolvedAt: IsoDateTime
+});
 const DispatchableClientOrchestrationCommand = Schema$1.Union([
 	ProjectCreateCommand,
 	ProjectMetaUpdateCommand,
@@ -2344,7 +2409,8 @@ const DispatchableClientOrchestrationCommand = Schema$1.Union([
 	ThreadCheckpointRevertCommand,
 	ThreadSessionStopCommand,
 	ThreadPairCreateCommand,
-	ThreadPairDetachCommand
+	ThreadPairDetachCommand,
+	ThreadPairGateResolveCommand
 ]);
 const ClientOrchestrationCommand = Schema$1.Union([
 	ProjectCreateCommand,
@@ -2370,7 +2436,8 @@ const ClientOrchestrationCommand = Schema$1.Union([
 	ThreadCheckpointRevertCommand,
 	ThreadSessionStopCommand,
 	ThreadPairCreateCommand,
-	ThreadPairDetachCommand
+	ThreadPairDetachCommand,
+	ThreadPairGateResolveCommand
 ]);
 const ThreadSessionSetCommand = Schema$1.Struct({
 	type: Schema$1.Literal("thread.session.set"),
@@ -2399,6 +2466,31 @@ const ThreadPairCursorAdvanceCommand = Schema$1.Struct({
 	implementerSequence: NonNegativeInt,
 	advancedAt: IsoDateTime
 });
+/** Server-only: gates are opened by detection reactors, never by clients. */
+const ThreadPairGateOpenCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread-pair.gate.open"),
+	commandId: CommandId,
+	pairId: ThreadPairId,
+	gateId: ThreadPairGateId,
+	kind: ThreadPairGateKind,
+	requestId: Schema$1.optional(ApprovalRequestId),
+	planId: Schema$1.optional(OrchestrationProposedPlanId),
+	commandTitle: Schema$1.optional(TrimmedNonEmptyString),
+	openedAt: IsoDateTime
+});
+/** Server-only: moves the open gate between its states and counts rounds. */
+const ThreadPairGateAdvanceCommand = Schema$1.Struct({
+	type: Schema$1.Literal("thread-pair.gate.advance"),
+	commandId: CommandId,
+	pairId: ThreadPairId,
+	gateId: ThreadPairGateId,
+	transition: Schema$1.Literals([
+		"objection",
+		"implementer-responded",
+		"escalate"
+	]),
+	advancedAt: IsoDateTime
+});
 const ThreadMessageAssistantDeltaCommand = Schema$1.Struct({
 	type: Schema$1.Literal("thread.message.assistant.delta"),
 	commandId: CommandId,
@@ -2454,6 +2546,8 @@ const InternalOrchestrationCommand = Schema$1.Union([
 	ThreadSessionSetCommand,
 	ThreadTurnCompleteCommand,
 	ThreadPairCursorAdvanceCommand,
+	ThreadPairGateOpenCommand,
+	ThreadPairGateAdvanceCommand,
 	ThreadMessageAssistantDeltaCommand,
 	ThreadMessageAssistantCompleteCommand,
 	ThreadProposedPlanUpsertCommand,
@@ -2494,7 +2588,10 @@ const OrchestrationEventType = Schema$1.Literals([
 	"thread.turn-completed",
 	"thread-pair.created",
 	"thread-pair.detached",
-	"thread-pair.cursor-advanced"
+	"thread-pair.cursor-advanced",
+	"thread-pair.gate-opened",
+	"thread-pair.gate-advanced",
+	"thread-pair.gate-resolved"
 ]);
 const OrchestrationAggregateKind = Schema$1.Literals([
 	"project",
@@ -2683,6 +2780,8 @@ const ThreadPairCreatedPayload$1 = Schema$1.Struct({
 	implementerThreadId: ThreadId,
 	watcherThreadId: ThreadId,
 	lastReviewedImplementerSequence: NonNegativeInt,
+	roundCap: Schema$1.optional(NonNegativeInt),
+	gateTimeoutMs: Schema$1.optional(NonNegativeInt),
 	createdAt: IsoDateTime
 });
 const ThreadPairDetachedPayload$1 = Schema$1.Struct({
@@ -2694,6 +2793,36 @@ const ThreadPairCursorAdvancedPayload$1 = Schema$1.Struct({
 	implementerSequence: NonNegativeInt,
 	advancedAt: IsoDateTime
 });
+/**
+* Gate events carry both thread ids so reactors and clients can act on them
+* without a pair lookup - the wake, the activity fan-out and the gated pill
+* all key on the halves, not the pair id.
+*/
+const ThreadPairGateOpenedPayload$1 = Schema$1.Struct({
+	pairId: ThreadPairId,
+	implementerThreadId: ThreadId,
+	watcherThreadId: ThreadId,
+	gate: OrchestrationThreadPairGate,
+	openedAt: IsoDateTime
+});
+const ThreadPairGateAdvancedPayload$1 = Schema$1.Struct({
+	pairId: ThreadPairId,
+	implementerThreadId: ThreadId,
+	watcherThreadId: ThreadId,
+	gate: OrchestrationThreadPairGate,
+	advancedAt: IsoDateTime
+});
+const ThreadPairGateResolvedPayload$1 = Schema$1.Struct({
+	pairId: ThreadPairId,
+	implementerThreadId: ThreadId,
+	watcherThreadId: ThreadId,
+	gateId: ThreadPairGateId,
+	kind: ThreadPairGateKind,
+	requestId: Schema$1.NullOr(ApprovalRequestId),
+	outcome: ThreadPairGateOutcome,
+	resolvedBy: ThreadPairGateResolver,
+	resolvedAt: IsoDateTime
+});
 const ThreadProposedPlanUpsertedPayload$1 = Schema$1.Struct({
 	threadId: ThreadId,
 	proposedPlan: OrchestrationProposedPlan
@@ -2894,6 +3023,21 @@ const OrchestrationEvent = Schema$1.Union([
 		...EventBaseFields,
 		type: Schema$1.Literal("thread-pair.cursor-advanced"),
 		payload: ThreadPairCursorAdvancedPayload$1
+	}),
+	Schema$1.Struct({
+		...EventBaseFields,
+		type: Schema$1.Literal("thread-pair.gate-opened"),
+		payload: ThreadPairGateOpenedPayload$1
+	}),
+	Schema$1.Struct({
+		...EventBaseFields,
+		type: Schema$1.Literal("thread-pair.gate-advanced"),
+		payload: ThreadPairGateAdvancedPayload$1
+	}),
+	Schema$1.Struct({
+		...EventBaseFields,
+		type: Schema$1.Literal("thread-pair.gate-resolved"),
+		payload: ThreadPairGateResolvedPayload$1
 	})
 ]);
 const OrchestrationThreadStreamItem = Schema$1.Union([
@@ -9261,6 +9405,82 @@ var TrackerApiKeyError = class extends Schema$1.TaggedErrorClass()("TrackerApiKe
 	}
 };
 //#endregion
+//#region ../../packages/contracts/src/threadAdvise.ts
+/**
+* Thread advising over MCP - the cross-thread write surface behind the advise
+* capability.
+*
+* Watching (`threadWatch`) is read-only by design; this module is the change
+* that makes cross-thread access write-capable, which is why advise is a
+* separate capability rather than a wider watch. Read access never implies the
+* ability to steer: a session holding `watch` alone cannot call anything here,
+* and a session holding `advise` reaches exactly the threads in its explicit
+* `adviseThreadIds` grant - in practice the paired implementer and nothing
+* else. A request for any other thread fails closed.
+*
+* @module contracts/threadAdvise
+*/
+const ThreadAdviseInput = Schema$1.Struct({
+	threadId: ThreadId.annotate({ description: "The paired builder thread to advise. Must be explicitly granted." }),
+	message: TrimmedNonEmptyString.annotate({ description: "The advice to post into the builder thread. The builder sees it as supervisor advice and is expected to respond." }),
+	interrupt: Schema$1.optional(Schema$1.Boolean.annotate({ description: "Cancel the builder's running turn before posting, so the advice is read now rather than at the next boundary. Use only when continuing would waste or damage work." }))
+});
+const ThreadAdviseResult = Schema$1.Struct({
+	threadId: ThreadId,
+	messageId: MessageId,
+	interrupted: Schema$1.Boolean
+});
+const ThreadGateRespondInput = Schema$1.Struct({
+	threadId: ThreadId.annotate({ description: "The paired builder thread whose open gate this answers." }),
+	gateId: ThreadPairGateId.annotate({ description: "The open gate's id, given in the gate review prompt." }),
+	decision: Schema$1.Literals(["approve", "object"]).annotate({ description: "approve clears the gate and lets the builder proceed. object sends the message to the builder as an objection and spends one exchange round; when the rounds are used up the gate escalates to the human instead." }),
+	message: Schema$1.optional(TrimmedNonEmptyString.annotate({ description: "The objection to deliver. Required when decision is object." }))
+});
+const ThreadGateRespondResult = Schema$1.Struct({
+	threadId: ThreadId,
+	gateId: ThreadPairGateId,
+	kind: ThreadPairGateKind,
+	outcome: Schema$1.Literals([
+		"approved",
+		"objection-sent",
+		"escalated"
+	])
+});
+var AdviseToolUnavailableError = class extends Schema$1.TaggedErrorClass()("AdviseToolUnavailableError", {
+	capability: Schema$1.Literal("advise"),
+	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 - the same split `threadWatch` makes, so an adviser can tell "you
+* cannot advise at all" apart from "not this thread".
+*/
+var ThreadAdviseNotPermittedError = class extends Schema$1.TaggedErrorClass()("ThreadAdviseNotPermittedError", { threadId: ThreadId }) {
+	get message() {
+		return `This session was not granted advise access to thread ${this.threadId}.`;
+	}
+};
+var ThreadAdviseFailedError = class extends Schema$1.TaggedErrorClass()("ThreadAdviseFailedError", {
+	threadId: ThreadId,
+	detail: Schema$1.String
+}) {
+	get message() {
+		return `Advising thread ${this.threadId} failed: ${this.detail}`;
+	}
+};
+const ThreadAdviseToolError = Schema$1.Union([
+	AdviseToolUnavailableError,
+	ThreadAdviseNotPermittedError,
+	ThreadAdviseFailedError
+]);
+//#endregion
 //#region ../../packages/contracts/src/threadControl.ts
 /**
 * Thread control over MCP - the toolkit an agent uses to act on its own thread
@@ -9332,7 +9552,10 @@ const ThreadSpawnResult = Schema$1.Struct({
 	projectId: ProjectId,
 	title: TrimmedNonEmptyString
 });
-const ThreadPairCreateInput = Schema$1.Struct({ watcherThreadId: ThreadId.annotate({ description: "The supervisor thread to pair with this session's own builder thread. It must have been created by this session through thread_spawn." }) });
+const ThreadPairCreateInput = Schema$1.Struct({
+	watcherThreadId: ThreadId.annotate({ description: "The supervisor thread to pair with this session's own builder thread. It must have been created by this session through thread_spawn." }),
+	gateTimeoutMs: Schema$1.optional(NonNegativeInt.annotate({ description: "How long a gate waits on the supervisor before failing open, in milliseconds. Defaults to 120000." }))
+});
 const ThreadPairCreateResult = Schema$1.Struct({
 	pairId: ThreadPairId,
 	implementerThreadId: ThreadId,
@@ -15176,6 +15399,29 @@ var _046_ThreadPairs_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/persistence/Migrations/047_ThreadPairGates.ts
+/**
+* Fusion second cut: per-pair gate configuration and the persisted open gate.
+*
+* The open gate lives in a JSON column rather than its own table because a
+* pair holds at most one open gate at a time and gate history already lives in
+* the event log. Persisting it here is what makes the fail-open timeout
+* enforceable across a server restart: the sweeper reads this row, not any
+* in-memory approval state.
+*/
+var _047_ThreadPairGates_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* sql`
+    ALTER TABLE thread_pairs ADD COLUMN round_cap INTEGER NOT NULL DEFAULT 2
+  `;
+	yield* sql`
+    ALTER TABLE thread_pairs ADD COLUMN gate_timeout_ms INTEGER NOT NULL DEFAULT 120000
+  `;
+	yield* sql`
+    ALTER TABLE thread_pairs ADD COLUMN active_gate_json TEXT
+  `;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -15426,6 +15672,11 @@ const migrationEntries = [
 		46,
 		"ThreadPairs",
 		_046_ThreadPairs_default
+	],
+	[
+		47,
+		"ThreadPairGates",
+		_047_ThreadPairGates_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -18094,6 +18345,51 @@ var _009_Feed_default = Effect.gen(function* () {
       VALUES (${id}, ${name}, ${kind}, ${feedUrl}, ${siteUrl}, 1, ${now}, ${now})`;
 });
 //#endregion
+//#region src/hub/Migrations/010_DefaultFeedSources.ts
+var _010_DefaultFeedSources_default = Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const now = DateTime.formatIso(yield* DateTime.now);
+	for (const [id, name, kind, feedUrl, siteUrl] of [
+		[
+			"hacker-news",
+			"Hacker News",
+			"hacker_news",
+			"https://hnrss.org/frontpage",
+			"https://news.ycombinator.com"
+		],
+		[
+			"techcrunch",
+			"TechCrunch",
+			"syndication",
+			"https://techcrunch.com/feed/",
+			"https://techcrunch.com"
+		],
+		[
+			"the-verge",
+			"The Verge",
+			"syndication",
+			"https://www.theverge.com/rss/index.xml",
+			"https://www.theverge.com"
+		],
+		[
+			"ars-technica",
+			"Ars Technica",
+			"syndication",
+			"https://feeds.arstechnica.com/arstechnica/index",
+			"https://arstechnica.com"
+		],
+		[
+			"wired",
+			"Wired",
+			"syndication",
+			"https://www.wired.com/feed/rss",
+			"https://www.wired.com"
+		]
+	]) yield* sql`INSERT OR IGNORE INTO feed_sources
+      (id, name, kind, feed_url, site_url, enabled, created_at, updated_at)
+      VALUES (${id}, ${name}, ${kind}, ${feedUrl}, ${siteUrl}, 1, ${now}, ${now})`;
+});
+//#endregion
 //#region src/hub/Migrations.ts
 /**
 * Hub migrations.
@@ -18149,6 +18445,11 @@ const hubMigrationEntries = [
 		9,
 		"Feed",
 		_009_Feed_default
+	],
+	[
+		10,
+		"DefaultFeedSources",
+		_010_DefaultFeedSources_default
 	]
 ];
 const hubMigrationLoader = Migrator.fromRecord(Object.fromEntries(hubMigrationEntries.map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -22889,6 +23190,9 @@ const ThreadActivityAppendedPayload = ThreadActivityAppendedPayload$1;
 const ThreadPairCreatedPayload = ThreadPairCreatedPayload$1;
 const ThreadPairDetachedPayload = ThreadPairDetachedPayload$1;
 const ThreadPairCursorAdvancedPayload = ThreadPairCursorAdvancedPayload$1;
+const ThreadPairGateOpenedPayload = ThreadPairGateOpenedPayload$1;
+const ThreadPairGateAdvancedPayload = ThreadPairGateAdvancedPayload$1;
+const ThreadPairGateResolvedPayload = ThreadPairGateResolvedPayload$1;
 //#endregion
 //#region src/orchestration/projector.ts
 function checkpointStatusToLatestTurnState(status) {
@@ -22980,6 +23284,9 @@ function projectEvent(model, event) {
 				implementerThreadId: payload.implementerThreadId,
 				watcherThreadId: payload.watcherThreadId,
 				lastReviewedImplementerSequence: payload.lastReviewedImplementerSequence,
+				roundCap: payload.roundCap ?? 2,
+				gateTimeoutMs: payload.gateTimeoutMs ?? 12e4,
+				activeGate: null,
 				createdAt: payload.createdAt,
 				detachedAt: null
 			}]
@@ -22998,6 +23305,27 @@ function projectEvent(model, event) {
 				lastReviewedImplementerSequence: payload.implementerSequence
 			} : pair)
 		})));
+		case "thread-pair.gate-opened": return decodeForEvent(ThreadPairGateOpenedPayload, event.payload, event.type, "payload").pipe(Effect.map((payload) => ({
+			...nextBase,
+			threadPairs: (nextBase.threadPairs ?? []).map((pair) => pair.id === payload.pairId ? {
+				...pair,
+				activeGate: payload.gate
+			} : pair)
+		})));
+		case "thread-pair.gate-advanced": return decodeForEvent(ThreadPairGateAdvancedPayload, event.payload, event.type, "payload").pipe(Effect.map((payload) => ({
+			...nextBase,
+			threadPairs: (nextBase.threadPairs ?? []).map((pair) => pair.id === payload.pairId ? {
+				...pair,
+				activeGate: payload.gate
+			} : pair)
+		})));
+		case "thread-pair.gate-resolved": return decodeForEvent(ThreadPairGateResolvedPayload, event.payload, event.type, "payload").pipe(Effect.map((payload) => ({
+			...nextBase,
+			threadPairs: (nextBase.threadPairs ?? []).map((pair) => pair.id === payload.pairId ? {
+				...pair,
+				activeGate: null
+			} : pair)
+		})));
 		case "project.created": return decodeForEvent(ProjectCreatedPayload, event.payload, event.type, "payload").pipe(Effect.map((payload) => {
 			const existing = nextBase.projects.find((entry) => entry.id === payload.projectId);
 			const nextProject = {
@@ -23604,6 +23932,8 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 					implementerThreadId: command.implementerThreadId,
 					watcherThreadId: command.watcherThreadId,
 					lastReviewedImplementerSequence: readModel.snapshotSequence,
+					...command.roundCap !== void 0 ? { roundCap: command.roundCap } : {},
+					...command.gateTimeoutMs !== void 0 ? { gateTimeoutMs: command.gateTimeoutMs } : {},
 					createdAt: command.createdAt
 				}
 			};
@@ -23674,6 +24004,118 @@ const decideOrchestrationCommand = Effect.fn("decideOrchestrationCommand")(funct
 				}
 			};
 		}
+		case "thread-pair.gate.open": {
+			const pair = (readModel.threadPairs ?? []).find((candidate) => candidate.id === command.pairId);
+			if (pair === void 0 || pair.detachedAt !== null) return yield* new OrchestrationCommandInvariantError({
+				commandType: command.type,
+				detail: `Active thread pair '${command.pairId}' does not exist.`
+			});
+			if (pair.activeGate !== null) return yield* new OrchestrationCommandInvariantError({
+				commandType: command.type,
+				detail: `Thread pair '${command.pairId}' already has an open gate.`
+			});
+			return {
+				...yield* withEventBase({
+					aggregateKind: "thread-pair",
+					aggregateId: command.pairId,
+					occurredAt: command.openedAt,
+					commandId: command.commandId
+				}),
+				type: "thread-pair.gate-opened",
+				payload: {
+					pairId: command.pairId,
+					implementerThreadId: pair.implementerThreadId,
+					watcherThreadId: pair.watcherThreadId,
+					gate: {
+						id: command.gateId,
+						kind: command.kind,
+						state: "awaiting-watcher",
+						round: 0,
+						requestId: command.requestId ?? null,
+						planId: command.planId ?? null,
+						commandTitle: command.commandTitle ?? null,
+						openedAt: command.openedAt,
+						awaitingWatcherSince: command.openedAt,
+						updatedAt: command.openedAt
+					},
+					openedAt: command.openedAt
+				}
+			};
+		}
+		case "thread-pair.gate.advance": {
+			const pair = (readModel.threadPairs ?? []).find((candidate) => candidate.id === command.pairId);
+			const gate = pair?.detachedAt === null ? pair.activeGate : null;
+			if (pair === void 0 || gate === null || gate === void 0 || gate.id !== command.gateId) return yield* new OrchestrationCommandInvariantError({
+				commandType: command.type,
+				detail: `Open gate '${command.gateId}' does not exist on thread pair '${command.pairId}'.`
+			});
+			const transition = command.transition;
+			if (transition === "objection" && gate.state !== "awaiting-watcher" || transition === "implementer-responded" && gate.state !== "awaiting-implementer" || transition === "escalate" && gate.state === "escalated") return yield* new OrchestrationCommandInvariantError({
+				commandType: command.type,
+				detail: `Gate '${command.gateId}' in state '${gate.state}' cannot take transition '${transition}'.`
+			});
+			const nextGate = transition === "objection" ? {
+				...gate,
+				state: "awaiting-implementer",
+				round: gate.round + 1,
+				awaitingWatcherSince: null,
+				updatedAt: command.advancedAt
+			} : transition === "implementer-responded" ? {
+				...gate,
+				state: "awaiting-watcher",
+				awaitingWatcherSince: command.advancedAt,
+				updatedAt: command.advancedAt
+			} : {
+				...gate,
+				state: "escalated",
+				awaitingWatcherSince: null,
+				updatedAt: command.advancedAt
+			};
+			return {
+				...yield* withEventBase({
+					aggregateKind: "thread-pair",
+					aggregateId: command.pairId,
+					occurredAt: command.advancedAt,
+					commandId: command.commandId
+				}),
+				type: "thread-pair.gate-advanced",
+				payload: {
+					pairId: command.pairId,
+					implementerThreadId: pair.implementerThreadId,
+					watcherThreadId: pair.watcherThreadId,
+					gate: nextGate,
+					advancedAt: command.advancedAt
+				}
+			};
+		}
+		case "thread-pair.gate.resolve": {
+			const pair = (readModel.threadPairs ?? []).find((candidate) => candidate.id === command.pairId);
+			const gate = pair?.detachedAt === null ? pair.activeGate : null;
+			if (pair === void 0 || gate === null || gate === void 0 || gate.id !== command.gateId) return yield* new OrchestrationCommandInvariantError({
+				commandType: command.type,
+				detail: `Open gate '${command.gateId}' does not exist on thread pair '${command.pairId}'.`
+			});
+			return {
+				...yield* withEventBase({
+					aggregateKind: "thread-pair",
+					aggregateId: command.pairId,
+					occurredAt: command.resolvedAt,
+					commandId: command.commandId
+				}),
+				type: "thread-pair.gate-resolved",
+				payload: {
+					pairId: command.pairId,
+					implementerThreadId: pair.implementerThreadId,
+					watcherThreadId: pair.watcherThreadId,
+					gateId: gate.id,
+					kind: gate.kind,
+					requestId: gate.requestId,
+					outcome: command.outcome,
+					resolvedBy: command.resolvedBy,
+					resolvedAt: command.resolvedAt
+				}
+			};
+		}
 		case "thread.archive": {
 			yield* requireThreadNotArchived({
 				readModel,
@@ -24366,7 +24808,10 @@ function commandToAggregateRef(command) {
 		};
 		case "thread-pair.create":
 		case "thread-pair.detach":
-		case "thread-pair.cursor.advance": return {
+		case "thread-pair.cursor.advance":
+		case "thread-pair.gate.open":
+		case "thread-pair.gate.advance":
+		case "thread-pair.gate.resolve": return {
 			aggregateKind: "thread-pair",
 			aggregateId: command.pairId
 		};
@@ -26285,6 +26730,9 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
               implementer_thread_id,
               watcher_thread_id,
               last_reviewed_implementer_sequence,
+              round_cap,
+              gate_timeout_ms,
+              active_gate_json,
               created_at,
               detached_at
             ) VALUES (
@@ -26292,6 +26740,9 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
               ${event.payload.implementerThreadId},
               ${event.payload.watcherThreadId},
               ${event.payload.lastReviewedImplementerSequence},
+              ${event.payload.roundCap ?? 2},
+              ${event.payload.gateTimeoutMs ?? 12e4},
+              NULL,
               ${event.payload.createdAt},
               NULL
             )
@@ -26299,10 +26750,28 @@ const makeOrchestrationProjectionPipeline = Effect.fn("makeOrchestrationProjecti
               implementer_thread_id = excluded.implementer_thread_id,
               watcher_thread_id = excluded.watcher_thread_id,
               last_reviewed_implementer_sequence = excluded.last_reviewed_implementer_sequence,
+              round_cap = excluded.round_cap,
+              gate_timeout_ms = excluded.gate_timeout_ms,
+              active_gate_json = NULL,
               created_at = excluded.created_at,
               detached_at = NULL
           `.pipe(Effect.mapError(toPersistenceSqlError("ProjectionPipeline.threadPairs:create")));
 				return;
+			case "thread-pair.gate-opened":
+			case "thread-pair.gate-advanced":
+				yield* sql`
+            UPDATE thread_pairs
+            SET active_gate_json = ${JSON.stringify(event.payload.gate)}
+            WHERE pair_id = ${event.payload.pairId}
+          `.pipe(Effect.mapError(toPersistenceSqlError("ProjectionPipeline.threadPairs:gate")));
+				return;
+			case "thread-pair.gate-resolved":
+				yield* sql`
+            UPDATE thread_pairs
+            SET active_gate_json = NULL
+            WHERE pair_id = ${event.payload.pairId}
+          `.pipe(Effect.mapError(toPersistenceSqlError("ProjectionPipeline.threadPairs:gateResolve")));
+				return;
 			case "thread-pair.detached":
 				yield* sql`
             UPDATE thread_pairs
@@ -27714,6 +28183,9 @@ const ProjectionThreadPairDbRowSchema = Schema$1.Struct({
 	implementerThreadId: ThreadId,
 	watcherThreadId: ThreadId,
 	lastReviewedImplementerSequence: NonNegativeInt,
+	roundCap: NonNegativeInt,
+	gateTimeoutMs: NonNegativeInt,
+	activeGate: Schema$1.NullOr(Schema$1.fromJsonString(OrchestrationThreadPairGate)),
 	createdAt: IsoDateTime,
 	detachedAt: Schema$1.NullOr(IsoDateTime)
 });
@@ -27898,10 +28370,31 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           implementer_thread_id AS "implementerThreadId",
           watcher_thread_id AS "watcherThreadId",
           last_reviewed_implementer_sequence AS "lastReviewedImplementerSequence",
+          round_cap AS "roundCap",
+          gate_timeout_ms AS "gateTimeoutMs",
+          active_gate_json AS "activeGate",
           created_at AS "createdAt",
           detached_at AS "detachedAt"
         FROM thread_pairs
         ORDER BY created_at ASC, pair_id ASC
+      `
+	});
+	const getThreadPairRow = SqlSchema.findOneOption({
+		Request: ThreadPairId,
+		Result: ProjectionThreadPairDbRowSchema,
+		execute: (pairId) => sql`
+        SELECT
+          pair_id AS "id",
+          implementer_thread_id AS "implementerThreadId",
+          watcher_thread_id AS "watcherThreadId",
+          last_reviewed_implementer_sequence AS "lastReviewedImplementerSequence",
+          round_cap AS "roundCap",
+          gate_timeout_ms AS "gateTimeoutMs",
+          active_gate_json AS "activeGate",
+          created_at AS "createdAt",
+          detached_at AS "detachedAt"
+        FROM thread_pairs
+        WHERE pair_id = ${pairId}
       `
 	});
 	const listThreadRows = SqlSchema.findAll({
@@ -29056,6 +29549,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			messageCreatedAt: row.messageCreatedAt
 		})) };
 	});
+	const getThreadPairById = (pairId) => getThreadPairRow(pairId).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadPairById:query", "ProjectionSnapshotQuery.getThreadPairById:decodeRow")));
 	const getThreadShellById = (threadId) => Effect.gen(function* () {
 		const [threadRow, latestTurnRow, sessionRow] = yield* Effect.all([
 			getActiveThreadRowById({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadShellById:getThread:query", "ProjectionSnapshotQuery.getThreadShellById:getThread:decodeRow"))),
@@ -29186,6 +29680,7 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		getFirstActiveThreadIdByProjectId,
 		getThreadCheckpointContext,
 		getFullThreadDiffContext,
+		getThreadPairById,
 		getThreadShellById,
 		getThreadDetailById,
 		getThreadDetailSnapshot
@@ -45681,6 +46176,24 @@ const requireWatchCapability = Effect.fn("mcp.requireWatchCapability")(function*
 	if (!invocation.watchThreadIds?.has(watchedThreadId)) return yield* new ThreadWatchNotPermittedError({ threadId: watchedThreadId });
 	return invocation;
 });
+/**
+* The advise guard mirrors the watch guard's two checks - capability present
+* AND thread in the explicit grant - because advising carries strictly more
+* power than watching. A watch-only credential fails the first check here no
+* matter what threads it can read.
+*/
+const requireAdviseCapability = Effect.fn("mcp.requireAdviseCapability")(function* (advisedThreadId) {
+	const invocation = yield* McpInvocationContext;
+	if (!invocation.capabilities.has("advise")) return yield* new AdviseToolUnavailableError({
+		capability: "advise",
+		environmentId: invocation.environmentId,
+		threadId: invocation.threadId,
+		providerSessionId: invocation.providerSessionId,
+		providerInstanceId: invocation.providerInstanceId
+	});
+	if (!invocation.adviseThreadIds?.has(advisedThreadId)) return yield* new ThreadAdviseNotPermittedError({ threadId: advisedThreadId });
+	return invocation;
+});
 /** Third of the trio, for the same reason the second exists. */
 const requireThreadCapability = Effect.fn("mcp.requireThreadCapability")(function* () {
 	const invocation = yield* McpInvocationContext;
@@ -60494,7 +61007,6 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 	const serverSelfUpdate = yield* ServerSelfUpdate;
 	const textGeneration = yield* TextGeneration;
 	const config = yield* ServerConfig$1;
-	const allowAbsoluteFileReads = config.mode === "desktop" && !isRemoteReachableHost(config.host);
 	const lifecycleEvents = yield* ServerLifecycleEvents;
 	const serverSettings = yield* ServerSettingsService;
 	const hubLink = yield* HubLink;
@@ -60612,10 +61124,24 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 					implementerThreadId: event.payload.implementerThreadId,
 					watcherThreadId: event.payload.watcherThreadId,
 					lastReviewedImplementerSequence: event.payload.lastReviewedImplementerSequence,
+					roundCap: event.payload.roundCap ?? 2,
+					gateTimeoutMs: event.payload.gateTimeoutMs ?? 12e4,
+					activeGate: null,
 					createdAt: event.payload.createdAt,
 					detachedAt: null
 				}
 			}));
+			case "thread-pair.gate-opened":
+			case "thread-pair.gate-advanced":
+			case "thread-pair.gate-resolved":
+			case "thread-pair.cursor-advanced": return projectionSnapshotQuery.getThreadPairById(event.payload.pairId).pipe(Effect.retry({ times: 1 }), Effect.map(Option.map((pair) => ({
+				kind: "thread-pair-upserted",
+				sequence: event.sequence,
+				pair
+			}))), Effect.tapError((error) => Effect.logWarning("orchestration shell pair refetch failed", {
+				pairId: event.payload.pairId,
+				error
+			})), Effect.orElseSucceed(() => Option.none()));
 			case "thread-pair.detached": return Effect.succeed(Option.some({
 				kind: "thread-pair-removed",
 				sequence: event.sequence,
@@ -61228,17 +61754,11 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 			...projectEntriesFailureContext(cause),
 			cause
 		}))), { "rpc.aggregate": "workspace" }),
-		[WS_METHODS.projectsReadFile]: (input) => observeRpcEffect$1(WS_METHODS.projectsReadFile, Effect.gen(function* () {
-			if ("absolutePath" in input && !allowAbsoluteFileReads) return yield* new ProjectReadFileError({
-				...input,
-				failure: "workspace_path_outside_root"
-			});
-			return yield* workspaceFileSystem.readFile(input).pipe(Effect.mapError((cause) => new ProjectReadFileError({
-				...input,
-				...projectFileFailureContext(cause),
-				cause
-			})));
-		}), { "rpc.aggregate": "workspace" }),
+		[WS_METHODS.projectsReadFile]: (input) => observeRpcEffect$1(WS_METHODS.projectsReadFile, workspaceFileSystem.readFile(input).pipe(Effect.mapError((cause) => new ProjectReadFileError({
+			...input,
+			...projectFileFailureContext(cause),
+			cause
+		}))), { "rpc.aggregate": "workspace" }),
 		[WS_METHODS.projectsWriteFile]: (input) => observeRpcEffect$1(WS_METHODS.projectsWriteFile, workspaceFileSystem.writeFile(input).pipe(Effect.mapError((cause) => new ProjectWriteFileError({
 			cwd: input.cwd,
 			relativePath: input.relativePath,
@@ -62125,12 +62645,14 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 		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 adviseThreadIds = new Set((request.adviseThreadIds ?? []).map((threadId) => ThreadId.make(threadId)));
 		const capabilities = /* @__PURE__ */ new Set([
 			"preview",
 			"tasks",
 			"threads"
 		]);
 		if (watchThreadIds.size > 0) capabilities.add("watch");
+		if (adviseThreadIds.size > 0) capabilities.add("advise");
 		const threadId = ThreadId.make(request.threadId);
 		const scopeWith = (mayCreateThreads) => ({
 			environmentId,
@@ -62139,6 +62661,7 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			providerInstanceId: ProviderInstanceId.make(request.providerInstanceId),
 			capabilities,
 			...watchThreadIds.size > 0 ? { watchThreadIds } : {},
+			...adviseThreadIds.size > 0 ? { adviseThreadIds } : {},
 			mayCreateThreads,
 			issuedAt
 		});
@@ -62254,6 +62777,54 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 			};
 		});
 	});
+	const grantAdviseThread = Effect.fn("McpSessionRegistry.grantAdviseThread")(function* ({ watcherThreadId, advisedThreadId }) {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+			const next = new Map(records);
+			for (const [tokenHash, record] of records) {
+				if (record.scope.threadId !== watcherThreadId) continue;
+				next.set(tokenHash, {
+					...record,
+					scope: {
+						...record.scope,
+						capabilities: /* @__PURE__ */ new Set([...record.scope.capabilities, "advise"]),
+						adviseThreadIds: /* @__PURE__ */ new Set([...record.scope.adviseThreadIds ?? [], advisedThreadId])
+					}
+				});
+			}
+			return {
+				records: next,
+				spawnedThreadIds
+			};
+		});
+	});
+	const revokeAdviseThread = Effect.fn("McpSessionRegistry.revokeAdviseThread")(function* ({ watcherThreadId, advisedThreadId }) {
+		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
+			const next = new Map(records);
+			for (const [tokenHash, record] of records) {
+				if (record.scope.threadId !== watcherThreadId) continue;
+				const adviseThreadIds = new Set(record.scope.adviseThreadIds ?? []);
+				adviseThreadIds.delete(advisedThreadId);
+				const capabilities = new Set(record.scope.capabilities);
+				if (adviseThreadIds.size === 0) capabilities.delete("advise");
+				const { adviseThreadIds: _previousAdviseThreadIds, ...scopeWithoutAdvise } = record.scope;
+				next.set(tokenHash, {
+					...record,
+					scope: adviseThreadIds.size > 0 ? {
+						...scopeWithoutAdvise,
+						capabilities,
+						adviseThreadIds
+					} : {
+						...scopeWithoutAdvise,
+						capabilities
+					}
+				});
+			}
+			return {
+				records: next,
+				spawnedThreadIds
+			};
+		});
+	});
 	const recordSpawnedThread = Effect.fn("McpSessionRegistry.recordSpawnedThread")(function* (input) {
 		yield* SynchronizedRef.update(state, ({ records, spawnedThreadIds }) => {
 			const next = new Map(records);
@@ -62277,6 +62848,8 @@ const makeWithOptions = Effect.fn("McpSessionRegistry.make")(function* (options
 		touch,
 		grantWatchThread,
 		revokeWatchThread,
+		grantAdviseThread,
+		revokeAdviseThread,
 		recordSpawnedThread,
 		revokeProviderSession: Effect.fn("McpSessionRegistry.revokeProviderSession")(function* (providerSessionId) {
 			yield* revokeWhere((record) => record.scope.providerSessionId === providerSessionId);
@@ -62305,6 +62878,8 @@ const issueActiveMcpCredential = (request) => activeMcpSessionRegistry ? activeM
 const touchActiveMcpThread = (threadId) => activeMcpSessionRegistry ? activeMcpSessionRegistry.touch(threadId) : Effect.void;
 const grantActiveMcpWatchThread = (input) => activeMcpSessionRegistry ? activeMcpSessionRegistry.grantWatchThread(input) : Effect.void;
 const revokeActiveMcpWatchThread = (input) => activeMcpSessionRegistry ? activeMcpSessionRegistry.revokeWatchThread(input) : Effect.void;
+const grantActiveMcpAdviseThread = (input) => activeMcpSessionRegistry ? activeMcpSessionRegistry.grantAdviseThread(input) : Effect.void;
+const revokeActiveMcpAdviseThread = (input) => activeMcpSessionRegistry ? activeMcpSessionRegistry.revokeAdviseThread(input) : Effect.void;
 const revokeActiveMcpThread = (threadId) => activeMcpSessionRegistry ? activeMcpSessionRegistry.revokeThread(threadId) : Effect.void;
 const revokeAllActiveMcpCredentials = () => activeMcpSessionRegistry ? activeMcpSessionRegistry.revokeAll : Effect.void;
 //#endregion
@@ -62390,10 +62965,11 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (options)
 	const directory = yield* ProviderSessionDirectory;
 	const runtimeEventPubSub = yield* PubSub.unbounded();
 	const nowIso = Effect.map(DateTime.now, DateTime.formatIso);
-	const prepareMcpSession = (threadId, providerInstanceId, watchThreadIds) => issueActiveMcpCredential({
+	const prepareMcpSession = (threadId, providerInstanceId, watchThreadIds, adviseThreadIds) => issueActiveMcpCredential({
 		threadId,
 		providerInstanceId,
-		...watchThreadIds !== void 0 ? { watchThreadIds } : {}
+		...watchThreadIds !== void 0 ? { watchThreadIds } : {},
+		...adviseThreadIds !== void 0 ? { adviseThreadIds } : {}
 	}).pipe(Effect.tap((credential) => credential ? Effect.sync(() => setMcpProviderSession(credential.config)) : Effect.void));
 	const clearMcpSession = (threadId) => revokeActiveMcpThread(threadId).pipe(Effect.tap(() => Effect.sync(() => clearMcpProviderSession(threadId))));
 	const publishRuntimeEvent = (event) => Effect.succeed(event).pipe(Effect.tap((canonicalEvent) => canonicalEventLogger ? canonicalEventLogger.write(canonicalEvent, canonicalEvent.threadId) : Effect.void), Effect.flatMap((canonicalEvent) => PubSub.publish(runtimeEventPubSub, canonicalEvent)), Effect.asVoid);
@@ -62574,7 +63150,7 @@ const makeProviderService = Effect.fn("makeProviderService")(function* (options)
 				"provider.cwd.effective": effectiveCwd ?? ""
 			});
 			const adapter = yield* registry.getByInstance(resolvedInstanceId);
-			yield* prepareMcpSession(threadId, resolvedInstanceId, options?.watchThreadIds);
+			yield* prepareMcpSession(threadId, resolvedInstanceId, options?.watchThreadIds, options?.adviseThreadIds);
 			const session = yield* adapter.startSession({
 				...input,
 				providerInstanceId: resolvedInstanceId,
@@ -100761,7 +101337,7 @@ const invokeTargeted = (operation, input, timeoutMs) => {
 	const { tabId, ...operationInput } = input;
 	return invoke(operation, operationInput, timeoutMs, tabId);
 };
-const handlers$3 = {
+const handlers$4 = {
 	preview_status: (input) => invokeTargeted("status", input ?? {}),
 	preview_open: (input) => invokeTargeted("open", normalizePreviewOpenInput(input)),
 	preview_navigate: (input) => invokeTargeted("navigate", input, input.timeoutMs),
@@ -100777,10 +101353,10 @@ const handlers$3 = {
 	preview_recording_start: (input) => invokeTargeted("recordingStart", input ?? {}),
 	preview_recording_stop: (input) => invokeTargeted("recordingStop", input ?? {})
 };
-const { preview_snapshot, ...standardHandlers } = handlers$3;
+const { preview_snapshot, ...standardHandlers } = handlers$4;
 const PreviewStandardToolkitHandlersLive = PreviewStandardToolkit.toLayer(standardHandlers);
 const PreviewSnapshotToolkitHandlersLive = PreviewSnapshotToolkit.toLayer({ preview_snapshot });
-PreviewToolkit.toLayer(handlers$3);
+PreviewToolkit.toLayer(handlers$4);
 //#endregion
 //#region src/mcp/TicketResolver.ts
 var TicketResolver = class extends Context.Service()("@p4code/cli/mcp/TicketResolver") {};
@@ -101751,6 +102327,214 @@ const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 	})
 });
 //#endregion
+//#region src/mcp/toolkits/advise/tools.ts
+/**
+* The write half of cross-thread access, and the reason advise is its own
+* capability: `thread_watch_events` reads another thread, these tools steer
+* one. Both handlers admit only threads in the session's explicit
+* `adviseThreadIds` grant - in practice the paired implementer - so a
+* watch-only credential cannot reach them at all and an advise credential
+* cannot reach past its own pair.
+*/
+const ThreadAdviseTool = Tool.make("thread_advise", {
+	description: "Post advice into the paired builder thread. The builder sees the message as supervisor advice and responds in its own pane. Set interrupt to cancel the builder's running turn first, when continuing would waste or damage work. Do not use this while a gate is awaiting your answer - answer the gate with thread_gate_respond instead. After advising, end your turn; you are woken automatically when the builder finishes responding.",
+	parameters: ThreadAdviseInput,
+	success: ThreadAdviseResult,
+	failure: ThreadAdviseToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		ProjectionSnapshotQuery,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Advise the paired builder").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
+const ThreadGateRespondTool = Tool.make("thread_gate_respond", {
+	description: "Answer the open gate on the paired builder thread. approve clears the gate and lets the builder proceed; object delivers your objection to the builder and spends one exchange round - when the rounds are used up the gate escalates to the human instead. The gate id is given in the gate review prompt. After answering, end your turn; you are woken automatically at the next boundary.",
+	parameters: ThreadGateRespondInput,
+	success: ThreadGateRespondResult,
+	failure: ThreadAdviseToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		ProjectionSnapshotQuery,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Answer the open gate").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
+const AdviseToolkit = Toolkit.make(ThreadAdviseTool, ThreadGateRespondTool);
+//#endregion
+//#region src/mcp/toolkits/advise/handlers.ts
+const newId = Effect.gen(function* () {
+	return yield* (yield* Crypto.Crypto).randomUUIDv4.pipe(Effect.orDie);
+});
+/** Every dispatch here reports failure as the one error the toolkit declares. */
+const dispatchAdvise = Effect.fn("mcp.advise.dispatch")(function* (command, threadId) {
+	yield* (yield* OrchestrationEngineService).dispatch(command).pipe(Effect.mapError((cause) => new ThreadAdviseFailedError({
+		threadId,
+		detail: cause.message
+	})));
+});
+const readCommandModel = Effect.fn("mcp.advise.readModel")(function* (threadId) {
+	return yield* (yield* ProjectionSnapshotQuery).getCommandReadModel().pipe(Effect.mapError((cause) => new ThreadAdviseFailedError({
+		threadId,
+		detail: cause.message
+	})));
+});
+/**
+* Starts a turn on the advised thread carrying the supervisor's message. The
+* thread's own modes ride along so advice never changes how the builder runs.
+*/
+const sendAdviceTurn = Effect.fn("mcp.advise.sendAdviceTurn")(function* (input) {
+	const messageId = MessageId.make(yield* newId);
+	yield* dispatchAdvise({
+		type: "thread.turn.start",
+		commandId: CommandId.make(yield* newId),
+		threadId: input.thread.id,
+		message: {
+			messageId,
+			role: "user",
+			text: input.text,
+			attachments: []
+		},
+		runtimeMode: input.thread.runtimeMode,
+		interactionMode: input.thread.interactionMode,
+		compressMode: input.thread.compressMode,
+		unpromptedSubagents: input.thread.unpromptedSubagents,
+		createdAt: input.createdAt
+	}, input.thread.id);
+	return messageId;
+});
+const AdviseToolkitHandlersLive = AdviseToolkit.toLayer({
+	thread_advise: (input) => Effect.gen(function* () {
+		yield* requireAdviseCapability(input.threadId);
+		const readModel = yield* readCommandModel(input.threadId);
+		const thread = readModel.threads.find((candidate) => candidate.id === input.threadId && candidate.deletedAt === null);
+		if (thread === void 0) return yield* new ThreadAdviseFailedError({
+			threadId: input.threadId,
+			detail: "The advised thread does not exist."
+		});
+		const gatedPair = (readModel.threadPairs ?? []).find((pair) => pair.detachedAt === null && pair.implementerThreadId === input.threadId && pair.activeGate !== null && pair.activeGate.state === "awaiting-watcher");
+		if (gatedPair !== void 0) return yield* new ThreadAdviseFailedError({
+			threadId: input.threadId,
+			detail: `Gate '${gatedPair.activeGate?.id}' is awaiting your answer. Answer it with thread_gate_respond instead of thread_advise.`
+		});
+		const createdAt = DateTime.formatIso(yield* DateTime.now);
+		const interrupted = input.interrupt === true;
+		if (interrupted) yield* dispatchAdvise({
+			type: "thread.turn.interrupt",
+			commandId: CommandId.make(yield* newId),
+			threadId: input.threadId,
+			createdAt
+		}, input.threadId);
+		const messageId = yield* sendAdviceTurn({
+			thread,
+			text: `${FUSION_ADVICE_PROMPT_PREFIX} ${input.message}`,
+			createdAt
+		});
+		return {
+			threadId: input.threadId,
+			messageId,
+			interrupted
+		};
+	}),
+	thread_gate_respond: (input) => Effect.gen(function* () {
+		yield* requireAdviseCapability(input.threadId);
+		const readModel = yield* readCommandModel(input.threadId);
+		const pair = (readModel.threadPairs ?? []).find((candidate) => candidate.detachedAt === null && candidate.implementerThreadId === input.threadId);
+		const gate = pair?.activeGate ?? null;
+		if (pair === void 0 || gate === null || gate.id !== input.gateId) return yield* new ThreadAdviseFailedError({
+			threadId: input.threadId,
+			detail: `Gate '${input.gateId}' is not open on this thread. It may already be resolved.`
+		});
+		if (gate.state !== "awaiting-watcher") return yield* new ThreadAdviseFailedError({
+			threadId: input.threadId,
+			detail: `Gate '${input.gateId}' is not awaiting the supervisor (state: ${gate.state}).`
+		});
+		const thread = readModel.threads.find((candidate) => candidate.id === input.threadId && candidate.deletedAt === null);
+		if (thread === void 0) return yield* new ThreadAdviseFailedError({
+			threadId: input.threadId,
+			detail: "The advised thread does not exist."
+		});
+		const now = DateTime.formatIso(yield* DateTime.now);
+		if (input.decision === "approve") {
+			yield* dispatchAdvise({
+				type: "thread-pair.gate.resolve",
+				commandId: CommandId.make(yield* newId),
+				pairId: pair.id,
+				gateId: gate.id,
+				outcome: "approved",
+				resolvedBy: "watcher",
+				resolvedAt: now
+			}, input.threadId);
+			if (gate.kind === "command-approval" && gate.requestId !== null) yield* dispatchAdvise({
+				type: "thread.approval.respond",
+				commandId: CommandId.make(yield* newId),
+				threadId: input.threadId,
+				requestId: gate.requestId,
+				decision: "accept",
+				createdAt: now
+			}, input.threadId);
+			if (gate.kind === "repeated-failure") yield* sendAdviceTurn({
+				thread,
+				text: `${FUSION_GATE_PROMPT_PREFIX} The supervisor reviewed the repeated command failures and cleared the gate. Continue the work.`,
+				createdAt: now
+			});
+			return {
+				threadId: input.threadId,
+				gateId: gate.id,
+				kind: gate.kind,
+				outcome: "approved"
+			};
+		}
+		if (input.message === void 0) return yield* new ThreadAdviseFailedError({
+			threadId: input.threadId,
+			detail: "An objection requires a message for the builder."
+		});
+		if (gate.round >= pair.roundCap) {
+			yield* dispatchAdvise({
+				type: "thread-pair.gate.advance",
+				commandId: CommandId.make(yield* newId),
+				pairId: pair.id,
+				gateId: gate.id,
+				transition: "escalate",
+				advancedAt: now
+			}, input.threadId);
+			return {
+				threadId: input.threadId,
+				gateId: gate.id,
+				kind: gate.kind,
+				outcome: "escalated"
+			};
+		}
+		yield* dispatchAdvise({
+			type: "thread-pair.gate.advance",
+			commandId: CommandId.make(yield* newId),
+			pairId: pair.id,
+			gateId: gate.id,
+			transition: "objection",
+			advancedAt: now
+		}, input.threadId);
+		if (gate.kind === "command-approval" && gate.requestId !== null) yield* dispatchAdvise({
+			type: "thread.approval.respond",
+			commandId: CommandId.make(yield* newId),
+			threadId: input.threadId,
+			requestId: gate.requestId,
+			decision: "decline",
+			createdAt: now
+		}, input.threadId);
+		yield* sendAdviceTurn({
+			thread,
+			text: `${FUSION_ADVICE_PROMPT_PREFIX} ${input.message}`,
+			createdAt: now
+		});
+		return {
+			threadId: input.threadId,
+			gateId: gate.id,
+			kind: gate.kind,
+			outcome: "objection-sent"
+		};
+	})
+});
+//#endregion
 //#region src/mcp/toolkits/watch/tools.ts
 /**
 * Cross-thread by design, which is exactly why it is the most guarded tool in
@@ -101891,12 +102675,13 @@ const PreviewToolkitRegistrationLive = Layer.mergeAll(PreviewStandardToolkitRegi
 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 AdviseToolkitRegistrationLive = McpServer.toolkit(AdviseToolkit).pipe(Layer.provide(AdviseToolkitHandlersLive));
 const McpTransportLive = McpServer.layerHttp({
 	name: "P4Code",
 	version,
 	path: "/mcp"
 }).pipe(Layer.provide(McpAuthMiddlewareLive));
-const layer = Layer.mergeAll(PreviewToolkitRegistrationLive, TaskToolkitRegistrationLive, ThreadToolkitRegistrationLive, WatchToolkitRegistrationLive).pipe(Layer.provideMerge(McpTransportLive));
+const layer = Layer.mergeAll(PreviewToolkitRegistrationLive, TaskToolkitRegistrationLive, ThreadToolkitRegistrationLive, WatchToolkitRegistrationLive, AdviseToolkitRegistrationLive).pipe(Layer.provideMerge(McpTransportLive));
 //#endregion
 //#region src/orchestration/Services/CheckpointReactor.ts
 /**
@@ -102526,6 +103311,7 @@ function runtimeEventToActivities(event, taskTitle, compressMode) {
 				summary: event.payload.title ?? "Tool",
 				payload: {
 					itemType: event.payload.itemType,
+					...event.payload.status ? { status: event.payload.status } : {},
 					...event.payload.detail ? { detail: truncateDetail(event.payload.detail) } : {},
 					...event.payload.data !== void 0 ? { data: event.payload.data } : {}
 				},
@@ -103559,6 +104345,10 @@ const make$3 = Effect.gen(function* () {
 			watcherThreadId: threadId,
 			watchedThreadId
 		}), { discard: true });
+		yield* Effect.forEach(watchThreadIds, (advisedThreadId) => grantActiveMcpAdviseThread({
+			watcherThreadId: threadId,
+			advisedThreadId
+		}), { discard: true });
 		const resolveActiveSession = (threadId) => providerService.listSessions().pipe(Effect.map((sessions) => sessions.find((session) => session.threadId === threadId)));
 		const activeSession = yield* resolveActiveSession(threadId);
 		const activeThreadSession = thread.session !== null && thread.session.status !== "stopped" && activeSession ? thread.session : null;
@@ -103648,7 +104438,10 @@ const make$3 = Effect.gen(function* () {
 				runtimeMode: desiredRuntimeMode,
 				compressMode: thread.compressMode,
 				unpromptedSubagents: thread.unpromptedSubagents
-			}, watchThreadIds.length > 0 ? { watchThreadIds } : void 0);
+			}, watchThreadIds.length > 0 ? {
+				watchThreadIds,
+				adviseThreadIds: watchThreadIds
+			} : void 0);
 		};
 		const bindSessionToThread = (session) => Effect.gen(function* () {
 			if (session.providerInstanceId === void 0) return yield* new ProviderAdapterRequestError({
@@ -104581,9 +105374,28 @@ const make$2 = Effect.gen(function* () {
 const CheckpointReactorLive = Layer.effect(CheckpointReactor, make$2);
 //#endregion
 //#region src/orchestration/Layers/FusionWatcherReactor.ts
+const GATE_TIMEOUT_SWEEP_INTERVAL = "10 seconds";
 const reviewCommandId = (pairId, sequence) => CommandId.make(`server:fusion:${pairId}:review:${sequence}`);
 const cursorCommandId = (pairId, sequence) => CommandId.make(`server:fusion:${pairId}:cursor:${sequence}`);
 const reviewMessageId = (pairId, sequence) => MessageId.make(`fusion-review:${pairId}:${sequence}`);
+const gateCommandId = (pairId, gateId, suffix) => CommandId.make(`server:fusion:${pairId}:gate:${gateId}:${suffix}`);
+const gateMessageId = (gateId, round) => MessageId.make(`fusion-gate:${gateId}:wake:${round}`);
+const gateActivityId = (gateId, threadId, suffix) => EventId.make(`fusion-gate:${gateId}:${suffix}:${threadId}`);
+/**
+* What the watcher can do, spelled out in every wake. The instructions repeat
+* per prompt because the watcher has no separate system prompt: these messages
+* are the only place its powers and its stop condition are stated. The stop
+* condition matters as much as the powers - a watcher that polls
+* thread_watch_events waiting for new activity burns its turn spinning, which
+* is exactly the "supervisor stuck working" failure this text exists to
+* prevent.
+*/
+const watcherPowers = (implementerThreadId) => `You can steer the builder:
+
+- thread_advise with threadId ${implementerThreadId} posts advice into the builder thread. Use it when the builder should change course, and whenever the user asks you to tell, instruct or guide the builder.
+- thread_advise with interrupt: true cancels the builder's running turn before the advice lands. Reserve it for scope drift or work that is causing damage right now.
+
+Never call thread_watch_events repeatedly to wait for new activity, and never wait for the builder to respond: deliver your review and any advice, then end your turn. The server wakes you at the next turn boundary.`;
 const watcherPrompt = (input) => `${FUSION_REVIEW_PROMPT_PREFIX}
 Review builder thread ${input.implementerThreadId} after its accepted turn completion.
 
@@ -104595,14 +105407,361 @@ Give the user a concise status report after every review:
 - Verification: summarize checks run and their results, including missing verification.
 - Assessment: list concrete objections such as correctness risks, missed requirements, regressions, unsafe changes, or unnecessary scope. Cite evidence. If none exist, say "No objections found."
 
+${watcherPowers(input.implementerThreadId)}
+
 Mention blockers or unfinished work explicitly. Do not work silently. Do not return only ${FUSION_NO_OBJECTION_TEXT}.`;
+const gateKindDescription = (gate) => {
+	switch (gate.kind) {
+		case "plan": return "the builder finished a proposed plan and is paused for your review before work starts";
+		case "command-approval": return `the builder raised an approval request (request ${gate.requestId ?? "unknown"}) and its turn is blocked until it is answered`;
+		case "repeated-failure": return `the same command failed 3 times (${gate.commandTitle ?? "unknown command"}) and the builder's turn was interrupted for your review`;
+	}
+};
+const gatePrompt = (input) => `${FUSION_GATE_PROMPT_PREFIX}
+Gate ${input.gate.id} is open on builder thread ${input.implementerThreadId}: ${gateKindDescription(input.gate)}. Round ${Math.min(input.gate.round + 1, input.roundCap)} of ${input.roundCap}.
+
+Read the delta first: call thread_watch_events with threadId ${input.implementerThreadId} and afterSequence ${input.afterSequence}, paging through sequence ${input.throughSequence}. Inspect the repository when useful.
+
+Then answer with thread_gate_respond, threadId ${input.implementerThreadId}, gateId ${input.gate.id}:
+
+- decision "approve" clears the gate and lets the builder proceed.
+- decision "object" with a message delivers your objection to the builder and spends one exchange round. After ${input.roundCap} objections the gate escalates to the user instead.
+
+If you do not answer within ${Math.round(input.gateTimeoutMs / 1e3)} seconds the gate fails open and is recorded as passed unwatched. Answer the gate, tell the user your reasoning in a few sentences, then end your turn - do not wait for the builder.`;
 const make$1 = Effect.gen(function* () {
 	const orchestrationEngine = yield* OrchestrationEngineService;
 	const projectionSnapshotQuery = yield* ProjectionSnapshotQuery;
+	/**
+	* Consecutive identical command failures per implementer thread. In-memory
+	* on purpose: the counter's turn dies with the server anyway, and the cost
+	* of losing it is one extra failed attempt after a restart, not a stuck
+	* approval.
+	*/
+	const repeatedFailures = /* @__PURE__ */ new Map();
+	/**
+	* Gate detection and human-override resolution act on the CURRENT persisted
+	* gate state, so replaying them against historical events is wrong twice
+	* over: an old plan event would open a fresh gate, and an old user message
+	* would resolve a gate that opened long after it. They therefore run only
+	* for events sequenced after the head observed at startup. The replay-safe
+	* paths (reviews, gate wakes, activities) keep their deterministic command
+	* ids instead.
+	*/
+	let liveEventsAfterSequence = Number.MAX_SAFE_INTEGER;
+	const readPairs = Effect.gen(function* () {
+		const readModel = yield* projectionSnapshotQuery.getCommandReadModel();
+		return {
+			readModel,
+			activePairs: (readModel.threadPairs ?? []).filter((pair) => pair.detachedAt === null)
+		};
+	});
+	const appendGateActivity = Effect.fn("FusionWatcherReactor.appendGateActivity")(function* (input) {
+		yield* orchestrationEngine.dispatch({
+			type: "thread.activity.append",
+			commandId: CommandId.make(`server:fusion:gate:${input.gateId}:${input.suffix}:${input.threadId}`),
+			threadId: input.threadId,
+			activity: {
+				id: gateActivityId(input.gateId, input.threadId, input.suffix),
+				tone: input.tone,
+				kind: input.kind,
+				summary: input.summary,
+				payload: input.payload,
+				turnId: null,
+				createdAt: input.createdAt
+			},
+			createdAt: input.createdAt
+		});
+	});
+	const appendGateActivityToBoth = Effect.fn("FusionWatcherReactor.appendGateActivityToBoth")(function* (input) {
+		yield* appendGateActivity({
+			...input,
+			threadId: input.pair.implementerThreadId
+		});
+		yield* appendGateActivity({
+			...input,
+			threadId: input.pair.watcherThreadId
+		});
+	});
+	/** Starts one watcher turn for the open gate and advances the pair cursor. */
+	const wakeWatcherForGate = Effect.fn("FusionWatcherReactor.wakeWatcherForGate")(function* (event) {
+		const gate = event.payload.gate;
+		if (gate.state !== "awaiting-watcher") return;
+		const { readModel, activePairs } = yield* readPairs;
+		const pair = activePairs.find((candidate) => candidate.id === event.payload.pairId);
+		if (pair === void 0) return;
+		const watcher = readModel.threads.find((thread) => thread.id === pair.watcherThreadId && thread.deletedAt === null);
+		if (watcher === void 0) return;
+		yield* orchestrationEngine.dispatch({
+			type: "thread.turn.start",
+			commandId: gateCommandId(pair.id, gate.id, `wake:${gate.round}`),
+			threadId: watcher.id,
+			message: {
+				messageId: gateMessageId(gate.id, gate.round),
+				role: "user",
+				text: gatePrompt({
+					implementerThreadId: pair.implementerThreadId,
+					gate,
+					roundCap: pair.roundCap,
+					gateTimeoutMs: pair.gateTimeoutMs,
+					afterSequence: pair.lastReviewedImplementerSequence,
+					throughSequence: event.sequence
+				}),
+				attachments: []
+			},
+			runtimeMode: watcher.runtimeMode,
+			interactionMode: watcher.interactionMode,
+			compressMode: watcher.compressMode,
+			unpromptedSubagents: watcher.unpromptedSubagents,
+			createdAt: event.payload.gate.updatedAt
+		});
+		if (event.sequence > pair.lastReviewedImplementerSequence) yield* orchestrationEngine.dispatch({
+			type: "thread-pair.cursor.advance",
+			commandId: cursorCommandId(pair.id, event.sequence),
+			pairId: pair.id,
+			implementerSequence: event.sequence,
+			advancedAt: event.payload.gate.updatedAt
+		});
+	});
+	const processGateOpened = Effect.fn("FusionWatcherReactor.processGateOpened")(function* (event) {
+		const gate = event.payload.gate;
+		yield* appendGateActivityToBoth({
+			pair: event.payload,
+			gateId: gate.id,
+			suffix: "opened",
+			tone: "approval",
+			kind: "fusion.gate.opened",
+			summary: gate.kind === "plan" ? "Gate opened: plan review" : gate.kind === "command-approval" ? "Gate opened: approval review" : "Gate opened: repeated command failures",
+			payload: {
+				pairId: event.payload.pairId,
+				gateId: gate.id,
+				gateKind: gate.kind,
+				...gate.requestId !== null ? { requestId: gate.requestId } : {},
+				...gate.commandTitle !== null ? { commandTitle: gate.commandTitle } : {}
+			},
+			createdAt: event.payload.openedAt
+		});
+		yield* wakeWatcherForGate(event);
+	});
+	const processGateAdvanced = Effect.fn("FusionWatcherReactor.processGateAdvanced")(function* (event) {
+		const gate = event.payload.gate;
+		if (gate.state === "escalated") {
+			yield* appendGateActivityToBoth({
+				pair: event.payload,
+				gateId: gate.id,
+				suffix: "escalated",
+				tone: "approval",
+				kind: "fusion.gate.escalated",
+				summary: "Gate escalated: the builder and supervisor did not converge",
+				payload: {
+					pairId: event.payload.pairId,
+					gateId: gate.id,
+					gateKind: gate.kind,
+					round: gate.round
+				},
+				createdAt: event.payload.advancedAt
+			});
+			return;
+		}
+		yield* wakeWatcherForGate(event);
+	});
+	const processGateResolved = Effect.fn("FusionWatcherReactor.processGateResolved")(function* (event) {
+		const { outcome, resolvedBy, kind, requestId } = event.payload;
+		const unwatched = outcome === "unwatched";
+		yield* appendGateActivityToBoth({
+			pair: event.payload,
+			gateId: event.payload.gateId,
+			suffix: `resolved:${outcome}`,
+			tone: unwatched ? "error" : "approval",
+			kind: unwatched ? "fusion.gate.unwatched" : "fusion.gate.resolved",
+			summary: unwatched ? FUSION_GATE_UNWATCHED_SUMMARY : outcome === "approved" ? "Gate approved by the supervisor" : "Gate answered by the user",
+			payload: {
+				pairId: event.payload.pairId,
+				gateId: event.payload.gateId,
+				gateKind: kind,
+				outcome,
+				resolvedBy
+			},
+			createdAt: event.payload.resolvedAt
+		});
+		if (outcome !== "unwatched" && outcome !== "human") return;
+		if (kind === "command-approval" && requestId !== null && unwatched) yield* orchestrationEngine.dispatch({
+			type: "thread.approval.respond",
+			commandId: gateCommandId(event.payload.pairId, event.payload.gateId, "timeout-accept"),
+			threadId: event.payload.implementerThreadId,
+			requestId: ApprovalRequestId.make(requestId),
+			decision: "accept",
+			createdAt: event.payload.resolvedAt
+		});
+		if (kind === "repeated-failure") {
+			const { readModel } = yield* readPairs;
+			const implementer = readModel.threads.find((thread) => thread.id === event.payload.implementerThreadId && thread.deletedAt === null);
+			if (implementer === void 0) return;
+			if (outcome === "human" && implementer.latestTurn?.state === "running") return;
+			yield* orchestrationEngine.dispatch({
+				type: "thread.turn.start",
+				commandId: gateCommandId(event.payload.pairId, event.payload.gateId, "unblock-continue"),
+				threadId: implementer.id,
+				message: {
+					messageId: MessageId.make(`fusion-gate:${event.payload.gateId}:unblock-continue`),
+					role: "user",
+					text: unwatched ? `${FUSION_GATE_PROMPT_PREFIX} The supervisor did not answer the repeated-failure gate within the timeout. The gate passed unwatched. Continue the work.` : `${FUSION_GATE_PROMPT_PREFIX} The user skipped the repeated-failure gate. Continue the work.`,
+					attachments: []
+				},
+				runtimeMode: implementer.runtimeMode,
+				interactionMode: implementer.interactionMode,
+				compressMode: implementer.compressMode,
+				unpromptedSubagents: implementer.unpromptedSubagents,
+				createdAt: event.payload.resolvedAt
+			});
+		}
+	});
+	const openGate = Effect.fn("FusionWatcherReactor.openGate")(function* (input) {
+		yield* orchestrationEngine.dispatch({
+			type: "thread-pair.gate.open",
+			commandId: CommandId.make(`server:fusion:${input.pair.id}:gate-open:${input.sequence}`),
+			pairId: input.pair.id,
+			gateId: ThreadPairGateId.make(`${input.pair.id}:g${input.sequence}`),
+			kind: input.kind,
+			...input.requestId !== void 0 ? { requestId: ApprovalRequestId.make(input.requestId) } : {},
+			...input.planId !== void 0 ? { planId: input.planId } : {},
+			...input.commandTitle !== void 0 ? { commandTitle: input.commandTitle } : {},
+			openedAt: input.occurredAt
+		});
+	});
+	const processPlanUpserted = Effect.fn("FusionWatcherReactor.processPlanUpserted")(function* (event) {
+		if (event.sequence <= liveEventsAfterSequence) return;
+		const { activePairs } = yield* readPairs;
+		const pair = activePairs.find((candidate) => candidate.implementerThreadId === event.payload.threadId);
+		if (pair === void 0 || pair.activeGate !== null) return;
+		yield* openGate({
+			pair,
+			sequence: event.sequence,
+			kind: "plan",
+			occurredAt: event.occurredAt,
+			planId: event.payload.proposedPlan.id
+		});
+	});
+	const activityRequestId = (payload) => {
+		if (typeof payload !== "object" || payload === null) return void 0;
+		const requestId = payload["requestId"];
+		return typeof requestId === "string" && requestId.length > 0 ? requestId : void 0;
+	};
+	const processActivityAppended = Effect.fn("FusionWatcherReactor.processActivityAppended")(function* (event) {
+		if (event.sequence <= liveEventsAfterSequence) return;
+		const activity = event.payload.activity;
+		const { activePairs } = yield* readPairs;
+		const pair = activePairs.find((candidate) => candidate.implementerThreadId === event.payload.threadId);
+		if (pair === void 0) return;
+		if (activity.kind === "approval.requested") {
+			if (pair.activeGate !== null) return;
+			const requestId = activityRequestId(activity.payload);
+			if (requestId === void 0) return;
+			yield* openGate({
+				pair,
+				sequence: event.sequence,
+				kind: "command-approval",
+				occurredAt: event.occurredAt,
+				requestId
+			});
+			return;
+		}
+		if (activity.kind === "approval.resolved") {
+			const requestId = activityRequestId(activity.payload);
+			const gate = pair.activeGate;
+			if (gate === null || gate.kind !== "command-approval" || requestId === void 0 || gate.requestId !== requestId) return;
+			yield* orchestrationEngine.dispatch({
+				type: "thread-pair.gate.resolve",
+				commandId: gateCommandId(pair.id, gate.id, `external-resolve:${event.sequence}`),
+				pairId: pair.id,
+				gateId: gate.id,
+				outcome: "human",
+				resolvedBy: "human",
+				resolvedAt: event.occurredAt
+			});
+			return;
+		}
+		if (activity.kind === "tool.completed") {
+			const payload = typeof activity.payload === "object" && activity.payload !== null ? activity.payload : void 0;
+			if (payload?.["itemType"] !== "command_execution") return;
+			const key = activity.summary;
+			if (payload["status"] !== "failed") {
+				repeatedFailures.delete(event.payload.threadId);
+				return;
+			}
+			const previous = repeatedFailures.get(event.payload.threadId);
+			const count = previous !== void 0 && previous.key === key ? previous.count + 1 : 1;
+			repeatedFailures.set(event.payload.threadId, {
+				key,
+				count
+			});
+			if (count < 3 || pair.activeGate !== null) return;
+			repeatedFailures.delete(event.payload.threadId);
+			yield* orchestrationEngine.dispatch({
+				type: "thread.turn.interrupt",
+				commandId: CommandId.make(`server:fusion:${pair.id}:gate-interrupt:${event.sequence}`),
+				threadId: pair.implementerThreadId,
+				createdAt: event.occurredAt
+			});
+			yield* openGate({
+				pair,
+				sequence: event.sequence,
+				kind: "repeated-failure",
+				occurredAt: event.occurredAt,
+				commandTitle: key
+			});
+		}
+	});
+	const processApprovalResponseRequested = Effect.fn("FusionWatcherReactor.processApprovalResponseRequested")(function* (event) {
+		if (event.sequence <= liveEventsAfterSequence) return;
+		const { activePairs } = yield* readPairs;
+		const pair = activePairs.find((candidate) => candidate.implementerThreadId === event.payload.threadId);
+		const gate = pair?.activeGate ?? null;
+		if (pair === void 0 || gate === null || gate.kind !== "command-approval" || gate.requestId !== event.payload.requestId) return;
+		yield* orchestrationEngine.dispatch({
+			type: "thread-pair.gate.resolve",
+			commandId: gateCommandId(pair.id, gate.id, `respond-resolve:${event.sequence}`),
+			pairId: pair.id,
+			gateId: gate.id,
+			outcome: "human",
+			resolvedBy: "human",
+			resolvedAt: event.payload.createdAt
+		});
+	});
+	const isFusionProtocolText = (text) => text.startsWith("[fusion-review]") || text.startsWith("[fusion-gate]") || text.startsWith("[fusion-advice]");
+	const processMessageSent = Effect.fn("FusionWatcherReactor.processMessageSent")(function* (event) {
+		if (event.sequence <= liveEventsAfterSequence) return;
+		if (event.payload.role !== "user") return;
+		if (isFusionProtocolText(event.payload.text)) return;
+		const { activePairs } = yield* readPairs;
+		const pair = activePairs.find((candidate) => candidate.implementerThreadId === event.payload.threadId);
+		const gate = pair?.activeGate ?? null;
+		if (pair === void 0 || gate === null) return;
+		yield* orchestrationEngine.dispatch({
+			type: "thread-pair.gate.resolve",
+			commandId: gateCommandId(pair.id, gate.id, `human-message:${event.sequence}`),
+			pairId: pair.id,
+			gateId: gate.id,
+			outcome: "human",
+			resolvedBy: "human",
+			resolvedAt: event.payload.createdAt
+		});
+	});
 	const processReview = Effect.fn("FusionWatcherReactor.processReview")(function* (pair, completion) {
 		const readModel = yield* projectionSnapshotQuery.getCommandReadModel();
 		const currentPair = (readModel.threadPairs ?? []).find((candidate) => candidate.id === pair.id);
 		if (currentPair === void 0 || currentPair.detachedAt !== null || completion.sequence <= currentPair.lastReviewedImplementerSequence) return;
+		const gate = currentPair.activeGate;
+		if (gate !== null) {
+			if (gate.state === "awaiting-implementer") yield* orchestrationEngine.dispatch({
+				type: "thread-pair.gate.advance",
+				commandId: gateCommandId(currentPair.id, gate.id, `responded:${completion.sequence}`),
+				pairId: currentPair.id,
+				gateId: gate.id,
+				transition: "implementer-responded",
+				advancedAt: completion.occurredAt
+			});
+			return;
+		}
 		const watcher = readModel.threads.find((thread) => thread.id === currentPair.watcherThreadId && thread.deletedAt === null);
 		if (watcher === void 0) return;
 		yield* orchestrationEngine.dispatch({
@@ -104645,42 +105804,98 @@ const make$1 = Effect.gen(function* () {
 			discard: true
 		});
 	});
-	const processEvent = Effect.fn("FusionWatcherReactor.processEvent")(function* (event) {
-		if (event.type === "thread.turn-completed") {
-			yield* processCompletion(event);
-			return;
-		}
-		if (event.type === "thread-pair.created") {
-			yield* grantActiveMcpWatchThread({
-				watcherThreadId: event.payload.watcherThreadId,
-				watchedThreadId: event.payload.implementerThreadId
+	/**
+	* The fail-open timeout, enforced against the persisted gate rather than
+	* any in-memory state, so a server restart mid-gate resumes the countdown
+	* instead of stranding the run.
+	*/
+	const sweepGateTimeouts = Effect.gen(function* () {
+		const now = yield* Clock.currentTimeMillis;
+		const { activePairs } = yield* readPairs;
+		for (const pair of activePairs) {
+			const gate = pair.activeGate;
+			if (gate === null || gate.state !== "awaiting-watcher") continue;
+			if (gate.awaitingWatcherSince === null) continue;
+			const since = Date.parse(gate.awaitingWatcherSince);
+			if (Number.isNaN(since) || now - since < pair.gateTimeoutMs) continue;
+			yield* orchestrationEngine.dispatch({
+				type: "thread-pair.gate.resolve",
+				commandId: gateCommandId(pair.id, gate.id, `timeout:${gate.round}`),
+				pairId: pair.id,
+				gateId: gate.id,
+				outcome: "unwatched",
+				resolvedBy: "timeout",
+				resolvedAt: new Date(now).toISOString()
 			});
-			return;
 		}
-		const pair = ((yield* projectionSnapshotQuery.getCommandReadModel()).threadPairs ?? []).find((candidate) => candidate.id === event.payload.pairId);
-		if (pair === void 0) return;
-		yield* revokeActiveMcpWatchThread({
-			watcherThreadId: pair.watcherThreadId,
-			watchedThreadId: pair.implementerThreadId
-		});
+	});
+	const FUSION_REACTOR_EVENT_TYPES = /* @__PURE__ */ new Set([
+		"thread.turn-completed",
+		"thread.proposed-plan-upserted",
+		"thread.activity-appended",
+		"thread.approval-response-requested",
+		"thread.message-sent",
+		"thread-pair.created",
+		"thread-pair.detached",
+		"thread-pair.gate-opened",
+		"thread-pair.gate-advanced",
+		"thread-pair.gate-resolved"
+	]);
+	const processEvent = Effect.fn("FusionWatcherReactor.processEvent")(function* (event) {
+		switch (event.type) {
+			case "thread.turn-completed": return yield* processCompletion(event);
+			case "thread.proposed-plan-upserted": return yield* processPlanUpserted(event);
+			case "thread.activity-appended": return yield* processActivityAppended(event);
+			case "thread.approval-response-requested": return yield* processApprovalResponseRequested(event);
+			case "thread.message-sent": return yield* processMessageSent(event);
+			case "thread-pair.gate-opened": return yield* processGateOpened(event);
+			case "thread-pair.gate-advanced": return yield* processGateAdvanced(event);
+			case "thread-pair.gate-resolved": return yield* processGateResolved(event);
+			case "thread-pair.created":
+				yield* grantActiveMcpWatchThread({
+					watcherThreadId: event.payload.watcherThreadId,
+					watchedThreadId: event.payload.implementerThreadId
+				});
+				yield* grantActiveMcpAdviseThread({
+					watcherThreadId: event.payload.watcherThreadId,
+					advisedThreadId: event.payload.implementerThreadId
+				});
+				return;
+			case "thread-pair.detached": {
+				const pair = ((yield* projectionSnapshotQuery.getCommandReadModel()).threadPairs ?? []).find((candidate) => candidate.id === event.payload.pairId);
+				if (pair === void 0) return;
+				yield* revokeActiveMcpWatchThread({
+					watcherThreadId: pair.watcherThreadId,
+					watchedThreadId: pair.implementerThreadId
+				});
+				yield* revokeActiveMcpAdviseThread({
+					watcherThreadId: pair.watcherThreadId,
+					advisedThreadId: pair.implementerThreadId
+				});
+				return;
+			}
+		}
 	});
 	const processSafely = (event) => processEvent(event).pipe(Effect.catchCause((cause) => {
 		if (Cause.hasInterruptsOnly(cause)) return Effect.failCause(cause);
-		return Effect.logWarning("fusion watcher reactor failed to process completion", {
+		return Effect.logWarning("fusion watcher reactor failed to process event", {
 			eventType: event.type,
 			sequence: event.sequence,
 			cause: Cause.pretty(cause)
 		});
 	}));
 	const worker = yield* makeDrainableWorker(processSafely);
-	const enqueueEvent = (event) => event.type === "thread.turn-completed" || event.type === "thread-pair.created" || event.type === "thread-pair.detached" ? worker.enqueue(event) : Effect.void;
+	const enqueueEvent = (event) => FUSION_REACTOR_EVENT_TYPES.has(event.type) ? worker.enqueue(event) : Effect.void;
 	return {
 		start: Effect.fn("FusionWatcherReactor.start")(function* () {
 			yield* Effect.forkScoped(Stream.runForEach(orchestrationEngine.streamDomainEvents, enqueueEvent));
+			yield* Effect.forkScoped(sweepGateTimeouts.pipe(Effect.catchCause((cause) => Effect.logWarning("fusion gate timeout sweep failed", { cause: Cause.pretty(cause) })), Effect.repeat(Schedule.spaced(GATE_TIMEOUT_SWEEP_INTERVAL))));
 			const headSequence = yield* orchestrationEngine.latestSequence;
+			liveEventsAfterSequence = headSequence;
 			yield* Stream.runForEach(orchestrationEngine.readEvents(0, Math.max(1, headSequence)), enqueueEvent).pipe(Effect.catchCause((cause) => Effect.logWarning("fusion watcher reactor failed historical replay", { cause: Cause.pretty(cause) })));
 		}),
-		drain: worker.drain
+		drain: worker.drain,
+		sweepGates: sweepGateTimeouts.pipe(Effect.catchCause((cause) => Effect.logWarning("fusion gate timeout sweep failed", { cause: Cause.pretty(cause) })))
 	};
 });
 const FusionWatcherReactorLive = Layer.effect(FusionWatcherReactor, make$1);