@gajae-code/coding-agent 0.2.4 → 0.3.0

package/src/commands/team.ts

@@ -1,11 +1,13 @@
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { renderTeamStatusMarkdown } from "../gjc-runtime/state-renderer";
 import {
 	buildTeamHudSummary,
 	executeGjcTeamApiOperation,
 	type GjcTeamSnapshot,
 	listGjcTeams,
-	monitorGjcTeam,
+	monitorGjcTeamSnapshot,
 	parseTeamLaunchArgs,
+	persistGjcTeamModeStateSummary,
 	readGjcTeamEvents,
 	readGjcTeamSnapshot,
 	shutdownGjcTeam,
@@ -31,6 +33,7 @@ async function syncTeamHud(snapshot: GjcTeamSnapshot): Promise<void> {
 			hud: await buildTeamHudSummary(snapshot, events.at(-1)),
 			source: "gjc-team",
 		});
+		await persistGjcTeamModeStateSummary(snapshot, process.cwd());
 	} catch {
 		// HUD sync is best-effort and must not change command semantics.
 	}
@@ -42,29 +45,6 @@ function formatTaskCounts(counts: Record<string, number>): string {
 		.join(" ");
 }
 
-function formatNotificationSummary(snapshot: GjcTeamSnapshot): string {
-	const summary = snapshot.notification_summary;
-	return `notifications: total=${summary.total} replay_eligible=${summary.replay_eligible} pending=${summary.by_state.pending} queued=${summary.by_state.queued} deferred=${summary.by_state.deferred} failed=${summary.by_state.failed}`;
-}
-
-function formatAwaitingIntegrationNextStep(snapshot: GjcTeamSnapshot): string[] {
-	if (snapshot.phase !== "awaiting_integration") return [];
-	return [
-		"next: worker tasks are completed, but integration still needs leader attention before the team is complete",
-	];
-}
-
-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");
 	if (index < 0) return {};
