@gajae-code/coding-agent 0.5.0 → 0.5.1

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

@@ -21,6 +21,8 @@ interface RalplanHudState extends WorkflowGateHudState {
 	stage?: string;
 	waiting?: string;
 	iteration?: number;
+	iterationFromIndex?: number;
+	stages?: string;
 	verdict?: string;
 	latestSummary?: string;
 	pendingApproval?: boolean;
@@ -100,6 +102,95 @@ export function buildDeepInterviewHudSummary(state: DeepInterviewHudState): Work
 	};
 }
 
+export interface DeepInterviewHudDeriveOptions {
+	phase?: string;
+	specStatus?: string;
+	updatedAt?: string;
+}
+
+function diIsPlainObject(value: unknown): value is Record<string, unknown> {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function latestScoredAmbiguity(rounds: unknown): number | undefined {
+	if (!Array.isArray(rounds)) return undefined;
+	for (let index = rounds.length - 1; index >= 0; index--) {
+		const round = rounds[index];
+		if (diIsPlainObject(round) && round.lifecycle === "scored" && typeof round.ambiguity === "number") {
+			return round.ambiguity;
+		}
+	}
+	return undefined;
+}
+
+function weakestDimensionFromTopology(
+	topology: Record<string, unknown>,
+	targetComponent: string | undefined,
+): string | undefined {
+	if (!Array.isArray(topology.components)) return undefined;
+	const components = topology.components.filter(diIsPlainObject);
+	const dimensionOf = (component: Record<string, unknown>): string | undefined =>
+		typeof component.weakest_dimension === "string" && component.weakest_dimension.trim()
+			? component.weakest_dimension
+			: undefined;
+	if (targetComponent) {
+		const targeted = components.find(component => component.id === targetComponent && dimensionOf(component));
+		if (targeted) return dimensionOf(targeted);
+	}
+	const active = components.find(component => component.status !== "deferred" && dimensionOf(component));
+	if (active) return dimensionOf(active);
+	const any = components.find(component => dimensionOf(component));
+	return any ? dimensionOf(any) : undefined;
+}
+
+/**
+ * Single source of deep-interview HUD derivation. Reads a complete (normalized)
+ * mode-state envelope so recorder, `gjc state write`, reconcile, seed, and handoff
+ * all produce identical chips. Topology-aware `target`/`weakest` come from
+ * `state.topology`; `legacy_missing` topology omits those chips (no synthetic values).
+ */
+export function deriveDeepInterviewHud(
+	payload: Record<string, unknown>,
+	options: DeepInterviewHudDeriveOptions = {},
+): WorkflowHudSummary {
+	const stateField = diIsPlainObject(payload.state) ? payload.state : {};
+	const isNumber = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
+	const isArray = (value: unknown): value is unknown[] => Array.isArray(value);
+	const pick = <T>(key: string, guard: (value: unknown) => value is T): T | undefined => {
+		const value = stateField[key] ?? payload[key];
+		return guard(value) ? value : undefined;
+	};
+
+	const phase = options.phase ?? (typeof payload.current_phase === "string" ? payload.current_phase : undefined);
+	const rounds = pick("rounds", isArray);
+	const ambiguity = pick("current_ambiguity", isNumber) ?? latestScoredAmbiguity(rounds);
+	const threshold = pick("threshold", isNumber);
+	const rawTopology = diIsPlainObject(stateField.topology)
+		? stateField.topology
+		: diIsPlainObject(payload.topology)
+			? payload.topology
+			: undefined;
+	// `legacy_missing` topology was never confirmed: omit target/weakest even if stale fields linger.
+	const topology = rawTopology && rawTopology.status !== "legacy_missing" ? rawTopology : undefined;
+	const targetComponent =
+		topology && typeof topology.last_targeted_component_id === "string"
+			? topology.last_targeted_component_id
+			: undefined;
+	const weakestDimension = topology ? weakestDimensionFromTopology(topology, targetComponent) : undefined;
+	const specStatus = options.specStatus ?? (typeof payload.spec_status === "string" ? payload.spec_status : undefined);
+
+	return buildDeepInterviewHudSummary({
+		phase,
+		ambiguity,
+		threshold,
+		roundCount: rounds?.length,
+		targetComponent,
+		weakestDimension,
+		specStatus,
+		updatedAt: options.updatedAt ?? new Date().toISOString(),
+	});
+}
+
 export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSummary {
 	const verdict = state.verdict?.toUpperCase();
 	const verdictSeverity =
@@ -118,7 +209,14 @@ export function buildRalplanHudSummary(state: RalplanHudState): WorkflowHudSumma
 			...gateChips(state, 6),
 			chip("stage", state.stage, 10),
 			chip("waiting", state.waiting, 20),
-			chip("iter", state.iteration === undefined ? undefined : String(state.iteration), 30),
+			chip(
+				"iter",
+				(state.iterationFromIndex ?? state.iteration) === undefined
+					? undefined
+					: String(state.iterationFromIndex ?? state.iteration),
+				30,
+			),
+			chip("stages", state.stages, 35),
 			chip("verdict", verdict, 40, verdictSeverity),
 		]),
 		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
