@gajae-code/coding-agent 0.12.6 → 0.12.8

package/src/config/resolve-config-value.ts

@@ -16,22 +16,24 @@ const commandInFlight = new Map<string, Promise<string | undefined>>();
  * Resolve a config value (API key, header value, etc.) to an actual value.
  * - If starts with "!", executes the rest as a shell command and uses stdout (cached)
  * - Otherwise checks environment variable first, then treats as literal (not cached)
+ * - `cacheScope` isolates command-cache entries when a caller rotates its config
  */
-export async function resolveConfigValue(config: string): Promise<string | undefined> {
+export async function resolveConfigValue(config: string, cacheScope?: string): Promise<string | undefined> {
 	if (config.startsWith("!")) {
-		return await executeCommand(config);
+		return await executeCommand(config, cacheScope);
 	}
 	const envValue = process.env[config];
 	return envValue || config;
 }
 
-async function executeCommand(commandConfig: string): Promise<string | undefined> {
-	const cached = commandResultCache.get(commandConfig);
+async function executeCommand(commandConfig: string, cacheScope?: string): Promise<string | undefined> {
+	const cacheKey = cacheScope === undefined ? commandConfig : `${cacheScope}\u0000${commandConfig}`;
+	const cached = commandResultCache.get(cacheKey);
 	if (cached !== undefined) {
 		return cached;
 	}
 
-	const existing = commandInFlight.get(commandConfig);
+	const existing = commandInFlight.get(cacheKey);
 	if (existing) {
 		return await existing;
 	}
@@ -40,15 +42,15 @@ async function executeCommand(commandConfig: string): Promise<string | undefined
 	const promise = runShellCommand(command, 10_000)
 		.then(result => {
 			if (result !== undefined) {
-				commandResultCache.set(commandConfig, result);
+				commandResultCache.set(cacheKey, result);
 			}
 			return result;
 		})
 		.finally(() => {
-			commandInFlight.delete(commandConfig);
+			commandInFlight.delete(cacheKey);
 		});
 
-	commandInFlight.set(commandConfig, promise);
+	commandInFlight.set(cacheKey, promise);
 	return await promise;
 }
 

package/src/config/settings-schema.ts

@@ -149,7 +149,7 @@ export type AnyUiMetadata = UiBase & {
 
 interface BooleanDef {
 	type: "boolean";
-	default: boolean;
+	default?: boolean;
 	ui?: UiBoolean;
 }
 
@@ -285,6 +285,7 @@ export const SETTINGS_SCHEMA = {
 
 	// Notifications (shared daemon with Telegram/Discord/Slack presentation adapters)
 	"notifications.enabled": { type: "boolean", default: false },
+	"notifications.telegram.enabled": { type: "boolean" },
 	"notifications.telegram.botToken": {
 		type: "string",
 		default: undefined,
@@ -336,10 +337,12 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 	"notifications.telegram.topics.nameTemplate": { type: "string", default: undefined },
+	"notifications.discord.enabled": { type: "boolean" },
 	"notifications.discord.botToken": { type: "string", default: undefined },
 	"notifications.discord.applicationId": { type: "string", default: undefined },
 	"notifications.discord.guildId": { type: "string", default: undefined },
 	"notifications.discord.parentChannelId": { type: "string", default: undefined },
+	"notifications.slack.enabled": { type: "boolean" },
 	"notifications.slack.botToken": { type: "string", default: undefined },
 	"notifications.slack.appToken": { type: "string", default: undefined },
 	"notifications.slack.workspaceId": { type: "string", default: undefined },
@@ -3646,25 +3649,28 @@ type Schema = typeof SETTINGS_SCHEMA;
 export type SettingPath = keyof Schema;
 
 /** Infer the value type for a setting path */
-export type SettingValue<P extends SettingPath> = Schema[P] extends { type: "boolean" }
+export type SettingValue<P extends SettingPath> = Schema[P] extends { type: "boolean"; default: boolean }
 	? boolean
-	: Schema[P] extends { type: "string" }
-		? string | undefined
-		: Schema[P] extends { type: "number" }
-			? number
-			: Schema[P] extends { type: "enum"; values: infer V }
-				? V extends readonly string[]
-					? V[number]
-					: never
-				: Schema[P] extends { type: "array"; default: infer D }
-					? D
-					: Schema[P] extends { type: "record"; default: infer D }
+	: Schema[P] extends { type: "boolean" }
+		? boolean | undefined
+		: Schema[P] extends { type: "string" }
+			? string | undefined
+			: Schema[P] extends { type: "number" }
+				? number
+				: Schema[P] extends { type: "enum"; values: infer V }
+					? V extends readonly string[]
+						? V[number]
+						: never
+					: Schema[P] extends { type: "array"; default: infer D }
 						? D
-						: never;
+						: Schema[P] extends { type: "record"; default: infer D }
+							? D
+							: never;
 
 /** Get the default value for a setting path */
 export function getDefault<P extends SettingPath>(path: P): SettingValue<P> {
-	return SETTINGS_SCHEMA[path].default as SettingValue<P>;
+	const definition = SETTINGS_SCHEMA[path];
+	return ("default" in definition ? definition.default : undefined) as SettingValue<P>;
 }
 
 /** Check if a path has UI metadata (should appear in settings panel) */
@@ -3991,6 +3997,7 @@ export interface MemoryGuardSettings {
 export interface NotificationsSettings {
 	enabled: boolean;
 	telegram: {
+		enabled?: boolean;
 		botToken: string | undefined;
 		chatId: string | undefined;
 		sound: "all" | "important" | "none";
@@ -4014,16 +4021,19 @@ export interface NotificationsSettings {
 		};
 	};
 	discord: {
+		enabled?: boolean;
 		botToken: string | undefined;
 		applicationId: string | undefined;
 		guildId: string | undefined;
 		parentChannelId: string | undefined;
 	};
 	slack: {
+		enabled?: boolean;
 		botToken: string | undefined;
 		appToken: string | undefined;
 		workspaceId: string | undefined;
 		channelId: string | undefined;
+		authorizedUserId: string | undefined;
 	};
 	redact: boolean;
 	verbosity: "lean" | "verbose";

package/src/config/settings.ts

@@ -98,7 +98,7 @@ type DurableBatchRevision = {
 };
 type NotificationValidationState = {
 	malformedConfigRoot: boolean;
-	invalidNotificationConfiguration: boolean;
+	invalidNotificationGlobal: boolean;
 	generation: number;
 };
 type NotificationValidationRestoreGuard = {
@@ -378,7 +378,7 @@ export class Settings implements NotificationSettingsReader {
 	#hasMalformedConfigRoot = false;
 	/** YAML syntax was unrecoverable, so the loaded defaults are read-only until config.yml is repaired. */
 	#hasRecoveredConfigSyntax = false;
-	#hasInvalidNotificationConfiguration = false;
+	#hasInvalidNotificationGlobal = false;
 	#notificationValidationGeneration = 0;
 	/** Notification subtree fingerprint from the last raw durable config read. */
 	#durableNotificationFingerprint: string | undefined;
@@ -513,7 +513,7 @@ export class Settings implements NotificationSettingsReader {
 	 */
 	getNotificationSettingsSnapshot(): NotificationSettingsSnapshot {
 		return parseNotificationSettingsSnapshot(
-			this.#hasMalformedConfigRoot || this.#hasInvalidNotificationConfiguration ? null : this.#global,
+			this.#hasMalformedConfigRoot || this.#hasInvalidNotificationGlobal ? null : this.#rawNotificationConfig,
 		);
 	}
 
@@ -895,7 +895,7 @@ export class Settings implements NotificationSettingsReader {
 		cloned.#futureSchemaVersion = this.#futureSchemaVersion;
 		cloned.#hasMalformedConfigRoot = this.#hasMalformedConfigRoot;
 		cloned.#hasRecoveredConfigSyntax = this.#hasRecoveredConfigSyntax;
-		cloned.#hasInvalidNotificationConfiguration = this.#hasInvalidNotificationConfiguration;
+		cloned.#hasInvalidNotificationGlobal = this.#hasInvalidNotificationGlobal;
 		cloned.#notificationValidationGeneration = this.#notificationValidationGeneration;
 		cloned.#global = structuredClone(this.#global);
 		cloned.#rawNotificationConfig = structuredClone(this.#rawNotificationConfig);
@@ -1149,7 +1149,7 @@ export class Settings implements NotificationSettingsReader {
 	#resetYamlLoadState(): void {
 		this.#hasMalformedConfigRoot = false;
 		this.#hasRecoveredConfigSyntax = false;
-		this.#hasInvalidNotificationConfiguration = false;
+		this.#hasInvalidNotificationGlobal = false;
 		this.#schemaReport = { issues: [], valid: true };
 		this.#schemaMigrationPending = false;
 		this.#futureSchemaVersion = false;
@@ -1211,7 +1211,7 @@ export class Settings implements NotificationSettingsReader {
 				parseNotificationSettingsSnapshot(parsedRaw);
 			} catch (error) {
 				if (!(error instanceof Error) || error.message !== "gjc_notify_daemon_invalid_configuration") throw error;
-				this.#hasInvalidNotificationConfiguration = true;
+				this.#hasInvalidNotificationGlobal = true;
 			}
 		}
 		this.#futureSchemaVersion =
@@ -1875,7 +1875,7 @@ export class Settings implements NotificationSettingsReader {
 	#notificationValidationState(): NotificationValidationState {
 		return {
 			malformedConfigRoot: this.#hasMalformedConfigRoot,
-			invalidNotificationConfiguration: this.#hasInvalidNotificationConfiguration,
+			invalidNotificationGlobal: this.#hasInvalidNotificationGlobal,
 			generation: this.#notificationValidationGeneration,
 		};
 	}
@@ -1900,7 +1900,7 @@ export class Settings implements NotificationSettingsReader {
 	}
 	#restoreNotificationValidationState(state: NotificationValidationState): void {
 		this.#hasMalformedConfigRoot = state.malformedConfigRoot;
-		this.#hasInvalidNotificationConfiguration = state.invalidNotificationConfiguration;
+		this.#hasInvalidNotificationGlobal = state.invalidNotificationGlobal;
 	}
 	#rejectAtomicNotificationRepairForMalformedRoot(patches: readonly AtomicYamlPatch[], root: unknown): void {
 		if (
@@ -1951,17 +1951,17 @@ export class Settings implements NotificationSettingsReader {
 	#recomputeNotificationValidationFromRaw(): void {
 		if (this.#rawNotificationConfig === undefined) {
 			this.#hasMalformedConfigRoot = true;
-			this.#hasInvalidNotificationConfiguration = false;
+			this.#hasInvalidNotificationGlobal = false;
 			return;
 		}
 		try {
 			parseNotificationSettingsSnapshot(this.#rawNotificationConfig);
 			this.#hasMalformedConfigRoot = false;
-			this.#hasInvalidNotificationConfiguration = false;
+			this.#hasInvalidNotificationGlobal = false;
 		} catch (error) {
 			if (error instanceof Error && error.message === "gjc_notify_daemon_invalid_configuration") {
 				this.#hasMalformedConfigRoot = false;
-				this.#hasInvalidNotificationConfiguration = true;
+				this.#hasInvalidNotificationGlobal = true;
 				return;
 			}
 			throw error;
@@ -1973,10 +1973,10 @@ export class Settings implements NotificationSettingsReader {
 		try {
 			parseNotificationSettingsSnapshot(this.#rawNotificationConfig);
 			this.#hasMalformedConfigRoot = false;
-			this.#hasInvalidNotificationConfiguration = false;
+			this.#hasInvalidNotificationGlobal = false;
 		} catch (error) {
 			if (error instanceof Error && error.message === "gjc_notify_daemon_invalid_configuration") {
-				this.#hasInvalidNotificationConfiguration = true;
+				this.#hasInvalidNotificationGlobal = true;
 				return;
 			}
 			throw error;
@@ -2054,9 +2054,9 @@ export class Settings implements NotificationSettingsReader {
 // Setting Hooks
 // ═══════════════════════════════════════════════════════════════════════════
 
-type SettingHook<P extends SettingPath> = (value: SettingValue<P>, prev: SettingValue<P>) => void;
+type SettingHook = (value: unknown, prev: unknown) => void;
 
-const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook<any>>> = {
+const SETTING_HOOKS: Partial<Record<SettingPath, SettingHook>> = {
 	"theme.dark": value => {
 		if (typeof value === "string") {
 			setAutoThemeMapping("dark", value);

package/src/cursor.ts

@@ -14,7 +14,6 @@ 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 {
@@ -49,14 +48,6 @@ 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,
@@ -65,12 +56,11 @@ async function executeTool(
 ): Promise<ToolResultMessage> {
 	const tool = options.tools.get(toolName);
 	if (!tool) {
-		const result = await buildFinalToolErrorResult(options, toolName, `Tool "${toolName}" not available`);
+		const result = buildToolErrorResult(`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;
@@ -92,10 +82,16 @@ async function executeTool(
 		: undefined;
 
 	try {
-		result = await tool.execute(toolCallId, args as Record<string, unknown>, undefined, onUpdate, context);
+		result = await tool.execute(
+			toolCallId,
+			args as Record<string, unknown>,
+			undefined,
+			onUpdate,
+			options.getToolContext?.(),
+		);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		result = await buildFinalToolErrorResult(options, toolName, message);
+		result = buildToolErrorResult(message);
 		isError = true;
 	}
 
@@ -137,7 +133,6 @@ 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);
@@ -227,9 +222,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 				const globPath = `${args.path || "."}/${args.glob}`;
 				return executeTool(this.#optionsForCall(), "find", toolCallId, { paths: [globPath] });
 			}
-			const result = await buildFinalToolErrorResult(
-				this.#optionsForCall(),
-				"search",
+			const result = buildToolErrorResult(
 				"Cursor grep request rejected: pattern must not be empty. Provide a non-empty search pattern.",
 			);
 			return createToolResultMessage(toolCallId, "search", result, true);
@@ -279,7 +272,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		const toolName = "bash";
 		const tool = options.tools.get(toolName);
 		if (!tool) {
-			const result = await buildFinalToolErrorResult(options, toolName, `Tool "${toolName}" not available`);
+			const result = buildToolErrorResult(`Tool "${toolName}" not available`);
 			return createToolResultMessage(toolCallId, toolName, result, true);
 		}
 
@@ -338,7 +331,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 = await buildFinalToolErrorResult(options, toolName, message);
+			result = buildToolErrorResult(message);
 			isError = true;
 		}
 
@@ -388,7 +381,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 = await buildFinalToolErrorResult(options, toolName, message);
+			const result = buildToolErrorResult(message);
 			return createToolResultMessage(toolCallId, toolName, result, true);
 		}
 

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

@@ -295,8 +295,7 @@ 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.** 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.
-
+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.
 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.
@@ -310,7 +309,7 @@ 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` (`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.
+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:
    ```sh
    gjc ultragoal record-review-blockers --goal-id <id> --title "Resolve verification blockers" --objective "<blocker-resolution objective>" --evidence "<joined cohort findings>"

package/src/eval/backend.ts

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