@gajae-code/coding-agent 0.7.7 → 0.7.9

package/src/slash-commands/builtin-registry.ts

@@ -12,7 +12,12 @@ import {
 	GJC_MODEL_ASSIGNMENT_TARGETS,
 	type GjcModelAssignmentTargetId,
 } from "../config/model-registry";
-import { extractExplicitThinkingSelector, formatModelSelectorValue, parseModelPattern } from "../config/model-resolver";
+import {
+	extractExplicitThinkingSelector,
+	formatModelSelectorValue,
+	parseModelPattern,
+	parseModelString,
+} from "../config/model-resolver";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../discovery/helpers.js";
 import { resolveMemoryBackend } from "../memory-backend";
 import { DynamicBorder } from "../modes/components/dynamic-border";
@@ -169,11 +174,32 @@ function splitExplicitThinkingSelector(selector: string): { baseSelector: string
 	return thinkingLevel ? { baseSelector: trimmed.slice(0, colonIndex), thinkingLevel } : { baseSelector: trimmed };
 }
 
-function resolveModelCommandSelection(
+interface ModelCommandSelection {
+	model: Model;
+	selector: string;
+	thinkingLevel?: ThinkingLevel;
+}
+
+interface ModelCommandResolutionFailure {
+	message: string;
+}
+
+type ModelCommandResolution =
+	| { ok: true; selection: ModelCommandSelection }
+	| { ok: false; failure: ModelCommandResolutionFailure };
+
+function parseProviderQualifiedSelector(selector: string): { provider: string; modelId: string } | undefined {
+	const splitSelector = splitExplicitThinkingSelector(selector);
+	const parsed = parseModelString(splitSelector.baseSelector);
+	if (!parsed) return undefined;
+	return { provider: parsed.provider, modelId: parsed.id };
+}
+
+function resolveModelCommandSelectionFromAvailable(
 	runtime: SlashCommandRuntime,
 	selector: string,
-): { model: Model; selector: string; thinkingLevel?: ThinkingLevel } | undefined {
-	const availableModels = runtime.session.getAvailableModels?.() ?? [];
+	availableModels: Model[],
+): ModelCommandSelection | undefined {
 	const matchPreferences = { usageOrder: runtime.settings.getStorage()?.getModelUsageOrder() };
 	const resolved = parseModelPattern(selector, availableModels, matchPreferences, {
 		modelRegistry: runtime.session.modelRegistry,
@@ -198,6 +224,78 @@ function resolveModelCommandSelection(
 	};
 }
 
+function formatDiscoverableProviderFailure(
+	selector: string,
+	provider: string,
+	modelId: string,
+	runtime: SlashCommandRuntime,
+): string {
+	const state = runtime.session.modelRegistry.getProviderDiscoveryState?.(provider);
+	const discovered = state?.models ?? [];
+	const base = `Unknown model: ${selector}.`;
+	if (!modelId.trim()) {
+		return `${base} Local provider model selectors must use provider/model-id syntax with a non-empty model id.`;
+	}
+	if (!state) {
+		return `${base} Provider ${provider} is configured for discovery but has not reported models yet.`;
+	}
+	if (state.status === "unavailable") {
+		const details = state.error ? ` (${state.error})` : "";
+		return `${base} Provider ${provider} discovery is unavailable${details}. Check the local endpoint and run /model again.`;
+	}
+	if (state.status === "unauthenticated") {
+		return `${base} Provider ${provider} requires authentication before model discovery.`;
+	}
+	if (state.status === "empty") {
+		return `${base} Provider ${provider} discovery succeeded but returned no models.`;
+	}
+	if (discovered.length > 0) {
+		const preview = discovered.slice(0, 8).join(", ");
+		const suffix = discovered.length > 8 ? ", …" : "";
+		return `${base} Provider ${provider} did not report model ${modelId}. Available local models: ${preview}${suffix}.`;
+	}
+	return `${base} Provider ${provider} did not report model ${modelId}.`;
+}
+
+async function resolveModelCommandSelection(
+	runtime: SlashCommandRuntime,
+	selector: string,
+): Promise<ModelCommandResolution> {
+	let availableModels = runtime.session.getAvailableModels?.() ?? [];
+	const initialSelection = resolveModelCommandSelectionFromAvailable(runtime, selector, availableModels as Model[]);
+	if (initialSelection) {
+		return { ok: true, selection: initialSelection };
+	}
+
+	const providerRef = parseProviderQualifiedSelector(selector);
+	const discoverableProviders = runtime.session.modelRegistry?.getDiscoverableProviders?.() ?? [];
+	if (providerRef && discoverableProviders.includes(providerRef.provider)) {
+		await runtime.session.modelRegistry.refreshProvider?.(providerRef.provider, "online");
+		availableModels = runtime.session.getAvailableModels?.() ?? [];
+		const refreshedSelection = resolveModelCommandSelectionFromAvailable(
+			runtime,
+			selector,
+			availableModels as Model[],
+		);
+		if (refreshedSelection) {
+			return { ok: true, selection: refreshedSelection };
+		}
+		return {
+			ok: false,
+			failure: {
+				message: formatDiscoverableProviderFailure(selector, providerRef.provider, providerRef.modelId, runtime),
+			},
+		};
+	}
+
+	return {
+		ok: false,
+		failure: {
+			message: `Unknown model: ${selector}. Configure or login to a provider first, then list/select models with /model.`,
+		},
+	};
+}
+
 function modelSelectionUsage(runtime: SlashCommandRuntime, currentModelLine?: string): string {
 	return [
 		currentModelLine,
@@ -282,16 +380,11 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 						runtime,
 					);
 				}
-				const selection = resolveModelCommandSelection(runtime, modelId);
-				if (!selection) {
-					return usage(
-						modelSelectionUsage(
-							runtime,
-							`Unknown model: ${modelId}. Configure or login to a provider first, then list/select models with /model.`,
-						),
-						runtime,
-					);
+				const resolution = await resolveModelCommandSelection(runtime, modelId);
+				if (!resolution.ok) {
+					return usage(modelSelectionUsage(runtime, resolution.failure.message), runtime);
 				}
+				const { selection } = resolution;
 				try {
 					const persistedSelector = formatModelSelectorValue(selection.selector, selection.thinkingLevel);
 					if (parsedArgs.targetId === "default") {

package/src/tools/ask.ts

@@ -62,6 +62,11 @@ const DeepInterviewMeta = z.object({
 	ambiguity: z.number().min(0).max(1).describe("ambiguity at ask time (0..1)"),
 });
 
+const WorkflowGateMeta = z.object({
+	stage: z.enum(["deep-interview", "ralplan", "ultragoal"]).describe("workflow gate stage"),
+	kind: z.enum(["question", "approval", "execution"]).describe("workflow gate kind"),
+});
+
 const QuestionItem = z.object({
 	id: z.string().describe("question id"),
 	question: z.string().describe("question text"),
@@ -69,6 +74,7 @@ const QuestionItem = z.object({
 	multi: z.boolean().describe("allow multiple selections").optional(),
 	recommended: z.number().describe("recommended option index").optional(),
 	deepInterview: DeepInterviewMeta.describe("optional deep-interview round metadata").optional(),
+	workflowGate: WorkflowGateMeta.describe("optional workflow gate stage/kind override").optional(),
 });
 
 export const askSchema = z.object({
@@ -551,7 +557,10 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		_onUpdate?: AgentToolUpdateCallback<AskToolDetails>,
 		context?: AgentToolContext,
 	): Promise<AgentToolResult<AskToolDetails>> {
-		await assertUltragoalAskAllowed(this.session.cwd);
+		await assertUltragoalAskAllowed(this.session.cwd, {
+			activeSkillState: this.session.getActiveSkillState?.(),
+			sessionId: this.session.getSessionId?.() ?? null,
+		});
 		const gateEmitter = this.session.getWorkflowGateEmitter?.();
 		const canUseWorkflowGate = gateEmitter?.isUnattended() === true;
 
@@ -665,6 +674,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					multi: q.multi,
 					recommended: q.recommended,
 					deepInterview: q.deepInterview,
+					workflowGate: q.workflowGate,
 				};
 				const answer = await gateEmitter.emitGate(questionToGate(gateQuestion));
 				const decoded = gateAnswerToResult(gateQuestion, answer);

package/src/tools/eval.ts

@@ -754,8 +754,8 @@ function formatStatusEventExpanded(event: EvalStatusEvent, theme: Theme): string
 		case "git_log":
 			if (data.entries) {
 				addItems(data.entries as unknown[], e => {
-					const entry = e as { sha: string; subject: string };
-					return `${entry.sha} ${truncateToWidth(entry.subject, 50)}`;
+					const entry = e as { sha?: string; subject?: string };
+					return `${String(entry.sha ?? "")} ${truncateToWidth(String(entry.subject ?? ""), 50)}`;
 				});
 			}
 			break;

package/src/tools/render-utils.ts

@@ -86,6 +86,7 @@ export const EXPAND_HINT = "(Ctrl+O for more)";
  * Get first N lines of text as preview, with each line truncated.
  */
 export function getPreviewLines(text: string, maxLines: number, maxLineLen: number, ellipsis?: Ellipsis): string[] {
+	if (typeof text !== "string") return [];
 	const lines = text.split("\n").filter(l => l.trim());
 	return lines.slice(0, maxLines).map(l => truncateToWidth(l.trim(), maxLineLen, ellipsis));
 }
@@ -568,6 +569,7 @@ export function truncateDiffByHunk(
 // =============================================================================
 
 export function shortenPath(filePath: string, homeDir?: string): string {
+	if (typeof filePath !== "string") return "";
 	const home = homeDir ?? os.homedir();
 	if (home && filePath.startsWith(home)) {
 		return `~${filePath.slice(home.length)}`;

package/src/tools/ultragoal-ask-guard.ts

@@ -10,6 +10,29 @@ const ULTRAGOAL_ASK_GUARD = Symbol.for("gajae-code.ultragoalAskGuard");
 
 type GuardedTool = AgentTool & { [ULTRAGOAL_ASK_GUARD]?: true };
 
+export interface UltragoalAskGuardContext {
+	activeSkillState?: { skill?: string; session_id?: string } | null;
+	sessionId?: string | null;
+}
+
+const UPSTREAM_PLANNING_ASK_SKILLS = new Set(["deep-interview", "ralplan"]);
+
+function normalizedActiveSkill(context?: UltragoalAskGuardContext): string | undefined {
+	const skill = context?.activeSkillState?.skill?.trim();
+	return skill || undefined;
+}
+
+function sessionScopedAskGuardId(
+	context: UltragoalAskGuardContext,
+	activeSkill: string | undefined,
+): string | undefined {
+	if (activeSkill !== "ultragoal" && !UPSTREAM_PLANNING_ASK_SKILLS.has(activeSkill ?? "")) return undefined;
+	const activeSessionId = context.activeSkillState?.session_id?.trim();
+	if (activeSessionId) return activeSessionId;
+	const sessionId = context.sessionId?.trim();
+	return sessionId || undefined;
+}
+
 export function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiagnostic): string {
 	return [
 		diagnostic.message,
@@ -18,15 +41,26 @@ export function formatUltragoalAskBlockMessage(diagnostic: UltragoalAskBlockDiag
 	].join("\n");
 }
 
-export async function assertUltragoalAskAllowed(cwd: string): Promise<void> {
-	const diagnostic = await isUltragoalAskBlocked(cwd);
+export async function assertUltragoalAskAllowed(cwd: string, context: UltragoalAskGuardContext = {}): Promise<void> {
+	const activeSkill = normalizedActiveSkill(context);
+	// Deep-interview and ralplan are upstream planning workflows whose core gates
+	// are `ask` calls. Scope their Ultragoal check to the current session so stale
+	// or ambiguous Ultragoal durable state from another session cannot hijack those
+	// prompts; same-session active Ultragoal state still falls through to the
+	// blocker/nudge checks below.
+	const sessionId = sessionScopedAskGuardId(context, activeSkill);
+	const diagnostic = await isUltragoalAskBlocked(cwd, { sessionId });
 	if (!diagnostic.active) return;
-	const nudge = await consumeUltragoalAskNudge(cwd);
+	const nudge = await consumeUltragoalAskNudge(cwd, sessionId);
 	if (nudge.nudged) throw new ToolError(nudge.message);
 	throw new ToolError(formatUltragoalAskBlockMessage(diagnostic));
 }
 
-export function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: () => string): T {
+export function guardToolForUltragoalAsk<T extends AgentTool>(
+	tool: T,
+	getCwd: () => string,
+	getContext: () => UltragoalAskGuardContext = () => ({}),
+): T {
 	if (tool.name !== "ask") return tool;
 	const candidate = tool as GuardedTool;
 	if (candidate[ULTRAGOAL_ASK_GUARD]) return tool;
@@ -35,7 +69,7 @@ export function guardToolForUltragoalAsk<T extends AgentTool>(tool: T, getCwd: (
 			if (prop === ULTRAGOAL_ASK_GUARD) return true;
 			if (prop !== "execute") return Reflect.get(target, prop, receiver);
 			return async (...args: unknown[]): Promise<unknown> => {
-				await assertUltragoalAskAllowed(getCwd());
+				await assertUltragoalAskAllowed(getCwd(), getContext());
 				return Reflect.apply(target.execute, target, args);
 			};
 		},