@p4code/cli 0.3.15 → 0.3.17

package/dist/bin.mjs

@@ -238,7 +238,7 @@ const make$91 = () => {
 const layer$82 = Layer.sync(NetService, make$91);
 //#endregion
 //#region package.json
-var version = "0.3.15";
+var version = "0.3.17";
 //#endregion
 //#region src/config.ts
 /**
@@ -2173,11 +2173,46 @@ const OrchestrationSubscribeThreadInput = Schema$1.Struct({
 	* Requests an explicit marker after the subscription has emitted its initial
 	* snapshot or catch-up replay and before it begins emitting live events.
 	*/
-	requestCompletionMarker: Schema$1.optionalKey(Schema$1.Boolean)
+	requestCompletionMarker: Schema$1.optionalKey(Schema$1.Boolean),
+	/**
+	* When provided, the fallback snapshot frame (sent when `afterSequence` is
+	* missing or the catch-up gap is too large) is windowed to the last
+	* `turnLimit` user-anchored turns and carries `page` metadata. Absent means
+	* the fallback snapshot is the full thread, preserving pre-pagination client
+	* behavior. Live events are unaffected either way.
+	*/
+	turnLimit: Schema$1.optionalKey(PositiveInt)
+});
+Schema$1.Struct({
+	turnLimit: Schema$1.optionalKey(PositiveInt),
+	beforeCursor: Schema$1.optionalKey(TrimmedNonEmptyString)
+});
+/**
+* Page metadata for a windowed thread detail read. `beforeCursor` is opaque and
+* exclusive: passing it back returns the adjacent disjoint slice of older
+* turns. `null` means the thread is fully loaded below this page. The
+* `snapshotSequence` mirrors the top-level snapshot sequence so history pages
+* can be sequence-checked against live state before merging.
+*/
+const OrchestrationThreadDetailPage = Schema$1.Struct({
+	beforeCursor: Schema$1.NullOr(TrimmedNonEmptyString),
+	hasMore: Schema$1.Boolean,
+	snapshotSequence: NonNegativeInt,
+	/**
+	* Highest event sequence applied to THIS thread at page read time. The
+	* global `snapshotSequence` advances with every thread's events, so a
+	* client cannot wait for it via its per-thread subscription; this
+	* thread-scoped watermark is reachable. A client merging an older page
+	* must first have applied live events up to it — otherwise a streaming
+	* turn outside the loaded window could have deltas replayed on top of
+	* page content that already includes them, duplicating text.
+	*/
+	threadSequence: Schema$1.optionalKey(NonNegativeInt)
 });
 const OrchestrationThreadDetailSnapshot = Schema$1.Struct({
 	snapshotSequence: NonNegativeInt,
-	thread: OrchestrationThread
+	thread: OrchestrationThread,
+	page: Schema$1.optional(OrchestrationThreadDetailPage)
 });
 const ProjectCreateCommand = Schema$1.Struct({
 	type: Schema$1.Literal("project.create"),
@@ -4709,6 +4744,10 @@ var EnvironmentAuthHttpApi = class extends HttpApiGroup.make("auth").add(HttpApi
 	error: EnvironmentScopedOperationErrors
 }).middleware(EnvironmentAuthenticatedAuth)) {};
 const EnvironmentOrchestrationThreadSnapshotParams = Schema$1.Struct({ threadId: ThreadId });
