@gajae-code/coding-agent 0.1.3 → 0.2.1

package/src/cli/skills-cli.ts

@@ -0,0 +1,88 @@
+/**
+ * Handles `gjc skills` for inspecting bundled workflow skill definitions.
+ */
+import {
+	DEFAULT_GJC_DEFINITION_NAMES,
+	type EmbeddedDefaultGjcSkill,
+	getEmbeddedDefaultGjcSkills,
+} from "../defaults/gjc-defaults";
+
+export type SkillsAction = "list" | "read";
+
+export interface SkillsCommandArgs {
+	action: SkillsAction;
+	name?: string;
+	flags?: {
+		json?: boolean;
+	};
+}
+
+interface SkillsListEntry {
+	name: string;
+	description: string;
+	path: string;
+	source: string;
+}
+
+interface SkillsReadEntry extends SkillsListEntry {
+	content: string;
+}
+
+function getEmbeddedSkill(name: string): EmbeddedDefaultGjcSkill | undefined {
+	return getEmbeddedDefaultGjcSkills().find(skill => skill.name === name);
+}
+
+function listEmbeddedSkills(): SkillsListEntry[] {
+	return getEmbeddedDefaultGjcSkills().map(skill => ({
+		name: skill.name,
+		description: skill.description,
+		path: skill.filePath,
+		source: skill.source,
+	}));
+}
+
+function writeJson(value: unknown): void {
+	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function runSkillsCommand(cmd: SkillsCommandArgs): Promise<void> {
+	if (cmd.action === "list") {
+		const skills = listEmbeddedSkills();
+		if (cmd.flags?.json) {
+			writeJson({ skills });
+			return;
+		}
+		for (const skill of skills) {
+			process.stdout.write(`${skill.name}\t${skill.description}\t${skill.path}\n`);
+		}
+		return;
+	}
+
+	const name = cmd.name?.trim();
+	if (!name) {
+		process.stderr.write(`error: skill name is required for read (${DEFAULT_GJC_DEFINITION_NAMES.join(", ")})\n`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const skill = getEmbeddedSkill(name);
+	if (!skill) {
+		process.stderr.write(`error: unknown embedded skill "${name}" (${DEFAULT_GJC_DEFINITION_NAMES.join(", ")})\n`);
+		process.exitCode = 1;
+		return;
+	}
+
+	const entry: SkillsReadEntry = {
+		name: skill.name,
+		description: skill.description,
+		path: skill.filePath,
+		source: skill.source,
+		content: skill.content,
+	};
+	if (cmd.flags?.json) {
+		writeJson(entry);
+		return;
+	}
+	process.stdout.write(skill.content);
+	if (!skill.content.endsWith("\n")) process.stdout.write("\n");
+}

package/src/cli.ts

@@ -34,6 +34,7 @@ const commands: CommandEntry[] = [
 	{ name: "question", load: () => import("./commands/question").then(m => m.default) },
 	{ name: "state", load: () => import("./commands/state").then(m => m.default) },
 	{ name: "setup", load: () => import("./commands/setup").then(m => m.default) },
+	{ name: "skills", load: () => import("./commands/skills").then(m => m.default) },
 	{ name: "team", load: () => import("./commands/team").then(m => m.default) },
 	{ name: "ultragoal", load: () => import("./commands/ultragoal").then(m => m.default) },
 	{ name: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },

package/src/commands/deep-interview.ts

@@ -1,5 +1,6 @@
 import { Command } from "@gajae-code/utils/cli";
-import { runBridgedRuntimeEndpoint } from "./gjc-runtime-bridge";
+import { syncSkillActiveState } from "../skill-state/active-state";
+import { runGjcRuntimeBridgeWithHudSidecar } from "./gjc-runtime-bridge";
 
 export default class DeepInterview extends Command {
 	static description = "Run private GJC deep-interview workflow commands";
@@ -7,6 +8,24 @@ export default class DeepInterview extends Command {
 	static examples = ["$ gjc deep-interview --help"];
 
 	async run(): Promise<void> {
-		await runBridgedRuntimeEndpoint("deep-interview", this.argv);
+		const cwd = process.cwd();
+		const result = await runGjcRuntimeBridgeWithHudSidecar("deep-interview", this.argv, {
+			cwd,
+			sidecarSkill: "deep-interview",
+			onHudPayload: payload =>
+				syncSkillActiveState({
+					cwd,
+					skill: "deep-interview",
+					active: payload.active ?? true,
+					phase: payload.phase,
+					sessionId: payload.session_id,
+					threadId: payload.thread_id,
+					turnId: payload.turn_id,
+					hud: payload.hud,
+					source: "gjc-runtime-bridge",
+				}),
+		});
+		if (result.error) process.stderr.write(`${result.error}\n`);
+		process.exitCode = result.status;
 	}
 }

package/src/commands/gjc-runtime-bridge.ts

@@ -1,15 +1,46 @@
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { normalizeWorkflowHudSummary, type WorkflowHudSummary } from "../skill-state/active-state";
 
 const BRIDGE_ENV = "GJC_RUNTIME_BINARY";
 const LEGACY_BRIDGE_ENV = "GJC_LEGACY_RUNTIME_BINARY";
 const GUARD_ENV = "GJC_RUNTIME_BRIDGE_ACTIVE";
+export const WORKFLOW_HUD_PROTOCOL = "workflow-hud-summary-v1";
 
 export interface GjcRuntimeBridgeResult {
 	status: number;
 	error?: string;
 }
 
+const SKILL_ENTRYPOINT_ENDPOINTS = new Set(["deep-interview", "ralplan"]);
+
+export interface WorkflowHudBridgePayload {
+	version: 1;
+	skill: string;
+	phase?: string;
+	active?: boolean;
+	session_id?: string;
+	thread_id?: string;
+	turn_id?: string;
+	hud: WorkflowHudSummary;
+}
+
+export interface GjcRuntimeHudBridgeResult extends GjcRuntimeBridgeResult {
+	hudPayload?: WorkflowHudBridgePayload;
+}
+
+export interface GjcRuntimeHudBridgeOptions {
+	cwd?: string;
+	env?: NodeJS.ProcessEnv;
+	sidecarSkill: string;
+	onHudPayload?: (payload: WorkflowHudBridgePayload) => Promise<void> | void;
+	pollIntervalMs?: number;
+}
+
 function candidateBinaries(env: NodeJS.ProcessEnv): string[] {
 	return [env[BRIDGE_ENV], env[LEGACY_BRIDGE_ENV]].filter(
 		(value): value is string => typeof value === "string" && value.trim().length > 0,
@@ -24,6 +55,61 @@ function canAttempt(command: string): boolean {
 	return !isPathLike(command) || existsSync(command);
 }
 
+function unavailableBridgeResult(
+	endpoint: string,
+	env: NodeJS.ProcessEnv,
+	attempted: string[],
+): GjcRuntimeBridgeResult {
+	const configured = [env[BRIDGE_ENV], env[LEGACY_BRIDGE_ENV]].filter(Boolean).join(", ");
+	const guidance = SKILL_ENTRYPOINT_ENDPOINTS.has(endpoint)
+		? `Inside a GJC agent session, invoke /skill:${endpoint} instead so the bundled skill is loaded directly.`
+		: `Configure ${BRIDGE_ENV} with a GJC-compatible private runtime binary for the ${endpoint} endpoint.`;
+	return {
+		status: 1,
+		error: [
+			`gjc ${endpoint} is a private runtime bridge command.`,
+			guidance,
+			`Only private runtime deployments should call this bridge command; configure them with ${BRIDGE_ENV}.`,
+			configured
+				? `Configured runtime candidates failed: ${configured}.`
+				: "No private GJC runtime binary was configured.",
+			attempted.length > 0 ? `Attempted: ${attempted.join(", ")}.` : undefined,
+		]
+			.filter(Boolean)
+			.join("\n"),
+	};
+}
+
+export function normalizeWorkflowHudBridgePayload(
+	raw: unknown,
+	expectedSkill: string,
+): WorkflowHudBridgePayload | null {
+	if (!raw || typeof raw !== "object") return null;
+	const record = raw as Record<string, unknown>;
+	if (record.version !== 1 || record.skill !== expectedSkill) return null;
+	const hud = normalizeWorkflowHudSummary(record.hud);
+	if (!hud) return null;
+	return {
+		version: 1,
+		skill: expectedSkill,
+		phase: typeof record.phase === "string" && record.phase.trim() ? record.phase.trim() : undefined,
+		active: typeof record.active === "boolean" ? record.active : undefined,
+		session_id:
+			typeof record.session_id === "string" && record.session_id.trim() ? record.session_id.trim() : undefined,
+		thread_id: typeof record.thread_id === "string" && record.thread_id.trim() ? record.thread_id.trim() : undefined,
+		turn_id: typeof record.turn_id === "string" && record.turn_id.trim() ? record.turn_id.trim() : undefined,
+		hud,
+	};
+}
+
+async function readHudPayload(sidecarPath: string, expectedSkill: string): Promise<WorkflowHudBridgePayload | null> {
+	try {
+		return normalizeWorkflowHudBridgePayload(JSON.parse(await Bun.file(sidecarPath).text()), expectedSkill);
+	} catch {
+		return null;
+	}
+}
+
 export function runGjcRuntimeBridge(
 	endpoint: string,
 	args: string[],
@@ -58,20 +144,80 @@ export function runGjcRuntimeBridge(
 		return { status: child.status ?? (child.signal ? 1 : 0) };
 	}
 
-	const configured = [env[BRIDGE_ENV], env[LEGACY_BRIDGE_ENV]].filter(Boolean).join(", ");
-	return {
-		status: 1,
-		error: [
-			`gjc ${endpoint} requires the private GJC runtime endpoint implementation.`,
-			`Set ${BRIDGE_ENV} to a GJC-compatible runtime binary.`,
-			configured
-				? `Configured runtime candidates failed: ${configured}.`
-				: "No gjc runtime binary was found on PATH.",
-			attempted.length > 0 ? `Attempted: ${attempted.join(", ")}.` : undefined,
-		]
-			.filter(Boolean)
-			.join("\n"),
-	};
+	return unavailableBridgeResult(endpoint, env, attempted);
+}
+
+export async function runGjcRuntimeBridgeWithHudSidecar(
+	endpoint: string,
+	args: string[],
+	options: GjcRuntimeHudBridgeOptions,
+): Promise<GjcRuntimeHudBridgeResult> {
+	const env = options.env ?? process.env;
+	if (env[GUARD_ENV] === "1") return { status: 1, error: `Refusing recursive gjc runtime bridge for ${endpoint}.` };
+
+	const attempted: string[] = [];
+	for (const binary of candidateBinaries(env)) {
+		const command = binary.trim();
+		if (!canAttempt(command)) continue;
+		attempted.push(command);
+		const sidecarDir = await fs.mkdtemp(path.join(os.tmpdir(), "gjc-workflow-hud-"));
+		const sidecarPath = path.join(sidecarDir, `${options.sidecarSkill}-${randomUUID()}.json`);
+		let latestPayload: WorkflowHudBridgePayload | undefined;
+		let lastRaw = "";
+		const publishPayload = async (): Promise<void> => {
+			let raw = "";
+			try {
+				raw = await Bun.file(sidecarPath).text();
+			} catch {
+				return;
+			}
+			if (!raw || raw === lastRaw) return;
+			lastRaw = raw;
+			const payload = await readHudPayload(sidecarPath, options.sidecarSkill);
+			if (!payload) return;
+			latestPayload = payload;
+			try {
+				await options.onHudPayload?.(payload);
+			} catch {
+				// HUD sidecar sync is best-effort and must not change child command semantics.
+			}
+		};
+		try {
+			const child = spawn(command, [endpoint, ...args], {
+				cwd: options.cwd,
+				stdio: "inherit",
+				env: {
+					...env,
+					[GUARD_ENV]: "1",
+					GJC_WORKFLOW_HUD_PROTOCOL: WORKFLOW_HUD_PROTOCOL,
+					GJC_WORKFLOW_HUD_SIDECAR: sidecarPath,
+					GJC_WORKFLOW_HUD_SKILL: options.sidecarSkill,
+				},
+			});
+			const interval = setInterval(() => {
+				void publishPayload();
+			}, options.pollIntervalMs ?? 100);
+			const exit = Promise.withResolvers<{ status: number; error?: string; code?: string }>();
+			child.on("error", error => {
+				const fsError = error as NodeJS.ErrnoException;
+				exit.resolve({ status: 1, error: error.message, code: fsError.code });
+			});
+			child.on("exit", (code, signal) => exit.resolve({ status: code ?? (signal ? 1 : 0) }));
+			const result = await exit.promise;
+			clearInterval(interval);
+			await publishPayload();
+			if (result.code === "ENOENT") continue;
+			return {
+				status: result.status,
+				...(result.error ? { error: result.error } : {}),
+				...(latestPayload ? { hudPayload: latestPayload } : {}),
+			};
+		} finally {
+			await fs.rm(sidecarDir, { recursive: true, force: true });
+		}
+	}
+
+	return unavailableBridgeResult(endpoint, env, attempted);
 }
 
 export async function runBridgedRuntimeEndpoint(endpoint: string, args: string[]): Promise<void> {

package/src/commands/ralplan.ts

@@ -1,5 +1,6 @@
 import { Command } from "@gajae-code/utils/cli";
-import { runBridgedRuntimeEndpoint } from "./gjc-runtime-bridge";
+import { syncSkillActiveState } from "../skill-state/active-state";
+import { runGjcRuntimeBridgeWithHudSidecar } from "./gjc-runtime-bridge";
 
 export default class Ralplan extends Command {
 	static description = "Run private GJC RALPLAN workflow commands";
@@ -7,6 +8,24 @@ export default class Ralplan extends Command {
 	static examples = ["$ gjc ralplan --help"];
 
 	async run(): Promise<void> {
-		await runBridgedRuntimeEndpoint("ralplan", this.argv);
+		const cwd = process.cwd();
+		const result = await runGjcRuntimeBridgeWithHudSidecar("ralplan", this.argv, {
+			cwd,
+			sidecarSkill: "ralplan",
+			onHudPayload: payload =>
+				syncSkillActiveState({
+					cwd,
+					skill: "ralplan",
+					active: payload.active ?? true,
+					phase: payload.phase,
+					sessionId: payload.session_id,
+					threadId: payload.thread_id,
+					turnId: payload.turn_id,
+					hud: payload.hud,
+					source: "gjc-runtime-bridge",
+				}),
+		});
+		if (result.error) process.stderr.write(`${result.error}\n`);
+		process.exitCode = result.status;
 	}
 }

package/src/commands/skills.ts

@@ -0,0 +1,48 @@
+/**
+ * Inspect bundled workflow skills.
+ */
+import { Args, Command, Flags, renderCommandHelp } from "@gajae-code/utils/cli";
+import { runSkillsCommand, type SkillsAction, type SkillsCommandArgs } from "../cli/skills-cli";
+
+const ACTIONS: SkillsAction[] = ["list", "read"];
+
+export default class Skills extends Command {
+	static description = "Inspect bundled GJC workflow skills";
+
+	static args = {
+		action: Args.string({
+			description: "Skills action",
+			required: false,
+			options: ACTIONS,
+		}),
+		name: Args.string({
+			description: "Bundled skill name to read",
+			required: false,
+		}),
+	};
+
+	static flags = {
+		json: Flags.boolean({ description: "Output JSON" }),
+	};
+
+	static examples = [
+		"# List bundled workflow skills\n  gjc skills list",
+		"# Read an embedded workflow skill without requiring .gjc files\n  gjc skills read ultragoal",
+		"# Machine-readable embedded skill content\n  gjc skills read ralplan --json",
+	];
+
+	async run(): Promise<void> {
+		const { args, flags } = await this.parse(Skills);
+		if (!args.action) {
+			renderCommandHelp("gjc", "skills", Skills);
+			return;
+		}
+
+		const cmd: SkillsCommandArgs = {
+			action: args.action as SkillsAction,
+			name: args.name,
+			flags: { json: flags.json },
+		};
+		await runSkillsCommand(cmd);
+	}
+}

package/src/commands/team.ts

@@ -1,12 +1,17 @@
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import {
+	buildTeamHudSummary,
 	executeGjcTeamApiOperation,
+	type GjcTeamSnapshot,
 	listGjcTeams,
 	monitorGjcTeam,
 	parseTeamLaunchArgs,
+	readGjcTeamEvents,
+	readGjcTeamSnapshot,
 	shutdownGjcTeam,
 	startGjcTeam,
 } from "../gjc-runtime/team-runtime";
+import { syncSkillActiveState } from "../skill-state/active-state";
 
 function writeJson(value: unknown): void {
 	process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
@@ -15,6 +20,38 @@ function writeJson(value: unknown): void {
 function writeText(lines: string[]): void {
 	process.stdout.write(`${lines.join("\n")}\n`);
 }
+async function syncTeamHud(snapshot: GjcTeamSnapshot): Promise<void> {
+	try {
+		const events = await readGjcTeamEvents(snapshot.team_name);
+		await syncSkillActiveState({
+			cwd: process.cwd(),
+			skill: "team",
+			active: snapshot.phase !== "complete" && snapshot.phase !== "cancelled",
+			phase: snapshot.phase,
+			hud: await buildTeamHudSummary(snapshot, events.at(-1)),
+			source: "gjc-team",
+		});
+	} catch {
+		// HUD sync is best-effort and must not change command semantics.
+	}
+}
+
+function formatTaskCounts(counts: Record<string, number>): string {
+	return Object.entries(counts)
+		.map(([status, count]) => `${status}=${count}`)
+		.join(" ");
+}
+
+function formatIntegrationSummary(snapshot: {
+	integration_by_worker?: Record<string, { status?: string; conflict_files?: string[] }>;
+}): string[] {
+	const entries = Object.entries(snapshot.integration_by_worker ?? {});
+	if (entries.length === 0) return ["integration: no attempts recorded"];
+	return entries.map(([worker, state]) => {
+		const files = state.conflict_files?.length ? ` files=${state.conflict_files.join(",")}` : "";
+		return `integration: ${worker} ${state.status ?? "unknown"}${files}`;
+	});
+}
 
 function parseInputFlag(argv: string[]): Record<string, unknown> {
 	const index = argv.indexOf("--input");
@@ -69,6 +106,7 @@ export default class Team extends Command {
 			const teamName = rest.find(arg => !arg.startsWith("--"));
 			if (!teamName) throw new Error("missing_team_name");
 			const snapshot = await monitorGjcTeam(teamName);
+			await syncTeamHud(snapshot);
 			if (json) {
 				writeJson(snapshot);
 				return;
@@ -76,9 +114,11 @@ export default class Team extends Command {
 			writeText([
 				`team: ${snapshot.team_name}`,
 				`phase: ${snapshot.phase}`,
-				`tmux: ${snapshot.tmux_session}`,
+				`tmux: ${snapshot.tmux_target || snapshot.tmux_session}`,
 				`state: ${snapshot.state_dir}`,
-				`tasks: ${snapshot.task_total}`,
+				`tasks: ${snapshot.task_total} (${formatTaskCounts(snapshot.task_counts)})`,
+				`workers: ${snapshot.workers.map(worker => `${worker.id}:${worker.status}`).join(" ")}`,
+				...formatIntegrationSummary(snapshot),
 			]);
 			return;
 		}
@@ -87,6 +127,7 @@ export default class Team extends Command {
 			const teamName = rest.find(arg => !arg.startsWith("--"));
 			if (!teamName) throw new Error("missing_team_name");
 			const snapshot = await shutdownGjcTeam(teamName);
+			await syncTeamHud(snapshot);
 			if (json) {
 				writeJson(snapshot);
 				return;
@@ -108,13 +149,23 @@ export default class Team extends Command {
 				return;
 			}
 			const input = parseInputFlag(rest);
-			writeJson(await executeGjcTeamApiOperation(operation, input));
+			const result = await executeGjcTeamApiOperation(operation, input);
+			const teamName = String(input.team_name ?? input.teamName ?? "").trim();
+			if (teamName) {
+				try {
+					await syncTeamHud(await readGjcTeamSnapshot(teamName));
+				} catch {
+					// API operations without a resolvable snapshot leave HUD state unchanged.
+				}
+			}
+			writeJson(result);
 			return;
 		}
 
 		const startArgs = action === "start" ? rest : this.argv;
 		const options = parseTeamLaunchArgs(startArgs);
 		const snapshot = await startGjcTeam({ ...options, dryRun });
+		await syncTeamHud(snapshot);
 		if (json) {
 			writeJson(snapshot);
 			return;

package/src/commands/ultragoal.ts

@@ -6,7 +6,13 @@ import {
 	writeCurrentSessionGoalModeState,
 	writePendingGoalModeRequest,
 } from "../gjc-runtime/goal-mode-request";
-import { runNativeUltragoalCommand } from "../gjc-runtime/ultragoal-runtime";
+import {
+	buildUltragoalHudSummary,
+	getUltragoalStatus,
+	readUltragoalLedger,
+	runNativeUltragoalCommand,
+} from "../gjc-runtime/ultragoal-runtime";
+import { syncSkillActiveState } from "../skill-state/active-state";
 
 export default class Ultragoal extends Command {
 	static description = "Run native GJC Ultragoal workflow commands";
@@ -19,6 +25,20 @@ export default class Ultragoal extends Command {
 		if (result.stdout) process.stdout.write(result.stdout);
 		if (result.stderr) process.stderr.write(result.stderr);
 		process.exitCode = result.status;
+		try {
+			const summary = await getUltragoalStatus(process.cwd());
+			const ledger = await readUltragoalLedger(process.cwd());
+			await syncSkillActiveState({
+				cwd: process.cwd(),
+				skill: "ultragoal",
+				active: summary.exists && summary.status !== "complete",
+				phase: summary.status,
+				hud: buildUltragoalHudSummary(summary, ledger.at(-1)),
+				source: "gjc-ultragoal",
+			});
+		} catch {
+			// HUD sync is best-effort and must not change command semantics.
+		}
 		if (result.status !== 0 || !shouldActivateGoalMode) return;
 
 		const cwd = process.cwd();

package/src/commit/agentic/index.ts

@@ -31,6 +31,7 @@ export async function runAgenticCommit(args: CommitCommandArgs): Promise<void> {
 	process.stdout.write("● Resolving model...\n");
 	const modelRegistry = new ModelRegistry(authStorage);
 	await modelRegistry.refresh();
+	modelRegistry.applyConfiguredModelBindings(settings);
 	const stagedFilesPromise = (async () => {
 		let stagedFiles = await git.diff.changedFiles(cwd, { cached: true });
 		if (stagedFiles.length === 0) {

package/src/commit/pipeline.ts

@@ -45,6 +45,7 @@ async function runLegacyCommitCommand(args: CommitCommandArgs): Promise<void> {
 	const authStorage = await discoverAuthStorage();
 	const modelRegistry = new ModelRegistry(authStorage);
 	await modelRegistry.refresh();
+	modelRegistry.applyConfiguredModelBindings(settings);
 
 	const {
 		model: primaryModel,