@gajae-code/coding-agent 0.1.3 → 0.2.1

package/src/sdk.ts

@@ -811,6 +811,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	});
 	const settings = options.settings ?? (await logger.time("settings", Settings.init, { cwd, agentDir }));
+	modelRegistry.applyConfiguredModelBindings(settings);
 	logger.time("initializeWithSettings", initializeWithSettings, settings);
 	if (!options.modelRegistry) {
 		modelRegistry.refreshInBackground();

package/src/session/agent-session.ts

@@ -138,6 +138,7 @@ import type { HookCommandContext } from "../extensibility/hooks/types";
 import type { Skill, SkillWarning } from "../extensibility/skills";
 import { expandSlashCommand, type FileSlashCommand } from "../extensibility/slash-commands";
 import { buildGjcRuntimeSessionEnv, consumePendingGoalModeRequest } from "../gjc-runtime/goal-mode-request";
+import { requestGjcWorkerIntegrationAttempt } from "../gjc-runtime/team-runtime";
 import { GoalRuntime } from "../goals/runtime";
 import type { Goal, GoalModeState } from "../goals/state";
 import type { HindsightSessionState } from "../hindsight/state";
@@ -2578,6 +2579,11 @@ export class AgentSession {
 
 	/** Emit extension events based on session events */
 	async #emitExtensionEvent(event: AgentSessionEvent): Promise<void> {
+		if (event.type === "turn_end") {
+			await requestGjcWorkerIntegrationAttempt(this.sessionManager.getCwd(), process.env).catch(error => {
+				logger.warn("GJC team worker integration request failed", { error: String(error) });
+			});
+		}
 		if (!this.#extensionRunner) return;
 		if (event.type === "agent_start") {
 			this.#turnIndex = 0;

package/src/setup/provider-onboarding.ts

@@ -1,3 +1,4 @@
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getAgentDir } from "@gajae-code/utils";
 import { YAML } from "bun";
@@ -131,6 +132,7 @@ async function writeModelsConfig(modelsPath: string, config: ModelsConfig): Prom
 		const where = first?.path.length ? `/${first.path.map(String).join("/")}` : "root";
 		throw new Error(`Generated models config is invalid at ${where}: ${first?.message ?? "unknown schema error"}`);
 	}
+	await fs.mkdir(path.dirname(modelsPath), { recursive: true });
 	await Bun.write(modelsPath, YAML.stringify(checked.data, null, 2));
 }
 

package/src/skill-state/active-state.ts

@@ -7,6 +7,23 @@ export const SKILL_ACTIVE_STALE_MS = 24 * 60 * 60 * 1000;
 export const CANONICAL_GJC_WORKFLOW_SKILLS = ["deep-interview", "ralplan", "ultragoal", "team"] as const;
 
 export type CanonicalGjcWorkflowSkill = (typeof CANONICAL_GJC_WORKFLOW_SKILLS)[number];
+export type WorkflowHudSeverity = "info" | "warning" | "blocked" | "error" | "success";
+
+export interface WorkflowHudChip {
+	label: string;
+	value?: string;
+	priority?: number;
+	severity?: WorkflowHudSeverity;
+}
+
+export interface WorkflowHudSummary {
+	version: 1;
+	summary?: string;
+	chips?: WorkflowHudChip[];
+	details?: WorkflowHudChip[];
+	severity?: WorkflowHudSeverity;
+	updated_at?: string;
+}
 
 export interface SkillActiveEntry {
 	skill: string;
@@ -17,6 +34,8 @@ export interface SkillActiveEntry {
 	session_id?: string;
 	thread_id?: string;
 	turn_id?: string;
+	hud?: WorkflowHudSummary;
+	stale?: boolean;
 }
 
 export interface SkillActiveState {
@@ -50,12 +69,79 @@ export interface SyncSkillActiveStateOptions {
 	turnId?: string;
 	nowIso?: string;
 	source?: string;
+	hud?: WorkflowHudSummary;
 }
 
+const HUD_TEXT_LIMIT = 80;
+const HUD_CHIP_LIMIT = 6;
+const HUD_DETAIL_LIMIT = 12;
+const ANSI_PATTERN = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+const HUD_SEVERITIES = new Set<WorkflowHudSeverity>(["info", "warning", "blocked", "error", "success"]);
+
 function safeString(value: unknown): string {
 	return typeof value === "string" ? value : "";
 }
 
+function sanitizeHudString(value: unknown, limit = HUD_TEXT_LIMIT): string | undefined {
+	const normalized = safeString(value)
+		.replace(ANSI_PATTERN, "")
+		.replace(/[\r\n\t]+/g, " ")
+		.trim();
+	if (!normalized) return undefined;
+	return normalized.length > limit ? normalized.slice(0, limit) : normalized;
+}
+
+function normalizeSeverity(value: unknown): WorkflowHudSeverity | undefined {
+	return typeof value === "string" && HUD_SEVERITIES.has(value as WorkflowHudSeverity)
+		? (value as WorkflowHudSeverity)
+		: undefined;
+}
+
+function normalizeHudChip(raw: unknown): WorkflowHudChip | null {
+	if (!raw || typeof raw !== "object") return null;
+	const record = raw as Record<string, unknown>;
+	const label = sanitizeHudString(record.label, 32);
+	if (!label) return null;
+	const value = sanitizeHudString(record.value, HUD_TEXT_LIMIT);
+	const priority =
+		typeof record.priority === "number" && Number.isFinite(record.priority) ? record.priority : undefined;
+	const severity = normalizeSeverity(record.severity);
+	return {
+		label,
+		...(value ? { value } : {}),
+		...(priority !== undefined ? { priority } : {}),
+		...(severity ? { severity } : {}),
+	};
+}
+
+function normalizeHudChips(raw: unknown, limit: number): WorkflowHudChip[] | undefined {
+	if (!Array.isArray(raw)) return undefined;
+	const chips = raw
+		.map(normalizeHudChip)
+		.filter((chip): chip is WorkflowHudChip => chip !== null)
+		.slice(0, limit);
+	return chips.length > 0 ? chips : undefined;
+}
+
+export function normalizeWorkflowHudSummary(raw: unknown): WorkflowHudSummary | undefined {
+	if (!raw || typeof raw !== "object") return undefined;
+	const record = raw as Record<string, unknown>;
+	if (record.version !== 1) return undefined;
+	const summary = sanitizeHudString(record.summary);
+	const chips = normalizeHudChips(record.chips, HUD_CHIP_LIMIT);
+	const details = normalizeHudChips(record.details, HUD_DETAIL_LIMIT);
+	const severity = normalizeSeverity(record.severity);
+	const updatedAt = sanitizeHudString(record.updated_at, 40);
+	return {
+		version: 1,
+		...(summary ? { summary } : {}),
+		...(chips ? { chips } : {}),
+		...(details ? { details } : {}),
+		...(severity ? { severity } : {}),
+		...(updatedAt ? { updated_at: updatedAt } : {}),
+	};
+}
+
 function encodePathSegment(value: string): string {
 	return encodeURIComponent(value).replaceAll(".", "%2E");
 }
@@ -70,16 +156,25 @@ function timestampMs(value: string | undefined): number | null {
 	return Number.isFinite(ms) ? ms : null;
 }
 
+function entryTimestampMs(entry: SkillActiveEntry): number | null {
+	return timestampMs(entry.hud?.updated_at) ?? timestampMs(entry.updated_at) ?? timestampMs(entry.activated_at);
+}
+
 function isFreshEntry(entry: SkillActiveEntry, nowMs = Date.now()): boolean {
-	const ms = timestampMs(entry.updated_at) ?? timestampMs(entry.activated_at);
+	const ms = entryTimestampMs(entry);
 	return ms === null || nowMs - ms <= SKILL_ACTIVE_STALE_MS;
 }
 
+function withDerivedStale(entry: SkillActiveEntry, nowMs = Date.now()): SkillActiveEntry {
+	return { ...entry, stale: !isFreshEntry(entry, nowMs) };
+}
+
 function normalizeEntry(raw: unknown): SkillActiveEntry | null {
 	if (!raw || typeof raw !== "object") return null;
 	const record = raw as Record<string, unknown>;
 	const skill = safeString(record.skill).trim();
 	if (!skill) return null;
+	const hud = normalizeWorkflowHudSummary(record.hud);
 	return {
 		...record,
 		skill,
@@ -90,6 +185,8 @@ function normalizeEntry(raw: unknown): SkillActiveEntry | null {
 		session_id: safeString(record.session_id).trim() || undefined,
 		thread_id: safeString(record.thread_id).trim() || undefined,
 		turn_id: safeString(record.turn_id).trim() || undefined,
+		...(hud ? { hud } : {}),
+		stale: undefined,
 	};
 }
 
@@ -185,11 +282,12 @@ function mergeVisibleEntries(
 	rootState: SkillActiveState | null,
 	sessionId?: string,
 ): SkillActiveEntry[] {
-	const rootEntries = filterRootEntriesForSession(listActiveSkills(rootState), sessionId).filter(entry =>
-		isFreshEntry(entry),
+	const nowMs = Date.now();
+	const rootEntries = filterRootEntriesForSession(listActiveSkills(rootState), sessionId).map(entry =>
+		withDerivedStale(entry, nowMs),
 	);
 	const merged = new Map(rootEntries.map(entry => [entryKey(entry), entry]));
-	for (const entry of listActiveSkills(sessionState).filter(entry => isFreshEntry(entry))) {
+	for (const entry of listActiveSkills(sessionState).map(candidate => withDerivedStale(candidate, nowMs))) {
 		merged.set(entryKey(entry), entry);
 	}
 	return [...merged.values()];
@@ -229,6 +327,7 @@ function upsertEntry(entries: SkillActiveEntry[], entry: SkillActiveEntry, activ
 
 export async function syncSkillActiveState(options: SyncSkillActiveStateOptions): Promise<void> {
 	const nowIso = options.nowIso ?? new Date().toISOString();
+	const hud = normalizeWorkflowHudSummary(options.hud);
 	const entry: SkillActiveEntry = {
 		skill: options.skill,
 		phase: options.phase,
@@ -238,6 +337,7 @@ export async function syncSkillActiveState(options: SyncSkillActiveStateOptions)
 		session_id: options.sessionId,
 		thread_id: options.threadId,
 		turn_id: options.turnId,
+		...(hud ? { hud } : {}),
 	};
 	const { rootPath, sessionPath } = getSkillActiveStatePaths(options.cwd, options.sessionId);
 	const rootState = (await readStateFile(rootPath)) ?? { version: 1, active_skills: [] };

package/src/skill-state/workflow-hud.ts

@@ -0,0 +1,160 @@
+import type { WorkflowHudChip, WorkflowHudSummary } from "./active-state";
+
+interface DeepInterviewHudState {
+	phase?: string;
+	ambiguity?: number;
+	threshold?: number;
+	roundCount?: number;
+	targetComponent?: string;
+	weakestDimension?: string;
+	specStatus?: string;
+	updatedAt?: string;
+}
+
+interface RalplanHudState {
+	stage?: string;
+	waiting?: string;
+	iteration?: number;
+	verdict?: string;
+	latestSummary?: string;
+	pendingApproval?: boolean;
+	updatedAt?: string;
+}
+
+interface UltragoalLikeGoal {
+	id: string;
+	title: string;
+	status: string;
+}
+
+interface UltragoalHudState {
+	status: string;
+	currentGoal?: UltragoalLikeGoal;
+	counts: Record<string, number>;
+	goals: UltragoalLikeGoal[];
+	latestLedgerEvent?: { event?: string; goalId?: string; timestamp?: string };
+	updatedAt?: string;
+}
+
+interface TeamHudWorker {
+	id: string;
+	status?: string;
+}
+
+interface TeamHudState {
+	phase: string;
+	task_total: number;
+	task_counts: Record<string, number>;
+	workers: TeamHudWorker[];
+	updated_at?: string;
+	latestEvent?: { type?: string; worker?: string; message?: string };
+	latestMessage?: { from_worker?: string; body?: string };
+}
+
+function percent(value: number | undefined): string | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value)) return undefined;
+	return `${Math.round(value * 100)}%`;
+}
+
+function chip(
+	label: string,
+	value: string | undefined,
+	priority: number,
+	severity?: WorkflowHudChip["severity"],
+): WorkflowHudChip | null {
+	if (!value) return null;
+	return { label, value, priority, ...(severity ? { severity } : {}) };
+}
+
+function compactChips(chips: Array<WorkflowHudChip | null>): WorkflowHudChip[] {
+	return chips.filter((item): item is WorkflowHudChip => item !== null);
+}
+
+export function buildDeepInterviewHudSummary(state: DeepInterviewHudState): WorkflowHudSummary {
+	return {
+		version: 1,
+		chips: compactChips([
+			chip("phase", state.phase, 10),
+			chip("ambiguity", [percent(state.ambiguity), percent(state.threshold)].filter(Boolean).join("/"), 20),
+			chip("round", state.roundCount === undefined ? undefined : String(state.roundCount), 30),
+			chip("target", state.targetComponent, 40),
+			chip("weakest", state.weakestDimension, 50),
+			chip("spec", state.specStatus, 60),
+		]),
+		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
+	};
+}
+
+export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSummary {
+	const verdict = state.verdict?.toUpperCase();
+	const verdictSeverity =
+		verdict === "BLOCK"
+			? "blocked"
+			: verdict === "ITERATE" || verdict === "WATCH"
+				? "warning"
+				: verdict === "APPROVE" || verdict === "CLEAR"
+					? "success"
+					: undefined;
+	return {
+		version: 1,
+		summary: state.latestSummary,
+		chips: compactChips([
+			state.pendingApproval ? { label: "pending", value: "approval", priority: 5, severity: "warning" } : null,
+			chip("stage", state.stage, 10),
+			chip("waiting", state.waiting, 20),
+			chip("iter", state.iteration === undefined ? undefined : String(state.iteration), 30),
+			chip("verdict", verdict, 40, verdictSeverity),
+		]),
+		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
+	};
+}
+
+export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudSummary {
+	const total = state.goals.length;
+	const complete = state.counts.complete ?? 0;
+	const blockers = (state.counts.blocked ?? 0) + (state.counts.review_blocked ?? 0) + (state.counts.failed ?? 0);
+	return {
+		version: 1,
+		chips: compactChips([
+			blockers > 0 ? { label: "blocked", value: String(blockers), priority: 5, severity: "blocked" } : null,
+			chip("goals", `${complete}/${total}`, 10),
+			chip("current", state.currentGoal ? `${state.currentGoal.id}:${state.currentGoal.title}` : state.status, 20),
+			chip("status", state.status, 30, state.status === "complete" ? "success" : undefined),
+		]),
+		details: state.latestLedgerEvent
+			? compactChips([
+					chip(
+						"ledger",
+						[state.latestLedgerEvent.event, state.latestLedgerEvent.goalId].filter(Boolean).join(":"),
+						100,
+					),
+				])
+			: undefined,
+		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
+	};
+}
+
+export function buildTeamHudSummary(state: TeamHudState): WorkflowHudSummary {
+	const failedWorkers = state.workers.filter(
+		worker => worker.status === "failed" || worker.status === "blocked",
+	).length;
+	const stoppedWorkers = state.workers.filter(worker => worker.status === "stopped").length;
+	const completed = state.task_counts.completed ?? 0;
+	const failedTasks = (state.task_counts.failed ?? 0) + (state.task_counts.blocked ?? 0);
+	const latest = state.latestEvent?.message ?? state.latestEvent?.type ?? state.latestMessage?.body;
+	return {
+		version: 1,
+		chips: compactChips([
+			failedWorkers > 0 || failedTasks > 0
+				? { label: "blocked", value: String(failedWorkers + failedTasks), priority: 5, severity: "blocked" }
+				: stoppedWorkers > 0
+					? { label: "stopped", value: String(stoppedWorkers), priority: 5, severity: "warning" }
+					: null,
+			chip("phase", state.phase, 10),
+			chip("workers", `${state.workers.length - failedWorkers}/${state.workers.length}`, 20),
+			chip("tasks", `${completed}/${state.task_total}`, 30),
+			chip("latest", latest, 50),
+		]),
+		...(state.updated_at ? { updated_at: state.updated_at } : {}),
+	};
+}

package/src/slash-commands/acp-builtins.ts

@@ -1,5 +1,9 @@
 import type { AvailableCommand } from "@agentclientprotocol/sdk";
-import { BUILTIN_SLASH_COMMANDS_INTERNAL, lookupBuiltinSlashCommand } from "./builtin-registry";
+import {
+	BUILTIN_SLASH_COMMANDS_INTERNAL,
+	formatUnknownBuiltinSlashCommandDiagnostic,
+	lookupBuiltinSlashCommand,
+} from "./builtin-registry";
 import { parseSlashCommand } from "./helpers/parse";
 import type { AcpBuiltinCommandRuntime, AcpBuiltinSlashCommandResult } from "./types";
 
@@ -39,7 +43,12 @@ export async function executeAcpBuiltinSlashCommand(
 	const parsed = parseSlashCommand(text);
 	if (!parsed) return false;
 	const command = lookupBuiltinSlashCommand(parsed.name);
-	if (!command?.handle) return false;
+	if (!command?.handle) {
+		const diagnostic = formatUnknownBuiltinSlashCommandDiagnostic(parsed.name);
+		if (!diagnostic) return false;
+		await runtime.output(diagnostic);
+		return { consumed: true };
+	}
 	const result = await command.handle(parsed, runtime);
 	if (result === undefined) return { consumed: true };
 	return result;

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

@@ -993,6 +993,15 @@ for (const command of ACTIVE_BUILTIN_SLASH_COMMAND_REGISTRY) {
 	}
 }
 
+export function formatUnknownBuiltinSlashCommandDiagnostic(commandName: string): string | undefined {
+	if (commandName !== "provicer") return undefined;
+	return [
+		"Unknown slash command: /provicer.",
+		"Did you mean /provider?",
+		"Run: /provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model>",
+	].join("\n");
+}
+
 /** Builtin command metadata used for slash-command autocomplete and help text. */
 export const BUILTIN_SLASH_COMMAND_DEFS: ReadonlyArray<BuiltinSlashCommand> = ACTIVE_BUILTIN_SLASH_COMMAND_REGISTRY.map(
 	command => ({
@@ -1025,7 +1034,13 @@ export async function executeBuiltinSlashCommand(
 	if (!parsed) return false;
 
 	const command = BUILTIN_SLASH_COMMAND_LOOKUP.get(parsed.name);
-	if (!command) return false;
+	if (!command) {
+		const diagnostic = formatUnknownBuiltinSlashCommandDiagnostic(parsed.name);
+		if (!diagnostic) return false;
+		runtime.ctx.showError(diagnostic);
+		runtime.ctx.editor.setText("");
+		return true;
+	}
 	if (parsed.args.length > 0 && !command.allowArgs) {
 		return false;
 	}