+const EnvironmentOrchestrationThreadSnapshotQuery = {
+	turnLimit: Schema$1.optional(Schema$1.FiniteFromString.check(Schema$1.isInt(), Schema$1.isGreaterThanOrEqualTo(1))),
+	beforeCursor: Schema$1.optional(TrimmedNonEmptyString)
+};
 var EnvironmentOrchestrationHttpApi = class extends HttpApiGroup.make("orchestration").add(HttpApiEndpoint.get("snapshot", "/api/orchestration/snapshot", {
 	headers: OptionalBearerHeaders,
 	success: OrchestrationReadModel,
@@ -4720,6 +4759,7 @@ var EnvironmentOrchestrationHttpApi = class extends HttpApiGroup.make("orchestra
 }).middleware(EnvironmentAuthenticatedAuth)).add(HttpApiEndpoint.get("threadSnapshot", "/api/orchestration/threads/:threadId", {
 	headers: OptionalBearerHeaders,
 	params: EnvironmentOrchestrationThreadSnapshotParams,
+	payload: EnvironmentOrchestrationThreadSnapshotQuery,
 	success: OrchestrationThreadDetailSnapshot,
 	error: EnvironmentOrchestrationThreadSnapshotErrors
 }).middleware(EnvironmentAuthenticatedAuth)).add(HttpApiEndpoint.post("dispatch", "/api/orchestration/dispatch", {
@@ -8812,7 +8852,13 @@ const ServerConfig = Schema$1.Struct({
 	/** Whether shell subscriptions can emit an opt-in catch-up completion marker. */
 	shellResumeCompletionMarker: Schema$1.optionalKey(Schema$1.Boolean),
 	/** Whether thread subscriptions can emit an opt-in catch-up completion marker. */
-	threadResumeCompletionMarker: Schema$1.optionalKey(Schema$1.Boolean)
+	threadResumeCompletionMarker: Schema$1.optionalKey(Schema$1.Boolean),
+	/**
+	* Whether thread detail reads accept a turn window (`turnLimit`/
+	* `beforeCursor`) and return `page` metadata. Clients must not send window
+	* fields to servers that don't advertise this.
+	*/
+	threadSnapshotPagination: Schema$1.optionalKey(Schema$1.Boolean)
 });
 const ServerUpsertKeybindingReplaceTarget = Schema$1.Struct({
 	key: KeybindingValue,
@@ -15774,6 +15820,21 @@ var _052_CompactHistoricalToolActivities_default = Effect.gen(function* () {
   `;
 });
 //#endregion
+//#region src/persistence/Migrations/053_ProjectionTurnsKeysetIndex.ts
+/**
+* Composite index for windowed thread detail reads. Pagination orders turns by
+* the stable keyset (requested_at, turn_id); the pre-existing
+* (thread_id, requested_at) index cannot serve the tiebreak order, forcing a
+* temp B-tree over all of a thread's turns before the page LIMIT applies.
+* With this index the candidates scan is genuinely bounded by the page size.
+*/
+var _053_ProjectionTurnsKeysetIndex_default = Effect.gen(function* () {
+	yield* (yield* SqlClient.SqlClient)`
+    CREATE INDEX IF NOT EXISTS idx_projection_turns_thread_keyset
+    ON projection_turns(thread_id, requested_at, turn_id)
+  `;
+});
+//#endregion
 //#region src/persistence/Migrations.ts
 /**
 * MigrationsLive - Migration runner with inline loader
@@ -16054,6 +16115,11 @@ const migrationEntries = [
 		52,
 		"CompactHistoricalToolActivities",
 		_052_CompactHistoricalToolActivities_default
+	],
+	[
+		53,
+		"ProjectionTurnsKeysetIndex",
+		_053_ProjectionTurnsKeysetIndex_default
 	]
 ];
 const makeMigrationLoader = (throughId) => Migrator.fromRecord(Object.fromEntries(migrationEntries.filter(([id]) => throughId === void 0 || id <= throughId).map(([id, name, migration]) => [`${id}_${name}`, migration])));
@@ -16562,7 +16628,19 @@ function projectActivityPayload(activity) {
 	if (item) projectedData.item = item;
 	if ("command" in data) projectedData.command = data.command;
 	const input = asRecord$6(data.input);
-	if (input && "command" in input) projectedData.input = { command: input.command };
+	if (input) {
+		const projectedInput = {};
+		if ("command" in input) projectedInput.command = input.command;
+		if (payload.itemType === "collab_agent_tool_call") {
+			for (const field of [
+				"description",
+				"prompt",
+				"subagent_type",
+				"model"
+			]) if (field in input) projectedInput[field] = input[field];
+		}
+		if (Object.keys(projectedInput).length > 0) projectedData.input = projectedInput;
+	}
 	const changedFiles = [];
 	collectChangedFiles(data, changedFiles, /* @__PURE__ */ new Set(), 0);
 	if (changedFiles.length > 0) projectedData.files = changedFiles.map((path) => ({ path }));
@@ -30156,6 +30234,37 @@ Schema$1.Struct({
 Schema$1.Struct({ threadId: ThreadId });
 Context.Service()("@p4code/cli/persistence/Services/ProjectionCheckpoints/ProjectionCheckpointRepository");
 //#endregion
+//#region src/orchestration/threadDetailCursor.ts
+function encodeThreadDetailPageCursor(cursor) {
+	return Buffer.from(JSON.stringify({
+		t: cursor.threadId,
+		a: cursor.beforeAnchorAt,
+		i: cursor.beforeTurnId
+	})).toString("base64url");
+}
+/**
+* Returns null for anything that is not a well-formed cursor. Callers degrade
+* a malformed or foreign-thread cursor to a first-page request.
+*/
+function decodeThreadDetailPageCursor(encoded) {
+	let parsed;
+	try {
+		parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+	} catch {
+		return null;
+	}
+	if (parsed === null || typeof parsed !== "object") return null;
+	const record = parsed;
+	if (typeof record.t !== "string" || record.t.length === 0) return null;
+	if (typeof record.a !== "string") return null;
+	if (typeof record.i !== "string") return null;
+	return {
+		threadId: record.t,
+		beforeAnchorAt: record.a,
+		beforeTurnId: record.i
+	};
+}
+//#endregion
 //#region ../../packages/shared/src/sourceControl.ts
 const GITHUB_CHANGE_REQUEST_PRESENTATION = {
 	icon: "github",
@@ -30852,6 +30961,24 @@ const ProjectionThreadSearchRow = Schema$1.Struct({
 const WorkspaceRootLookupInput = Schema$1.Struct({ workspaceRoot: Schema$1.String });
 const ProjectIdLookupInput = Schema$1.Struct({ projectId: ProjectId });
 const ThreadIdLookupInput = Schema$1.Struct({ threadId: ThreadId });
+const ThreadTurnWindowLookupInput = Schema$1.Struct({
+	threadId: ThreadId,
+	beforeAnchorAt: Schema$1.String,
+	beforeTurnKey: Schema$1.String,
+	userTurnLimit: Schema$1.Number,
+	maxRawTurns: Schema$1.Number
+});
+const ProjectionTurnWindowRowSchema = Schema$1.Struct({
+	anchorAt: Schema$1.String,
+	turnKey: Schema$1.String
+});
+const ThreadTurnRangeLookupInput = Schema$1.Struct({
+	threadId: ThreadId,
+	minAnchorAt: Schema$1.String,
+	minTurnKey: Schema$1.String,
+	beforeAnchorAt: Schema$1.String,
+	beforeTurnKey: Schema$1.String
+});
 const ProjectionProjectLookupRowSchema = ProjectionProjectDbRowSchema;
 const ProjectionThreadIdLookupRowSchema = Schema$1.Struct({ threadId: ThreadId });
 const ProjectionThreadCheckpointContextThreadRowSchema = Schema$1.Struct({
@@ -31769,6 +31896,115 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
           LIMIT ${BTW_CONTEXT_MESSAGE_LIMIT}
         ) AS bounded
         ORDER BY created_at ASC, message_id ASC
+      `
+	});
+	const getThreadEventWatermarkRow = SqlSchema.findOneOption({
+		Request: Schema$1.Struct({
+			threadId: ThreadId,
+			maxSequence: Schema$1.Number
+		}),
+		Result: Schema$1.Struct({ threadSequence: Schema$1.NullOr(Schema$1.Number) }),
+		execute: ({ threadId, maxSequence }) => sql`
+        SELECT MAX(sequence) AS "threadSequence"
+        FROM orchestration_events
+        WHERE aggregate_kind = 'thread'
+          AND stream_id = ${threadId}
+          AND sequence <= ${maxSequence}
+          AND event_type IN (
+            'thread.message-sent',
+            'thread.proposed-plan-upserted',
+            'thread.activity-appended',
+            'thread.turn-diff-completed',
+            'thread.reverted',
+            'thread.session-set'
+          )
+      `
+	});
+	const listTurnWindowRows = SqlSchema.findAll({
+		Request: ThreadTurnWindowLookupInput,
+		Result: ProjectionTurnWindowRowSchema,
+		execute: ({ threadId, beforeAnchorAt, beforeTurnKey, userTurnLimit, maxRawTurns }) => sql`
+        WITH candidates AS (
+          SELECT
+            turns.requested_at AS anchor_at,
+            COALESCE(turns.turn_id, '') AS turn_key,
+            turns.pending_message_id
+          FROM projection_turns AS turns
+          WHERE turns.thread_id = ${threadId}
+            AND (
+              turns.requested_at < ${beforeAnchorAt}
+              OR (
+                turns.requested_at = ${beforeAnchorAt}
+                AND COALESCE(turns.turn_id, '') < ${beforeTurnKey}
+              )
+            )
+          ORDER BY turns.requested_at DESC, turns.turn_id DESC
+          LIMIT ${maxRawTurns}
+        ),
+        walked AS (
+          SELECT
+            candidates.anchor_at,
+            candidates.turn_key,
+            CASE WHEN messages.role = 'user' THEN 1 ELSE 0 END AS is_user_turn,
+            SUM(CASE WHEN messages.role = 'user' THEN 1 ELSE 0 END) OVER (
+              ORDER BY candidates.anchor_at DESC, candidates.turn_key DESC
+            ) AS user_turns_seen
+          FROM candidates
+          LEFT JOIN projection_thread_messages AS messages
+            ON messages.message_id = candidates.pending_message_id
+        )
+        SELECT
+          anchor_at AS "anchorAt",
+          turn_key AS "turnKey"
+        FROM walked
+        WHERE user_turns_seen < ${userTurnLimit}
+          OR (user_turns_seen = ${userTurnLimit} AND is_user_turn = 1)
+        ORDER BY anchor_at ASC, turn_key ASC
+      `
+	});
+	const listThreadMessageRowsByThreadWindow = SqlSchema.findAll({
+		Request: ThreadTurnRangeLookupInput,
+		Result: ProjectionThreadMessageDbRowSchema,
+		execute: ({ threadId, minAnchorAt, minTurnKey, beforeAnchorAt, beforeTurnKey }) => sql`
+        SELECT
+          message_id AS "messageId",
+          thread_id AS "threadId",
+          turn_id AS "turnId",
+          role,
+          text,
+          attachments_json AS "attachments",
+          is_streaming AS "isStreaming",
+          created_at AS "createdAt",
+          updated_at AS "updatedAt"
+        FROM projection_thread_messages
+        WHERE thread_id = ${threadId}
+          AND (
+            turn_id IN (
+              SELECT turn_id FROM projection_turns
+              WHERE thread_id = ${threadId}
+                AND turn_id IS NOT NULL
+                AND (
+                  requested_at > ${minAnchorAt}
+                  OR (
+                    requested_at = ${minAnchorAt}
+                    AND turn_id >= ${minTurnKey}
+                  )
+                )
+                AND (
+                  requested_at < ${beforeAnchorAt}
+                  OR (
+                    requested_at = ${beforeAnchorAt}
+                    AND turn_id < ${beforeTurnKey}
+                  )
+                )
+            )
+            OR (
+              turn_id IS NULL
+              AND created_at >= ${minAnchorAt}
+              AND created_at < ${beforeAnchorAt}
+            )
+          )
+        ORDER BY created_at ASC, message_id ASC
       `
 	});
 	const getBtwThreadRow = SqlSchema.findOneOption({
@@ -31789,6 +32025,54 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
             OR projects.deleted_at IS NULL
           )
         LIMIT 1
+      `
+	});
+	const listThreadActivityRowsByThreadWindow = SqlSchema.findAll({
+		Request: ThreadTurnRangeLookupInput,
+		Result: ProjectionThreadActivityDbRowSchema,
+		execute: ({ threadId, minAnchorAt, minTurnKey, beforeAnchorAt, beforeTurnKey }) => sql`
+        SELECT
+          activity_id AS "activityId",
+          thread_id AS "threadId",
+          turn_id AS "turnId",
+          tone,
+          kind,
+          summary,
+          payload_json AS "payload",
+          sequence,
+          created_at AS "createdAt"
+        FROM projection_thread_activities
+        WHERE thread_id = ${threadId}
+          AND (
+            turn_id IN (
+              SELECT turn_id FROM projection_turns
+              WHERE thread_id = ${threadId}
+                AND turn_id IS NOT NULL
+                AND (
+                  requested_at > ${minAnchorAt}
+                  OR (
+                    requested_at = ${minAnchorAt}
+                    AND turn_id >= ${minTurnKey}
+                  )
+                )
+                AND (
+                  requested_at < ${beforeAnchorAt}
+                  OR (
+                    requested_at = ${beforeAnchorAt}
+                    AND turn_id < ${beforeTurnKey}
+                  )
+                )
+            )
+            OR (
+              turn_id IS NULL
+              AND created_at >= ${minAnchorAt}
+              AND created_at < ${beforeAnchorAt}
+            )
+          )
+        ORDER BY
+          sequence ASC,
+          created_at ASC,
+          activity_id ASC
       `
 	});
 	const getFullThreadDiffContextRow = SqlSchema.findOneOption({
@@ -32358,12 +32642,18 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 			scheduledWakeAt: threadRow.value.scheduledWakeAt
 		});
 	});
-	const getThreadDetailById = (threadId) => Effect.gen(function* () {
+	const getThreadDetailByIdBounded = (threadId, bounds) => Effect.gen(function* () {
 		const [threadRow, messageRows, proposedPlanRows, activityRows, checkpointRows, turnRows, latestTurnRow, sessionRow] = yield* Effect.all([
 			getActiveThreadRowById({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:getThread:query", "ProjectionSnapshotQuery.getThreadDetailById:getThread:decodeRow"))),
-			listThreadMessageRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listMessages:query", "ProjectionSnapshotQuery.getThreadDetailById:listMessages:decodeRows"))),
+			(bounds === void 0 ? listThreadMessageRowsByThread({ threadId }) : listThreadMessageRowsByThreadWindow({
+				threadId,
+				...bounds
+			})).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listMessages:query", "ProjectionSnapshotQuery.getThreadDetailById:listMessages:decodeRows"))),
 			listThreadProposedPlanRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listPlans:query", "ProjectionSnapshotQuery.getThreadDetailById:listPlans:decodeRows"))),
-			listThreadActivityRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listActivities:query", "ProjectionSnapshotQuery.getThreadDetailById:listActivities:decodeRows"))),
+			(bounds === void 0 ? listThreadActivityRowsByThread({ threadId }) : listThreadActivityRowsByThreadWindow({
+				threadId,
+				...bounds
+			})).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listActivities:query", "ProjectionSnapshotQuery.getThreadDetailById:listActivities:decodeRows"))),
 			listCheckpointRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listCheckpoints:query", "ProjectionSnapshotQuery.getThreadDetailById:listCheckpoints:decodeRows"))),
 			listTurnSummaryRowsByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:listTurnSummaries:query", "ProjectionSnapshotQuery.getThreadDetailById:listTurnSummaries:decodeRows"))),
 			getLatestTurnRowByThread({ threadId }).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailById:getLatestTurn:query", "ProjectionSnapshotQuery.getThreadDetailById:getLatestTurn:decodeRow"))),
@@ -32434,13 +32724,70 @@ const makeProjectionSnapshotQuery = Effect.gen(function* () {
 		};
 		return Option.some(yield* decodeThread(thread).pipe(Effect.mapError(toPersistenceDecodeError("ProjectionSnapshotQuery.getThreadDetailById:decodeThread"))));
 	});
-	const getThreadDetailSnapshot = (threadId) => sql.withTransaction(Effect.gen(function* () {
-		const thread = yield* getThreadDetailById(threadId);
+	const getThreadDetailById = (threadId) => getThreadDetailByIdBounded(threadId, void 0);
+	const THREAD_DETAIL_MAX_RAW_TURNS_PER_PAGE = 150;
+	const ANCHOR_UNBOUNDED = "~";
+	const getThreadDetailSnapshot = (threadId, window) => sql.withTransaction(Effect.gen(function* () {
+		if (window?.turnLimit === void 0) {
+			const thread = yield* getThreadDetailById(threadId);
+			if (Option.isNone(thread)) return Option.none();
+			const { snapshotSequence } = yield* getSnapshotSequence();
+			return Option.some({
+				snapshotSequence,
+				thread: thread.value
+			});
+		}
+		const decodedCursor = window.beforeCursor === void 0 ? null : decodeThreadDetailPageCursor(window.beforeCursor);
+		const cursor = decodedCursor?.threadId === threadId ? decodedCursor : null;
+		const oldest = (yield* listTurnWindowRows({
+			threadId,
+			beforeAnchorAt: cursor?.beforeAnchorAt ?? ANCHOR_UNBOUNDED,
+			beforeTurnKey: cursor?.beforeTurnId ?? "",
+			userTurnLimit: window.turnLimit,
+			maxRawTurns: THREAD_DETAIL_MAX_RAW_TURNS_PER_PAGE
+		}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailSnapshot:listTurnWindow:query", "ProjectionSnapshotQuery.getThreadDetailSnapshot:listTurnWindow:decodeRows"))))[0];
+		const bounds = oldest === void 0 && cursor === null ? void 0 : {
+			minAnchorAt: oldest?.anchorAt ?? "",
+			minTurnKey: oldest?.turnKey ?? "",
+			beforeAnchorAt: cursor?.beforeAnchorAt ?? ANCHOR_UNBOUNDED,
+			beforeTurnKey: cursor?.beforeTurnId ?? ""
+		};
+		const thread = yield* getThreadDetailByIdBounded(threadId, (oldest === void 0 && cursor !== null ? {
+			minAnchorAt: "",
+			minTurnKey: "",
+			beforeAnchorAt: "",
+			beforeTurnKey: ""
+		} : void 0) ?? bounds);
 		if (Option.isNone(thread)) return Option.none();
+		const hasMore = oldest !== void 0 && (yield* listTurnWindowRows({
+			threadId,
+			beforeAnchorAt: oldest.anchorAt,
+			beforeTurnKey: oldest.turnKey,
+			userTurnLimit: 1,
+			maxRawTurns: 1
+		}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailSnapshot:probeOlder:query", "ProjectionSnapshotQuery.getThreadDetailSnapshot:probeOlder:decodeRows")))).length > 0;
 		const { snapshotSequence } = yield* getSnapshotSequence();
+		const watermarkRow = yield* getThreadEventWatermarkRow({
+			threadId,
+			maxSequence: snapshotSequence
+		}).pipe(Effect.mapError(toPersistenceSqlOrDecodeError$1("ProjectionSnapshotQuery.getThreadDetailSnapshot:threadWatermark:query", "ProjectionSnapshotQuery.getThreadDetailSnapshot:threadWatermark:decodeRow")));
+		const threadSequence = Option.match(watermarkRow, {
+			onNone: () => 0,
+			onSome: (row) => row.threadSequence ?? 0
+		});
 		return Option.some({
 			snapshotSequence,
-			thread: thread.value
+			thread: thread.value,
+			page: {
+				beforeCursor: hasMore && oldest !== void 0 ? encodeThreadDetailPageCursor({
+					threadId,
+					beforeAnchorAt: oldest.anchorAt,
+					beforeTurnId: oldest.turnKey
+				}) : null,
+				hasMore,
+				snapshotSequence,
+				threadSequence
+			}
 		});
 	})).pipe(Effect.mapError((error) => isPersistenceError(error) ? error : toPersistenceSqlError("ProjectionSnapshotQuery.getThreadDetailSnapshot:transaction")(error)));
 	return {
@@ -63445,7 +63792,8 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 			},
 			settings,
 			shellResumeCompletionMarker: true,
-			threadResumeCompletionMarker: true
+			threadResumeCompletionMarker: true,
+			threadSnapshotPagination: true
 		};
 	});
 	const refreshGitStatus = (cwd) => vcsStatusBroadcaster.refreshStatus(cwd).pipe(Effect.ignoreCause({ log: true }), Effect.forkDetach, Effect.asVoid);
@@ -63561,7 +63909,7 @@ const makeWsRpcLayer = (currentSession, previewAutomationBroker) => WsRpcGroup.t
 				const afterCatchUp = input.requestCompletionMarker === true ? Stream.concat(Stream.fromEffect(Queue.offer(liveBuffer, { kind: "synchronized" })).pipe(Stream.drain), bufferedLiveStream) : bufferedLiveStream;
 				return Stream.concat(catchUpStream, afterCatchUp);
 			}
-			const snapshot = yield* projectionSnapshotQuery.getThreadDetailSnapshot(input.threadId).pipe(Effect.mapError((cause) => new OrchestrationGetSnapshotError({
+			const snapshot = yield* projectionSnapshotQuery.getThreadDetailSnapshot(input.threadId, input.turnLimit === void 0 ? void 0 : { turnLimit: input.turnLimit }).pipe(Effect.mapError((cause) => new OrchestrationGetSnapshotError({
 				message: `Failed to load thread ${input.threadId}`,
 				cause
 			})));
@@ -90956,13 +91304,19 @@ const COLLAB_TERMINAL_STATUSES = {
 	shutdown: "stopped",
 	notFound: "stopped"
 };
-function collabTaskEvents(event, canonicalThreadId, item) {
+function collabTaskEventBase(base, taskId, phase) {
+	return {
+		...base,
+		eventId: EventId.make(`${base.eventId}:subagent:${taskId}:${phase}`)
+	};
+}
+function collabTaskEvents(event, canonicalThreadId, item, defaults) {
 	const base = runtimeEventBase(event, canonicalThreadId);
 	if (item.type === "subAgentActivity") {
 		const taskId = RuntimeTaskId.make(item.agentThreadId);
 		const name = agentNameFromPath(item.agentPath);
 		if (item.kind === "started") return [{
-			...base,
+			...collabTaskEventBase(base, taskId, "started"),
 			type: "task.started",
 			payload: {
 				taskId,
@@ -90973,7 +91327,7 @@ function collabTaskEvents(event, canonicalThreadId, item) {
 			}
 		}];
 		if (item.kind === "interrupted") return [{
-			...base,
+			...collabTaskEventBase(base, taskId, "completed"),
 			type: "task.completed",
 			payload: {
 				taskId,
@@ -90981,7 +91335,7 @@ function collabTaskEvents(event, canonicalThreadId, item) {
 			}
 		}];
 		return [{
-			...base,
+			...collabTaskEventBase(base, taskId, "progress"),
 			type: "task.progress",
 			payload: {
 				taskId,
@@ -90992,11 +91346,11 @@ function collabTaskEvents(event, canonicalThreadId, item) {
 	if (item.type !== "collabAgentToolCall") return [];
 	const events = [];
 	const prompt = trimText$1(item.prompt);
-	const model = trimText$1(item.model);
-	const reasoningEffort = trimText$1(item.reasoningEffort);
+	const model = trimText$1(item.model) ?? trimText$1(defaults?.model);
+	const reasoningEffort = trimText$1(item.reasoningEffort) ?? trimText$1(defaults?.reasoningEffort);
 	if (item.tool === "spawnAgent") for (const receiverThreadId of item.receiverThreadIds) {
 		events.push({
-			...base,
+			...collabTaskEventBase(base, RuntimeTaskId.make(receiverThreadId), "started"),
 			type: "task.started",
 			payload: {
 				taskId: RuntimeTaskId.make(receiverThreadId),
@@ -91005,8 +91359,8 @@ function collabTaskEvents(event, canonicalThreadId, item) {
 				...reasoningEffort ? { reasoningEffort } : {}
 			}
 		});
-		if (!(receiverThreadId in item.agentsStates)) events.push({
-			...base,
+		events.push({
+			...collabTaskEventBase(base, RuntimeTaskId.make(receiverThreadId), "progress"),
 			type: "task.progress",
 			payload: {
 				taskId: RuntimeTaskId.make(receiverThreadId),
@@ -91020,7 +91374,7 @@ function collabTaskEvents(event, canonicalThreadId, item) {
 		const terminalStatus = COLLAB_TERMINAL_STATUSES[state.status];
 		if (terminalStatus) {
 			events.push({
-				...base,
+				...collabTaskEventBase(base, taskId, "completed"),
 				type: "task.completed",
 				payload: {
 					taskId,
@@ -91030,8 +91384,9 @@ function collabTaskEvents(event, canonicalThreadId, item) {
 			});
 			continue;
 		}
+		if (item.tool === "spawnAgent" && !message) continue;
 		events.push({
-			...base,
+			...collabTaskEventBase(base, taskId, "progress"),
 			type: "task.progress",
 			payload: {
 				taskId,
@@ -91215,7 +91570,7 @@ function mapItemLifecycle(event, canonicalThreadId, lifecycle) {
 		}
 	};
 }
-function mapToRuntimeEvents(event, canonicalThreadId) {
+function mapToRuntimeEvents(event, canonicalThreadId, collabDefaults) {
 	if (event.kind === "error") {
 		if (!event.message) return [];
 		return [{
@@ -91409,7 +91764,7 @@ function mapToRuntimeEvents(event, canonicalThreadId) {
 	if (event.method === "item/started") {
 		const started = mapItemLifecycle(event, canonicalThreadId, "item.started");
 		const item = readPayload(V2ItemStartedNotification, event.payload)?.item;
-		const taskEvents = item ? collabTaskEvents(event, canonicalThreadId, item) : [];
+		const taskEvents = item ? collabTaskEvents(event, canonicalThreadId, item, collabDefaults) : [];
 		return started ? [started, ...taskEvents] : taskEvents;
 	}
 	if (event.method === "item/completed") {
@@ -91426,7 +91781,7 @@ function mapToRuntimeEvents(event, canonicalThreadId) {
 			}];
 		}
 		const completed = mapItemLifecycle(event, canonicalThreadId, "item.completed");
-		const taskEvents = collabTaskEvents(event, canonicalThreadId, item);
+		const taskEvents = collabTaskEvents(event, canonicalThreadId, item, collabDefaults);
 		return completed ? [completed, ...taskEvents] : taskEvents;
 	}
 	if (event.method === "item/reasoning/summaryPartAdded" || event.method === "item/commandExecution/terminalInteraction") return [{
@@ -91798,9 +92153,13 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 			detail: cause.message,
 			cause
 		})));
+		const collabDefaults = {
+			model: input.modelSelection?.instanceId === boundInstanceId ? input.modelSelection.model : void 0,
+			reasoningEffort: input.modelSelection?.instanceId === boundInstanceId ? getModelSelectionStringOptionValue(input.modelSelection, "reasoningEffort") : void 0
+		};
 		const eventFiber = yield* Stream.runForEach(runtime.events, (event) => Effect.gen(function* () {
 			yield* writeNativeEvent(event);
-			const runtimeEvents = mapToRuntimeEvents(event, event.threadId);
+			const runtimeEvents = mapToRuntimeEvents(event, event.threadId, collabDefaults);
 			if (runtimeEvents.length === 0) {
 				yield* Effect.logDebug("ignoring unhandled Codex provider event", {
 					method: event.method,
@@ -91823,6 +92182,7 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 			scope: sessionScope,
 			runtime,
 			eventFiber,
+			collabDefaults,
 			stopped: false
 		});
 		sessionScopeTransferred = true;
@@ -91854,6 +92214,10 @@ const makeCodexAdapter = Effect.fn("makeCodexAdapter")(function* (codexConfig, o
 		const session = yield* requireSession(input.threadId);
 		const reasoningEffort = input.modelSelection?.instanceId === boundInstanceId ? getModelSelectionStringOptionValue(input.modelSelection, "reasoningEffort") : void 0;
 		const serviceTier = input.modelSelection?.instanceId === boundInstanceId ? getCodexServiceTierOptionValue(input.modelSelection) : void 0;
+		if (input.modelSelection?.instanceId === boundInstanceId) {
+			session.collabDefaults.model = input.modelSelection.model;
+			session.collabDefaults.reasoningEffort = reasoningEffort;
+		}
 		return yield* session.runtime.sendTurn({
 			...input.input !== void 0 ? { input: input.input } : {},
 			...input.modelSelection?.instanceId === boundInstanceId ? { model: input.modelSelection.model } : {},
@@ -109768,7 +110132,10 @@ const orchestrationHttpApiLayer = HttpApiBuilder.group(EnvironmentHttpApi, "orch
 	})).handle("threadSnapshot", Effect.fn("environment.orchestration.threadSnapshot")(function* (args) {
 		yield* annotateEnvironmentRequest(args.endpoint.name);
 		yield* requireEnvironmentScope(AuthOrchestrationReadScope);
-		const snapshot = yield* projectionSnapshotQuery.getThreadDetailSnapshot(args.params.threadId).pipe(Effect.catch((cause) => failEnvironmentInternal("orchestration_thread_snapshot_failed", cause)));
+		const snapshot = yield* projectionSnapshotQuery.getThreadDetailSnapshot(args.params.threadId, args.payload.turnLimit === void 0 ? void 0 : {
+			turnLimit: args.payload.turnLimit,
+			...args.payload.beforeCursor !== void 0 ? { beforeCursor: args.payload.beforeCursor } : {}
+		}).pipe(Effect.catch((cause) => failEnvironmentInternal("orchestration_thread_snapshot_failed", cause)));
 		if (Option.isNone(snapshot)) return yield* failEnvironmentNotFound("thread_not_found");
 		return projectThreadDetailSnapshot(snapshot.value);
 	})).handle("dispatch", Effect.fn("environment.orchestration.dispatch")(function* (args) {