@gajae-code/coding-agent 0.12.5 → 0.12.6

package/src/config/model-profiles.ts

@@ -92,6 +92,13 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		critic: "openai-codex/gpt-5.6-sol:max",
 		architect: "openai-codex/gpt-5.6-sol:xhigh",
 	}),
+	profile("lunamaxxing", ["openai-codex"], {
+		default: "openai-codex/gpt-5.6-luna:medium",
+		executor: "openai-codex/gpt-5.6-luna:xhigh",
+		planner: "openai-codex/gpt-5.6-luna:max",
+		critic: "openai-codex/gpt-5.6-luna:max",
+		architect: "openai-codex/gpt-5.6-luna:max",
+	}),
 	profile("opencodego", ["opencode-go"], {
 		default: "opencode-go/kimi-k2.6",
 		executor: "opencode-go/deepseek-v4-flash",
@@ -327,6 +334,7 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"codex-eco": { displayName: "Codex Eco", providerGroup: "CODEX" },
 	"codex-medium": { displayName: "Codex Medium", providerGroup: "CODEX" },
 	"codex-pro": { displayName: "Codex Pro", providerGroup: "CODEX" },
+	lunamaxxing: { displayName: "LunaMaxxing", providerGroup: "CODEX" },
 	opencodego: { displayName: "OpenCodeGo", providerGroup: "OPENCODEGO" },
 	"claude-opus": { displayName: "Claude Opus", providerGroup: "CLAUDE" },
 	"claude-fable": { displayName: "Claude Fable", providerGroup: "CLAUDE" },

package/src/config/settings-schema.ts

@@ -3744,6 +3744,11 @@ function schemaPaths(value: Record<string, unknown>, prefix = ""): string[] {
 	return paths;
 }
 
+function validArraySettingValue(value: unknown, allowedValues: readonly string[] | undefined): boolean {
+	if (!Array.isArray(value)) return false;
+	return !allowedValues || value.every(item => typeof item === "string" && allowedValues.includes(item));
+}
+
 function validSettingValue(definition: (typeof SETTINGS_SCHEMA)[SettingPath], value: unknown): boolean {
 	return (
 		(definition.type === "boolean" && typeof value === "boolean") ||
@@ -3755,7 +3760,8 @@ function validSettingValue(definition: (typeof SETTINGS_SCHEMA)[SettingPath], va
 		(definition.type === "enum" &&
 			typeof value === "string" &&
 			(definition.values as readonly string[]).includes(value)) ||
-		(definition.type === "array" && Array.isArray(value)) ||
+		(definition.type === "array" &&
+			validArraySettingValue(value, "items" in definition ? definition.items?.enum : undefined)) ||
 		(definition.type === "record" && !!value && typeof value === "object" && !Array.isArray(value))
 	);
 }
@@ -3792,8 +3798,16 @@ export function reconcileSettingsSchema(raw: Record<string, unknown>): {
 			schemaSetAtPath(settings, path, next);
 			issues.push({ path, kind: "coerced", detail: `Coerced ${typeof value} to ${definition.type}.` });
 		}
-		if (!validSettingValue(definition, next))
-			issues.push({ path, kind: "invalid", detail: `Expected ${definition.type}.` });
+		if (!validSettingValue(definition, next)) {
+			const arrayItemEnum =
+				definition.type === "array" && Array.isArray(next) && "items" in definition
+					? definition.items?.enum
+					: undefined;
+			const detail = arrayItemEnum
+				? `Expected array items to be one of: ${arrayItemEnum.join(", ")}.`
+				: `Expected ${definition.type}.`;
+			issues.push({ path, kind: "invalid", detail });
+		}
 		if (
 			definition.type === "record" &&
 			"valueSchema" in definition &&

package/src/cursor.ts

@@ -14,6 +14,7 @@ import type {
 	ToolResultMessage,
 } from "@gajae-code/ai";
 import { sanitizeText } from "@gajae-code/utils";
+import { finalizeToolResultForDelivery } from "./tools/output-meta";
 import { resolveToCwd } from "./tools/path-utils";
 
 interface CursorExecBridgeOptions {
@@ -48,6 +49,14 @@ function buildToolErrorResult(message: string): AgentToolResult<unknown> {
 	};
 }
 
+async function buildFinalToolErrorResult(
+	options: CursorExecBridgeOptions,
+	toolName: string,
+	message: string,
+): Promise<AgentToolResult<unknown>> {
+	return finalizeToolResultForDelivery(buildToolErrorResult(message), toolName, options.getToolContext?.());
+}
+
 async function executeTool(
 	options: CursorExecBridgeOptions,
 	toolName: string,
@@ -56,11 +65,12 @@ async function executeTool(
 ): Promise<ToolResultMessage> {
 	const tool = options.tools.get(toolName);
 	if (!tool) {
-		const result = buildToolErrorResult(`Tool "${toolName}" not available`);
+		const result = await buildFinalToolErrorResult(options, toolName, `Tool "${toolName}" not available`);
 		return createToolResultMessage(toolCallId, toolName, result, true);
 	}
 
 	options.emitEvent?.({ type: "tool_execution_start", toolCallId, toolName, args });
+	const context = options.getToolContext?.();
 
 	let result: AgentToolResult<unknown>;
 	let isError = false;
@@ -82,16 +92,10 @@ async function executeTool(
 		: undefined;
 
 	try {
-		result = await tool.execute(
-			toolCallId,
-			args as Record<string, unknown>,
-			undefined,
-			onUpdate,
-			options.getToolContext?.(),
-		);
+		result = await tool.execute(toolCallId, args as Record<string, unknown>, undefined, onUpdate, context);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		result = buildToolErrorResult(message);
+		result = await buildFinalToolErrorResult(options, toolName, message);
 		isError = true;
 	}
 
@@ -133,6 +137,7 @@ async function executeDelete(options: CursorExecBridgeOptions, pathArg: string,
 		result = buildToolErrorResult(message);
 		isError = true;
 	}
+	result = await finalizeToolResultForDelivery(result, toolName, options.getToolContext?.());
 
 	options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result, isError });
 	return createToolResultMessage(toolCallId, toolName, result, isError);
@@ -222,7 +227,9 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 				const globPath = `${args.path || "."}/${args.glob}`;
 				return executeTool(this.#optionsForCall(), "find", toolCallId, { paths: [globPath] });
 			}
-			const result = buildToolErrorResult(
+			const result = await buildFinalToolErrorResult(
+				this.#optionsForCall(),
+				"search",
 				"Cursor grep request rejected: pattern must not be empty. Provide a non-empty search pattern.",
 			);
 			return createToolResultMessage(toolCallId, "search", result, true);
@@ -272,7 +279,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		const toolName = "bash";
 		const tool = options.tools.get(toolName);
 		if (!tool) {
-			const result = buildToolErrorResult(`Tool "${toolName}" not available`);
+			const result = await buildFinalToolErrorResult(options, toolName, `Tool "${toolName}" not available`);
 			return createToolResultMessage(toolCallId, toolName, result, true);
 		}
 
@@ -331,7 +338,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 			result = await tool.execute(toolCallId, toolArgs, undefined, onUpdate, options.getToolContext?.());
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			result = buildToolErrorResult(message);
+			result = await buildFinalToolErrorResult(options, toolName, message);
 			isError = true;
 		}
 
@@ -381,7 +388,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		if (!tool) {
 			const availableTools = Array.from(options.tools.keys()).filter(name => name.startsWith("mcp__"));
 			const message = formatMcpToolErrorMessage(toolName, availableTools);
-			const result = buildToolErrorResult(message);
+			const result = await buildFinalToolErrorResult(options, toolName, message);
 			return createToolResultMessage(toolCallId, toolName, result, true);
 		}
 

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

@@ -295,7 +295,8 @@ The heavyweight gate runs **once per boundary generation**, not once per story a
 One generation freezes the change set and reviews it exactly once:
 
 1. Run implementation verification for the boundary's cumulative change set.
-2. **Freeze the change set.** Compute one immutable `sourceHash` over the reviewed source. Every lane in this generation inspects that same frozen snapshot; a lane verdict carrying a different `sourceHash` is rejected.
+2. **Freeze the change set.** Use the native coordinator: run `gjc ultragoal review-source freeze --json` before dispatch, then create each lane with `gjc ultragoal review-source dispatch --cohort-id <id> --task-id <id> --lane <cleaner|architect|qa|critic> --rerun-command <command> --json` and pass the returned leader-issued `reviewSource` object to `task`. The runtime derives and persists the canonical source identity; never hand-author or copy a `sourceHash`. Every delivered lane receipt is classified `current`, `stale_review_delivery`, or `invalid_provenance` against the active source, and only current runtime-owned delivery IDs may enter the gate.
+
 3. **Run the cohort lanes on the frozen snapshot** — at most one `cleaner`, one `architect`, and one `qa` lane per generation. They may run in parallel because they share the frozen source; a second architect or QA lane in the same generation is rejected. The `cleaner` lane is the internal ai-slop-cleaner skill fragment run over the frozen change set: a read-only detector that emits an `AI SLOP CLEANUP REPORT`, and it still runs and records a passed/no-op report when there are no relevant edits. Its BLOCKING findings join the cohort findings rather than starting their own fix loop; advisory findings are included in the gate report only and are not written to the Ultragoal ledger.
 4. Delegate an `architect` review covering all three lanes:
    - architecture-side: system boundaries, layering, data/control flow, operational risks.
@@ -309,11 +310,13 @@ One generation freezes the change set and reviews it exactly once:
    - 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.
 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.
+8. **Join before repairing.** Fold all three lane verdicts and the final code review into the strict gate under `iteration.reviewCohort` (`cohortId`, `reviewGeneration`, runtime-derived `sourceHash`, `joined: true`, and the three lanes with runtime-issued `deliveryId`). No lane may checkpoint on its own, and no fix work starts until the findings are joined. A `stale_review_delivery` stays visible for audit, is excluded from approval and blocker authority, and must be rerun using the rendered command. 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 receipt-bound to the active snapshot, every evidence field is non-empty, every required matrix row is present, and every blockers array is empty. `COMMENT`, `WATCH`, `REQUEST CHANGES`, `BLOCK`, stale/invalid provenance, 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:
    ```sh
    gjc ultragoal record-review-blockers --goal-id <id> --title "Resolve verification blockers" --objective "<blocker-resolution objective>" --evidence "<joined cohort findings>"
    ```
+
+   Review-blocker recursion cap (#3613): `record-review-blockers` dedups identical-objective blockers (same trimmed objective + same blocked goal + open status) and bounds the number of unresolved review_blocker descents per blocked goal to **3**. Descents 1..3 may exist; an attempt to create a 4th throws a typed `review_blocker_recursion_cap` terminal handoff (CLI exit 1, operator-visible marker) — never silently auto-completing findings. When the cap fires, record a human pause/escalation or resolve existing blockers before recording more.
 10. One consolidated fix batch produces exactly **one new generation**. Re-freeze the fixed source as a new `sourceHash`, bump `reviewGeneration`, and set `deltaOnly: true` with `priorGenerationSourceHash` and the `deltaPaths` actually changed. Generation 2+ reviews are **delta-only**: they may not pull in unrelated scope without an explicit `scopeExpansion` carrying `severity`, `novelty`, and `justification`. Repeat until a generation joins clean.
 11. Only after a generation joins clean, checkpoint the story as complete with a structured quality gate. The terminal critic runs **once** on that final joined generation; when `criticReview.sourceHash` is present it must match the cohort's `sourceHash`. The checkpoint creates a receipt in `ledger.jsonl`; `goals.json.status` alone is not proof. In aggregate mode, the final aggregate receipt must exist before the agent calls `goal({"op":"complete"})` to reconcile the inline UX goal state.
 

package/src/eval/backend.ts

@@ -11,8 +11,8 @@ export interface ExecutorBackendExecOptions {
 	session: ToolSession;
 	deadlineMs: number;
 	reset: boolean;
-	artifactPath: string | undefined;
-	artifactId: string | undefined;
+	artifactPath?: string;
+	artifactId?: string;
 	onChunk: (chunk: string) => void;
 }