@gajae-code/coding-agent 0.12.5 → 0.12.6

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> {