@@ -136,17 +234,15 @@ export function buildUltragoalHudSummary(state: UltragoalHudState): WorkflowHudS
 			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),
+			chip(
+				"ledger",
+				state.latestLedgerEvent?.event
+					? [state.latestLedgerEvent.event, state.latestLedgerEvent.goalId].filter(Boolean).join(":")
+					: undefined,
+				35,
+			),
 			...gateChips(state, 40),
 		]),
-		details: state.latestLedgerEvent
-			? compactChips([
-					chip(
-						"ledger",
-						[state.latestLedgerEvent.event, state.latestLedgerEvent.goalId].filter(Boolean).join(":"),
-						100,
-					),
-				])
-			: undefined,
 		...(state.updatedAt ? { updated_at: state.updatedAt } : {}),
 	};
 }

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

@@ -4,6 +4,7 @@ import type { ThinkingLevel } from "@gajae-code/agent-core";
 import { type Model, modelsAreEqual } from "@gajae-code/ai";
 import { getOAuthProviders } from "@gajae-code/ai/utils/oauth";
 import { setProjectDir } from "@gajae-code/utils";
+import { jobElapsedMs } from "../async";
 import {
 	GJC_MODEL_ASSIGNMENT_TARGET_IDS,
 	GJC_MODEL_ASSIGNMENT_TARGETS,
@@ -506,14 +507,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			if (snapshot.running.length > 0) {
 				lines.push("", "Running Jobs");
 				for (const job of snapshot.running) {
-					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(now - job.startTime)}`);
+					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(jobElapsedMs(job, now))}`);
 					lines.push(`    ${job.label}`);
 				}
 			}
 			if (snapshot.recent.length > 0) {
 				lines.push("", "Recent Jobs");
 				for (const job of snapshot.recent) {
-					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(now - job.startTime)}`);
+					lines.push(`  [${job.id}] ${job.type} (${job.status}) — ${formatDuration(jobElapsedMs(job, now))}`);
 					lines.push(`    ${job.label}`);
 				}
 			}

package/src/task/executor.ts

@@ -1154,6 +1154,15 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					resolvedModel: model.id,
 				});
 			}
+			// Record which model the subagent actually runs on (and any auth fallback,
+			// see #985) so the subagent panel can surface it to the user.
+			if (model) {
+				AsyncJobManager.instance()?.updateSubagentModel?.(options.subagentId ?? id, {
+					requestedModel: modelSubstitutionWarning?.requested ?? resolvedModelString,
+					effectiveModel: resolvedModelString,
+					modelFellBack: authFallbackUsed === true,
+				});
+			}
 			if (model?.contextWindow && model.contextWindow > 0) {
 				progress.contextWindow = model.contextWindow;
 			}

package/src/tools/ask.ts

@@ -34,6 +34,8 @@ import {
 	renderDeepInterviewAskQuestion,
 } from "../deep-interview/render-middleware";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
+import { appendOrMergeDeepInterviewRound } from "../gjc-runtime/deep-interview-recorder";
+import { deepInterviewStatePath } from "../gjc-runtime/deep-interview-runtime";
 import { gateAnswerToResult, questionToGate } from "../modes/shared/agent-wire/deep-interview-gate";
 import { getMarkdownTheme, type Theme, theme } from "../modes/theme/theme";
 import askDescription from "../prompts/tools/ask.md" with { type: "text" };
@@ -50,15 +52,25 @@ const OptionItem = z.object({
 	label: z.string().describe("display label"),
 });
 
+/** Optional structured deep-interview round metadata; when present the round is recorded automatically. */
+const DeepInterviewMeta = z.object({
+	round_id: z.string().describe("stable optional round identity").optional(),
+	round: z.number().int().nonnegative().describe("round number"),
+	component: z.string().min(1).describe("targeted topology component"),
+	dimension: z.string().min(1).describe("targeted clarity dimension"),
+	ambiguity: z.number().min(0).max(1).describe("ambiguity at ask time (0..1)"),
+});
+
 const QuestionItem = z.object({
 	id: z.string().describe("question id"),
 	question: z.string().describe("question text"),
 	options: z.array(OptionItem).describe("available options"),
 	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(),
 });
 
-const askSchema = z.object({
+export const askSchema = z.object({
 	questions: z.array(QuestionItem).min(1).describe("questions to ask"),
 });
 
@@ -456,6 +468,45 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 		TERMINAL.sendNotification("Waiting for input");
 	}
 
+	/**
+	 * Record a resolved deep-interview round when the question carries structured
+	 * metadata. The runtime owns durable record/merge semantics; this tool is only the
+	 * caller. Best-effort: a state-write hiccup must not break the user's answer flow.
+	 */
+	async #recordDeepInterviewRound(
+		q: AskParams["questions"][number],
+		selectedOptions: string[],
+		customInput: string | undefined,
+	): Promise<void> {
+		const meta = q.deepInterview;
+		if (!meta) return;
+		try {
+			const cwd = this.session.cwd;
+			const sessionId = this.session.getSessionId?.() ?? undefined;
+			const statePath = deepInterviewStatePath(cwd, sessionId);
+			await appendOrMergeDeepInterviewRound(
+				cwd,
+				statePath,
+				{
+					round: meta.round,
+					round_id: meta.round_id,
+					questionId: q.id,
+					questionText: q.question,
+					component: meta.component,
+					dimension: meta.dimension,
+					ambiguity: meta.ambiguity,
+					selectedOptions,
+					customInput,
+				},
+				{ sessionId },
+			);
+		} catch (error) {
+			console.warn(
+				`ask: deep-interview round recording failed: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
 	async execute(
 		_toolCallId: string,
 		params: AskParams,
@@ -515,6 +566,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 					options: q.options,
 					multi: q.multi,
 					recommended: q.recommended,
+					deepInterview: q.deepInterview,
 				};
 				const answer = await gateEmitter.emitGate(questionToGate(gateQuestion));
 				const decoded = gateAnswerToResult(gateQuestion, answer);
@@ -582,6 +634,7 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 				context?.abort();
 				throw new ToolAbortError("Ask tool was cancelled by the user");
 			}
