@gajae-code/coding-agent 0.12.11 → 0.12.13

package/src/coordinator-mcp/server.ts

@@ -18,6 +18,11 @@ import { type EnsureBrokerSettings, ensureBroker } from "../sdk/broker/ensure";
 import { UnsupportedStateVersionError } from "../sdk/broker/state-version";
 import { SdkClient, SdkClientError } from "../sdk/client/client";
 import { readSdkBrokerDiscovery } from "../sdk/client/discovery";
+import {
+	type ActivatedPreparedSession,
+	requestPreparedSessionActivation,
+	SessionActivationError,
+} from "../sdk/session-activation";
 import {
 	type CoordinatorModelProfileLoader,
 	loadCoordinatorModelProfiles,
@@ -222,6 +227,8 @@ interface TurnRecord {
 
 type CoordinatorSessionStateValue =
 	| "booting"
+	/** Live and endpoint-addressable, but withholding readiness until activation. */
+	| "prepared"
 	| "ready_for_input"
 	| "running"
 	| "needs_user_input"
@@ -290,6 +297,8 @@ interface CoordinatorEventInput {
 	metadata?: Record<string, string | number | boolean | null>;
 }
 
+const UNOBSERVED_COMPENSATION_CODE = "broker_compensation_unobserved";
+
 const MISSING_FINAL_RESPONSE_ADVISORY = "completion_missing_final_response";
 const PROMPT_ACK_TIMEOUT_REASON = "runtime_prompt_ack_timeout";
 const DEFAULT_RUNTIME_PROMPT_ACK_TIMEOUT_MS = 10_000;
@@ -364,12 +373,18 @@ function toolSchema(name: CoordinatorToolName): {
 	if (name === "gjc_coordinator_start_session") {
 		return {
 			name,
-			description: "Start a broker-managed GJC session through canonical SDK lifecycle control.",
+			description:
+				"Start a broker-managed GJC session through canonical SDK lifecycle control. Set prepare_existing_thread to hold the session at prepared (endpoint-addressable, readiness withheld) so an existing chat thread can be bound before activation.",
 			inputSchema: {
 				type: "object",
 				properties: {
 					cwd,
 					prompt: { type: "string" },
+					prepare_existing_thread: {
+						type: "boolean",
+						description:
+							"Create the session prepared instead of ready: no readiness is published and no initial prompt is accepted until gjc_coordinator_activate_session proves activation.",
+					},
 					mpreset,
 					idempotency_key: idempotencyKey,
 					allow_mutation: allowMutation,
@@ -378,6 +393,22 @@ function toolSchema(name: CoordinatorToolName): {
 			},
 		};
 	}
+	if (name === "gjc_coordinator_activate_session") {
+		return {
+			name,
+			description:
+				"Activate a prepared session so it publishes the readiness it withheld. Requires the session's own proof at the exact endpoint generation, so it fails closed while no existing-thread binding has been applied.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					session_id: sessionId,
+					idempotency_key: idempotencyKey,
+					allow_mutation: allowMutation,
+				},
+				required: ["session_id", "idempotency_key", "allow_mutation"],
+			},
+		};
+	}
 	if (name === "gjc_coordinator_stop_session") {
 		return {
 			name,
@@ -853,6 +884,38 @@ function boundedPublicResponse(response: Record<string, unknown>): Record<string
 	return asRecord(value) ?? { ok: false, error: { code: "unavailable", message: "Invalid coordinator response." } };
 }
 
+/**
+ * `activation_outcome_unknown` states only that the activation's outcome could
+ * not be observed: the session may already have published the readiness the
+ * request asked for. It is the one activation answer that proves nothing, so it
+ * is returned to the caller without being sealed as a settled receipt.
+ */
+function isUnknownActivationOutcome(response: Record<string, unknown>): boolean {
+	if (response.ok !== false) return false;
+	return asRecord(response.error)?.code === "activation_outcome_unknown";
+}
+
+/**
+ * Which durable states may reach the activation proof, and which of them is
+ * already settled.
+ *
+ * Durable state is a record of what was proved, never a proof on its own. Only
+ * a `prepared` session (readiness still withheld) and a `ready_for_input` one
+ * (readiness already proved once) are activatable, and both are answered by the
+ * live session at the exact endpoint, generation, incarnation, and binding.
+ * Every other observed state — stale, booting, running, needs_user_input,
+ * completed, errored, unknown, or a missing state file — is not activatable and
+ * fails closed before any frame is sent.
+ */
+function classifyCoordinatorActivation(
+	state: CoordinatorSessionState | null,
+): { activatable: true; settled: boolean; observed: string } | { activatable: false; observed: string } {
+	const observed = state?.state ?? "unknown";
+	if (observed === "prepared") return { activatable: true, settled: false, observed };
+	if (observed === "ready_for_input") return { activatable: true, settled: true, observed };
+	return { activatable: false, observed };
+}
+
 interface RuntimePromptAcknowledgement {
 	accepted: true;
 	command_id: string;
@@ -2509,6 +2572,16 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 		return normalizeRuntimePromptAcknowledgement(result);
 	}
 
+	/**
+	 * The outcome of a failed compensating close is unobserved, not decided: the
+	 * session may still be running. Sealing it under the idempotency key would
+	 * answer that uncertainty forever, so the key stays open for a real retry.
+	 */
+	function isUnobservedCompensation(response: Record<string, unknown>): boolean {
+		const error = asRecord(response.error);
+		return error?.code === UNOBSERVED_COMPENSATION_CODE;
+	}
+
 	function sdkError(error: unknown): Record<string, unknown> {
 		if (error instanceof SdkClientError) return { ok: false, error: { code: error.code, message: error.message } };
 		return {
@@ -2528,12 +2601,26 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 		return path.join(namespaceDir, "idempotency", `${keyDigest}.json`);
 	}
 
+	/**
+	 * Run one mutation under its idempotency key, then seal its response as the
+	 * key's terminal replay.
+	 *
+	 * `isNonterminal` is the one exception. Sealing is correct for a decided
+	 * outcome, and wrong for a response that states only that the outcome could
+	 * not be observed: the key would answer that uncertainty forever, even once
+	 * the remote effect settled. A tool may declare such a response nonterminal,
+	 * which returns it to this caller while the receipt stays `in_progress`, so
+	 * an exact same-key retry re-runs the observation under the same request
+	 * digest. The default declares nothing nonterminal, so every other tool keeps
+	 * its existing caching, conflict, and replay behaviour unchanged.
+	 */
 	async function withToolIdempotency(
 		tool: string,
 		idempotencyKey: string,
 		canonicalArgs: Record<string, unknown>,
 		operation: () => Promise<Record<string, unknown>>,
 		recoverInProgress = false,
+		isNonterminal: (response: Record<string, unknown>) => boolean = () => false,
 	): Promise<Record<string, unknown>> {
 		const keyDigest = createHash("sha256").update(idempotencyKey).digest("hex");
 		const requestDigest = createHash("sha256")
@@ -2584,6 +2671,9 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 					};
 				if (existing.state === "in_progress") {
 					const response = boundedPublicResponse(await operation().catch(error => sdkError(error)));
+					// The receipt keeps its original key and request digests, so a
+					// reused key still conflicts and a later settled answer still seals.
+					if (isNonterminal(response)) return response;
 					await writeCoordinatorIdempotencyFile(file, {
 						...existing,
 						state: "completed",
@@ -2610,6 +2700,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 			};
 			await writeCoordinatorIdempotencyFile(file, started);
 			const response = boundedPublicResponse(await operation().catch(error => sdkError(error)));
+			if (isNonterminal(response)) return response;
 			await writeCoordinatorIdempotencyFile(file, {
 				...started,
 				state: "completed",
@@ -2803,6 +2894,75 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 		return binding.endpoint;
 	}
 
+	/**
+	 * The same incarnation-bound authority `resolveSessionEndpoint` requires,
+	 * plus the exact endpoint generation the activation frame has to name. A
+	 * session whose endpoint rolled or whose workspace binding drifted is refused
+	 * here, before any activation is attempted.
+	 */
+	async function resolveSessionActivationTarget(
+		session: Record<string, unknown>,
+		idempotencyKey?: string,
+	): Promise<{ endpoint: { url: string; token: string }; endpointGeneration: number }> {
+		const sessionId = optionalString(session.session_id) ?? optionalString(session.sessionId);
+		const cwd = optionalString(session.cwd);
+		const persistedWorkspace = optionalString(session.broker_workspace);
+		const persistedGeneration =
+			typeof session.endpoint_generation === "number" &&
+			Number.isSafeInteger(session.endpoint_generation) &&
+			session.endpoint_generation > 0
+				? session.endpoint_generation
+				: null;
+		const persistedIncarnation = optionalString(session.endpoint_incarnation);
+		if (!sessionId || !cwd || !persistedWorkspace || persistedGeneration === null || !persistedIncarnation)
+			throw new SdkClientError("not_found", "Coordinator session has no incarnation-bound broker identity.");
+		const workspace = await canonicalBrokerWorkspace(cwd);
+		if (!sameCanonicalPath(workspace, persistedWorkspace, platform))
+			throw new SdkClientError("endpoint_stale", "Coordinator session workspace binding is stale.");
+		const binding = await exactBrokerSessionBinding(sessionId, workspace, idempotencyKey);
+		if (binding.endpointGeneration !== persistedGeneration || binding.endpointIncarnation !== persistedIncarnation)
+			throw new SdkClientError("endpoint_stale", "Coordinator session endpoint incarnation is stale.");
+		return { endpoint: binding.endpoint, endpointGeneration: binding.endpointGeneration };
+	}
+
+	/**
+	 * Ask a prepared session to publish its withheld readiness.
+	 *
+	 * The Coordinator never writes a chat mapping and never fakes a readiness
+	 * signal: it proves exact endpoint authority, then delegates to the same
+	 * activation exchange the `gjc notify activate-thread` CLI uses. The session's
+	 * own activation gate remains the authority on whether a binding exists.
+	 */
+	async function activatePreparedCoordinatorSession(
+		session: Record<string, unknown>,
+		sessionId: string,
+		idempotencyKey: string,
+	): Promise<ActivatedPreparedSession> {
+		const target = await resolveSessionActivationTarget(session, idempotencyKey);
+		let client: SdkClient;
+		try {
+			client = await (services.connectSdk ?? ((url, token) => SdkClient.connect(url, token)))(
+				target.endpoint.url,
+				target.endpoint.token,
+			);
+		} catch {
+			// Nothing was sent, so no activation can have been applied.
+			throw new SessionActivationError("activation_unavailable", "The session endpoint could not be reached.");
+		}
+		try {
+			return await requestPreparedSessionActivation(
+				{
+					request: async frame => (await client.request(frame)) as Record<string, unknown>,
+					close: async () => await client.close(),
+				},
+				sessionId,
+				target.endpointGeneration,
+			);
+		} finally {
+			await client.close().catch(() => undefined);
+		}
+	}
+
 	async function listSessions(cwd?: string): Promise<Array<Record<string, unknown>>> {
 		const roots = cwd ? [cwd] : config.allowedRoots;
 		const listings = await Promise.all(
@@ -3606,6 +3766,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 						return response;
 					},
 					true,
+					isUnobservedCompensation,
 				);
 			}
 			if (name === "gjc_coordinator_read_status") {
@@ -4026,10 +4187,41 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 					};
 				}
 				const prompt = typeof args.prompt === "string" && args.prompt.length > 0 ? args.prompt : null;
+				/**
+				 * A prepared session is deliberately not ready for input: its readiness
+				 * is withheld until an operator-supplied thread is bound and activation
+				 * is proven. Accepting an initial prompt here would either be silently
+				 * dropped or delivered to a session no consumer has been told is live,
+				 * so it is refused before any broker mutation or idempotency record.
+				 */
+				// Runtime dispatch hands `params.arguments` through unvalidated, so a
+				// client sending the string "true" would coerce to false here and start
+				// an ordinary ready session that accepts the prompt — the opposite of
+				// what the schema promises. Reject a non-boolean before any mutation.
+				const requestedPrepare = (args as Record<string, unknown>).prepare_existing_thread;
+				if (requestedPrepare !== undefined && typeof requestedPrepare !== "boolean")
+					return {
+						ok: false,
+						error: {
+							code: "invalid_input",
+							message: `prepare_existing_thread must be a boolean; received ${typeof requestedPrepare}.`,
+						},
+					};
+				const preparesExistingThread = requestedPrepare === true;
+				if (preparesExistingThread && prompt)
+					return {
+						ok: false,
+						error: {
+							code: "invalid_input",
+							message:
+								"prepare_existing_thread cannot carry an initial prompt; activate the session first, then send_prompt.",
+						},
+					};
 				const canonicalArgs = {
 					cwd,
 					mpreset: mpresetResolution.mpreset,
 					...(prompt ? { prompt } : {}),
+					...(preparesExistingThread ? { prepare_existing_thread: true } : {}),
 					allow_mutation: true,
 				};
 				return await withToolIdempotency(
@@ -4056,10 +4248,45 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 										cwd,
 										target: coordinatorLifecycleTarget(config.sessionCommand, cwd),
 										...(mpresetResolution.mpreset ? { modelPreset: mpresetResolution.mpreset } : {}),
+										...(preparesExistingThread ? { readiness: "deferred" } : {}),
 									},
 									idempotencyKey,
 								),
 							);
+							/**
+							 * Preparation is only real when the broker proves it. A create that
+							 * silently published readiness would leave a live session whose root
+							 * is already claimed, so the session is closed rather than reported
+							 * as prepared.
+							 */
+							if (preparesExistingThread && created.readiness !== "prepared") {
+								const unpreparedId = optionalString(created.sessionId ?? created.session_id);
+								let compensated = true;
+								if (unpreparedId) {
+									compensated = await brokerSession(
+										cwd,
+										"session.close",
+										{ sessionId: unpreparedId },
+										`${idempotencyKey}:unprepared-close`,
+									).then(
+										() => true,
+										() => false,
+									);
+								}
+								// A swallowed compensation leaves a live, untracked session while
+								// idempotency seals the failure, so exact retries only replay the
+								// cached error and never reach the session again. Name the session
+								// and mark the outcome unobserved so the key is not sealed.
+								if (!compensated)
+									throw new SdkClientError(
+										UNOBSERVED_COMPENSATION_CODE,
+										`SDK broker did not prepare the requested session, and closing the unprepared session ${unpreparedId} failed; it may still be running.`,
+									);
+								throw new SdkClientError(
+									"broker_request_unavailable",
+									"SDK broker did not prepare the requested session.",
+								);
+							}
 							sessionId = safeExternalId("session", created.sessionId ?? created.session_id);
 							const sessionCwd = await canonicalBrokerWorkspace(optionalString(created.cwd) ?? cwd);
 							const binding = await exactBrokerSessionBinding(sessionId, sessionCwd, idempotencyKey);
@@ -4076,7 +4303,7 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 							kind: "start",
 							session: canonicalCreationSnapshot(session),
 							remote_create_key: creation.request.remote_create_key,
-							initial_state: prompt ? "running" : "ready_for_input",
+							initial_state: prompt ? "running" : preparesExistingThread ? "prepared" : "ready_for_input",
 							initial_prompt: prompt
 								? { text: prompt, caller_key_digest: createHash("sha256").update(idempotencyKey).digest("hex") }
 								: null,
@@ -4117,14 +4344,18 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 							await advanceCreationReceipt(questionPaths, creation.keyDigest, "completed", response);
 							return response;
 						}
-						const sessionState = await writeSessionState(namespaceDir, sessionId, "ready_for_input", {
-							live: null,
-							reason: null,
-						});
+						const sessionState = await writeSessionState(
+							namespaceDir,
+							sessionId,
+							preparesExistingThread ? "prepared" : "ready_for_input",
+							{ live: null, reason: null },
+						);
 						await appendCoordinatorEvent(namespaceDir, {
 							kind: "session.started",
 							sessionId,
-							summary: `Session ${sessionId} started through SDK lifecycle control`,
+							summary: preparesExistingThread
+								? `Session ${sessionId} prepared through SDK lifecycle control`
+								: `Session ${sessionId} started through SDK lifecycle control`,
 							payloadRef: path.relative(namespaceDir, sessionFile(sessionId)),
 						});
 						const response = {
@@ -4132,12 +4363,113 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 							session: publicCoordinatorSession(session),
 							session_state: publicCoordinatorSessionState(sessionState),
 							lifecycle,
+							...(preparesExistingThread ? { session_id: sessionId, state: "prepared" as const } : {}),
 						};
 						await advanceCreationReceipt(questionPaths, creation.keyDigest, "projected", response);
 						await advanceCreationReceipt(questionPaths, creation.keyDigest, "completed", response);
 						return response;
 					},
 					true,
+					isUnobservedCompensation,
+				);
+			}
+			if (name === "gjc_coordinator_activate_session") {
+				requireCoordinatorMutation(config, "sessions", args);
+				const idempotencyKey = requiredIdempotencyKey(args);
+				const sessionId = safeExternalId("session", args.session_id);
+				return await withToolIdempotency(
+					name,
+					idempotencyKey,
+					{ session_id: sessionId, allow_mutation: true },
+					async () =>
+						await withSessionTransition(sessionId, async () => {
+							const currentSession = asRecord(await readJsonFile(sessionFile(sessionId)));
+							if (!currentSession)
+								return {
+									ok: false,
+									error: { code: "not_found", message: `Coordinator session not found: ${sessionId}` },
+								};
+							const before = await readSessionState(namespaceDir, sessionId);
+							/**
+							 * A settled activation is not reported from durable state alone: a
+							 * session that went stale, errored, completed, or never recorded a
+							 * state cannot be answered `already`, and even a recorded
+							 * `ready_for_input` has to be re-proved against the live session
+							 * below before it may be.
+							 */
+							const eligibility = classifyCoordinatorActivation(before);
+							if (!eligibility.activatable)
+								return {
+									ok: false,
+									session_id: sessionId,
+									state: eligibility.observed,
+									session_state: publicCoordinatorSessionState(before),
+									error: {
+										code: "session_not_activatable",
+										message: `Coordinator session is not activatable in state ${eligibility.observed}.`,
+									},
+								};
+							let activated: ActivatedPreparedSession;
+							try {
+								activated = await activatePreparedCoordinatorSession(currentSession, sessionId, idempotencyKey);
+							} catch (error) {
+								if (!(error instanceof SessionActivationError)) throw error;
+								return {
+									ok: false,
+									session_id: sessionId,
+									state: before?.state ?? "unknown",
+									session_state: publicCoordinatorSessionState(before),
+									error: { code: error.code, message: error.message },
+								};
+							}
+							/**
+							 * An already-ready session transitions nothing: the answer above is
+							 * the live session's own, proved at the exact endpoint generation
+							 * this call resolved, so durable state is neither rewritten nor
+							 * given a second readiness event.
+							 */
+							if (eligibility.settled)
+								return {
+									ok: true,
+									session_id: sessionId,
+									status: activated.status,
+									state: "ready_for_input" as const,
+									endpoint_generation: activated.endpointGeneration,
+									session_state: publicCoordinatorSessionState(before),
+								};
+							// Only a proven `activated`/`already` moves durable state to ready.
+							const sessionState = await writeSessionState(namespaceDir, sessionId, "ready_for_input", {
+								live: true,
+								reason: null,
+							});
+							await appendCoordinatorEvent(namespaceDir, {
+								kind: "session.started",
+								sessionId,
+								summary: `Session ${sessionId} activated its withheld readiness`,
+								payloadRef: path.relative(namespaceDir, sessionFile(sessionId)),
+								metadata: {
+									status: activated.status,
+									endpoint_generation: activated.endpointGeneration,
+								},
+							});
+							return {
+								ok: true,
+								session_id: sessionId,
+								status: activated.status,
+								state: "ready_for_input" as const,
+								endpoint_generation: activated.endpointGeneration,
+								session_state: publicCoordinatorSessionState(sessionState),
+							};
+						}),
+					/**
+					 * A crash between writing the receipt and settling it leaves an
+					 * in-progress activation. Recovering it is safe because every retry
+					 * re-proves the workspace, generation, and incarnation before it
+					 * sends anything, and the session answers a repeated activation
+					 * `already` rather than publishing readiness twice.
+					 */
+					true,
+					isUnknownActivationOutcome,
 				);
 			}
 			if (name === "gjc_coordinator_send_prompt") {
@@ -4166,6 +4498,25 @@ export function createCoordinatorMcpServer(options: CoordinatorMcpServerOptions
 									error: { code: "not_found", message: `Coordinator session not found: ${sessionId}` },
 								};
 							}
