@p4code/cli 0.5.14 → 0.5.16

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.14";
+var version$1 = "0.5.16";
 //#endregion
 //#region src/config.ts
 /**
@@ -12885,11 +12885,11 @@ const ThreadWatchReviewResult = Schema$1.Struct({
 /**
 * 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
+* Three 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.
+* full context, and a failure is a misconfiguration worth fixing. The fourth
+* state - a read no report ever answered - is not sayable here: only the
+* server can observe it, through `ThreadEvidenceActivityOutcome`.
 */
 const ThreadEvidenceReportOutcome = Schema$1.Literals([
 	"summarized",
@@ -12942,19 +12942,52 @@ const ThreadEvidenceReportContext = Schema$1.Struct({
 	maxTokens: Schema$1.NullOr(NonNegativeInt),
 	capacityPercent: Schema$1.NullOr(Schema$1.Number)
 });
+/**
+* How the recorded row ended, which is the supervisor's three outcomes plus the
+* one only the server can state: the review closed with no report at all.
+*
+* `unreported` is never accepted from a tool call. The server writes it when a
+* supervisor turn ends over an evidence read that nothing answered, so the
+* absence survives outside a live client that could infer it from two rows.
+*/
+const ThreadEvidenceActivityOutcome = Schema$1.Literals([
+	"summarized",
+	"fallback",
+	"failed",
+	"unreported"
+]);
+/**
+* Server clock around one review, never the supervisor's own account of it.
+*
+* `readAt` is when the evidence-read row was recorded and `closedAt` when the
+* row that closes the review was: the report for a reported review, the
+* completed supervisor turn for an unreported one. A supervisor turn that
+* failed or was interrupted closes nothing, so its read keeps no timing until
+* some later turn reports on it.
+*/
+const ThreadEvidenceReportTiming = Schema$1.Struct({
+	readAt: IsoDateTime,
+	closedAt: IsoDateTime,
+	durationMs: NonNegativeInt
+});
 Schema$1.Struct({
 	watchedThreadId: ThreadId,
 	firstSequence: NonNegativeInt,
 	lastSequence: NonNegativeInt,
 	throughSequence: NonNegativeInt,
-	outcome: ThreadEvidenceReportOutcome,
+	outcome: ThreadEvidenceActivityOutcome,
 	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)
+	context: Schema$1.NullOr(ThreadEvidenceReportContext),
+	/**
+	* Null when the evidence-read row behind this review is no longer readable,
+	* and absent on rows stored before the server measured a review at all.
+	*/
+	timing: Schema$1.optionalKey(Schema$1.NullOr(ThreadEvidenceReportTiming))
 });
 const ThreadEvidenceReportResult = Schema$1.Struct({
 	recorded: Schema$1.Boolean,
@@ -41541,6 +41574,28 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           detached_at AS "detachedAt"
         FROM thread_pairs
         ORDER BY created_at ASC, pair_id ASC
+      `
+	});
+	const listActiveThreadPairRows = SqlSchema.findAll({
+		Request: Schema$1.Void,
+		Result: ProjectionThreadPairDbRowSchema,
+		execute: () => sql`
+        SELECT
+          pair_id AS "id",
+          implementer_thread_id AS "implementerThreadId",
+          watcher_thread_id AS "watcherThreadId",
+          last_reviewed_implementer_sequence AS "lastReviewedImplementerSequence",
+          triaged_from_sequence AS "triagedFromSequence",
+          activation_turn_id AS "activationTurnId",
+          round_cap AS "roundCap",
+          gate_timeout_ms AS "gateTimeoutMs",
+          review_experiment_json AS "reviewExperiment",
+          active_gate_json AS "activeGate",
+          created_at AS "createdAt",
+          detached_at AS "detachedAt"
+        FROM thread_pairs
+        WHERE detached_at IS NULL
+        ORDER BY created_at ASC, pair_id ASC
       `
 	});
 	const LatestContextWindowRow = Schema$1.Struct({
@@ -41562,15 +41617,137 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
         LIMIT 1
       `
 	});
-	const EvidenceReadContextRow = Schema$1.Struct({ usedTokensAtRead: Schema$1.Number });
+	const EvidenceReadContextRow = Schema$1.Struct({
+		usedTokensAtRead: Schema$1.NullOr(Schema$1.Number),
+		readAt: Schema$1.String,
+		afterSequence: Schema$1.NullOr(Schema$1.Number)
+	});
 	const getEvidenceReadContextRow = SqlSchema.findOneOption({
 		Request: Schema$1.String,
 		Result: EvidenceReadContextRow,
 		execute: (activityId) => sql`
-        SELECT json_extract(payload_json, '$.usedTokensAtRead') AS "usedTokensAtRead"
+        SELECT
+          CASE
+            WHEN json_extract(payload_json, '$.usedTokensAtRead') >= 0
+              THEN json_extract(payload_json, '$.usedTokensAtRead')
+            ELSE NULL
+          END AS "usedTokensAtRead",
+          created_at AS "readAt",
+          json_extract(payload_json, '$.afterSequence') AS "afterSequence"
         FROM projection_thread_activities
         WHERE activity_id = ${activityId}
-          AND json_extract(payload_json, '$.usedTokensAtRead') >= 0
+        LIMIT 1
+      `
+	});
+	const TurnStartRow = Schema$1.Struct({
+		threadId: ThreadId,
+		messageId: Schema$1.NullOr(Schema$1.String),
+		startedAt: Schema$1.NullOr(Schema$1.String)
+	});
+	/**
+	* The message a turn was started from, by the table's own key.
+	*
+	* Thread and turn together, because the unique key is the pair: a turn id is
+	* provider-supplied for some providers, and matching on it alone would let
+	* one provider's collision answer for another thread.
+	*/
+	const getTurnStartRow = SqlSchema.findOneOption({
+		Request: Schema$1.Struct({
+			threadId: ThreadId,
+			turnId: TurnId
+		}),
+		Result: TurnStartRow,
+		execute: (input) => sql`
+        SELECT
+          thread_id AS "threadId",
+          pending_message_id AS "messageId",
+          started_at AS "startedAt"
+        FROM projection_turns
+        WHERE thread_id = ${input.threadId}
+          AND turn_id = ${input.turnId}
+        LIMIT 1
+      `
+	});
+	/** The turn a thread's session is running, by the session projection's own row. */
+	const getActiveTurnIdRow = SqlSchema.findOneOption({
+		Request: ThreadId,
+		Result: Schema$1.Struct({ activeTurnId: Schema$1.NullOr(Schema$1.String) }),
+		execute: (threadId) => sql`
+        SELECT active_turn_id AS "activeTurnId"
+        FROM projection_thread_sessions
+        WHERE thread_id = ${threadId}
+        LIMIT 1
+      `
+	});
+	const ThreadMessageStampRow = Schema$1.Struct({
+		messageId: Schema$1.String,
+		createdAt: Schema$1.String
+	});
+	/**
+	* The newest message on a thread whose id starts with a prefix.
+	*
+	* The server names the messages it sends itself, so asking by id prefix asks
+	* what the server last sent - a question no turn row can be talked out of by
+	* whichever turn happened to adopt a pending start.
+	*/
+	const getLatestThreadMessageWithIdPrefixRow = SqlSchema.findOneOption({
+		Request: Schema$1.Struct({
+			threadId: ThreadId,
+			idPrefix: Schema$1.String
+		}),
+		Result: ThreadMessageStampRow,
+		execute: (input) => sql`
+        SELECT
+          message_id AS "messageId",
+          created_at AS "createdAt"
+        FROM projection_thread_messages
+        WHERE thread_id = ${input.threadId}
+          AND message_id LIKE ${`${input.idPrefix}%`} ESCAPE '\\'
+        ORDER BY created_at DESC, message_id DESC
+        LIMIT 1
+      `
+	});
+	const LatestEvidenceReadRow = Schema$1.Struct({
+		watchedThreadId: ThreadId,
+		afterSequence: Schema$1.NullOr(Schema$1.Number),
+		throughSequence: Schema$1.Number,
+		/** The supervisor turn that recorded the read, absent on rows written before it was stamped. */
+		turnId: Schema$1.NullOr(Schema$1.String),
+		readAt: Schema$1.String,
+		hasReport: Schema$1.Number
+	});
+	/**
+	* The newest evidence read on a thread, with whether a report answered it.
+	*
+	* Newest only: a supervisor that read again against a later bound superseded
+	* the earlier read rather than leaving it unanswered, which is the same
+	* pairing rule the client's own rows follow.
+	*/
+	const getLatestEvidenceReadRow = SqlSchema.findOneOption({
+		Request: ThreadId,
+		Result: LatestEvidenceReadRow,
+		execute: (threadId) => sql`
+        SELECT
+          json_extract(reads.payload_json, '$.watchedThreadId') AS "watchedThreadId",
+          json_extract(reads.payload_json, '$.afterSequence') AS "afterSequence",
+          json_extract(reads.payload_json, '$.throughSequence') AS "throughSequence",
+          json_extract(reads.payload_json, '$.turnId') AS "turnId",
+          reads.created_at AS "readAt",
+          EXISTS (
+            SELECT 1
+            FROM projection_thread_activities reports
+            WHERE reports.thread_id = reads.thread_id
+              AND reports.kind = 'fusion.evidence.summary'
+              AND json_extract(reports.payload_json, '$.watchedThreadId')
+                = json_extract(reads.payload_json, '$.watchedThreadId')
+              AND json_extract(reports.payload_json, '$.throughSequence')
+                = json_extract(reads.payload_json, '$.throughSequence')
+          ) AS "hasReport"
+        FROM projection_thread_activities reads
+        WHERE reads.thread_id = ${threadId}
+          AND reads.kind = 'fusion.evidence.read'
+          AND json_extract(reads.payload_json, '$.throughSequence') >= 0
+        ORDER BY reads.created_at DESC, reads.rowid DESC
         LIMIT 1
       `
 	});
@@ -43362,8 +43539,26 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		})) };
 	});
 	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 getEvidenceReadContext = (activityId) => getEvidenceReadContextRow(activityId).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getEvidenceReadContext:query", "ProjectionSnapshotQuery.getEvidenceReadContext:decodeRow")));