+			await this.#recordDeepInterviewRound(q, selectedOptions, customInput);
 			const details: AskToolDetails = {
 				question: q.question,
 				options: optionLabels,
@@ -644,6 +697,8 @@ export class AskTool implements AgentTool<typeof askSchema, AskToolDetails> {
 				customInput,
 			};
 
+			await this.#recordDeepInterviewRound(q, selectedOptions, customInput);
+
 			if (navAction === "back") {
 				questionIndex = Math.max(0, questionIndex - 1);
 				continue;

package/src/tools/job.ts

@@ -3,7 +3,7 @@ import type { Component } from "@gajae-code/tui";
 import { Text } from "@gajae-code/tui";
 import { prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
-import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
+import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled, jobElapsedMs } from "../async";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import jobDescription from "../prompts/tools/job.md" with { type: "text" };
@@ -257,6 +257,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 			status: string;
 			label: string;
 			startTime: number;
+			endTime?: number;
 			resultText?: string;
 			errorText?: string;
 		}[],
@@ -270,7 +271,7 @@ export class JobTool implements AgentTool<typeof jobSchema, JobToolDetails> {
 				type: latest.type,
 				status: latest.status as JobSnapshot["status"],
 				label: latest.label,
-				durationMs: Math.max(0, now - latest.startTime),
+				durationMs: jobElapsedMs(latest, now),
 				...(latest.resultText ? { resultText: latest.resultText } : {}),
 				...(latest.errorText ? { errorText: latest.errorText } : {}),
 			};

package/src/tools/monitor.ts

@@ -3,6 +3,7 @@ import { logger, prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
 import { AsyncJobManager, isBackgroundJobSupportEnabled } from "../async";
 import monitorDescription from "../prompts/tools/monitor.md" with { type: "text" };
+import { truncateTail } from "../session/streaming-output";
 import { BashTool } from "./bash";
 import type { ToolSession } from "./index";
 import { ToolError } from "./tool-errors";
@@ -48,6 +49,8 @@ export interface MonitorToolDetails {
 
 const MONITOR_LABEL_MAX = 120;
 const MAX_PENDING_MONITOR_NOTIFICATIONS = 3;
+const MONITOR_NOTIFICATION_LINE_MAX_BYTES = 16 * 1024;
+const MONITOR_NOTIFICATION_LINE_MAX_LINES = 20;
 
 function buildMonitorLabel(params: MonitorParams): string {
 	const base = `[monitor:${params.kind}] ${params.description}`;
@@ -55,6 +58,34 @@ function buildMonitorLabel(params: MonitorParams): string {
 	return `${base.slice(0, MONITOR_LABEL_MAX - 3)}...`;
 }
 
+function formatMonitorNotificationLine(line: string): {
+	content: string;
+	truncated: boolean;
+	totalBytes: number;
+	outputBytes: number;
+} {
+	const truncation = truncateTail(line, {
+		maxBytes: MONITOR_NOTIFICATION_LINE_MAX_BYTES,
+		maxLines: MONITOR_NOTIFICATION_LINE_MAX_LINES,
+	});
+	const outputBytes = truncation.outputBytes ?? truncation.totalBytes;
+	if (!truncation.truncated) {
+		return {
+			content: truncation.content,
+			truncated: false,
+			totalBytes: truncation.totalBytes,
+			outputBytes,
+		};
+	}
+	const notice = `[Monitor output truncated: showing last ${outputBytes} of ${truncation.totalBytes} bytes]`;
+	return {
+		content: `${truncation.content}\n${notice}`,
+		truncated: true,
+		totalBytes: truncation.totalBytes,
+		outputBytes,
+	};
+}
+
 export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolDetails> {
 	readonly name = "monitor";
 	readonly label = "Monitor";
@@ -130,7 +161,8 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 			if (controller.closed) return;
 			const notificationId = `${jobId}:${sequence}`;
 			const suffix = count > 0 ? `\n(+${count} earlier lines)` : "";
-			const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted latest state:\n${line}${suffix}\n</task-notification>`;
+			const notificationLine = formatMonitorNotificationLine(line);
+			const content = `<task-notification>\nMonitor task ${jobId} (${params.kind}: ${params.description}) emitted latest state:\n${notificationLine.content}${suffix}\n</task-notification>`;
 			const details = {
 				taskId: jobId,
 				kind: params.kind,
@@ -139,6 +171,9 @@ export class MonitorTool implements AgentTool<typeof monitorSchema, MonitorToolD
 				notificationId,
 				sequence,
 				coalescedCount: count,
+				outputTruncated: notificationLine.truncated,
+				outputTotalBytes: notificationLine.totalBytes,
+				outputBytes: notificationLine.outputBytes,
 			};
 			pendingNotifications += 1;
 			if (pendingNotifications > MAX_PENDING_MONITOR_NOTIFICATIONS) {

package/src/tools/subagent-render.ts

@@ -66,6 +66,15 @@ function renderSubagentSnapshot(
 	if (snapshot.agent && snapshot.agent !== "unknown") {
 		lines.push(`  ${theme.fg("dim", `Agent: ${snapshot.agent} (${snapshot.agentSource})`)}`);
 	}
+	if (snapshot.effectiveModel) {
+		if (snapshot.modelFellBack && snapshot.requestedModel) {
+			lines.push(
+				`  ${theme.fg("warning", `Model: ${snapshot.effectiveModel} (requested ${snapshot.requestedModel}, fell back — no credentials)`)}`,
+			);
+		} else {
+			lines.push(`  ${theme.fg("dim", `Model: ${snapshot.effectiveModel}`)}`);
+		}
+	}
 	if (snapshot.description) lines.push(`  ${theme.fg("dim", `Description: ${snapshot.description}`)}`);
 	if (snapshot.outputRef) lines.push(`  ${theme.fg("dim", `Output: ${snapshot.outputRef}`)}`);
 	if (snapshot.assignment) {

package/src/tools/subagent.ts

@@ -2,7 +2,7 @@ import * as path from "node:path";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
 import { prompt } from "@gajae-code/utils";
 import * as z from "zod/v4";
-import { type AsyncJob, AsyncJobManager, type SubagentRecord } from "../async";
+import { type AsyncJob, AsyncJobManager, jobElapsedMs, type SubagentRecord } from "../async";
 import subagentDescription from "../prompts/tools/subagent.md" with { type: "text" };
 import type { AgentProgress, AgentSource } from "../task/types";
 import { Ellipsis, truncateToWidth } from "../tui";
@@ -67,6 +67,12 @@ export interface SubagentSnapshot {
 	progress?: AgentProgress;
 	/** True when a live in-session progress producer exists for this subagent. */
 	liveProgressAvailable?: boolean;
+	/** Model the subagent actually runs on (after any auth fallback). */
+	effectiveModel?: string;
+	/** Model originally requested via role/preset mapping; differs from effective on fallback. */
+	requestedModel?: string;
+	/** True when the requested model lacked credentials and fell back to the parent model. */
+	modelFellBack?: boolean;
 }
 
 export interface SubagentToolDetails {
@@ -508,6 +514,13 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			lines.push(`### ${snapshot.id} — ${snapshot.status}`);
 			if (snapshot.jobId !== snapshot.id) lines.push(`Job: ${snapshot.jobId}`);
 			if (snapshot.agent) lines.push(`Agent: ${snapshot.agent} (${snapshot.agentSource})`);
+			if (snapshot.effectiveModel) {
+				lines.push(
+					snapshot.modelFellBack && snapshot.requestedModel
+						? `Model: ${snapshot.effectiveModel} (requested ${snapshot.requestedModel}, fell back — no credentials)`
+						: `Model: ${snapshot.effectiveModel}`,
+				);
+			}
 			if (snapshot.description) lines.push(`Description: ${snapshot.description}`);
 			if (snapshot.outputRef) lines.push(`Output: ${snapshot.outputRef}`);
 			if (snapshot.assignment) lines.push("Assignment:", "```", snapshot.assignment, "```");
@@ -584,9 +597,19 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			durationMs: 0,
 			...(verifiedOutputIds.has(record.subagentId) ? { outputRef: `agent://${record.subagentId}` } : {}),
 			...liveFields,
+			...this.#modelFields(record),
 		};
 	}
 
+	#modelFields(record?: SubagentRecord): Partial<SubagentSnapshot> {
+		if (!record) return {};
+		const fields: Partial<SubagentSnapshot> = {};
+		if (record.effectiveModel) fields.effectiveModel = record.effectiveModel;
+		if (record.requestedModel) fields.requestedModel = record.requestedModel;
+		if (record.modelFellBack) fields.modelFellBack = true;
+		return fields;
+	}
+
 	#snapshot(
 		job: AsyncJob,
 		timedOut = false,
@@ -608,7 +631,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 			label: sanitizeText(job.label, RECEIPT_PREVIEW_WIDTH),
 			agent: subagent?.agent ?? "unknown",
 			agentSource: subagent?.agentSource ?? "bundled",
-			durationMs: Math.max(0, Date.now() - job.startTime),
+			durationMs: jobElapsedMs(job),
 			...(subagent?.description ? { description: sanitizeText(subagent.description, RECEIPT_PREVIEW_WIDTH) } : {}),
 			...(verbosity === "full" && subagent?.assignment
 				? { assignment: sanitizeText(subagent.assignment, FULL_PREVIEW_WIDTH) }
@@ -622,6 +645,7 @@ export class SubagentTool implements AgentTool<typeof subagentSchema, SubagentTo
 				: {}),
 			...(outputRef ? { outputRef } : {}),
 			...(runningTimeoutGuidance ? { guidance: runningTimeoutGuidance } : {}),
+			...this.#modelFields(record),
 		};
 	}