+							/**
+							 * A prepared session is not ready for input. Its readiness is still
+							 * withheld, so a prompt here would be delivered to a session no
+							 * consumer has been told is live, and (for an existing-thread
+							 * preparation) before its root binding could be applied.
+							 */
+							const preparedState = await readSessionState(namespaceDir, sessionId);
+							if (preparedState?.state === "prepared") {
+								return {
+									ok: false,
+									session_id: sessionId,
+									state: "prepared" as const,
+									error: {
+										code: "session_not_activated",
+										message: `Session ${sessionId} is prepared; activate it before sending a prompt.`,
+									},
+									session_state: publicCoordinatorSessionState(preparedState),
+								};
+							}
 							const previousActiveTurn = await readActiveTurn(namespaceDir, sessionId);
 							if (previousActiveTurn && args.queue !== true && args.force !== true) {
 								return {

package/src/defaults/gjc/skills/deep-interview/SKILL.md

@@ -122,7 +122,7 @@ Deep Interview threshold: <resolvedThresholdPercent> (source: <resolvedThreshold
    - Substitute `<resolvedThreshold>`, `<resolvedThresholdPercent>`, and `<resolvedThresholdSource>` throughout the remaining instructions before continuing.
    - Include `threshold_source` in the first `gjc deep-interview write` payload and preserve it on later state updates; do not edit `.gjc/_session-{sessionid}/state` files directly unless an explicit force override is active.
    - Include both threshold and source in the final spec metadata.
-- Read any `language` object from active deep-interview state and carry `language.instruction` forward mechanically. If absent, default to English unless `{{ARGUMENTS}}` makes another user/session language obvious or the user explicitly requests another language. Do not add language-specific special cases.
+- Read any `language` object from active deep-interview state and carry `language.instruction` forward mechanically. If absent, default to English unless the appended `User:` request makes another user/session language obvious or the user explicitly requests another language. Do not add language-specific special cases.
 
 ## Phase 0.5: Suitability Gate
 

package/src/defaults/gjc/skills/ultragoal/SKILL.md

@@ -308,6 +308,8 @@ One generation freezes the change set and reviews it exactly once:
    - Native/desktop/tui surfaces require a structurally valid screenshot, PTY capture with terminal control codes, or app-automation transcript.
    - API/package surfaces require a real artifact file or typed receipt whose artifact `kind` contains one of `api`, `package`, `consumer`, `black-box`, or `test-report`; examples: `api-package-test-report`, `package-consumer-report`, `black-box-api-receipt`. Algorithm/math surfaces require a real artifact file or typed receipt whose artifact `kind` contains one of `property`, `boundary`, `edge`, `adversarial`, `failure`, `math`, `algorithm`, or `test-report`; examples: `property-test-report`, `algorithm-boundary-report`. Bare `inlineEvidence` text alone is not sufficient for any surface.
    - The mandatory **computer-use** red-team suite (`kill-switch-bypass`, `suspended-enforcement`, `permission-revoked`, …) is conditional, not universal: require it only when computer/desktop control is genuinely part of the product surface being dogfooded. For every other product type, prove the change through the matching live surface instead — browser-use automation for web/GUI, bash/CLI live invocation or argv replay for CLI, and real artifacts or typed receipts for API/package/algorithm/math. Editing docs, prompts, or skills that merely mention computer-use does not by itself make the computer-use suite applicable; pick the red-team surface that matches what the change actually ships.
+   - **The runtime decides applicability from the change set, and it fails closed.** Judgement about "what the change actually ships" does not override it, so check the paths before assuming the suite is skippable. `gjc ultragoal checkpoint --status complete` requires the suite whenever the computed change set touches computer source (`crates/pi-natives/src/computer/**`), the computer tool (`packages/coding-agent/src/tools/computer.ts`, `packages/coding-agent/src/tools/computer/**`), or a **shared behavior registry** — `packages/coding-agent/src/config/settings-schema.ts`, `packages/coding-agent/src/tools/index.ts`, `packages/coding-agent/src/tools/renderers.ts`. The registries are deliberately unconditional: they mix computer and non-computer entries, and a path-only or uninspectable change cannot prove computer controls were untouched, so *any* edit to them demands the suite even when the diff contains nothing computer-related. The suite is also required whenever change-set capture was incomplete. Generated bindings (`packages/natives/native/index.{d.ts,js}`), prompt/skill/doc files, and every other path do not trigger it on their own.
+   - Practical consequence: a change that is not about computer-use at all — say a new settings key in `settings-schema.ts` — will still be gated on the seven mandatory cases. Do **not** fabricate them to get past the gate, and do not weaken the gate. Either supply a genuine suite, or treat it as a blocker and escalate to the operator (`gjc ultragoal record-critic-gate-override` exists for an authorized override).
 7. The executor QA/red-team lane must report a matrix using `executorQa.contractCoverage`, `executorQa.surfaceEvidence`, `executorQa.adversarialCases`, and `executorQa.artifactRefs`. Not-applicable rows are allowed only in `contractCoverage` and `surfaceEvidence`; each `status: "not_applicable"` row requires `contractRef` plus `reason`. `adversarialCases` rows cannot be not-applicable.
 8. **Join before repairing.** Fold all three lane verdicts and the final code review into the strict gate under `iteration.reviewCohort` (`reviewGeneration`, `sourceHash`, `joined: true`, and the three `lanes`). No lane may checkpoint on its own, and no fix work starts until the findings are joined. Clean means `architectReview.architectureStatus`, `architectReview.productStatus`, and `architectReview.codeStatus` are all `"CLEAR"`, `architectReview.recommendation` is `"APPROVE"`, executor QA statuses are `"passed"`, iteration is `"passed"` with `fullRerun: true`, the cohort is joined with every lane clean and hash-bound, every evidence field is non-empty, every required matrix row is present, and every blockers array is empty. `COMMENT`, `WATCH`, `REQUEST CHANGES`, `BLOCK`, missing evidence, missing or shallow matrix rows, plan/code mismatches, or non-empty blockers are non-clean.
 9. If the joined findings contain any blocker, do **not** checkpoint `complete` and do **not** call `goal({"op":"complete"})`. Record **one consolidated blocker batch** for all findings from the whole cohort instead of one story per lane:

package/src/extensibility/extensions/index.ts

@@ -9,6 +9,7 @@ export {
 	loadExtensionFromFactory,
 	loadExtensions,
 } from "./loader";
+export * from "./ouroboros-ooo-bridge";
 export * from "./prefix-command-bridge";
 export * from "./runner";
 // Type guards