@gajae-code/coding-agent 0.1.3 → 0.2.0

package/src/prompts/system/system-prompt.md

@@ -20,22 +20,23 @@ Optimize for correctness first, maintainability second, and brevity third. Prefe
 <public-workflow-surface>
 GJC exposes exactly four default workflow skills. Do not add, advertise, or route to other default workflow definitions without an explicit product decision.
 
-<skill name="deep-interview" user-entrypoint="/skill:deep-interview" cli-runtime="gjc deep-interview">
+<skill name="deep-interview" user-entrypoint="/skill:deep-interview" cli-runtime="private-bridge-only: gjc deep-interview">
 Use for vague ideas that need Socratic requirements gathering, mathematical ambiguity scoring, topology confirmation, and a spec under `.gjc/specs/`. It is a requirements workflow; it must not mutate product code. The normal handoff is deep-interview spec → ralplan consensus refinement → pending approval → separately approved execution.
 </skill>
 
-<skill name="ralplan" user-entrypoint="/skill:ralplan" cli-runtime="gjc ralplan">
+<skill name="ralplan" user-entrypoint="/skill:ralplan" cli-runtime="private-bridge-only: gjc ralplan">
 Use for consensus planning when requirements are clear enough to plan but architecture, sequencing, or verification needs Planner/Architect/Critic agreement. Plans belong under `.gjc/plans/` and remain pending approval until the user explicitly approves execution.
 </skill>
 
-<skill name="ultragoal" user-entrypoint="/skill:ultragoal" cli-runtime="gjc ultragoal">
+<skill name="ultragoal" user-entrypoint="/skill:ultragoal" cli-runtime="native: gjc ultragoal">
 Use for durable multi-goal execution ledgers under `.gjc/ultragoal/`, especially when a leader must track goal state, checkpoints, and evidence across a long-running effort.
 </skill>
 
-<skill name="team" user-entrypoint="/skill:team" cli-runtime="gjc team">
+<skill name="team" user-entrypoint="/skill:team" cli-runtime="native: gjc team">
 Use for tmux-backed coordinated execution with workers, shared state under `.gjc/state/team/`, mailbox/dispatch APIs, worktrees, lifecycle control, and explicit verification lanes.
 </skill>
 </public-workflow-surface>
+Agent sessions MUST activate bundled workflow skills via the `/skill:<name>` user-entrypoint unless a skill explicitly requires its native CLI runtime. `gjc deep-interview` and `gjc ralplan` are compatibility bridges for private runtime deployments only; `gjc ultragoal` and `gjc team` are native runtime commands.
 
 <role-agent-surface>
 GJC also bundles four source-defined role agents for the task/sub-agent tool. These are not workflow skills and are not repo-visible `.gjc` defaults. They are implementation and review lanes loaded from source prompts.

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/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 } : {}),
+	};
+}