@p4code/cli 0.5.12 → 0.5.13

package/dist/bin.mjs

@@ -265,7 +265,7 @@ const make$120 = () => {
 const layer$122 = Layer.sync(NetService, make$120);
 //#endregion
 //#region package.json
-var version$1 = "0.5.12";
+var version$1 = "0.5.13";
 //#endregion
 //#region src/config.ts
 /**
@@ -12516,6 +12516,16 @@ const ThreadRenameResult = Schema$1.Struct({
 	title: TrimmedNonEmptyString
 });
 const ThreadPlanUpdateInput = Schema$1.Struct({
+	/**
+	* The thread whose banner this plan belongs to.
+	*
+	* Omitted means the caller's own thread, which is every ordinary use. A
+	* Fusion supervisor names its paired builder here: the plan is the
+	* supervisor's to author, but it describes the builder's work, so it has to
+	* land on the builder's banner. Only a thread this session holds a watch
+	* grant for is accepted.
+	*/
+	threadId: Schema$1.optional(ThreadId.annotate({ description: "The thread to update. Omit for this session's own thread. Only a thread this session may watch can be named here." })),
 	explanation: Schema$1.optional(TrimmedNonEmptyString),
 	plan: Schema$1.Array(Schema$1.Struct({
 		step: TrimmedNonEmptyString,
@@ -12812,7 +12822,22 @@ const ThreadReviewItem = Schema$1.Union([Schema$1.Struct({
 	/** Apply append/replace by message identity across page boundaries. */
 	operation: Schema$1.Literals(["append", "replace"]),
 	complete: Schema$1.Boolean,
-	text: Schema$1.String
+	text: Schema$1.String,
+	/**
+	* What the message carried besides text.
+	*
+	* Present only when there was something: a message whose fragments are
+	* merged by identity would otherwise lose every trace of an image or a
+	* document the builder attached. Bounded by
+	* {@link THREAD_REVIEW_ITEM_MAX_ATTACHMENTS} so the item stays trimmable -
+	* only its text shrinks under the byte cap, so nothing else may be able to
+	* grow without limit.
+	*/
+	attachments: Schema$1.optionalKey(Schema$1.Array(Schema$1.Struct({
+		type: Schema$1.String,
+		name: Schema$1.String,
+		sizeBytes: NonNegativeInt
+	})))
 }), Schema$1.Struct({
 	...ReviewSourceFields,
 	kind: Schema$1.Literal("event"),
@@ -12857,6 +12882,84 @@ const ThreadWatchReviewResult = Schema$1.Struct({
 	*/
 	summary: Schema$1.optionalKey(Schema$1.NullOr(ThreadReviewSummary))
 });
+/**
+* How a review ended, from the supervisor's own account of it.
+*
+* Four states rather than a boolean because they are acted on differently: a
+* summary that arrived is evidence, a fallback is a working review that cost
+* full context, a failure is a misconfiguration worth fixing, and a read with
+* no report at all is the only one that cannot be told from a supervisor that
+* simply never reported - which is why the absence has to be visible too.
+*/
+const ThreadEvidenceReportOutcome = Schema$1.Literals([
+	"summarized",
+	"fallback",
+	"failed"
+]);
+/** Bounded so one report cannot dominate a thread's activity storage. */
+const THREAD_EVIDENCE_REPORT_MAX_CHARS = 8e3;
+const ThreadEvidenceReportInput = Schema$1.Struct({
+	/** The watched thread the summary covers, not the reporting thread. */
+	threadId: ThreadId,
+	firstSequence: NonNegativeInt,
+	lastSequence: NonNegativeInt,
+	/**
+	* The fixed review boundary the pages were read against.
+	*
+	* Identity, not description: the evidence-read rows are keyed on it, so a
+	* report that guessed from its own last sequence would look for a baseline
+	* that never existed whenever the range ended on a filtered event.
+	*/
+	throughSequence: NonNegativeInt,
+	outcome: ThreadEvidenceReportOutcome,
+	/** The summarizer's exact text. Required when the outcome is summarized. */
+	summary: Schema$1.optional(Schema$1.String),
+	/** The model the subagent ran on, when one was spawned. */
+	model: Schema$1.optional(Schema$1.String),
+	/** Why the summary is missing or degraded. Required unless summarized. */
+	reason: Schema$1.optional(Schema$1.String)
+});
+/**
+* The supervisor's own context around the read, correlated by the server.
+*
+* Self-reported numbers would be worth little, so these are read from the
+* reporting thread's projected context-window rows: `before` is what was
+* recorded when the evidence read happened, `after` what is recorded when the
+* report lands. `delta` can be negative when a compaction ran in between, and
+* is null whenever no read-time baseline exists.
+*/
+const ThreadEvidenceReportContext = Schema$1.Struct({
+	/**
+	* Null when no reading was recorded at read time.
+	*
+	* Never the report-time value standing in for itself: a delta of zero read
+	* as measurement would be a lie about a review that cost context.
+	*/
+	usedTokensBefore: Schema$1.NullOr(NonNegativeInt),
+	usedTokensAfter: NonNegativeInt,
+	/** Null exactly when `usedTokensBefore` is. */
+	deltaTokens: Schema$1.NullOr(Schema$1.Number),
+	maxTokens: Schema$1.NullOr(NonNegativeInt),
+	capacityPercent: Schema$1.NullOr(Schema$1.Number)
+});
+Schema$1.Struct({
+	watchedThreadId: ThreadId,
+	firstSequence: NonNegativeInt,
+	lastSequence: NonNegativeInt,
+	throughSequence: NonNegativeInt,
+	outcome: ThreadEvidenceReportOutcome,
+	summary: Schema$1.NullOr(Schema$1.String),
+	/** True when a snapshot dropped the text of a superseded report. */
+	summaryDropped: Schema$1.optionalKey(Schema$1.Boolean),
+	model: Schema$1.NullOr(Schema$1.String),
+	reason: Schema$1.NullOr(Schema$1.String),
+	/** Null when no context-window row exists yet for the reporting thread. */
+	context: Schema$1.NullOr(ThreadEvidenceReportContext)
+});
+const ThreadEvidenceReportResult = Schema$1.Struct({
+	recorded: Schema$1.Boolean,
+	context: Schema$1.NullOr(ThreadEvidenceReportContext)
+});
 var WatchToolUnavailableError = class extends Schema$1.TaggedErrorClass()("WatchToolUnavailableError", {
 	capability: Schema$1.Literal("watch"),
 	environmentId: EnvironmentId,
@@ -20405,12 +20508,46 @@ function dropSupersededToolUpdatedActivities(activities) {
 		return completionIndex === void 0 || completionIndex <= index || !completionPreservesUpdate(activity, activities[completionIndex]);
 	});
 }
+/**
+* Keeps only the newest evidence report's text per watched thread.
+*
+* A report carries the summarizer's exact words, and a snapshot retains
+* hundreds of activities: left whole, a long-running pair would put megabytes
+* of superseded diagnostics on the wire on every reconnect. Superseded rows
+* keep their outcome, range and context - everything the work log renders
+* collapsed - and lose only the body, flagged so the client can say the text
+* is no longer retained rather than that the review produced none.
+*/
+function dropSupersededEvidenceSummaries(activities) {
+	const latestIndexByWatched = /* @__PURE__ */ new Map();
+	for (let index = 0; index < activities.length; index += 1) {
+		const activity = activities[index];
+		if (activity.kind !== "fusion.evidence.summary") continue;
+		const watchedThreadId = asRecord$7(activity.payload)?.watchedThreadId;
+		if (typeof watchedThreadId === "string") latestIndexByWatched.set(watchedThreadId, index);
+	}
+	if (latestIndexByWatched.size === 0) return activities;
+	return activities.map((activity, index) => {
+		if (activity.kind !== "fusion.evidence.summary") return activity;
+		const payload = asRecord$7(activity.payload);
+		const watchedThreadId = payload?.watchedThreadId;
+		if (!payload || typeof watchedThreadId !== "string" || latestIndexByWatched.get(watchedThreadId) === index || payload.summary === null || payload.summary === void 0) return activity;
+		return {
+			...activity,
+			payload: {
+				...payload,
+				summary: null,
+				summaryDropped: true
+			}
+		};
+	});
+}
 function projectThreadDetailSnapshot(snapshot) {
 	return {
 		...snapshot,
 		thread: {
 			...snapshot.thread,
-			activities: dropSupersededToolUpdatedActivities(dropStaleContextWindowActivities(snapshot.thread.activities).map(projectActivityPayload))
+			activities: dropSupersededEvidenceSummaries(dropSupersededToolUpdatedActivities(dropStaleContextWindowActivities(snapshot.thread.activities).map(projectActivityPayload)))
 		}
 	};
 }
@@ -33071,7 +33208,7 @@ const layer$87 = Layer.effect(AssetSync, make$103);
 * runtime template. Applies to assistant prose only: code blocks, commits,
 * PRs, error strings, and safety-critical text stay uncompressed.
 */
-const COMPRESS_SHARED_RULES = `Respond terse. Keep all technical substance; remove fluff.
+const COMPRESS_SHARED_RULES = `Respond terse like smart caveman. All technical substance stay. Only fluff die.
 
 ## Persistence
 
@@ -41404,6 +41541,37 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           detached_at AS "detachedAt"
         FROM thread_pairs
         ORDER BY created_at ASC, pair_id ASC
+      `
+	});
+	const LatestContextWindowRow = Schema$1.Struct({
+		usedTokens: Schema$1.Number,
+		maxTokens: Schema$1.NullOr(Schema$1.Number)
+	});
+	const getLatestContextWindowRow = SqlSchema.findOneOption({
+		Request: ThreadId,
+		Result: LatestContextWindowRow,
+		execute: (threadId) => sql`
+        SELECT
+          json_extract(payload_json, '$.usedTokens') AS "usedTokens",
+          json_extract(payload_json, '$.maxTokens') AS "maxTokens"
+        FROM projection_thread_activities
+        WHERE thread_id = ${threadId}
+          AND kind = 'context-window.updated'
+          AND json_extract(payload_json, '$.usedTokens') >= 0
+        ORDER BY created_at DESC, rowid DESC
+        LIMIT 1
+      `
+	});
+	const EvidenceReadContextRow = Schema$1.Struct({ usedTokensAtRead: Schema$1.Number });
+	const getEvidenceReadContextRow = SqlSchema.findOneOption({
+		Request: Schema$1.String,
+		Result: EvidenceReadContextRow,
+		execute: (activityId) => sql`
+        SELECT json_extract(payload_json, '$.usedTokensAtRead') AS "usedTokensAtRead"
+        FROM projection_thread_activities
+        WHERE activity_id = ${activityId}
+          AND json_extract(payload_json, '$.usedTokensAtRead') >= 0
+        LIMIT 1
       `
 	});
 	const getThreadPairRow = SqlSchema.findOneOption({
@@ -43193,6 +43361,8 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			messageCreatedAt: row.messageCreatedAt
 		})) };
 	});
+	const getLatestThreadContextWindow = (threadId) => getLatestContextWindowRow(threadId).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getLatestThreadContextWindow:query", "ProjectionSnapshotQuery.getLatestThreadContextWindow:decodeRow")));
+	const getEvidenceReadContext = (activityId) => getEvidenceReadContextRow(activityId).pipe(Effect.map(Option.map((row) => row.usedTokensAtRead)), Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getEvidenceReadContext:query", "ProjectionSnapshotQuery.getEvidenceReadContext:decodeRow")));
 	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([
@@ -43418,7 +43588,9 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		getThreadDetailById,
 		getHandoffContext,
 		getBtwContext,
-		getThreadDetailSnapshot
+		getThreadDetailSnapshot,
+		getLatestThreadContextWindow,
+		getEvidenceReadContext
 	};
 });
 const OrchestrationProjectionSnapshotQueryLive = Layer.effect(ProjectionSnapshotQuery, makeProjectionSnapshotQuery).pipe(Layer.provide(layer$86));
@@ -43482,6 +43654,38 @@ function payloadPreview(payload) {
 		truncated
 	};
 }
+/**
+* Context-window rows are bookkeeping, not work.
+*
+* Every turn emits a stream of them and a single one can be large enough to
+* truncate, so leaving them in spends a reviewer's page budget on a token
+* meter they did not ask about. The prefix test covers the truncated case,
+* where the payload arrives as a JSON fragment that can no longer be parsed
+* but still carries the kind near its head.
+*/
+const CONTEXT_WINDOW_ACTIVITY_MARKER = "\"kind\":\"context-window.updated\"";
+function isContextWindowBookkeeping(type, payload, sourceTruncated) {
+	if (type !== "thread.activity-appended") return false;
+	if (sourceTruncated) return typeof payload === "string" && payload.includes(CONTEXT_WINDOW_ACTIVITY_MARKER);
+	const record = payload;
+	return typeof record === "object" && record !== null && record.activity?.kind === "context-window.updated";
+}
+/**
+* The trace an attachment leaves on a merged message.
+*
+* Fragments of one message collapse into a single item by identity, so an
+* image or a document has nowhere else to appear. Name and size are what a
+* reviewer needs to ask for it at source; the bytes themselves never belong on
+* a review page.
+*/
+function attachmentEvidence(attachments) {
+	if (!attachments?.length) return void 0;
+	return attachments.slice(0, 10).map((attachment) => ({
+		type: attachment.type,
+		name: attachment.name.slice(0, 120),
+		sizeBytes: attachment.sizeBytes
+	}));
+}
 function fitItem(item) {
 	let result = item;
 	let bytes = Buffer.byteLength(JSON.stringify(result));
@@ -43518,7 +43722,7 @@ function createThreadReviewPage(input) {
 	}));
 	function offer(event, sourceTruncated = false) {
 		if (event.sequence > input.throughSequence) return false;
-		if (event.aggregateKind !== "thread" || event.aggregateId !== input.threadId) {
+		if (event.aggregateKind !== "thread" || event.aggregateId !== input.threadId || isContextWindowBookkeeping(event.type, event.payload, sourceTruncated)) {
 			nextAfterSequence = event.sequence;
 			scannedEvents += 1;
 			return true;
@@ -43526,7 +43730,7 @@ function createThreadReviewPage(input) {
 		let item;
 		let index;
 		let messageKey;
-		if (event.type === "thread.message-sent" && !sourceTruncated && isMessagePayload(event.payload) && event.payload.role === "assistant" && !event.payload.attachments?.length && event.payload.messageId.length + (event.payload.turnId?.length ?? 0) <= MAX_MESSAGE_IDENTITY_LENGTH) {
+		if (event.type === "thread.message-sent" && !sourceTruncated && isMessagePayload(event.payload) && event.payload.role === "assistant" && event.payload.messageId.length + (event.payload.turnId?.length ?? 0) <= MAX_MESSAGE_IDENTITY_LENGTH) {
 			const payload = event.payload;
 			messageKey = JSON.stringify([payload.turnId, payload.messageId]);
 			index = messageIndexes.get(messageKey);
@@ -43534,6 +43738,7 @@ function createThreadReviewPage(input) {
 			const previousMessage = previous?.kind === "message" ? previous : void 0;
 			const replaces = !payload.streaming && payload.text.length > 0;
 			const part = excerpt(payload.text, THREAD_REVIEW_ITEM_MAX_BYTES);
+			const attachments = attachmentEvidence(payload.attachments) ?? previousMessage?.attachments;
 			item = fitItem({
 				kind: "message",
 				firstSequence: previousMessage?.firstSequence ?? event.sequence,
@@ -43544,7 +43749,8 @@ function createThreadReviewPage(input) {
 				operation: replaces ? "replace" : previousMessage?.operation ?? "append",
 				complete: !payload.streaming,
 				text: replaces ? part : (previousMessage?.text ?? "") + part,
-				truncated: part !== payload.text || !replaces && (previousMessage?.truncated ?? false)
+				truncated: part !== payload.text || !replaces && (previousMessage?.truncated ?? false),
+				...attachments === void 0 ? {} : { attachments }
 			});
 		} else {
 			const preview = sourceTruncated && typeof event.payload === "string" ? {
@@ -59043,14 +59249,14 @@ const readWorkflowScript = Effect.fn("orchestration.readWorkflowScript")(functio
 * written as if the setting applied only to user-facing answers.
 */
 const FUSION_PAIR_COMMUNICATION_INSTRUCTIONS = `Everything you send the other half of the pair obeys the thread's active response-compression mode, exactly as a user-facing answer does: phase reports, advice, reviews, questions, and handoffs. When the mode is off, write normal prose. Compression governs form only - never drop a requirement, a negation, a number or unit, a file, symbol, or command name, code, security or warning text, the evidence behind a claim, or an exact protocol heading or token in order to save words.`;
-const FUSION_BUILDER_INSTRUCTIONS = `You are Fusion Builder in an already-created native server pair. Server owns pairing and coordination. Follow the current turn's [fusion-review-policy] block when present; it overrides the phase-boundary scheduling rules below. Do not inspect or invoke the Fusion skill, create/pair/rename threads, or announce/setup Fusion. Start the user's task directly. Before editing, create and maintain the phase list with your provider's step-tracking tool (Claude Code: TaskCreate for each phase, then TaskUpdate for status, or TodoWrite when that is the tool offered; Codex: update_plan), never the MCP task board tools - one entry per phase in order, exactly one in progress at a time, marked completed at each phase end - so phases render in the task banner. That list holds phase entries only for the whole task; keep step-level or per-file todos out of it. Name each phase in 3-6 words by its outcome, never by a command, file path, or flag, because the banner shows the title verbatim. Prose alone leaves the banner empty. Split it into the fewest substantial phases the task genuinely needs plus a final integration/whole-task phase; most tasks need one to three work phases. Each phase is a complete reviewable slice of behavior. Never split per file, per function, or per trivial step: over-splitting spends review turns instead of finishing the job. Add a phase only when a real review boundary, risky decision, or independent behavior separates the work. Complete exactly one phase per turn, and finish the whole phase in that turn rather than stopping early. Do not run tests, typecheck, lint, or builds per phase; write the tests the change needs, then run verification once in the final phase over the whole task. Exception: a phase whose own correctness is unclear may run the single narrowest check that resolves it. End every phase turn with phase completed, todo status, changed behavior/files, and remaining phases; do not start the next phase in the same turn. Server then wakes the paired Supervisor, which resumes you through ${FUSION_ADVICE_PROMPT_PREFIX}; a user message may also revise or resume the work. Final phase verifies the entire task against the original request and labels it ready for whole-task review. Supervisor is unreachable during your turn. Never spawn/use another Supervisor thread/subagent or attribute Supervisor decisions without ${FUSION_ADVICE_PROMPT_PREFIX}. Within the current phase, continue when straightforward or evidence is clear. For a concrete unresolved tradeoff, correctness risk, or design decision materially needing judgment, stop safely before the risky choice; final response states the exact question and why review is needed. Evaluate/follow Supervisor advice unless conflicting with user request or verified repo state. ${FUSION_PAIR_COMMUNICATION_INSTRUCTIONS}`;
-const FUSION_WATCHER_TOOL_INSTRUCTIONS = `Supervisor tools belong to the p4-code MCP server: thread_watch_review, thread_watch_events, thread_advise, and thread_gate_respond. If absent from the visible tool list, first use the available tool search/discovery facility to load those exact tools, including provider-prefixed names; absence from the initial list does not establish unavailability. If discovery or a call fails, report the exact missing capability or error and the need to restore the p4-code MCP connection. Do not offer manual relay, draft or implement the task yourself, or abandon the supervisor role as a workaround. For an actionable user requirement, read the relevant builder evidence and relay it through thread_advise; when a gate is open, answer through thread_gate_respond instead. Structure every actionable supervisor advice message with these Markdown headings, in order:
+const FUSION_BUILDER_INSTRUCTIONS = `You are Fusion Builder in an already-created native server pair. Server owns pairing and coordination. Follow the current turn's [fusion-review-policy] block when present; it overrides the phase-boundary scheduling rules below. Do not inspect or invoke the Fusion skill, create/pair/rename threads, or announce/setup Fusion. Start the user's task directly. The phase plan is not yours: Supervisor authors it, orders it, and moves every phase status, and it renders in your task banner from there. Never create or edit a phase list yourself - not with TaskCreate, TaskUpdate, TodoWrite, update_plan, the MCP task board tools, or thread_plan_update - and never mark your own phase complete. Work the one phase Supervisor put in progress, and report what you did. Step-level notes for your own use are fine as long as they never become a phase list. Complete exactly one phase per turn, and finish the whole phase in that turn rather than stopping early. Do not run tests, typecheck, lint, or builds per phase; write the tests the change needs, then run verification once in the final phase over the whole task. Exception: a phase whose own correctness is unclear may run the single narrowest check that resolves it. End every phase turn with a report of at most six non-empty lines: the phase you finished, what changed and where, what you verified with its result, and anything unresolved. One line each, every fact once, no restatement of the plan or of advice you were given. Code, exact error text and security warnings are exempt from the cap. Do not start the next phase in the same turn. Server then wakes the paired Supervisor, which resumes you through ${FUSION_ADVICE_PROMPT_PREFIX}; a user message may also revise or resume the work. Final phase verifies the entire task against the original request and labels it ready for whole-task review. Supervisor is unreachable during your turn. Never spawn/use another Supervisor thread/subagent or attribute Supervisor decisions without ${FUSION_ADVICE_PROMPT_PREFIX}. Within the current phase, continue when straightforward or evidence is clear. For a concrete unresolved tradeoff, correctness risk, or design decision materially needing judgment, stop safely before the risky choice; final response states the exact question and why review is needed. Evaluate/follow Supervisor advice unless conflicting with user request or verified repo state. ${FUSION_PAIR_COMMUNICATION_INSTRUCTIONS}`;
+const FUSION_WATCHER_TOOL_INSTRUCTIONS = `Supervisor tools belong to the p4-code MCP server: thread_watch_review, thread_watch_events, thread_evidence_report, thread_plan_update, thread_advise, and thread_gate_respond. If absent from the visible tool list, first use the available tool search/discovery facility to load those exact tools, including provider-prefixed names; absence from the initial list does not establish unavailability. If discovery or a call fails, report the exact missing capability or error and the need to restore the p4-code MCP connection. Do not offer manual relay, draft or implement the task yourself, or abandon the supervisor role as a workaround. For an actionable user requirement, read the relevant builder evidence and relay it through thread_advise; when a gate is open, answer through thread_gate_respond instead. Structure every actionable supervisor advice message with these Markdown headings, in order:
 ## Recommendation
 State the decision or correction in one sentence. For a phase review, say whether the phase is approved or needs changes.
 ## Reason
 Give concise evidence, relevant file/line references, and any unresolved risk. Distinguish observed facts from assumptions; do not claim checks you did not run. Before prescribing a blocking product fix, identify the violated requirement and evidence of product ownership. If ownership is uncertain, state the hypothesis and request the smallest discriminating check, such as comparing the unchanged baseline or another app, rather than prescribing a speculative fix. Do not block a product fix on an artifact reproduced outside the product unless evidence still ties it to an unmet task requirement.
 ## Next step
-Give ordered, concrete actions for the builder, including the next phase and its completion condition. Preserve user requirements, constraints, and delivery authorization. Before repeating an objection, compare the builder's response and intervening changes with the prior finding; cite new evidence and explain why the builder's response does not resolve it. Without new evidence and an actionable next step, do not resend the objection or repeat passed checks; report the unresolved state in your own thread and end. A supported unresolved blocker remains unapproved; avoiding repetition never justifies approval. For an open gate, follow its response and escalation protocol. Keep each section short; omit empty bullets and repeated status. Formatting does not authorize an otherwise unnecessary advice turn or replace an exact protocol response.`;
+Give ordered, concrete actions for the builder, including the next phase and its completion condition. Preserve user requirements, constraints, and delivery authorization. Before repeating an objection, compare the builder's response and intervening changes with the prior finding; cite new evidence and explain why the builder's response does not resolve it. Without new evidence and an actionable next step, do not resend the objection or repeat passed checks; report the unresolved state in your own thread and end. A supported unresolved blocker remains unapproved; avoiding repetition never justifies approval. For an open gate, follow its response and escalation protocol. One line per section is the target and three is the ceiling; omit empty bullets and repeated status. Quote only the evidence the decision rests on, once, with its file:line or sequence. Exact errors, code and security text are exempt. Formatting does not authorize an otherwise unnecessary advice turn or replace an exact protocol response.`;
 /**
 * The directive that makes the supervisor read evidence through a subagent.
 *
@@ -59058,8 +59264,8 @@ Give ordered, concrete actions for the builder, including the next phase and its
 * turn off: with `Review evidence` off the supervisor reads the range itself,
 * which is what it did before this existed.
 */
-const FUSION_EVIDENCE_SUMMARY_INSTRUCTIONS = `Read the builder's evidence through a summarizer subagent rather than into your own context: spawn one subagent with the evidence range and have it call thread_watch_review itself, paging with nextAfterSequence against a fixed throughSequence until hasMore is false, and return a summary. Your tool grants reach it, so it can read the paired builder thread exactly as you can. Instruct that subagent that thread_watch_review and thread_watch_events may be absent from its visible tool list and that absence does not establish unavailability: it must first use the available tool search/discovery facility to load those exact tools by name, including provider-prefixed names, and if discovery itself fails it must report that exact error rather than reporting no such tool. Require of that summary: every file path touched with the scale of the change to each, every command run and whether it succeeded or failed, check and test results with their counts, exact error text quoted rather than characterized, the builder's completion claims marked as claims, and anything the builder flagged as uncertain, blocked or unresolved. Over a multi-turn range it must also carry unresolved objections of yours and whether each was answered, phases completed versus reopened, claims never verified, and files touched repeatedly. Every statement cites the sequences behind it so you can check any one of them with a targeted thread_watch_events read. Fail open: if no subagent is available, the spawn errors, it times out, or what comes back is empty or does not cite sequences, read the range yourself and review from the raw evidence. Never skip or shorten a review because a summary was unavailable. Record which fallback you took: a subagent that could not load the watch tools is a misconfiguration worth naming in your report, and it is not the same as a spawn that errored or timed out.`;
-const FUSION_WATCHER_INSTRUCTIONS = `You are Fusion Supervisor (watcher) in an already-created native server pair. Follow the current turn's [fusion-review-policy] block when present; it overrides phase scheduling. Server owns pairing and coordination and wakes you with ${FUSION_REVIEW_PROMPT_PREFIX} or ${FUSION_GATE_PROMPT_PREFIX} prompts at builder turn boundaries. A plain message outside such a wake may arrive after your conversational memory of the pair is gone; its [fusion-pair] metadata block is authoritative: the builder thread exists and is the counterpart thread id. Never report that no builder thread exists. For a new pair, the initial user request is yours, and its first turn is research, not relay. Research it: when the request names a ticket, read that ticket AND its comments, including replies and inline comments, and treat a later comment as newer intent than the description; read the code, docs, project instructions, and current state the request touches. Analyse what you found: root cause or the concrete design constraint, scope, what the user actually wants delivered, and which delivery steps they authorized. Only then direct the first actionable phase to the idle builder through thread_advise, stating the findings that make the direction actionable alongside the original requirements, constraints, and authorized delivery scope. Never echo the request back as its own direction, never hand over a plan you did not ground in evidence, and never send ${FUSION_NO_OBJECTION_TEXT} before the builder has received its first phase and produced a turn to review. The builder has not received the initial prompt and must not start before your direction. Missing builder turn evidence is expected before that first direction; do not wait for it or implement the work yourself. Ask the user only when needed to resolve a blocking requirement. ${FUSION_WATCHER_TOOL_INSTRUCTIONS} To resume supervision, read builder evidence with thread_watch_review from lastReviewedImplementerSequence, capture its throughSequence on the first page and reuse that fixed bound while paging with nextAfterSequence until hasMore is false (including empty pages). Apply message append/replace operations by identity; recover truncated evidence through targeted raw thread_watch_events source ranges. Retain reviewed requirements and evidence for final review; recover missing context with targeted history reads rather than mandatory raw replay from zero, derive phase from artifacts (git log/status, PR, builder events, including its turn.plan.updated phase list), steer with thread_advise, and answer an open gate with thread_gate_respond. When a review or gate wake prompt specifies an explicit event range, that range wins over this metadata. Never poll or wait for the builder; deliver review or advice, then end the turn. Every thread_advise starts a builder turn whose completion wakes you again, so never advise a builder that is idle on an external wait or has nothing actionable; report the state in your own thread and end without advising. ${FUSION_PAIR_COMMUNICATION_INSTRUCTIONS}`;
+const FUSION_EVIDENCE_SUMMARY_INSTRUCTIONS = `Read the builder's evidence through a summarizer subagent rather than into your own context: spawn one subagent with the evidence range and have it call thread_watch_review itself, paging with nextAfterSequence against a fixed throughSequence until hasMore is false, and return a summary. Your tool grants reach it, so it can read the paired builder thread exactly as you can. Instruct that subagent that thread_watch_review and thread_watch_events may be absent from its visible tool list and that absence does not establish unavailability: it must first use the available tool search/discovery facility to load those exact tools by name, including provider-prefixed names, and if discovery itself fails it must report that exact error rather than reporting no such tool. Require of that summary: every file path touched with the scale of the change to each, every command run and whether it succeeded or failed, check and test results with their counts, exact error text quoted rather than characterized, the builder's completion claims marked as claims, and anything the builder flagged as uncertain, blocked or unresolved. Over a multi-turn range it must also carry unresolved objections of yours and whether each was answered, phases completed versus reopened, claims never verified, and files touched repeatedly. Every statement cites the sequences behind it so you can check any one of them with a targeted thread_watch_events read. Fail open: if no subagent is available, the spawn errors, it times out, or what comes back is empty or does not cite sequences, read the range yourself and review from the raw evidence. Never skip or shorten a review because a summary was unavailable. Record which fallback you took: a subagent that could not load the watch tools is a misconfiguration worth naming in your report, and it is not the same as a spawn that errored or timed out. Then close the review by calling thread_evidence_report exactly once, after the last page: pass the watched thread id, the same fixed throughSequence the first review page returned - not lastSequence and not the final page's nextAfterSequence, because the server pairs the report to the read by that exact number - the first and last sequence you actually covered, the model you spawned on, and outcome summarized with the subagent's exact returned text, fallback when you read the raw range yourself, or failed when the summarizer could not run or could not report - with the reason in your own words for the last two. Report even when the summary never arrived; a review with no report cannot be told apart from a supervisor that never tried. Never paste builder tool output into it.`;
+const FUSION_WATCHER_INSTRUCTIONS = `You are Fusion Supervisor (watcher) in an already-created native server pair. Follow the current turn's [fusion-review-policy] block when present; it overrides phase scheduling. Server owns pairing and coordination and wakes you with ${FUSION_REVIEW_PROMPT_PREFIX} or ${FUSION_GATE_PROMPT_PREFIX} prompts at builder turn boundaries. A plain message outside such a wake may arrive after your conversational memory of the pair is gone; its [fusion-pair] metadata block is authoritative: the builder thread exists and is the counterpart thread id. Never report that no builder thread exists. For a new pair, the initial user request is yours, and its first turn is research, not relay. Research it: when the request names a ticket, read that ticket AND its comments, including replies and inline comments, and treat a later comment as newer intent than the description; read the code, docs, project instructions, and current state the request touches. Analyse what you found: root cause or the concrete design constraint, scope, what the user actually wants delivered, and which delivery steps they authorized. Only then write the phase plan and direct its first phase. The plan is yours alone: call thread_plan_update with the builder's threadId, sending the complete ordered list every time, each phase named in 3-6 words by its outcome rather than by a command, file path, or flag, with exactly one in progress. Split it into the fewest substantial phases the task genuinely needs plus a final integration/whole-task phase; most tasks need one to three work phases, each a complete reviewable slice of behavior. Never split per file, per function, or per trivial step. State each phase's completion condition to the builder in the advice, not in the banner title. On every later review, rewrite the same plan: an approved phase becomes completed and the next becomes in progress in the same call, an objection leaves the current phase in progress or reopens a phase you had marked completed, and the final approval completes the last phase. The builder never touches it, so a phase you do not move stays where it is. Then direct the phase to the idle builder through thread_advise, stating the findings that make the direction actionable alongside the original requirements, constraints, and authorized delivery scope. Never echo the request back as its own direction, never hand over a plan you did not ground in evidence, and never send ${FUSION_NO_OBJECTION_TEXT} before the builder has received its first phase and produced a turn to review. The builder has not received the initial prompt and must not start before your direction. Missing builder turn evidence is expected before that first direction; do not wait for it or implement the work yourself. Ask the user only when needed to resolve a blocking requirement. ${FUSION_WATCHER_TOOL_INSTRUCTIONS} To resume supervision, read builder evidence with thread_watch_review from lastReviewedImplementerSequence, capture its throughSequence on the first page and reuse that fixed bound while paging with nextAfterSequence until hasMore is false (including empty pages). Apply message append/replace operations by identity; recover truncated evidence through targeted raw thread_watch_events source ranges. Retain reviewed requirements and evidence for final review; recover missing context with targeted history reads rather than mandatory raw replay from zero, derive phase from artifacts (git log/status, PR, builder events, including its turn.plan.updated phase list), steer with thread_advise, and answer an open gate with thread_gate_respond. When a review or gate wake prompt specifies an explicit event range, that range wins over this metadata. Never poll or wait for the builder; deliver review or advice, then end the turn. Every thread_advise starts a builder turn whose completion wakes you again, so never advise a builder that is idle on an external wait or has nothing actionable; report the state in your own thread and end without advising. ${FUSION_PAIR_COMMUNICATION_INSTRUCTIONS}`;
 /**
 * The one-line stand-in for the full block on a message whose session already
 * carries the role instructions.
@@ -59119,10 +59325,20 @@ function resolveFusionSummarizerSelection(settings) {
 function summarizerModelLine(model) {
 	return model === null ? "No summarizer model is configured for this provider, so read the range yourself." : `Spawn that subagent on ${model}, a cheap fast model of your own provider.`;
 }
+/**
+* What a pair is told when the settings file cannot be read.
+*
+* Every field here has to match the shipped default of the setting it stands
+* in for, or an unreadable settings file silently changes what a pair is told -
+* which is the one thing the fallback exists to prevent. `evidenceSummary`
+* tracks `fusionEvidenceSummary` in `packages/contracts/src/settings.ts`, whose
+* decoding default is on; a test asserts the two stay equal.
+*/
 const DEFAULT_FUSION_PROMPT_SETTINGS = {
 	promptOverrides: null,
 	summarizerModel: null,
-	evidenceSummary: false
+	evidenceSummary: true,
+	optimizedContext: DEFAULT_SERVER_SETTINGS.enableOptimizedFusionPromptDelivery
 };
 /**
 * @param options.promptOverrides - The user's settings. An override replaces
@@ -59153,10 +59369,165 @@ function fusionRoleInstructionsWith(role, provider, settings) {
 		...provider === void 0 ? {} : { provider },
 		summarizerModelOverride: settings?.summarizerModel ?? null,
 		promptOverrides: settings?.promptOverrides ?? null,
-		evidenceSummary: settings?.evidenceSummary ?? false
+		evidenceSummary: settings?.evidenceSummary ?? DEFAULT_FUSION_PROMPT_SETTINGS.evidenceSummary
 	});
 }
 //#endregion
+//#region src/provider/FusionContextPolicy.ts
+/**
+* What a Fusion role is allowed to carry into its context.
+*
+* A pair pays for its context twice: once in the builder's window and once in
+* the supervisor's, on every turn of a review loop. Measured on a live pair,
+* the builder's session opened with 107,320 tokens of MCP tool definitions, of
+* which 86,005 belonged to servers neither role can use, plus 13,270 tokens of
+* global memory files. None of that is the user's task.
+*
+* The policy is provider-neutral on purpose: it says what a role may carry,
+* and each adapter expresses it with whatever native control it has. An
+* adapter that cannot express a rule keeps the baseline rather than pretending,
+* which is why the exported helpers are pure and the adapters stay the only
+* place that knows how a given CLI is configured.
+*
+* All of it is gated on the user's existing Fusion context optimization
+* setting, which is therefore the rollback: off reproduces today's context
+* byte for byte, for both roles and for every ordinary thread.
+*
+* @module provider/FusionContextPolicy
+*/
+/**
+* The four constraints that must survive losing global memory.
+*
+* Deliberately not a copy of the user's `CLAUDE.md`: that file is thousands of
+* tokens of preference, and only these four are things a wrong answer cannot be
+* walked back from. Everything else a pair needs is in the project's own
+* instructions, which this policy never drops.
+*/
+const FUSION_SAFETY_KERNEL = [
+	"Safety rules for this session, which override any default behaviour:",
+	"- Never commit secrets or .env files, and never delete a file without explicit confirmation in the current turn.",
+	"- Only touch work this session created. Never revert, stash, or overwrite uncommitted changes belonging to another session, and stage explicit paths rather than everything.",
+	"- Never commit, push, or open a pull request unless the current turn asked for it, and never commit to main or master directly.",
+	"- Never add AI attribution to a commit message, pull request, issue, comment, code, or document."
+].join("\n");
+/** Everything the supervisor half needs from the P4 MCP server, and nothing else. */
+const FUSION_SUPERVISOR_P4_TOOLS = /* @__PURE__ */ new Set([
+	"thread_watch_review",
+	"thread_watch_events",
+	"thread_evidence_report",
+	"thread_advise",
+	"thread_gate_respond",
+	"thread_plan_update",
+	"ask_user_question",
+	"task_current"
+]);
+/**
+* What the builder half must not reach.
+*
+* Framed as a denial rather than an allowance because the builder's job is
+* open-ended: it needs coding, verification and preview tools, and a new one of
+* those should reach it without an edit here. What it must never have is the
+* pair's own machinery - spawning threads, creating or detaching pairs,
+* advising, answering its own gate - the phase plan, which the supervisor
+* owns outright, plus task-board mutation and the external services that
+* belong to a person rather than to an implementation turn.
+*/
+const FUSION_BUILDER_DENIED_P4_TOOLS = /* @__PURE__ */ new Set([
+	"thread_spawn",
+	"thread_pair_create",
+	"thread_pair_detach",
+	"thread_cleanup",
+	"thread_rename",
+	"thread_configure",
+	"thread_snooze",
+	"thread_settle",
+	"thread_advise",
+	"thread_gate_respond",
+	"thread_plan_update",
+	"task_create",
+	"task_update",
+	"task_propose",
+	"memory_append",
+	"ticket_resolve"
+]);
+/**
+* Native planning tools the builder must not see either.
+*
+* The MCP denial above is only half of it: every provider ships its own
+* step-tracking tool, and a builder holding one would keep authoring the plan
+* the supervisor now owns. Named per provider because the names are the
+* provider's, not ours.
+*/
+const FUSION_BUILDER_DENIED_NATIVE_TOOLS = [
+	"TaskCreate",
+	"TaskUpdate",
+	"TaskGet",
+	"TaskList",
+	"TodoWrite",
+	"update_plan"
+];
+/**
+* What an adapter assumes when no optimization resolver was supplied.
+*
+* Mirrors the shipped setting rather than defaulting to off, so a driver that
+* has not been wired yet does not silently disable the profile.
+*/
+const DEFAULT_FUSION_CONTEXT_OPTIMIZATION = DEFAULT_SERVER_SETTINGS.enableOptimizedFusionPromptDelivery;
+/** The policy input, for adapters that read the two values separately. */
+function fusionContextPolicyFor(role, optimizedContext) {
+	return {
+		role,
+		optimizedContext
+	};
+}
+/** Whether the lean profile applies at all. Ordinary threads never reach it. */
+function fusionLeanContextApplies(input) {
+	return input.role !== void 0 && input.optimizedContext;
+}
+/**
+* The external MCP registrations a Fusion session keeps: none.
+*
+* Everything a user registered for their own work goes, because neither role
+* can act on it during a pair turn and every definition is paid for on every
+* turn of the loop. Computer Use needs no exception here - it is a
+* provider-owned endpoint attached only to a session that was granted it, not
+* a registration in this map, so a granted session keeps it either way.
+*/
+function fusionExternalMcpServers(servers, input) {
+	return fusionLeanContextApplies(input) ? {} : { ...servers };
+}
+/**
+* P4 tools this role must not see, given the full catalogue.
+*
+* Takes the catalogue rather than hard-coding it so a tool added to the server
+* is denied to the supervisor by default and offered to the builder by
+* default, which is the safe direction for each.
+*/
+function fusionHiddenP4Tools(catalogue, input) {
+	if (!fusionLeanContextApplies(input)) return [];
+	return input.role === "watcher" ? catalogue.filter((name) => !FUSION_SUPERVISOR_P4_TOOLS.has(name)) : catalogue.filter((name) => FUSION_BUILDER_DENIED_P4_TOOLS.has(name));
+}
+/**
+* Provider-native tools this role must not see.
+*
+* The supervisor keeps its own planning tool: it is the half that plans, and
+* for its own thread that tool is the ordinary one.
+*/
+function fusionHiddenNativeTools(input) {
+	return fusionLeanContextApplies(input) && input.role === "implementer" ? FUSION_BUILDER_DENIED_NATIVE_TOOLS : [];
+}
+/**
+* Setting sources a Fusion session reads.
+*
+* `user` carries the global memory files and the user-level skills; the
+* project's own instructions live in `project` and `local` and stay, because
+* they are the ones that describe the code being changed.
+*/
+function fusionSettingSources(sources, input) {
+	if (!fusionLeanContextApplies(input)) return sources;
+	return sources.filter((source) => source !== "user");
+}
+//#endregion
 //#region src/provider/ProviderOwnedProcessRegistry.ts
 /**
 * ProviderOwnedProcessRegistry - threadId to owned provider process handles.
@@ -61590,6 +61961,67 @@ function providerMcpEndpoints(config) {
 		authorizationHeader: config.computerUse.authorizationHeader
 	}] : []];
 }
+/**
+* Every tool the built-in `p4-code` server registers, by bare name.
+*
+* Declared rather than derived so an adapter can filter a session's tools
+* without importing the MCP server layer, which would drag the whole
+* orchestration graph into a provider process. `McpHttpServer.test.ts` asserts
+* this list equals what the toolkits actually register, so a tool added there
+* cannot silently go missing here.
+*/
+const P4CODE_MCP_TOOL_NAMES = [
+	"ask_user_question",
+	"asset_compress",
+	"device_action",
+	"device_close",
+	"device_command",
+	"device_inspect",
+	"device_list",
+	"device_open",
+	"device_screenshot",
+	"memory_append",
+	"preview_click",
+	"preview_evaluate",
+	"preview_navigate",
+	"preview_open",
+	"preview_press",
+	"preview_recording_start",
+	"preview_recording_stop",
+	"preview_resize",
+	"preview_save_screenshot",
+	"preview_scroll",
+	"preview_set_appearance",
+	"preview_snapshot",
+	"preview_status",
+	"preview_type",
+	"preview_wait_for",
+	"task_create",
+	"task_current",
+	"task_get",
+	"task_list",
+	"task_propose",
+	"task_update",
+	"thread_advise",
+	"thread_cleanup",
+	"thread_configure",
+	"thread_evidence_report",
+	"thread_gate_respond",
+	"thread_pair_create",
+	"thread_pair_detach",
+	"thread_plan_update",
+	"thread_rename",
+	"thread_settle",
+	"thread_snooze",
+	"thread_spawn",
+	"thread_watch_events",
+	"thread_watch_review",
+	"ticket_resolve"
+];
+/** The catalogue as the adapters read it. */
+function providerMcpToolNames() {
+	return P4CODE_MCP_TOOL_NAMES;
+}
 /** Non-Codex identities stay reserved even when their endpoint is disabled. */
 function providerMcpReservedNames() {
 	return /* @__PURE__ */ new Set([P4CODE_MCP_SERVER_NAME, COMPUTER_USE_MCP_SERVER_NAME]);
@@ -62279,7 +62711,7 @@ const makeAntigravityAdapter = Effect.fn("makeAntigravityAdapter")(function* (se
 				},
 				clientFileSystem: true,
 				...Option.isSome(cursor) ? { resumeSessionId: cursor.value.sessionId } : {},
-				mcpServers: antigravitySessionMcpServers(mcp, options.resolveMcpServers ? yield* options.resolveMcpServers : {}),
+				mcpServers: antigravitySessionMcpServers(mcp, fusionExternalMcpServers(options.resolveMcpServers ? yield* options.resolveMcpServers : {}, fusionContextPolicyFor(input.fusionRole, options.resolveFusionContextOptimization === void 0 ? DEFAULT_FUSION_CONTEXT_OPTIMIZATION : yield* options.resolveFusionContextOptimization))),
 				...makeNativeLoggers({
 					nativeEventLogger: options.nativeEventLogger,
 					provider: PROVIDER$7,
@@ -64621,6 +65053,7 @@ const AntigravityDriver = {
 			continuation: { groupKey: continuationIdentity.continuationKey }
 		});
 		const mcpRegistry = yield* McpRegistry;
+		const serverSettings = yield* ServerSettingsService;
 		const classifyModels = (draft) => modelManifest.current.pipe(Effect.map((manifest) => stampIdentity(applyModelManifest(draft, manifest, DRIVER))));
 		const makeRuntime = Effect.fn("AntigravityDriver.makeRuntime")(function* (input) {
 			if (authConfigIssue !== null) return yield* new ProviderSetupError({
@@ -64734,6 +65167,7 @@ const AntigravityDriver = {
 			makeRuntime,
 			withProcess: authFlow.withProcess,
 			resolveMcpServers: mcpRegistry.resolveForSession,
+			resolveFusionContextOptimization: serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableOptimizedFusionPromptDelivery), Effect.orElseSucceed(() => DEFAULT_FUSION_CONTEXT_OPTIMIZATION)),
 			defaultModel,
 			onSessionStarted: provider.onSessionStarted,
 			onConfigOptionsUpdated: provider.onConfigOptionsUpdated,
@@ -69266,13 +69700,19 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			...skillOverrides ? { skillOverrides } : {}
 		};
 		const mcpSession = readMcpProviderSession(input.threadId);
-		const externalMcpServers = Object.fromEntries(Object.entries(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers(input.cwd)).filter(([name]) => !providerMcpReservedNames().has(name)));
+		const registeredMcpServers = Object.fromEntries(Object.entries(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers(input.cwd)).filter(([name]) => !providerMcpReservedNames().has(name)));
 		const narrateBeforeTools = options?.resolveToolCallNarration === void 0 ? DEFAULT_SERVER_SETTINGS.enableToolCallNarration : yield* options.resolveToolCallNarration;
 		const guardrailSettings = options?.resolveGuardrailPrompts === void 0 ? {
 			enableVerificationBeforeCompletion: DEFAULT_SERVER_SETTINGS.enableVerificationBeforeCompletion,
 			enableRootCauseBeforeFix: DEFAULT_SERVER_SETTINGS.enableRootCauseBeforeFix
 		} : yield* options.resolveGuardrailPrompts;
 		const fusionPromptSettings = options?.resolveFusionPromptSettings === void 0 ? void 0 : yield* options.resolveFusionPromptSettings;
+		const fusionContextPolicy = {
+			role: input.fusionRole,
+			optimizedContext: fusionPromptSettings?.optimizedContext ?? DEFAULT_FUSION_PROMPT_SETTINGS.optimizedContext
+		};
+		const externalMcpServers = fusionExternalMcpServers(registeredMcpServers, fusionContextPolicy);
+		const hiddenTools = [...fusionHiddenP4Tools(providerMcpToolNames(), fusionContextPolicy).map((name) => `mcp__${P4CODE_MCP_SERVER_NAME}__${name}`), ...fusionHiddenNativeTools(fusionContextPolicy)];
 		const unpromptedSubagents = input.unpromptedSubagents !== void 0 ? input.unpromptedSubagents : options?.resolveUnpromptedSubagents === void 0 ? DEFAULT_SERVER_SETTINGS.enableUnpromptedSubagents : yield* options.resolveUnpromptedSubagents;
 		const compressRuleset = compressRulesetFor(input.compressMode ?? "off");
 		const systemPromptAppend = [
@@ -69281,8 +69721,9 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 			...narrateBeforeTools ? [NARRATE_BEFORE_TOOLS_PROMPT] : [],
 			...guardrailPromptsFor(guardrailSettings),
 			unpromptedSubagents ? SUBAGENTS_ALLOWED_PROMPT : SUBAGENTS_ON_REQUEST_PROMPT,
-			...compressRuleset !== void 0 ? [compressRuleset] : [],
-			...input.fusionRole !== void 0 ? [fusionRoleInstructionsWith(input.fusionRole, "claudeAgent", fusionPromptSettings)] : []
+			...input.fusionRole !== void 0 ? [fusionRoleInstructionsWith(input.fusionRole, "claudeAgent", fusionPromptSettings)] : [],
+			...fusionLeanContextApplies(fusionContextPolicy) ? [FUSION_SAFETY_KERNEL] : [],
+			...compressRuleset !== void 0 ? [compressRuleset] : []
 		].join("\n\n");
 		const compressionSubagentHook = async (hookInput) => {
 			if (hookInput.hook_event_name !== "SubagentStart") return {};
@@ -69301,7 +69742,8 @@ const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (claudeSettin
 				preset: "claude_code",
 				...systemPromptAppend.length > 0 ? { append: systemPromptAppend } : {}
 			},
-			settingSources: [...CLAUDE_SETTING_SOURCES],
+			settingSources: [...fusionSettingSources(CLAUDE_SETTING_SOURCES, fusionContextPolicy)],
+			...hiddenTools.length > 0 ? { disallowedTools: hiddenTools } : {},
 			...effectiveEffort ? { effort: effectiveEffort } : {},
 			...permissionMode ? { permissionMode } : {},
 			...permissionMode === "bypassPermissions" ? { allowDangerouslySkipPermissions: true } : {},
@@ -69710,7 +70152,8 @@ const ClaudeDriver = {
 			resolveFusionPromptSettings: serverSettings.getSettings.pipe(Effect.map((settings) => ({
 				promptOverrides: settings.fusionPromptOverrides,
 				summarizerModel: resolveFusionSummarizerSelection(settings),
-				evidenceSummary: settings.fusionEvidenceSummary
+				evidenceSummary: settings.fusionEvidenceSummary,
+				optimizedContext: settings.enableOptimizedFusionPromptDelivery
 			})), Effect.orElseSucceed(() => DEFAULT_FUSION_PROMPT_SETTINGS)),
 			resolveUnpromptedSubagents: serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableUnpromptedSubagents), Effect.orElseSucceed(() => DEFAULT_SERVER_SETTINGS.enableUnpromptedSubagents)),
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
@@ -89079,8 +89522,11 @@ function buildCodexDeveloperInstructions(interactionMode, runtime, compressMode,
 	return [
 		browserToolsAvailable ? base : base.replace(P4_CODE_BROWSER_TOOL_INSTRUCTIONS, ""),
 		...guardrailPromptsFor(guardrailSettings),
+		...fusionRole === void 0 ? [] : [`<fusion_role>${fusionRoleInstructionsWith(fusionRole, "codex", fusionPromptSettings)}</fusion_role>`, ...fusionLeanContextApplies({
+			role: fusionRole,
+			optimizedContext: fusionPromptSettings?.optimizedContext ?? DEFAULT_FUSION_PROMPT_SETTINGS.optimizedContext
+		}) ? [`<safety_rules>${FUSION_SAFETY_KERNEL}</safety_rules>`] : []],
 		...compressRuleset === void 0 ? [] : [`<response_style>${compressRuleset}</response_style>`],
-		...fusionRole === void 0 ? [] : [`<fusion_role>${fusionRoleInstructionsWith(fusionRole, "codex", fusionPromptSettings)}</fusion_role>`],
 		`<runtime_info>In case you're asked: you are running in P4Code through the Codex harness, as ${toSingleLine(runtime.model)} with ${toSingleLine(runtime.reasoningEffort)} reasoning effort. No need to mention this otherwise.</runtime_info>`
 	].join("\n\n");
 }
@@ -90940,7 +91386,11 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 		if (existing && !existing.stopped) yield* Effect.suspend(() => stopSessionInternal(existing));
 		const serviceTier = input.modelSelection?.instanceId === boundInstanceId ? getCodexServiceTierOptionValue(input.modelSelection) : void 0;
 		const mcpSession = readMcpProviderSession(input.threadId);
-		const externalMcp = toCodexMcpConfig(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, P4CODE_MCP_SERVER_NAMES);
+		const resolvedFusionPromptSettings = options?.resolveFusionPromptSettings === void 0 ? void 0 : yield* options.resolveFusionPromptSettings;
+		const externalMcp = toCodexMcpConfig(fusionExternalMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, {
+			role: input.fusionRole,
+			optimizedContext: resolvedFusionPromptSettings?.optimizedContext ?? DEFAULT_FUSION_PROMPT_SETTINGS.optimizedContext
+		}), P4CODE_MCP_SERVER_NAMES);
 		for (const dropped of externalMcp.skipped) yield* Effect.logWarning("codex cannot express an mcp registration", {
 			server: dropped.name,
 			reason: dropped.reason
@@ -90949,7 +91399,6 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 			enableVerificationBeforeCompletion: DEFAULT_SERVER_SETTINGS.enableVerificationBeforeCompletion,
 			enableRootCauseBeforeFix: DEFAULT_SERVER_SETTINGS.enableRootCauseBeforeFix
 		} : yield* options.resolveGuardrailPrompts;
-		const resolvedFusionPromptSettings = options?.resolveFusionPromptSettings === void 0 ? void 0 : yield* options.resolveFusionPromptSettings;
 		const guardrailPromptsEnabled = resolvedGuardrailPrompts.enableVerificationBeforeCompletion || resolvedGuardrailPrompts.enableRootCauseBeforeFix;
 		const runtimeInput = {
 			...options?.onUsageLimits ? { onUsageLimits: options.onUsageLimits } : {},
@@ -91509,7 +91958,8 @@ const CodexDriver = {
 		const resolveFusionPromptSettings = serverSettings.getSettings.pipe(Effect.map((settings) => ({
 			promptOverrides: settings.fusionPromptOverrides,
 			summarizerModel: resolveFusionSummarizerSelection(settings),
-			evidenceSummary: settings.fusionEvidenceSummary
+			evidenceSummary: settings.fusionEvidenceSummary,
+			optimizedContext: settings.enableOptimizedFusionPromptDelivery
 		})), Effect.orElseSucceed(() => DEFAULT_FUSION_PROMPT_SETTINGS));
 		const textGeneration = yield* makeCodexTextGeneration(effectiveConfig, processEnv);
 		const checkProvider = checkCodexProviderStatus(effectiveConfig, void 0, processEnv).pipe(Effect.map(stampIdentity), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner), Effect.provideService(FileSystem.FileSystem, fileSystem));
@@ -92700,7 +93150,7 @@ function makeCursorAdapter(cursorSettings, options) {
 			});
 			const effectiveCursorSettings = options?.resolveSettings ? yield* options.resolveSettings : cursorSettings;
 			const mcpSession = readMcpProviderSession(input.threadId);
-			const mcpServers = [...toAcpMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, providerMcpReservedNames()), ...providerMcpEndpoints(mcpSession).map((entry) => ({
+			const mcpServers = [...toAcpMcpServers(fusionExternalMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, fusionContextPolicyFor(input.fusionRole, options?.resolveFusionContextOptimization === void 0 ? DEFAULT_FUSION_CONTEXT_OPTIMIZATION : yield* options.resolveFusionContextOptimization)), providerMcpReservedNames()), ...providerMcpEndpoints(mcpSession).map((entry) => ({
 				type: "http",
 				name: entry.name,
 				url: entry.url,
@@ -93207,6 +93657,7 @@ const CursorDriver = {
 		const adapter = yield* makeCursorAdapter(effectiveConfig, {
 			environment: processEnv,
 			resolveMcpServers: (yield* McpRegistry).resolveForSession,
+			resolveFusionContextOptimization: serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableOptimizedFusionPromptDelivery), Effect.orElseSucceed(() => DEFAULT_FUSION_CONTEXT_OPTIMIZATION)),
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {},
 			instanceId
 		});
@@ -93962,7 +94413,7 @@ function makeGrokAdapter(grokSettings, options) {
 				threadId: input.threadId
 			});
 			const mcpSession = readMcpProviderSession(input.threadId);
-			const mcpServers = [...toAcpMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, providerMcpReservedNames()), ...providerMcpEndpoints(mcpSession).map((entry) => ({
+			const mcpServers = [...toAcpMcpServers(fusionExternalMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, fusionContextPolicyFor(input.fusionRole, options?.resolveFusionContextOptimization === void 0 ? DEFAULT_FUSION_CONTEXT_OPTIMIZATION : yield* options.resolveFusionContextOptimization)), providerMcpReservedNames()), ...providerMcpEndpoints(mcpSession).map((entry) => ({
 				type: "http",
 				name: entry.name,
 				url: entry.url,
@@ -94806,6 +95257,7 @@ const GrokDriver = {
 		const adapter = yield* makeGrokAdapter(effectiveConfig, {
 			environment: processEnv,
 			resolveMcpServers: (yield* McpRegistry).resolveForSession,
+			resolveFusionContextOptimization: serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableOptimizedFusionPromptDelivery), Effect.orElseSucceed(() => DEFAULT_FUSION_CONTEXT_OPTIMIZATION)),
 			...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {},
 			instanceId
 		});
@@ -95995,7 +96447,7 @@ function makeMuseAdapter(museSettings, options) {
 					authorizationHeader: mcpSession.authorizationHeader
 				},
 				additionalOwnedServers: providerMcpEndpoints(mcpSession).filter((entry) => entry.name !== P4CODE_MCP_SERVER_NAME),
-				externalServers: options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers
+				externalServers: fusionExternalMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, fusionContextPolicyFor(input.fusionRole, options?.resolveFusionContextOptimization === void 0 ? DEFAULT_FUSION_CONTEXT_OPTIMIZATION : yield* options.resolveFusionContextOptimization))
 			}).pipe(Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path$1.Path, path), Effect.orElseSucceed(() => void 0)) : void 0;
 			if (overlay && overlay.skippedServers.length > 0) yield* Effect.logWarning("Muse cannot express these MCP servers", {
 				threadId: input.threadId,
@@ -96505,7 +96957,8 @@ const MuseDriver = {
 		const adapter = yield* makeMuseAdapter(effectiveConfig, {
 			environment: processEnv,
 			instanceId,
-			resolveMcpServers: (yield* McpRegistry).resolveForSession
+			resolveMcpServers: (yield* McpRegistry).resolveForSession,
+			resolveFusionContextOptimization: serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableOptimizedFusionPromptDelivery), Effect.orElseSucceed(() => DEFAULT_FUSION_CONTEXT_OPTIMIZATION))
 		});
 		const textGeneration = yield* makeMuseTextGeneration(effectiveConfig, processEnv);
 		const checkProvider = serverSettings.getSettings.pipe(Effect.map((settings) => settings.disabledSkills), Effect.orElseSucceed(() => [])).pipe(Effect.flatMap((disabledSkills) => checkMuseProviderStatus(effectiveConfig, processEnv).pipe(Effect.flatMap((draft) => withProviderSkills(draft, {
@@ -98079,7 +98532,7 @@ function makeOpenCodeAdapter(openCodeSettings, options) {
 					});
 					const mcpSession = readMcpProviderSession(input.threadId);
 					if (!server.external) {
-						const externalMcpServers = toOpenCodeMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, providerMcpReservedNames());
+						const externalMcpServers = toOpenCodeMcpServers(fusionExternalMcpServers(options?.resolveMcpServers === void 0 ? {} : yield* options.resolveMcpServers, fusionContextPolicyFor(input.fusionRole, options?.resolveFusionContextOptimization === void 0 ? DEFAULT_FUSION_CONTEXT_OPTIMIZATION : yield* options.resolveFusionContextOptimization)), providerMcpReservedNames());
 						for (const entry of externalMcpServers) yield* runOpenCodeSdk("mcp.add", () => client.mcp.add(entry)).pipe(Effect.catchCause((cause) => Effect.logWarning("opencode rejected an mcp registration", {
 							server: entry.name,
 							cause
@@ -98814,6 +99267,7 @@ const BUILT_IN_DRIVERS = [
 				instanceId,
 				environment: processEnv,
 				resolveMcpServers: (yield* McpRegistry).resolveForSession,
+				resolveFusionContextOptimization: serverSettings.getSettings.pipe(Effect.map((settings) => settings.enableOptimizedFusionPromptDelivery), Effect.orElseSucceed(() => DEFAULT_FUSION_CONTEXT_OPTIMIZATION)),
 				...eventLoggers.native ? { nativeEventLogger: eventLoggers.native } : {}
 			});
 			const textGeneration = yield* makeOpenCodeTextGeneration(effectiveConfig, processEnv);
@@ -132527,14 +132981,14 @@ const resolveSpawnModelSelection = (requested, inherited) => requested === void
 };
 const ThreadToolkitHandlersLive = ThreadToolkit.toLayer({
 	thread_plan_update: (input) => Effect.gen(function* () {
-		const { threadId } = yield* requireThreadCapability();
-		const threads = yield* ProjectionThreadRepository;
+		const invocation = yield* requireThreadCapability();
 		const reject = (detail) => new ThreadControlRejectedError({
-			threadId,
+			threadId: invocation.threadId,
 			commandType: "thread.activity.append",
 			detail
 		});
-		const thread = yield* threads.getById({ threadId }).pipe(Effect.mapError((cause) => reject(cause.message)));
+		const threadId = input.threadId === void 0 || input.threadId === invocation.threadId ? invocation.threadId : yield* requireWatchCapability(input.threadId).pipe(Effect.as(input.threadId), Effect.catch(() => reject("This session may not update that thread's plan")));
+		const thread = yield* (yield* ProjectionThreadRepository).getById({ threadId }).pipe(Effect.mapError((cause) => reject(cause.message)));
 		if (Option.isNone(thread)) return yield* reject("Current thread does not exist.");
 		if (input.plan.filter((step) => step.status === "in_progress").length > 1) return yield* reject("At most one phase may be in progress.");
 		const crypto = yield* Crypto.Crypto;
@@ -133470,19 +133924,19 @@ const estimateTokens = (text) => Math.ceil(text.length / 4);
 /** One line per event is plenty to answer "did anything reviewable happen". */
 const MAX_LINE_CHARS = 400;
 const oneLine = (text) => text.replace(/\s+/gu, " ").trim();
-const clip = (text) => text.length <= MAX_LINE_CHARS ? text : `${text.slice(0, MAX_LINE_CHARS)}…`;
+const clip$1 = (text) => text.length <= MAX_LINE_CHARS ? text : `${text.slice(0, MAX_LINE_CHARS)}…`;
 /** The line an event contributes, or null when it says nothing about the work. */
 function describeEvent(event, implementerThreadId) {
 	switch (event.type) {
 		case "thread.message-sent": {
 			if (event.payload.threadId !== implementerThreadId) return null;
 			const text = oneLine(event.payload.text);
-			return text.length === 0 ? null : clip(`${event.payload.role}: ${text}`);
+			return text.length === 0 ? null : clip$1(`${event.payload.role}: ${text}`);
 		}
 		case "thread.activity-appended": {
 			if (event.payload.threadId !== implementerThreadId) return null;
 			const activity = event.payload.activity;
-			return clip(oneLine(`${activity.kind}: ${activity.summary}`));
+			return clip$1(oneLine(`${activity.kind}: ${activity.summary}`));
 		}
 		case "thread.turn-completed":
 			if (event.payload.threadId !== implementerThreadId) return null;
@@ -133603,10 +134057,32 @@ const ThreadWatchReviewTool = Tool.make("thread_watch_review", {
 		McpInvocationContext,
 		ThreadEventStreamService,
 		OrchestrationEngineService,
+		ProjectionSnapshotQuery,
+		Crypto.Crypto
+	]
+}).annotate(Tool.Title, "Read compact thread review").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
+/**
+* What the supervisor says happened to the evidence it just read.
+*
+* Without it the review path is unobservable: a summarized read, a raw
+* fallback and a supervisor that never spawned anything all look identical
+* from outside. The context numbers are not taken from the report - the server
+* reads them off the reporting thread's own context-window rows - so the one
+* number a supervisor could be wrong about is the one it does not supply.
+*/
+const ThreadEvidenceReportTool = Tool.make("thread_evidence_report", {
+	description: "Report what happened to the builder evidence you just read: outcome summarized with the summarizer's exact text, fallback when you read the raw range yourself, or failed when the summarizer could not run or report. Give the sequence range you covered and the model you spawned on. Call it once per review, after the last page. The server records it and correlates your own context usage; do not include builder tool output.",
+	parameters: ThreadEvidenceReportInput,
+	success: ThreadEvidenceReportResult,
+	failure: ThreadWatchToolError,
+	dependencies: [
+		McpInvocationContext,
+		OrchestrationEngineService,
+		ProjectionSnapshotQuery,
 		Crypto.Crypto
 	]
-}).annotate(Tool.Title, "Read compact thread review").annotate(Tool.Readonly, true).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, true);
-const WatchToolkit = Toolkit.make(ThreadWatchEventsTool, ThreadWatchReviewTool);
+}).annotate(Tool.Title, "Report evidence summary").annotate(Tool.Readonly, false).annotate(Tool.Destructive, false).annotate(Tool.Idempotent, false);
+const WatchToolkit = Toolkit.make(ThreadWatchEventsTool, ThreadWatchReviewTool, ThreadEvidenceReportTool);
 //#endregion
 //#region src/mcp/toolkits/watch/handlers.ts
 /**
@@ -133618,6 +134094,15 @@ const WatchToolkit = Toolkit.make(ThreadWatchEventsTool, ThreadWatchReviewTool);
 * appending beside it.
 */
 const evidenceActivityId = (watchedThreadId, throughSequence) => EventId.make(`fusion-evidence:${watchedThreadId}:${throughSequence}`);
+/** One report per review, keyed like the read it reports on so a retry replaces. */
+const reportActivityId = (watchedThreadId, lastSequence) => EventId.make(`fusion-evidence-summary:${watchedThreadId}:${lastSequence}`);
+const MODEL_ID_MAX_CHARS = 120;
+/** Plain words, because the client capitalizes and renders them as the row heading. */
+const REPORT_HEADING = {
+	summarized: "Evidence summary",
+	fallback: "Evidence read raw",
+	failed: "Evidence summary failed"
+};
 /**
 * Records that the supervisor read the builder's evidence, in its own thread.
 *
@@ -133628,7 +134113,10 @@ const evidenceActivityId = (watchedThreadId, throughSequence) => EventId.make(`f
 const recordEvidenceRead = Effect.fn("mcp.watch.recordEvidenceRead")(function* (readerThreadId, page) {
 	const engine = yield* OrchestrationEngineService;
 	const crypto = yield* Crypto.Crypto;
+	const projections = yield* ProjectionSnapshotQuery;
 	const createdAt = DateTime.formatIso(yield* DateTime.now);
+	const recorded = yield* projections.getEvidenceReadContext(evidenceActivityId(page.threadId, page.throughSequence)).pipe(Effect.orElseSucceed(() => Option.none()));
+	const usedTokensAtRead = Option.isSome(recorded) ? recorded.value : yield* projections.getLatestThreadContextWindow(readerThreadId).pipe(Effect.map(Option.map((row) => row.usedTokens)), Effect.orElseSucceed(() => Option.none()), Effect.map(Option.getOrNull));
 	yield* engine.dispatch({
 		type: "thread.activity.append",
 		commandId: CommandId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)),
@@ -133646,7 +134134,8 @@ const recordEvidenceRead = Effect.fn("mcp.watch.recordEvidenceRead")(function* (
 				throughSequence: page.throughSequence,
 				nextAfterSequence: page.nextAfterSequence,
 				hasMore: page.hasMore,
-				scannedEvents: page.scannedEvents
+				scannedEvents: page.scannedEvents,
+				...usedTokensAtRead === null ? {} : { usedTokensAtRead }
 			}
 		}
 	}).pipe(Effect.catchCause((cause) => Effect.logWarning("could not record the supervisor's evidence read", {
@@ -133655,6 +134144,36 @@ const recordEvidenceRead = Effect.fn("mcp.watch.recordEvidenceRead")(function* (
 		cause
 	})));
 });
+/** Bounded so one report cannot dominate a thread's activity storage. */
+const clip = (value, limit) => {
+	const trimmed = value?.trim();
+	if (!trimmed) return null;
+	return trimmed.length <= limit ? trimmed : `${trimmed.slice(0, limit)}…`;
+};
+/**
+* The reporting thread's own context around the read it is reporting on.
+*
+* `before` comes off the evidence-read activity rather than the report, so the
+* pair of numbers brackets the ingestion instead of describing only the moment
+* the supervisor got around to reporting. A thread with no context-window row
+* yet yields null rather than a zero that would read as a real measurement.
+*/
+const correlateContext = Effect.fn("mcp.watch.correlateContext")(function* (readerThreadId, readActivityId) {
+	const projections = yield* ProjectionSnapshotQuery;
+	const latest = yield* projections.getLatestThreadContextWindow(readerThreadId).pipe(Effect.orElseSucceed(() => Option.none()));
+	const before = yield* projections.getEvidenceReadContext(readActivityId).pipe(Effect.orElseSucceed(() => Option.none()));
+	if (Option.isNone(latest)) return null;
+	const usedTokensAfter = latest.value.usedTokens;
+	const usedTokensBefore = Option.getOrNull(before);
+	const maxTokens = latest.value.maxTokens;
+	return {
+		usedTokensBefore,
+		usedTokensAfter,
+		deltaTokens: usedTokensBefore === null ? null : usedTokensAfter - usedTokensBefore,
+		maxTokens,
+		capacityPercent: maxTokens === null || maxTokens <= 0 ? null : Math.round(usedTokensAfter / maxTokens * 1e3) / 10
+	};
+});
 const WatchToolkitHandlersLive = WatchToolkit.toLayer({
 	thread_watch_review: (input) => Effect.gen(function* () {
 		const invocation = yield* requireWatchCapability(input.threadId);
@@ -133665,6 +134184,48 @@ const WatchToolkitHandlersLive = WatchToolkit.toLayer({
 		yield* recordEvidenceRead(invocation.threadId, page);
 		return page;
 	}),
+	thread_evidence_report: (input) => Effect.gen(function* () {
+		const invocation = yield* requireWatchCapability(input.threadId);
+		const engine = yield* OrchestrationEngineService;
+		const crypto = yield* Crypto.Crypto;
+		const createdAt = DateTime.formatIso(yield* DateTime.now);
+		const context = yield* correlateContext(invocation.threadId, evidenceActivityId(input.threadId, input.throughSequence));
+		const summary = clip(input.summary, THREAD_EVIDENCE_REPORT_MAX_CHARS);
+		const reason = clip(input.reason, 500);
+		const outcome = summary === null && input.outcome === "summarized" ? "failed" : input.outcome;
+		return {
+			recorded: yield* engine.dispatch({
+				type: "thread.activity.append",
+				commandId: CommandId.make(yield* crypto.randomUUIDv4.pipe(Effect.orDie)),
+				threadId: invocation.threadId,
+				createdAt,
+				activity: {
+					id: reportActivityId(input.threadId, input.throughSequence),
+					createdAt,
+					tone: outcome === "failed" ? "error" : "info",
+					kind: "fusion.evidence.summary",
+					summary: REPORT_HEADING[outcome],
+					turnId: null,
+					payload: {
+						watchedThreadId: input.threadId,
+						firstSequence: input.firstSequence,
+						lastSequence: input.lastSequence,
+						throughSequence: input.throughSequence,
+						outcome,
+						summary,
+						model: clip(input.model, MODEL_ID_MAX_CHARS),
+						reason: reason ?? (outcome === "summarized" ? null : "the supervisor gave no reason"),
+						context
+					}
+				}
+			}).pipe(Effect.as(true), Effect.catchCause((cause) => Effect.logWarning("could not record the supervisor's evidence report", {
+				readerThreadId: invocation.threadId,
+				watchedThreadId: input.threadId,
+				cause
+			}).pipe(Effect.as(false)))),
+			context
+		};
+	}),
 	thread_watch_events: (input) => Effect.gen(function* () {
 		yield* requireWatchCapability(input.threadId);
 		const page = yield* (yield* ThreadEventStreamService).read({
@@ -137405,7 +137966,8 @@ const make$6 = Effect.gen(function* () {
 		const fusionPromptSettings = yield* serverSettingsService.getSettings.pipe(Effect.map((value) => ({
 			promptOverrides: value.fusionPromptOverrides,
 			summarizerModel: resolveFusionSummarizerSelection(value),
-			evidenceSummary: value.fusionEvidenceSummary
+			evidenceSummary: value.fusionEvidenceSummary,
+			optimizedContext: value.enableOptimizedFusionPromptDelivery
 		})), Effect.catchCause(() => Effect.succeed(DEFAULT_FUSION_PROMPT_SETTINGS)));
 		const activeFusionPair = findActiveFusionPair(commandReadModel.threadPairs, input.threadId);
 		const fusionRole = activeFusionPair === void 0 ? void 0 : activeFusionPair.implementerThreadId === input.threadId ? "implementer" : "watcher";