+	const getTurnStart = (threadId, turnId) => getTurnStartRow({
+		threadId,
+		turnId
+	}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getTurnStart:query", "ProjectionSnapshotQuery.getTurnStart:decodeRow")));
+	const getActiveTurnId = (threadId) => getActiveTurnIdRow(threadId).pipe(Effect.map(Option.flatMap((row) => Option.fromNullable(row.activeTurnId))), Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getActiveTurnId:query", "ProjectionSnapshotQuery.getActiveTurnId:decodeRow")));
+	const getLatestThreadMessageWithIdPrefix = (threadId, idPrefix) => getLatestThreadMessageWithIdPrefixRow({
+		threadId,
+		idPrefix
+	}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getLatestThreadMessageWithIdPrefix:query", "ProjectionSnapshotQuery.getLatestThreadMessageWithIdPrefix:decodeRow")));
+	const getLatestEvidenceRead = (threadId) => getLatestEvidenceReadRow(threadId).pipe(Effect.map(Option.map((row) => ({
+		watchedThreadId: row.watchedThreadId,
+		afterSequence: row.afterSequence,
+		throughSequence: row.throughSequence,
+		turnId: row.turnId,
+		readAt: row.readAt,
+		hasReport: row.hasReport !== 0
+	}))), Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getLatestEvidenceRead:query", "ProjectionSnapshotQuery.getLatestEvidenceRead:decodeRow")));
 	const getThreadPairById = (pairId) => getThreadPairRow(pairId).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadPairById:query", "ProjectionSnapshotQuery.getThreadPairById:decodeRow")));
+	const getActiveThreadPairs = () => listActiveThreadPairRows(void 0).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getActiveThreadPairs:query", "ProjectionSnapshotQuery.getActiveThreadPairs:decodeRows")));
 	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"))),
@@ -43584,6 +43779,11 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		getThreadCheckpointContext,
 		getFullThreadDiffContext,
 		getThreadPairById,
+		getActiveThreadPairs,
+		getLatestEvidenceRead,
+		getTurnStart,
+		getLatestThreadMessageWithIdPrefix,
+		getActiveTurnId,
 		getThreadShellById,
 		getThreadDetailById,
 		getHandoffContext,
@@ -59353,6 +59553,21 @@ function fusionRoleInstructionsFor(role, options) {
 	const model = fusionSummarizerModelFor(options.provider, options.summarizerModelOverride);
 	return `${FUSION_WATCHER_INSTRUCTIONS} ${FUSION_EVIDENCE_SUMMARY_INSTRUCTIONS} ${summarizerModelLine(model)}`;
 }
+/**
+* The closing duty, restated in the wake that asks for the review.
+*
+* The same duty is in the supervisor's role block, but a wake message spells
+* out the whole turn and a model follows the instruction it was just handed:
+* with the duty only in the session channel, this install recorded 58 evidence
+* reads and no reports at all. Stated here it travels the common provider
+* input path, so it reaches every provider whatever its session prompt does.
+*/
+function fusionReviewClosingInstruction(input) {
+	const close = `Then close this review with exactly one thread_evidence_report call: threadId ${input.implementerThreadId}, throughSequence ${input.throughSequence} - that exact number, never lastSequence and never the final page's nextAfterSequence, because the server pairs the report to the read by it - plus the first and last sequence you actually covered.`;
+	return input.evidenceSummary ? `Read that evidence through one summarizer subagent against the same fixed throughSequence ${input.throughSequence} and review from what it returns. Fail open: if no subagent is available, the spawn errors, it times out, or what comes back is empty or cites no sequences, read the range yourself instead. Never skip or shorten the review because a summary was unavailable.
+
+${close} Outcome summarized with the subagent's exact returned text and the model it ran on, fallback when you read the range yourself, or failed when the summarizer could not run - with your reason in the last two cases. Report even when no summary ever arrived; an unreported review cannot be told from a supervisor that never tried. Never paste builder tool output into the report.` : `${close} Evidence summarization is off for this environment, so the outcome is fallback with the reason you read the range yourself. Never paste builder tool output into the report.`;
+}
 function fusionRoleReferenceLineFor(role) {
 	return role === "implementer" ? FUSION_BUILDER_REFERENCE_LINE : FUSION_WATCHER_REFERENCE_LINE;
 }
@@ -134032,6 +134247,86 @@ const TypeSafeToolkitHandlersLive = TypeSafeToolkit.toLayer({ typesafe_ask: (inp
 	}).pipe(Effect.mapError((error) => new TypeSafeAskFailedError({ reason: `TypeSafe: ${error.reason}` })));
 }) });
 //#endregion
+//#region src/orchestration/fusionEvidenceReport.ts
+/**
+* Shared shape of one Fusion review's evidence rows.
+*
+* Two writers close a review: the supervisor calling `thread_evidence_report`,
+* and the server itself when a supervisor turn ends over a read nothing
+* answered. Both key their row the same way and measure the same numbers from
+* the same recorded rows, so a reader cannot tell which writer it is looking at
+* apart from the outcome the row carries.
+*
+* @module fusionEvidenceReport
+*/
+/**
+* One activity per review, not one per page.
+*
+* A supervisor pages a range with a fixed `throughSequence`, so keying the id
+* on the watched thread and that bound collapses a whole paged read into a
+* single row: the projector replaces an activity of the same id rather than
+* appending beside it.
+*/
+const evidenceReadActivityId = (watchedThreadId, throughSequence) => EventId.make(`fusion-evidence:${watchedThreadId}:${throughSequence}`);
+/** One report per review, keyed like the read it reports on so a retry replaces. */
+const evidenceReportActivityId = (watchedThreadId, throughSequence) => EventId.make(`fusion-evidence-summary:${watchedThreadId}:${throughSequence}`);
+/**
+* Server clock across the review, from the two recorded rows that bracket it.
+*
+* An unparsable timestamp yields null rather than a zero, and a closing time
+* behind the read yields null as well: a negative duration is a clock problem,
+* not a review that took no time.
+*/
+const evidenceTiming = (readAt, closedAt) => {
+	const read = Date.parse(readAt);
+	const closed = Date.parse(closedAt);
+	if (Number.isNaN(read) || Number.isNaN(closed) || closed < read) return null;
+	return {
+		readAt,
+		closedAt,
+		durationMs: closed - read
+	};
+};
+/**
+* The reporting thread's own context and elapsed time around the read it is
+* closing.
+*
+* `before` comes off the evidence-read activity rather than the closing row, 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 correlateEvidence = Effect.fn("fusionEvidenceReport.correlateEvidence")(function* (input) {
+	const projections = yield* ProjectionSnapshotQuery;
+	const latest = yield* projections.getLatestThreadContextWindow(input.readerThreadId).pipe(Effect.orElseSucceed(() => Option.none()));
+	const read = yield* projections.getEvidenceReadContext(input.readActivityId).pipe(Effect.orElseSucceed(() => Option.none()));
+	const timing = Option.match(read, {
+		onNone: () => null,
+		onSome: (row) => evidenceTiming(row.readAt, input.closedAt)
+	});
+	if (Option.isNone(latest)) return {
+		context: null,
+		timing
+	};
+	const usedTokensAfter = latest.value.usedTokens;
+	const usedTokensBefore = Option.match(read, {
+		onNone: () => null,
+		onSome: (row) => row.usedTokensAtRead
+	});
+	const maxTokens = latest.value.maxTokens;
+	return {
+		context: {
+			usedTokensBefore,
+			usedTokensAfter,
+			deltaTokens: usedTokensBefore === null ? null : usedTokensAfter - usedTokensBefore,
+			maxTokens,
+			capacityPercent: maxTokens === null || maxTokens <= 0 ? null : Math.round(usedTokensAfter / maxTokens * 1e3) / 10
+		},
+		timing
+	};
+});
+//#endregion
 //#region src/mcp/toolkits/watch/tools.ts
 /**
 * Cross-thread by design, which is exactly why it is the most guarded tool in
@@ -134085,17 +134380,6 @@ const ThreadEvidenceReportTool = Tool.make("thread_evidence_report", {
 const WatchToolkit = Toolkit.make(ThreadWatchEventsTool, ThreadWatchReviewTool, ThreadEvidenceReportTool);
 //#endregion
 //#region src/mcp/toolkits/watch/handlers.ts
-/**
-* One activity per review, not one per page.
-*
-* A supervisor pages a range with a fixed `throughSequence`, so keying the id
-* on the watched thread and that bound collapses a whole paged read into a
-* single row: the projector replaces an activity of the same id rather than
-* 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 = {
@@ -134110,31 +134394,43 @@ const REPORT_HEADING = {
 * for; losing the note that it happened is a smaller loss than losing the page,
 * so a rejected dispatch is logged and the page is returned anyway.
 */
-const recordEvidenceRead = Effect.fn("mcp.watch.recordEvidenceRead")(function* (readerThreadId, page) {
+const recordEvidenceRead = Effect.fn("mcp.watch.recordEvidenceRead")(function* (readerThreadId, page, afterSequence) {
 	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));
+	const recorded = yield* projections.getEvidenceReadContext(evidenceReadActivityId(page.threadId, page.throughSequence)).pipe(Effect.orElseSucceed(() => Option.none()));
+	const opened = Option.isSome(recorded);
+	const readCreatedAt = Option.match(recorded, {
+		onNone: () => createdAt,
+		onSome: (row) => row.readAt
+	});
+	const readAfterSequence = Option.match(recorded, {
+		onNone: () => afterSequence,
+		onSome: (row) => row.afterSequence ?? afterSequence
+	});
+	const activeTurnId = yield* projections.getActiveTurnId(readerThreadId).pipe(Effect.orElseSucceed(() => Option.none()), Effect.map(Option.getOrNull));
+	const usedTokensAtRead = opened ? Option.getOrNull(Option.map(recorded, (row) => row.usedTokensAtRead)) : 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)),
 		threadId: readerThreadId,
 		createdAt,
 		activity: {
-			id: evidenceActivityId(page.threadId, page.throughSequence),
-			createdAt,
+			id: evidenceReadActivityId(page.threadId, page.throughSequence),
+			createdAt: readCreatedAt,
 			tone: "info",
 			kind: "fusion.evidence.read",
 			summary: "Read builder evidence",
 			turnId: null,
 			payload: {
 				watchedThreadId: page.threadId,
+				afterSequence: readAfterSequence,
 				throughSequence: page.throughSequence,
 				nextAfterSequence: page.nextAfterSequence,
 				hasMore: page.hasMore,
 				scannedEvents: page.scannedEvents,
+				...activeTurnId === null ? {} : { turnId: activeTurnId },
 				...usedTokensAtRead === null ? {} : { usedTokensAtRead }
 			}
 		}
@@ -134150,30 +134446,6 @@ const clip = (value, limit) => {
 	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);
@@ -134181,7 +134453,7 @@ const WatchToolkitHandlersLive = WatchToolkit.toLayer({
 			threadId: input.threadId,
 			detail: cause.message
 		})));