@@ -76,12 +56,13 @@ function parseInputFlag(argv: string[]): Record<string, unknown> {
 }
 
 export default class Team extends Command {
-	static description = "Run native GJC tmux team orchestration; --dry-run writes ephemeral .gjc/state/team state only";
+	static description =
+		"Run native GJC tmux team orchestration from inside an existing tmux/GJC --tmux session; --dry-run writes ephemeral .gjc/state/team state only";
 	static strict = false;
 
 	static args = {
 		action: Args.string({
-			description: "start (default), status, list, shutdown, resume, or api",
+			description: "start (default), status, monitor, list, shutdown, resume, or api",
 			required: false,
 		}),
 	};
@@ -96,8 +77,10 @@ export default class Team extends Command {
 	};
 
 	static examples = [
+		"gjc --tmux  # start/attach the required tmux-backed leader session first",
 		'gjc team 3:executor "Implement the approved plan"',
 		"gjc team status <team-name> --json",
+		"gjc team monitor <team-name> --json",
 		'gjc team api claim-task --input \'{"team_name":"demo","worker_id":"worker-1"}\' --json',
 		'gjc team 2:executor --dry-run --json "Preview state only"',
 		"gjc team shutdown <team-name>",
@@ -119,26 +102,36 @@ export default class Team extends Command {
 			return;
 		}
 
-		if (action === "status" || action === "resume") {
+		if (action === "status") {
+			const teamName = rest.find(arg => !arg.startsWith("--"));
+			if (!teamName) throw new Error("missing_team_name");
+			const snapshot = await readGjcTeamSnapshot(teamName);
+			if (json) {
+				writeJson(snapshot);
+				return;
+			}
+			writeText([
+				renderTeamStatusMarkdown(snapshot).trimEnd(),
+				"- mode: read-only status; use `gjc team monitor <team>` or `gjc team resume <team>` for recovery/integration",
+			]);
+			void formatTaskCounts(snapshot.task_counts);
+			return;
+		}
+
+		if (action === "monitor" || action === "resume") {
 			const teamName = rest.find(arg => !arg.startsWith("--"));
 			if (!teamName) throw new Error("missing_team_name");
-			const snapshot = await monitorGjcTeam(teamName);
+			const snapshot = await monitorGjcTeamSnapshot(teamName);
 			await syncTeamHud(snapshot);
 			if (json) {
 				writeJson(snapshot);
 				return;
 			}
 			writeText([
-				`team: ${snapshot.team_name}`,
-				`phase: ${snapshot.phase}`,
-				`tmux: ${snapshot.tmux_target || snapshot.tmux_session}`,
-				`state: ${snapshot.state_dir}`,
-				`tasks: ${snapshot.task_total} (${formatTaskCounts(snapshot.task_counts)})`,
-				`workers: ${snapshot.workers.map(worker => `${worker.id}:${worker.status}`).join(" ")}`,
-				formatNotificationSummary(snapshot),
-				...formatAwaitingIntegrationNextStep(snapshot),
-				...formatIntegrationSummary(snapshot),
+				renderTeamStatusMarkdown(snapshot).trimEnd(),
+				"- mode: mutating monitor; liveness recovery and integration may have run",
 			]);
+			void formatTaskCounts(snapshot.task_counts);
 			return;
 		}
 
@@ -162,8 +155,12 @@ export default class Team extends Command {
 					"Supported operations:",
 					"send-message broadcast mailbox-list mailbox-mark-delivered mailbox-mark-notified notification-list notification-read notification-replay notification-mark-pane-attempt worker-startup-ack",
 					"create-task read-task list-tasks update-task claim-task transition-task-status release-task-claim",
-					"read-config read-manifest read-worker-status read-worker-heartbeat update-worker-heartbeat write-worker-inbox write-worker-identity",
-					"append-event read-events await-event write-shutdown-request read-shutdown-ack read-monitor-snapshot write-monitor-snapshot read-task-approval write-task-approval",
+					"read-config read-manifest read-worker-status update-worker-status read-worker-heartbeat recover-stale-claims update-worker-heartbeat write-worker-inbox write-worker-identity",
+					"append-event read-events read-traces await-event write-shutdown-request read-shutdown-ack read-monitor-snapshot write-monitor-snapshot read-task-approval write-task-approval",
+					"Completion example:",
+					'transition-task-status --input \'{"team_name":"demo","task_id":"task-1","to":"completed","claim_token":"...","completion_evidence":{"summary":"done","items":[{"kind":"command","status":"passed","summary":"focused tests passed","command":"bun test packages/coding-agent/test/gjc-runtime/team-runtime.test.ts"}]}}\' --json',
+					'Review-only completion may use {"kind":"inspection","status":"verified","summary":"review passed","location":"agent://review"}.',
+					'Typed lane task example: create-task --input \'{"team_name":"demo","subject":"Verify delivery","description":"Run verification","owner":"worker-1","lane":"verification","required_role":"executor","depends_on":["task-1"]}\' --json',
 				]);
 				return;
 			}

package/src/config/settings-schema.ts

@@ -147,6 +147,7 @@ interface StringDef {
 interface NumberDef {
 	type: "number";
 	default: number;
+	validate?: (value: number) => boolean;
 	ui?: UiNumber;
 }
 
@@ -319,6 +320,12 @@ export const SETTINGS_SCHEMA = {
 
 	cycleOrder: { type: "array", default: DEFAULT_CYCLE_ORDER },
 
+	"gjc.deepInterview.ambiguityThreshold": {
+		type: "number",
+		default: 0.05,
+		validate: (value: number) => Number.isFinite(value) && value > 0 && value <= 1,
+	},
+
 	// ────────────────────────────────────────────────────────────────────────
 	// Appearance
 	// ────────────────────────────────────────────────────────────────────────
@@ -337,7 +344,7 @@ export const SETTINGS_SCHEMA = {
 
 	"theme.light": {
 		type: "string",
-		default: "light",
+		default: "blue-crab",
 		ui: {
 			tab: "appearance",
 			label: "Light Theme",
@@ -2530,6 +2537,7 @@ export const SETTINGS_SCHEMA = {
 		type: "enum",
 		values: [
 			"auto",
+			"duckduckgo",
 			"exa",
 			"brave",
 			"jina",
@@ -2554,7 +2562,12 @@ export const SETTINGS_SCHEMA = {
 				{
 					value: "auto",
 					label: "Auto",
-					description: "Preferred web-search provider",
+					description: "Active model's native search if its creds exist, else keyless DuckDuckGo",
+				},
+				{
+					value: "duckduckgo",
+					label: "DuckDuckGo",
+					description: "Keyless default — no API key or OAuth required",
 				},
 				{ value: "exa", label: "Exa", description: "Uses Exa API when EXA_API_KEY is set" },
 				{ value: "brave", label: "Brave", description: "Requires BRAVE_API_KEY" },

package/src/config/settings.ts

@@ -5,7 +5,7 @@
  *   import { settings } from "./settings";
  *
  *   const enabled = settings.get("compaction.enabled");  // sync read
- *   settings.set("theme.dark", "titanium");               // sync write, saves in background
+ *   settings.set("theme.dark", "red-claw");              // sync write, saves in background
  *
  * For tests:
  *   const isolated = Settings.isolated({ "compaction.enabled": false });
@@ -17,6 +17,7 @@ import * as path from "node:path";
 import {
 	getAgentDbPath,
 	getAgentDir,
+	getCustomThemesDir,
 	getProjectDir,
 	isEnoent,
 	logger,
@@ -100,6 +101,14 @@ function setByPath(obj: RawSettings, segments: string[], value: unknown): void {
 }
 
 const PATH_SCOPED_ARRAY_SETTINGS = new Set<SettingPath>(["enabledModels", "disabledProviders"]);
+const LEGACY_THEME_NAME_REPLACEMENTS = {
+	dark: "red-claw",
+	light: "blue-crab",
+} as const;
+
+function isLegacyThemeName(name: string): name is keyof typeof LEGACY_THEME_NAME_REPLACEMENTS {
+	return name === "dark" || name === "light";
+}
 
 type PathScopedStringArrayEntry = {
 	path?: unknown;
@@ -288,6 +297,11 @@ export class Settings {
 		return getDefault(path);
 	}
 
+	/** Check whether a setting is present in loaded settings/overrides rather than coming from schema defaults. */
+	has(path: SettingPath): boolean {
+		return getByPath(this.#merged, path.split(".")) !== undefined;
+	}
+
 	/**
 	 * Set a setting value (sync).
 	 * Updates global settings and queues a background save.
@@ -587,6 +601,25 @@ export class Settings {
 		}
 	}
 
+	#hasCustomThemeFile(name: string): boolean {
+		try {
+			return fs.existsSync(path.join(getCustomThemesDir(this.#agentDir), `${name}.json`));
+		} catch {
+			return false;
+		}
+	}
+
+	#migrateLegacyBuiltInThemeName(name: string): string {
+		if (isLegacyThemeName(name) && !this.#hasCustomThemeFile(name)) {
+			return LEGACY_THEME_NAME_REPLACEMENTS[name];
+		}
+		return name;
+	}
+
+	#getThemeSlotForName(name: string): "dark" | "light" {
+		return isLightTheme(name, this.#agentDir) ? "light" : "dark";
+	}
+
 	/** Apply schema migrations to raw settings */
 	#migrateRawSettings(raw: RawSettings): RawSettings {
 		// queueMode -> steeringMode
@@ -606,13 +639,22 @@ export class Settings {
 		// Migrate old flat "theme" string to nested theme.dark/theme.light
 		if (typeof raw.theme === "string") {
 			const oldTheme = raw.theme;
-			if (oldTheme === "light" || oldTheme === "dark") {
-				// Built-in defaults — just remove, let new defaults apply
-				delete raw.theme;
+			const migratedTheme = this.#migrateLegacyBuiltInThemeName(oldTheme);
+			if (oldTheme === "dark" && migratedTheme === "red-claw") {
+				raw.theme = { dark: migratedTheme };
+			} else if (oldTheme === "light" && migratedTheme === "blue-crab") {
+				raw.theme = { light: migratedTheme };
 			} else {
-				// Custom theme — detect luminance to place in correct slot
-				const slot = isLightTheme(oldTheme) ? "light" : "dark";
-				raw.theme = { [slot]: oldTheme };
+				const slot = this.#getThemeSlotForName(migratedTheme);
+				raw.theme = { [slot]: migratedTheme };
+			}
+		} else if (raw.theme && typeof raw.theme === "object" && !Array.isArray(raw.theme)) {
+			const themeObj = raw.theme as Record<string, unknown>;
+			if (typeof themeObj.dark === "string") {
+				themeObj.dark = this.#migrateLegacyBuiltInThemeName(themeObj.dark);
+			}
+			if (typeof themeObj.light === "string") {
+				themeObj.light = this.#migrateLegacyBuiltInThemeName(themeObj.light);
 			}
 		}
 

package/src/deep-interview/render-middleware.ts

@@ -0,0 +1,366 @@
+import { type Component, Container, Markdown, Spacer, Text } from "@gajae-code/tui";
+import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
+
+interface RoundQuestionModel {
+	kind: "round-question";
+	round: string;
+	component?: string;
+	targeting?: string;
+	mode?: string;
+	whyNow?: string;
+	ambiguity?: string;
+	question: string;
+}
+
+interface TopologyQuestionModel {
+	kind: "topology-question";
+	context?: string;
+	components: Array<{ name: string; description: string }>;
+	question: string;
+}
+
+interface ProgressDimension {
+	name: string;
+	score: string;
+	weight: string;
+	weighted: string;
+	gap: string;
+}
+
+interface ProgressModel {
+	kind: "progress";
+	round: string;
+	dimensions: ProgressDimension[];
+	ambiguity?: string;
+	topology?: string;
+	ontology?: string;
+	nextTarget?: string;
+	status?: string;
+	extra?: string;
+}
+
+interface ThresholdModel {
+	kind: "threshold";
+	threshold: string;
+	source: string;
+	rest: string;
+}
+
+type DeepInterviewModel = RoundQuestionModel | TopologyQuestionModel | ProgressModel | ThresholdModel;
+
+function normalizeText(text: string): string {
+	return text.trim().replaceAll("\r\n", "\n");
+}
+
+function stripMarkdownEmphasis(value: string): string {
+	return value.replace(/\*\*/g, "").replace(/^"|"$/g, "").trim();
+}
+
+function parseRoundQuestion(text: string): RoundQuestionModel | null {
+	const normalized = normalizeText(text);
+	const lines = normalized.split("\n");
+	const headerIndex = lines.findIndex(line => /^Round\s+\d+\s+\|/i.test(line.trim()));
+	if (headerIndex < 0) return null;
+	const headerLine = lines[headerIndex]?.trim() ?? "";
+	const body = lines
+		.slice(headerIndex + 1)
+		.join("\n")
+		.trim();
+	if (!body) return null;
+
+	const componentMatch =
+		/^Round\s+(\d+)\s+\|\s+Component:\s*(.*?)\s+\|\s+Targeting:\s*(.*?)\s+\|\s+Why now:\s*(.*?)\s+\|\s+Ambiguity:\s*(.+?)%?\s*$/i.exec(
+			headerLine,
+		);
+	if (componentMatch) {
+		return {
+			kind: "round-question",
+			round: componentMatch[1] ?? "?",
+			component: componentMatch[2]?.trim(),
+			targeting: componentMatch[3]?.trim(),
+			whyNow: componentMatch[4]?.trim(),
+			ambiguity: componentMatch[5]?.trim(),
+			question: body,
+		};
+	}
+
+	const targetingMatch =
+		/^Round\s+(\d+)\s+\|\s+Targeting:\s*(.*?)\s+\|\s+Why now:\s*(.*?)\s+\|\s+Ambiguity:\s*(.+?)%?\s*$/i.exec(
+			headerLine,
+		);
+	if (targetingMatch) {
+		return {
+			kind: "round-question",
+			round: targetingMatch[1] ?? "?",
+			targeting: targetingMatch[2]?.trim(),
+			whyNow: targetingMatch[3]?.trim(),
+			ambiguity: targetingMatch[4]?.trim(),
+			question: body,
+		};
+	}
+
+	const modeMatch = /^Round\s+(\d+)\s+\|\s+(.*?)\s+\|\s+Ambiguity:\s*(.+?)%?\s*$/i.exec(headerLine);
+	if (modeMatch) {
+		return {
+			kind: "round-question",
+			round: modeMatch[1] ?? "?",
+			mode: modeMatch[2]?.trim(),
+			ambiguity: modeMatch[3]?.trim(),
+			question: body,
+		};
+	}
+
+	return null;
+}
+
+function parseTopologyQuestion(text: string): TopologyQuestionModel | null {
+	const normalized = normalizeText(text);
+	const lines = normalized.split("\n");
+	const headerIndex = lines.findIndex(line =>
+		/^Round\s+0\s+\|\s+Topology confirmation\s+\|\s+Ambiguity:\s+not scored yet/i.test(line.trim()),
+	);
+	if (headerIndex < 0) {
+		return null;
+	}
+	const components: TopologyQuestionModel["components"] = [];
+	const contextLines: string[] = [];
+	const questionLines: string[] = [];
+	let inQuestion = false;
+	for (const line of lines.slice(headerIndex + 1)) {
+		const trimmed = line.trim();
+		const component = /^\s*\d+\.\s+([^:]+):\s+(.+)$/.exec(line);
+		if (component) {
+			components.push({ name: component[1]?.trim() ?? "", description: component[2]?.trim() ?? "" });
+			continue;
+		}
+		if (/\?$/.test(trimmed)) inQuestion = true;
+		if (!trimmed) continue;
+		if (inQuestion) questionLines.push(trimmed);
+		else contextLines.push(trimmed);
+	}
+	return {
+		kind: "topology-question",
+		context: contextLines.join("\n") || undefined,
+		components,
+		question: questionLines.join("\n"),
+	};
+}
+
+function splitMarkdownTableRow(line: string): string[] {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith("|") || !trimmed.endsWith("|")) return [];
+	return trimmed
+		.slice(1, -1)
+		.split("|")
+		.map(cell => stripMarkdownEmphasis(cell));
+}
+
+function parseProgress(text: string): ProgressModel | null {
+	const normalized = normalizeText(text);
+	const roundMatch = /^Round\s+(\d+)\s+complete\./i.exec(normalized);
+	if (!roundMatch) return null;
+
+	const lines = normalized.split("\n");
+	const dimensions: ProgressDimension[] = [];
+	const extraLines: string[] = [];
+	let ambiguity: string | undefined;
+	let topology: string | undefined;
+	let ontology: string | undefined;
+	let nextTarget: string | undefined;
+	let status: string | undefined;
+
+	for (const [index, line] of lines.entries()) {
+		if (index === 0) continue;
+		const trimmed = line.trim();
+		const cells = splitMarkdownTableRow(line);
+		if (cells.length >= 5) {
+			const [name = "", score = "", weight = "", weighted = "", gap = ""] = cells;
+			if (/^-+$/.test(name) || /^Dimension$/i.test(name)) continue;
+			if (/^Ambiguity$/i.test(name)) {
+				ambiguity = weighted || score || gap;
+				continue;
+			}
+			dimensions.push({ name, score, weight, weighted, gap });
+			continue;
+		}
+		const topologyMatch = /^\*\*Topology:\*\*\s*(.+)$/.exec(trimmed);
+		if (topologyMatch) {
+			topology = topologyMatch[1]?.trim();
+			continue;
+		}
+		const ontologyMatch = /^\*\*Ontology:\*\*\s*(.+)$/.exec(trimmed);
+		if (ontologyMatch) {
+			ontology = ontologyMatch[1]?.trim();
+			continue;
+		}
+		const nextTargetMatch = /^\*\*Next target:\*\*\s*(.+)$/.exec(trimmed);
+		if (nextTargetMatch) {
+			nextTarget = nextTargetMatch[1]?.trim();
+			continue;
+		}
+		if (/^(Clarity threshold met!|Focusing next question on:)/i.test(trimmed)) {
+			status = trimmed;
+			continue;
+		}
+		if (trimmed) extraLines.push(trimmed);
+	}
+
+	if (dimensions.length === 0 && !ambiguity && !topology && !ontology && !nextTarget) return null;
+	return {
+		kind: "progress",
+		round: roundMatch[1] ?? "?",
+		dimensions,
+		ambiguity,
+		topology,
+		ontology,
+		nextTarget,
+		status,
+		extra: extraLines.join("\n") || undefined,
+	};
+}
+
+function parseThreshold(text: string): ThresholdModel | null {
+	const normalized = normalizeText(text);
+	const match = /^Deep Interview threshold:\s*(.*?)\s*\(source:\s*(.*?)\)\s*$/im.exec(normalized.split("\n")[0] ?? "");
+	if (!match) return null;
+	return {
+		kind: "threshold",
+		threshold: match[1]?.trim() ?? "",
+		source: match[2]?.trim() ?? "",
+		rest: normalized.split("\n").slice(1).join("\n").trim(),
+	};
+}
+
+function parseDeepInterview(text: string): DeepInterviewModel | null {
+	return parseProgress(text) ?? parseTopologyQuestion(text) ?? parseRoundQuestion(text) ?? parseThreshold(text);
+}
+
+function addLabel(container: Container, label: string, value: string | undefined, uiTheme: Theme): void {
+	if (!value) return;
+	container.addChild(new Spacer(1));
+	container.addChild(new Text(uiTheme.fg("accent", uiTheme.bold(label)), 0, 0));
+	container.addChild(
+		new Markdown(value, 2, 0, getMarkdownTheme(), { color: (text: string) => uiTheme.fg("toolOutput", text) }),
+	);
+}
+
+function renderPipeSummary(title: string, value: string | undefined): string | undefined {
+	if (!value) return undefined;
+	return (
+		value
+			.split("|")
+			.map(part => part.trim())
+			.filter(Boolean)
+			.map(part => `- ${part}`)
+			.join("\n") || title
+	);
+}
+
+function renderModel(model: DeepInterviewModel, uiTheme: Theme): Component {
+	const container = new Container();
+	if (model.kind === "round-question") {
+		const meta = [
+			`Round ${model.round}`,
+			model.ambiguity ? `Ambiguity ${model.ambiguity.replace(/%$/, "")}%` : undefined,
+		]
+			.filter(Boolean)
+			.join(" · ");
+		container.addChild(new Text(uiTheme.fg("toolTitle", uiTheme.bold(`Deep Interview · ${meta}`)), 0, 0));
+		addLabel(container, "Component", model.component, uiTheme);
+		addLabel(container, "Mode", model.mode, uiTheme);
+		addLabel(container, "Target", model.targeting, uiTheme);
+		addLabel(container, "Why now", model.whyNow, uiTheme);
+		addLabel(container, "Question", model.question, uiTheme);
+		return container;
+	}
+
+	if (model.kind === "topology-question") {
+		container.addChild(
+			new Text(uiTheme.fg("toolTitle", uiTheme.bold("Deep Interview · Round 0 · Topology confirmation")), 0, 0),
+		);
+		addLabel(container, "Ambiguity", "Not scored yet", uiTheme);
+		addLabel(container, "Reading", model.context, uiTheme);
+		if (model.components.length > 0) {
+			const components = model.components
+				.map((component, index) => `${index + 1}. **${component.name}**\n   ${component.description}`)
+				.join("\n\n");
+			addLabel(container, "Components", components, uiTheme);
+		}
+		addLabel(container, "Question", model.question, uiTheme);
+		return container;
+	}
+
+	if (model.kind === "progress") {
+		container.addChild(
+			new Text(uiTheme.fg("toolTitle", uiTheme.bold(`Deep Interview · Round ${model.round} complete`)), 0, 0),
+		);
+		addLabel(container, "Ambiguity", model.ambiguity, uiTheme);
+		if (model.dimensions.length > 0) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(uiTheme.fg("accent", uiTheme.bold("Clarity")), 0, 0));
+			for (const dimension of model.dimensions) {
+				const body = [`Score ${dimension.score} · weight ${dimension.weight} · weighted ${dimension.weighted}`];
+				if (dimension.gap) body.push(/^clear$/i.test(dimension.gap) ? "Clear" : `Gap: ${dimension.gap}`);
+				addLabel(container, dimension.name, body.join("\n"), uiTheme);
+			}
+		}
+		addLabel(container, "Topology", renderPipeSummary("Topology", model.topology), uiTheme);
+		addLabel(container, "Ontology", renderPipeSummary("Ontology", model.ontology), uiTheme);
+		addLabel(container, "Next target", model.nextTarget, uiTheme);
+		addLabel(container, "Status", model.status, uiTheme);
+		addLabel(container, "Additional details", model.extra, uiTheme);
+		return container;
+	}
+
+	container.addChild(new Text(uiTheme.fg("toolTitle", uiTheme.bold("Deep Interview · Started")), 0, 0));
+	addLabel(container, "Threshold", `${model.threshold} · source: ${model.source}`, uiTheme);
+	addLabel(container, "Details", model.rest, uiTheme);
+	return container;
+}
+
+export function renderDeepInterviewAssistantText(text: string, uiTheme: Theme): Component | null {
+	const model = parseDeepInterview(text);
+	if (!model || model.kind === "round-question" || model.kind === "topology-question") return null;
+	return renderModel(model, uiTheme);
+}
+
+export function renderDeepInterviewAskQuestion(question: string, uiTheme: Theme): Component | null {
+	const model = parseTopologyQuestion(question) ?? parseRoundQuestion(question);
+	if (!model) return null;
+	return renderModel(model, uiTheme);
+}
+
+export function formatDeepInterviewSelectorPrompt(question: string): string | null {
+	const model = parseTopologyQuestion(question) ?? parseRoundQuestion(question);
+	if (!model) return null;
+	if (model.kind === "topology-question") {
+		const componentLines =
+			model.components.length > 0
+				? [
+						"Components:",
+						...model.components.map(
+							(component, index) => `${index + 1}. ${component.name} — ${component.description}`,
+						),
+					]
+				: [];
+		return [
+			"Deep Interview · Round 0 · Topology confirmation",
+			"Ambiguity: not scored yet",
+			model.context ? `Reading:\n${model.context}` : undefined,
+			...componentLines,
+			model.question ? `Question:\n${model.question}` : undefined,
+		]
+			.filter((line): line is string => Boolean(line))
+			.join("\n\n");
+	}
+	return [
+		`Deep Interview · Round ${model.round}${model.ambiguity ? ` · Ambiguity ${model.ambiguity.replace(/%$/, "")}%` : ""}`,
+		model.component ? `Component: ${model.component}` : undefined,
+		model.mode ? `Mode: ${model.mode}` : undefined,
+		model.targeting ? `Target: ${model.targeting}` : undefined,
+		model.whyNow ? `Why now: ${model.whyNow}` : undefined,
+		model.question,
+	]
+		.filter((line): line is string => Boolean(line))
+		.join("\n");
+}