@gajae-code/coding-agent 0.16.0 → 0.16.1

package/src/sdk/host/control/dispatch.ts

@@ -291,8 +291,8 @@ function invoke(
 			return surface.setQueueMode("steering", input.mode);
 		case "queue.follow_up_mode.set":
 			return surface.setQueueMode("follow_up", input.mode);
-		case "queue.interrupt_mode.set":
-			return surface.setQueueMode("interrupt", input.mode);
+		case "queue.tool_interrupt_policy.set":
+			return surface.setQueueMode("tool_interrupt", input.mode);
 		case "compaction.run":
 			return surface.runCompaction();
 		case "compaction.auto.set":

package/src/sdk/host/events.ts

@@ -2,6 +2,7 @@ import type { SdkFrame } from "./types";
 
 export interface EventFrame extends SdkFrame {
 	type: "event";
+	revision?: number;
 	generation: number;
 	seq: number;
 }

package/src/sdk/host/host.ts

@@ -354,6 +354,8 @@ export class SessionSdkHost {
 			if (this.events.generation !== generation) return "generation_changed";
 			if (this.#readyGeneration === generation) return "already";
 		}
+		if (!this.#started || this.#stopping) return "not_prepared";
+		if (this.events.generation !== generation) return "generation_changed";
 		this.#publishReadiness();
 		return "activated";
 	}

package/src/sdk/host/query/cursor.ts

@@ -18,6 +18,7 @@ export interface CursorEnvelope {
 	issuedAt?: number;
 	/** TTL metadata minted by `CursorRegistry.grant`: wall-clock ms when the cursor expires. */
 	expiresAt?: number;
+	purpose?: "checkpoint";
 	position: unknown;
 	direction: string;
 	pageShape: unknown;
@@ -68,6 +69,7 @@ export interface CursorQueryContext {
 	resourceId?: string;
 	direction: string;
 	pageShape: unknown;
+	purpose?: "checkpoint";
 }
 
 export class CursorError extends Error {
@@ -170,26 +172,68 @@ export class CursorRegistry {
 		cursor: string,
 		connectionId: string,
 		expected: CursorQueryContext,
-		resourceKind: string,
+		_resourceKind: string,
 		resourceId: string,
 	): Promise<{ cursor: string; envelope: CursorEnvelope }> {
 		const envelope = verifyCursor(cursor, this.sessionToken);
-		if (!envelope) throw new CursorError("invalid_cursor", false);
-		if (envelope.expiresAt === undefined || envelope.expiresAt <= this.now()) throw new CursorError("cursor_expired");
+		if (!envelope) {
+			this.release(cursor);
+			throw new CursorError("invalid_cursor", true);
+		}
+		const source = this.#active.get(cursor);
+		if (!source || envelope.expiresAt === undefined) {
+			this.release(cursor);
+			throw new CursorError("invalid_cursor", true);
+		}
+		const validatedAt = this.now();
+		if (source.expiresAt <= validatedAt || envelope.expiresAt <= validatedAt) {
+			this.release(cursor);
+			throw new CursorError("cursor_expired");
+		}
 		if (
 			envelope.sessionId !== expected.sessionId ||
 			(expected.resource !== undefined && envelope.resource !== expected.resource) ||
 			envelope.direction !== expected.direction ||
-			canonicalJson(envelope.pageShape) !== canonicalJson(expected.pageShape)
+			canonicalJson(envelope.pageShape) !== canonicalJson(expected.pageShape) ||
+			envelope.purpose !== expected.purpose ||
+			_resourceKind !== envelope.resource ||
+			source.resourceId !== resourceId
 		)
 			throw new CursorError("invalid_input", false, "cursor does not match query");
+		// Preserve the already-validated source while removing expired target
+		// grants before capacity accounting. The shared timestamp prevents the
+		// source from changing classification at a TTL boundary mid-exchange.
+		this.sweep(cursor, validatedAt);
+		const targetConnectionCount = [...this.#active.values()].filter(
+			item => item.connectionId === connectionId,
+		).length;
+		if (
+			this.#active.size > MAX_CURSORS_PER_SESSION ||
+			targetConnectionCount - (source.connectionId === connectionId ? 1 : 0) >= MAX_CURSORS_PER_CONNECTION
+		)
+			throw new CursorError("snapshot_capacity_exceeded", false);
 		const exchanged: CursorEnvelope = {
 			...envelope,
 			nonce: randomUUID(),
 			issuedAt: undefined,
 			expiresAt: undefined,
 		};
-		const exchangedCursor = await this.grant(connectionId, exchanged, resourceKind, resourceId);
+		const issuedAt = this.now();
+		exchanged.issuedAt = issuedAt;
+		exchanged.expiresAt = issuedAt + CURSOR_TTL_MS;
+		const exchangedCursor = signCursor(exchanged, this.sessionToken);
+		try {
+			this.revisions.transferPin(cursor, exchangedCursor);
+		} catch (error) {
+			if (error instanceof RevisionStoreError) throw new CursorError(error.code, false, error.message);
+			throw error;
+		}
+		this.#active.delete(cursor);
+		this.#active.set(exchangedCursor, {
+			connectionId,
+			resourceId,
+			expiresAt: exchanged.expiresAt,
+		});
 		return { cursor: exchangedCursor, envelope: exchanged };
 	}
 
@@ -227,8 +271,9 @@ export class CursorRegistry {
 	close(): void {
 		for (const cursor of this.#active.keys()) this.release(cursor);
 	}
-	sweep(): void {
-		for (const [cursor, active] of this.#active) if (active.expiresAt <= this.now()) this.release(cursor);
+	sweep(exceptCursor?: string, at = this.now()): void {
+		for (const [cursor, active] of this.#active)
+			if (cursor !== exceptCursor && active.expiresAt <= at) this.release(cursor);
 		this.revisions.sweep();
 	}
 	get size(): number {

package/src/sdk/host/query/handlers.ts

@@ -108,6 +108,7 @@ export interface SdkCheckpointRecord {
 	revision: number;
 	generation: number;
 	seq: number;
+	idle: boolean;
 }
 
 function isNonNegativeSafeInteger(value: unknown): value is number {
@@ -119,10 +120,11 @@ export function isCheckpointRecord(value: unknown): value is SdkCheckpointRecord
 	const record = value as Record<string, unknown>;
 	const keys = Object.keys(record);
 	return (
-		keys.length === 3 &&
+		keys.length === 4 &&
 		isNonNegativeSafeInteger(record.revision) &&
 		isNonNegativeSafeInteger(record.generation) &&
-		isNonNegativeSafeInteger(record.seq)
+		isNonNegativeSafeInteger(record.seq) &&
+		typeof record.idle === "boolean"
 	);
 }
 const sources: Record<string, { resource: string; method: keyof SessionSurface; mvcc: boolean }> = {
@@ -296,9 +298,10 @@ export class QueryHandlers {
 		let snapshot: unknown;
 		// The cursor may arrive either as the top-level continuation cursor or,
 		// on Q01 only (validated in `dispatch`), as the `checkpointToken` resume
-		// seed. Both are signed checkpoint cursors consumed through the same
-		// CursorRegistry authority; neither mints a fresh snapshot.
-		const rawCursorToken = request.cursor ?? (queryId === "Q01" ? request.input?.checkpointToken : undefined);
+		// seed. Both are consumed through the same CursorRegistry authority, but
+		// only the named input token is required to carry checkpoint purpose.
+		const checkpointToken = queryId === "Q01" ? request.input?.checkpointToken : undefined;
+		const rawCursorToken = request.cursor ?? checkpointToken;
 		if (rawCursorToken !== undefined && typeof rawCursorToken !== "string")
 			return this.#error(request, "invalid_request", false, "checkpointToken must be a non-empty string.");
 		const cursorToken = rawCursorToken;
@@ -309,6 +312,8 @@ export class QueryHandlers {
 				direction: "forward",
 				pageShape: { targetBytes: TARGET_PAGE_BYTES },
 			});
+			if (checkpointToken !== undefined && cursor.purpose !== "checkpoint")
+				throw new CursorError("invalid_input", false, "checkpointToken does not carry checkpoint purpose");
 			selector = assertCursorSelector(cursorSelector(cursor.position), selector);
 			resourceId = selector.resourceId ?? "default";
 			revision = cursor.revision;
@@ -467,10 +472,20 @@ export class QueryHandlers {
 						resource: "transcript",
 						direction: "forward",
 						pageShape: { targetBytes: TARGET_PAGE_BYTES },
+						purpose: "checkpoint",
 					},
 					"transcript",
 					"default",
 				);
+				if (!isCheckpointRecord(exchanged.envelope.highWatermark)) {
+					this.cursors.release(exchanged.cursor);
+					return this.#error(
+						request,
+						"invalid_input",
+						false,
+						"checkpointToken is not an authoritative checkpoint.",
+					);
+				}
 				return {
 					id: request.id,
 					ok: true,
@@ -494,13 +509,18 @@ export class QueryHandlers {
 		// Atomic synchronous capture (C9): entries and event-ring watermark come
 		// from the same host-owned call, so the pinned snapshot revision and the
 		// subscribe position can never straddle a concurrent append.
-		const captured =
-			typeof this.surface.getCheckpointSnapshot === "function" ? this.surface.getCheckpointSnapshot() : undefined;
-		const entries = captured !== undefined ? captured.entries : await this.surface.getTranscriptEntries();
-		const head: SdkCheckpointRecord =
-			captured !== undefined
-				? captured.watermark
-				: { revision: Array.isArray(entries) ? entries.length : 0, generation: 0, seq: 0 };
+		if (typeof this.surface.getCheckpointSnapshot !== "function")
+			return this.#error(request, "unavailable", false, "Atomic session checkpoint capture is unavailable.");
+		const captured = this.surface.getCheckpointSnapshot();
+		const entries = captured.entries;
+		const head = captured.watermark;
+		if (!isCheckpointRecord(head))
+			return this.#error(
+				request,
+				"unavailable",
+				false,
+				"Atomic session checkpoint capture returned an invalid watermark.",
+			);
 		// Mint the snapshot from the exact entries captured with the watermark;
 		// entries appended after this point are excluded from replay by
 		// construction (append-during-checkpoint), and the returned token is the
@@ -517,6 +537,7 @@ export class QueryHandlers {
 			highWatermark: head,
 			nonce,
 			position: { offset: 0, selector: { queryId: "Q01" } },
+			purpose: "checkpoint",
 			direction: "forward",
 			pageShape: { targetBytes: TARGET_PAGE_BYTES },
 		};

package/src/sdk/host/query/revision-store.ts

@@ -524,6 +524,18 @@ export class RevisionStore {
 		await this.#enforceMemory();
 	}
 
+	transferPin(sourceCursorId: string, replacementCursorId: string): void {
+		if (sourceCursorId === replacementCursorId) return;
+		if (this.#pinIndex.has(replacementCursorId))
+			throw new RevisionStoreError("snapshot_capacity_exceeded", "replacement cursor is already pinned");
+		const revision = this.#pinIndex.get(sourceCursorId);
+		if (!revision) throw new RevisionStoreError("snapshot_capacity_exceeded", "snapshot pin is unavailable");
+		revision.pins.delete(sourceCursorId);
+		revision.pins.add(replacementCursorId);
+		this.#pinIndex.delete(sourceCursorId);
+		this.#pinIndex.set(replacementCursorId, revision);
+	}
+
 	unpin(cursorId: string): void {
 		const revision = this.#pinIndex.get(cursorId);
 		if (!revision) return;