-		yield* recordEvidenceRead(invocation.threadId, page);
+		yield* recordEvidenceRead(invocation.threadId, page, input.afterSequence ?? 0);
 		return page;
 	}),
 	thread_evidence_report: (input) => Effect.gen(function* () {
@@ -134189,7 +134461,11 @@ const WatchToolkitHandlersLive = WatchToolkit.toLayer({
 		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 { context, timing } = yield* correlateEvidence({
+			readerThreadId: invocation.threadId,
+			readActivityId: evidenceReadActivityId(input.threadId, input.throughSequence),
+			closedAt: createdAt
+		});
 		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;
@@ -134200,7 +134476,7 @@ const WatchToolkitHandlersLive = WatchToolkit.toLayer({
 				threadId: invocation.threadId,
 				createdAt,
 				activity: {
-					id: reportActivityId(input.threadId, input.throughSequence),
+					id: evidenceReportActivityId(input.threadId, input.throughSequence),
 					createdAt,
 					tone: outcome === "failed" ? "error" : "info",
 					kind: "fusion.evidence.summary",
@@ -134215,7 +134491,8 @@ const WatchToolkitHandlersLive = WatchToolkit.toLayer({
 						summary,
 						model: clip(input.model, MODEL_ID_MAX_CHARS),
 						reason: reason ?? (outcome === "summarized" ? null : "the supervisor gave no reason"),
-						context
+						context,
+						timing
 					}
 				}
 			}).pipe(Effect.as(true), Effect.catchCause((cause) => Effect.logWarning("could not record the supervisor's evidence report", {
@@ -139153,6 +139430,12 @@ ${FUSION_WATCHER_TOOL_INSTRUCTIONS}
 
 Call thread_watch_review, threadId ${input.implementerThreadId}, afterSequence ${input.afterSequence}, throughSequence ${input.throughSequence}. Continue with nextAfterSequence and the same throughSequence until hasMore is false, including empty pages. Apply message append/replace operations by identity across pages. Recover truncated or uncertain evidence with targeted thread_watch_events reads using its source sequence range. Inspect repo when useful.
 
+${fusionReviewClosingInstruction({
+	implementerThreadId: input.implementerThreadId,
+	throughSequence: input.throughSequence,
+	evidenceSummary: input.evidenceSummary
+})}
+
 Always report concise:
 
 - Progress: work done; completeness.
@@ -139234,6 +139517,13 @@ const make$3 = Effect.gen(function* () {
 			activePairs: (readModel.threadPairs ?? []).filter((pair) => pair.detachedAt === null)
 		};
 	});
+	/**
+	* Activity events arrive at provider streaming speed on every thread in the
+	* install, and only a pair's own activities matter here. The pair table
+	* alone answers that, so the hot path never decodes the whole command read
+	* model; the rare branches that need threads read it themselves.
+	*/
+	const readActivePairs = projectionSnapshotQuery.getActiveThreadPairs();
 	const appendGateActivity = Effect.fn("FusionWatcherReactor.appendGateActivity")(function* (input) {
 		yield* orchestrationEngine.dispatch({
 			type: "thread.activity.append",
@@ -139488,10 +139778,18 @@ const make$3 = Effect.gen(function* () {
 		const requestId = payload["requestId"];
 		return typeof requestId === "string" && requestId.length > 0 ? requestId : void 0;
 	};
+	/** The only activity kinds this reactor reacts to; everything else returns first. */
+	const FUSION_ACTIVITY_KINDS = /* @__PURE__ */ new Set([
+		"provider.turn.start.failed",
+		"approval.requested",
+		"approval.resolved",
+		"tool.completed"
+	]);
 	const processActivityAppended = Effect.fn("FusionWatcherReactor.processActivityAppended")(function* (event) {
 		if (event.sequence <= liveEventsAfterSequence) return;
 		const activity = event.payload.activity;
-		const { activePairs } = yield* readPairs;
+		if (!FUSION_ACTIVITY_KINDS.has(activity.kind)) return;
+		const activePairs = yield* readActivePairs;
 		const pairedThread = activePairs.find((candidate) => candidate.implementerThreadId === event.payload.threadId || candidate.watcherThreadId === event.payload.threadId);
 		if (activity.kind === "provider.turn.start.failed" && pairedThread !== void 0) {
 			yield* pausePairAfterProviderFailure({
@@ -139657,6 +139955,14 @@ const make$3 = Effect.gen(function* () {
 		});
 	});
 	/**
+	* Unreadable settings mean the shipped default, not off: a supervisor that
+	* was told nothing about closing its review is the failure this line exists
+	* to prevent.
+	*/
+	const readEvidenceSummaryEnabled = Effect.gen(function* () {
+		return (yield* serverSettings.getSettings.pipe(Effect.catchCause(() => Effect.succeed(null))))?.fusionEvidenceSummary ?? DEFAULT_FUSION_PROMPT_SETTINGS.evidenceSummary;
+	});
+	/**
 	* The pre-filter's configuration, or null when it must not run at all.
 	*
 	* A settings read failure returns null rather than a default: an unreadable
@@ -139752,7 +140058,8 @@ const make$3 = Effect.gen(function* () {
 				text: watcherPrompt({
 					implementerThreadId: currentPair.implementerThreadId,
 					afterSequence: currentPair.lastReviewedImplementerSequence,
-					throughSequence: completion.sequence
+					throughSequence: completion.sequence,
+					evidenceSummary: yield* readEvidenceSummaryEnabled
 				}) + "\n\n" + fusionReviewPolicyInstructions(currentPair.reviewExperiment),
 				attachments: []
 			},
@@ -139820,6 +140127,73 @@ const make$3 = Effect.gen(function* () {
 			yield* processReview(pair, completion, turn);
 		}
 	});
+	/** Writes the row, once the caller has established the turn owed one. */
+	const stampUnreported = Effect.fn("FusionWatcherReactor.stampUnreported")(function* (pair, completion, latest) {
+		const { context, timing } = yield* correlateEvidence({
+			readerThreadId: pair.watcherThreadId,
+			readActivityId: evidenceReadActivityId(latest.watchedThreadId, latest.throughSequence),
+			closedAt: completion.occurredAt
+		});
+		yield* orchestrationEngine.dispatch({
+			type: "thread.activity.append",
+			commandId: CommandId.make(`server:fusion:${pair.id}:evidence-unreported:${latest.throughSequence}`),
+			threadId: pair.watcherThreadId,
+			createdAt: completion.occurredAt,
+			activity: {
+				id: evidenceReportActivityId(latest.watchedThreadId, latest.throughSequence),
+				createdAt: completion.occurredAt,
+				tone: "error",
+				kind: "fusion.evidence.summary",
+				summary: "Evidence never reported",
+				turnId: null,
+				payload: {
+					watchedThreadId: latest.watchedThreadId,
+					firstSequence: latest.afterSequence === null ? latest.throughSequence : Math.min(latest.afterSequence + 1, latest.throughSequence),
+					lastSequence: latest.throughSequence,
+					throughSequence: latest.throughSequence,
+					outcome: "unreported",
+					summary: null,
+					model: null,
+					reason: "the supervisor ended its turn without reporting on the evidence it read",
+					context,
+					timing
+				}
+			}
+		});
+	});
+	/**
+	* Closes a supervisor turn that read the builder's evidence and ended without
+	* reporting on it.
+	*
+	* The row it writes is keyed exactly like the supervisor's own report, so a
+	* later report replaces it rather than doubling it, and it carries the same
+	* server-measured context and timing. Without it, a review that was never
+	* reported is indistinguishable in stored history from one that was never
+	* attempted.
+	*/
+	const recordUnreportedEvidence = Effect.fn("FusionWatcherReactor.recordUnreportedEvidence")(function* (pair, completion, input) {
+		const read = yield* projectionSnapshotQuery.getLatestEvidenceRead(pair.watcherThreadId).pipe(Effect.orElseSucceed(() => Option.none()));
+		if (Option.isNone(read)) return;
+		const latest = read.value;
+		if (latest.hasReport || latest.watchedThreadId !== pair.implementerThreadId) return;
+		if (completion.payload.turnId === null) return;
+		const turn = yield* projectionSnapshotQuery.getTurnStart(pair.watcherThreadId, completion.payload.turnId).pipe(Effect.orElseSucceed(() => Option.none()));
+		if (Option.isNone(turn)) return;
+		const started = turn.value;
+		if (started.threadId !== pair.watcherThreadId) return;
+		const readAt = Date.parse(latest.readAt);
+		if (latest.turnId === null) {
+			if (input.replayed) return;
+			if (started.startedAt !== null && readAt < Date.parse(started.startedAt)) return;
+			if (readAt > Date.parse(completion.occurredAt)) return;
+		} else if (latest.turnId !== completion.payload.turnId) return;
+		const wakeAt = (prefix) => projectionSnapshotQuery.getLatestThreadMessageWithIdPrefix(pair.watcherThreadId, prefix).pipe(Effect.map(Option.flatMap((wake) => {
+			const sentAt = Date.parse(wake.createdAt);
+			return Number.isNaN(sentAt) || sentAt > readAt ? Option.none() : Option.some(sentAt);
+		})), Effect.orElseSucceed(() => Option.none()));
+		if (!(started.messageId === null ? yield* Effect.map(Effect.all([wakeAt("fusion-review:"), wakeAt("fusion-gate:")]), ([review, gate]) => Option.isSome(review) && (Option.isNone(gate) || gate.value < review.value)) : started.messageId.startsWith("fusion-review:"))) return;
+		yield* stampUnreported(pair, completion, latest);
+	});
 	const processCompletion = Effect.fn("FusionWatcherReactor.processCompletion")(function* (event) {
 		const activePairs = ((yield* projectionSnapshotQuery.getCommandReadModel()).threadPairs ?? []).filter((pair) => pair.detachedAt === null);
 		const failedPair = activePairs.find((pair) => pair.implementerThreadId === event.payload.threadId || pair.watcherThreadId === event.payload.threadId);
@@ -139834,6 +140208,11 @@ const make$3 = Effect.gen(function* () {
 			return;
 		}
 		if (event.payload.state !== "completed") return;
+		const watcherPair = activePairs.find((pair) => pair.watcherThreadId === event.payload.threadId);
+		if (watcherPair !== void 0) yield* recordUnreportedEvidence(watcherPair, event, { replayed: event.sequence <= liveEventsAfterSequence }).pipe(Effect.catchCause((cause) => Effect.logWarning("could not record an unreported Fusion evidence read", {
+			pairId: watcherPair.id,
+			cause: Cause.pretty(cause)
+		})));
 		const pairs = activePairs.filter((pair) => pair.implementerThreadId === event.payload.threadId && event.sequence > pair.lastReviewedImplementerSequence);
 		yield* Effect.forEach(pairs, (pair) => catchUpPair(pair, event.sequence), {
 			concurrency: 1,