@gajae-code/coding-agent 0.12.5 → 0.12.7

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/defaults/gjc/skills/ultragoal/SKILL.md

@@ -314,6 +314,8 @@ One generation freezes the change set and reviews it exactly once:
    ```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/extensibility/extensions/runner.ts

@@ -2,12 +2,20 @@
  * Extension runner - executes extensions and manages their lifecycle.
  */
 import type { AgentMessage } from "@gajae-code/agent-core";
-import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMetadata } from "@gajae-code/ai";
+import type { AttemptScope } from "@gajae-code/agent-core/attempt-scope";
+import type {
+	AttemptScopeRef,
+	CredentialDisabledEvent,
+	ImageContent,
+	Model,
+	ProviderResponseMetadata,
+} from "@gajae-code/ai";
 import type { KeyId } from "@gajae-code/tui";
 import { logger } from "@gajae-code/utils";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { WorkflowGateEmitter } from "../../modes/shared/agent-wire/workflow-gate-broker";
 import { type Theme, theme } from "../../modes/theme/theme";
+import type { AttemptRecordStore } from "../../session/attempt-record-store";
 import { createReadonlySessionManager, type SessionManager } from "../../session/session-manager";
 import type {
 	AfterProviderResponseEvent,
@@ -176,6 +184,7 @@ export class ExtensionRunner {
 	#uiContext: ExtensionUIContext;
 	#errorListeners: Set<ExtensionErrorListener> = new Set();
 	#handlersByEvent: Map<string, IndexedHandler[]> = new Map();
+	#attemptRecordStore: AttemptRecordStore | undefined;
 
 	#getModel: () => Model | undefined = () => undefined;
 	#isIdleFn: () => boolean = () => true;
@@ -504,6 +513,27 @@ export class ExtensionRunner {
 		return (this.#handlersByEvent.get(eventType)?.length ?? 0) > 0;
 	}
 
+	setAttemptRecordStore(store: AttemptRecordStore): void {
+		this.#attemptRecordStore = store;
+	}
+
+	#markAttemptExecuted(scope: AttemptScopeRef | undefined): void {
+		if (scope !== undefined) this.#attemptRecordStore?.markExecuted(scope as AttemptScope);
+	}
+
+	/**
+	 * Scope-presence guard. When the AttemptScope facility is active but a
+	 * handler-capable delivery lacks a scope, the handler is still delivered
+	 * (backward-compatible) but NO mark is recorded. The record stays
+	 * unknown/missing → `isClean` returns false → admission refuses
+	 * (fail-closed at the decision point, not at delivery).
+	 */
+	#requireScopeOrFailClosed(_scope: AttemptScopeRef | undefined, _eventLabel: string): void {
+		// No throw — handler is delivered (backward-compatible); mark is not
+		// recorded when scope is absent. isClean returns false for an
+		// unmarked scope → admission refuses (fail-closed at decision point).
+	}
+
 	getMessageRenderer(customType: string): MessageRenderer | undefined {
 		for (const ext of this.extensions) {
 			const renderer = ext.messageRenderers.get(customType);
@@ -704,15 +734,22 @@ export class ExtensionRunner {
 	async emit<TEvent extends RunnerEmitEvent>(
 		event: TEvent,
 		continueWhile?: () => boolean,
+		scope?: AttemptScopeRef,
 	): Promise<RunnerEmitResult<TEvent>> {
 		const handlers = this.#handlersByEvent.get(event.type) ?? [];
 		if (handlers.length === 0) return undefined as RunnerEmitResult<TEvent>;
+		this.#requireScopeOrFailClosed(scope, event.type);
 
 		const ctx = this.createContext();
 		let result: SessionBeforeEventResult | SessionCompactingResult | undefined;
+		let marked = false;
 
 		for (const { ext, handler } of handlers) {
 			if (continueWhile && !continueWhile()) return result as RunnerEmitResult<TEvent>;
+			if (!marked) {
+				this.#markAttemptExecuted(scope);
+				marked = true;
+			}
 			const handlerResult = await this.#runHandlerWithTimeout(handler, event, ctx, ext, extensionHandlerTimeoutMs);
 			if (continueWhile && !continueWhile()) return result as RunnerEmitResult<TEvent>;
 
@@ -731,15 +768,21 @@ export class ExtensionRunner {
 		return result as RunnerEmitResult<TEvent>;
 	}
 
-	async emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined> {
+	async emitToolResult(event: ToolResultEvent, scope?: AttemptScopeRef): Promise<ToolResultEventResult | undefined> {
 		const handlers = this.#handlersByEvent.get("tool_result") ?? [];
 		if (handlers.length === 0) return undefined;
+		this.#requireScopeOrFailClosed(scope, "tool_result");
 
 		const ctx = this.createContext();
 		const currentEvent: ToolResultEvent = { ...event };
 		let modified = false;
+		let marked = false;
 
 		for (const { ext, handler } of handlers) {
+			if (!marked) {
+				this.#markAttemptExecuted(scope);
+				marked = true;
+			}
 			const handlerResult = (await this.#runHandlerWithTimeout(
 				handler,
 				currentEvent,
@@ -772,14 +815,20 @@ export class ExtensionRunner {
 		};
 	}
 
-	async emitToolCall(event: ToolCallEvent): Promise<ToolCallEventResult | undefined> {
+	async emitToolCall(event: ToolCallEvent, scope?: AttemptScopeRef): Promise<ToolCallEventResult | undefined> {
 		const handlers = this.#handlersByEvent.get("tool_call") ?? [];
 		if (handlers.length === 0) return undefined;
+		this.#requireScopeOrFailClosed(scope, "tool_call");
 
 		const ctx = this.createContext();
 		let result: ToolCallEventResult | undefined;
+		let marked = false;
 
 		for (const { ext, handler } of handlers) {
+			if (!marked) {
+				this.#markAttemptExecuted(scope);
+				marked = true;
+			}
 			try {
 				const handlerResult = await handler(event, ctx);
 
@@ -894,9 +943,10 @@ export class ExtensionRunner {
 		return currentText !== text || currentImages !== images ? { text: currentText, images: currentImages } : {};
 	}
 
-	async emitContext(messages: AgentMessage[]): Promise<AgentMessage[]> {
+	async emitContext(messages: AgentMessage[], scope?: AttemptScopeRef): Promise<AgentMessage[]> {
 		const handlers = this.#handlersByEvent.get("context") ?? [];
 		if (handlers.length === 0) return messages;
+		this.#requireScopeOrFailClosed(scope, "context");
 
 		const ctx = this.createContext();
 		let currentMessages: AgentMessage[];
@@ -908,8 +958,13 @@ export class ExtensionRunner {
 			// return new message arrays rather than mutating in place.
 			currentMessages = [...messages];
 		}
+		let marked = false;
 
 		for (const { ext, handler } of handlers) {
+			if (!marked) {
+				this.#markAttemptExecuted(scope);
+				marked = true;
+			}
 			const event: ContextEvent = { type: "context", messages: currentMessages };
 			const handlerResult = await this.#runHandlerWithTimeout(handler, event, ctx, ext, extensionHandlerTimeoutMs);
 
@@ -921,14 +976,23 @@ export class ExtensionRunner {
 		return currentMessages;
 	}
 
-	async emitBeforeProviderRequest(payload: unknown): Promise<BeforeProviderRequestEventResult> {
+	async emitBeforeProviderRequest(
+		payload: unknown,
+		scope?: AttemptScopeRef,
+	): Promise<BeforeProviderRequestEventResult> {
 		const handlers = this.#handlersByEvent.get("before_provider_request") ?? [];
 		if (handlers.length === 0) return payload;
+		this.#requireScopeOrFailClosed(scope, "before_provider_request");
 
 		const ctx = this.createContext();
 		let currentPayload = payload;
+		let marked = false;
 
 		for (const { ext, handler } of handlers) {
+			if (!marked) {
+				this.#markAttemptExecuted(scope);
+				marked = true;
+			}
 			const event: BeforeProviderRequestEvent = {
 				type: "before_provider_request",
 				payload: currentPayload,
@@ -942,13 +1006,23 @@ export class ExtensionRunner {
 		return currentPayload;
 	}
 
-	async emitAfterProviderResponse(response: ProviderResponseMetadata, _model?: Model): Promise<void> {
+	async emitAfterProviderResponse(
+		response: ProviderResponseMetadata,
+		_model?: Model,
+		scope?: AttemptScopeRef,
+	): Promise<void> {
 		const handlers = this.#handlersByEvent.get("after_provider_response") ?? [];
 		if (handlers.length === 0) return;
+		this.#requireScopeOrFailClosed(scope, "after_provider_response");
 
 		const ctx = this.createContext();
+		let marked = false;
 
 		for (const { ext, handler } of handlers) {
+			if (!marked) {
+				this.#markAttemptExecuted(scope);
+				marked = true;
+			}
 			const event: AfterProviderResponseEvent = {
 				type: "after_provider_response",
 				status: response.status,

package/src/extensibility/extensions/wrapper.ts

@@ -109,15 +109,19 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		onUpdate?: AgentToolUpdateCallback<TDetails, TParameters>,
 		context?: AgentToolContext,
 	) {
+		const scope = context?.attemptScope;
 		// Emit tool_call event - extensions can block execution
 		if (this.runner.hasHandlers("tool_call")) {
 			try {
-				const callResult = (await this.runner.emitToolCall({
-					type: "tool_call",
-					toolName: this.tool.name,
-					toolCallId,
-					input: params as Record<string, unknown>,
-				})) as ToolCallEventResult | undefined;
+				const callResult = (await this.runner.emitToolCall(
+					{
+						type: "tool_call",
+						toolName: this.tool.name,
+						toolCallId,
+						input: params as Record<string, unknown>,
+					},
+					scope,
+				)) as ToolCallEventResult | undefined;
 
 				if (callResult?.block) {
 					const reason = callResult.reason || "Tool execution was blocked by an extension";
@@ -147,15 +151,18 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 
 		// Emit tool_result event - extensions can modify the result and error status
 		if (this.runner.hasHandlers("tool_result")) {
-			const resultResult = await this.runner.emitToolResult({
-				type: "tool_result",
-				toolName: this.tool.name,
-				toolCallId,
-				input: params as Record<string, unknown>,
-				content: result.content,
-				details: result.details,
-				isError: !!executionError,
-			});
+			const resultResult = await this.runner.emitToolResult(
+				{
+					type: "tool_result",
+					toolName: this.tool.name,
+					toolCallId,
+					input: params as Record<string, unknown>,
+					content: result.content,
+					details: result.details,
+					isError: !!executionError,
+				},
+				scope,
+			);
 
 			if (resultResult) {
 				const modifiedContent: (TextContent | ImageContent)[] = resultResult.content ?? result.content;

package/src/extensibility/runtime-skill-discovery.ts

@@ -132,15 +132,13 @@ function isAllowedByPolicy(
 	return true;
 }
 function matchesQuery(candidate: RuntimeSkillDiscoveryCandidate, query: string): boolean {
-	const normalized = query.trim().toLowerCase();
-	if (!normalized) return true;
+	const terms = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+	if (terms.length === 0) return true;
+	if (terms.includes(candidate.name.toLowerCase())) return true;
 	const haystack = [candidate.name, candidate.description, candidate.source, ...(candidate.useWhen ?? [])]
 		.join("\n")
 		.toLowerCase();
-	return normalized
-		.split(/\s+/)
-		.filter(Boolean)
-		.every(term => haystack.includes(term));
+	return terms.every(term => haystack.includes(term));
 }
 
 async function realPathOrSelf(filePath: string): Promise<string> {