@gajae-code/coding-agent 0.9.5 → 0.10.0

package/src/daemon/control-types.ts

@@ -47,6 +47,15 @@ export interface DaemonOperationOptions {
 	spawnIfStopped?: boolean;
 }
 
+export interface DaemonRecovery {
+	/** Machine-readable recovery category for automation branching. */
+	reason: "ownership_mismatch";
+	/** One-line human summary of why the operation could not proceed. */
+	summary: string;
+	/** Ordered, copy-pasteable remediation steps. */
+	steps: string[];
+}
+
 export interface DaemonOperationResult {
 	kind: DaemonKind;
 	action: Exclude<DaemonAction, "list">;
@@ -55,6 +64,8 @@ export interface DaemonOperationResult {
 	after?: DaemonStatus;
 	warnings: string[];
 	message: string;
+	/** Present when the operation was refused with an actionable recovery path (e.g. ownership mismatch). */
+	recovery?: DaemonRecovery;
 }
 
 export interface BuiltInDaemonController {

package/src/daemon/operator-contract.ts

@@ -0,0 +1,121 @@
+/**
+ * Shared operator contract for the `gjc daemon` command surface.
+ *
+ * One source of truth for the beginner-safe operational vocabulary so the
+ * guided human surface and the machine-readable JSON never drift:
+ * - the terse action verbs plus operator aliases (e.g. `restart` -> `reload`),
+ * - process exit codes,
+ * - concise vs. `--verbose` human rendering of statuses and results, and
+ * - actionable recovery guidance for a token/chat ownership mismatch.
+ *
+ * The full roots/debug payload lives behind `--verbose` (human) or `--json`
+ * (automation); the default human output stays a concise per-daemon result.
+ */
+
+import type { DaemonAction, DaemonOperationResult, DaemonRecovery, DaemonStatus } from "./control-types";
+
+/** Canonical daemon actions accepted as the leading verb. */
+export const DAEMON_CANONICAL_ACTIONS: readonly DaemonAction[] = ["list", "status", "stop", "reload"];
+
+/**
+ * Operator-friendly aliases resolved to a canonical action. `restart` is the
+ * routine "reload if running, otherwise start" verb; it maps onto `reload`,
+ * whose default already spawns a fresh owner when none is running.
+ */
+export const DAEMON_ACTION_ALIASES: Readonly<Record<string, DaemonAction>> = {
+	restart: "reload",
+};
+
+/** Every token accepted in the leading action position (canonical + aliases). */
+export const DAEMON_ACTION_TOKENS: readonly string[] = [
+	...DAEMON_CANONICAL_ACTIONS,
+	...Object.keys(DAEMON_ACTION_ALIASES),
+];
+
+/** Resolve a leading verb (canonical or alias) to its canonical action. */
+export function resolveDaemonAction(token: string | undefined): DaemonAction | undefined {
+	if (token === undefined) return undefined;
+	if ((DAEMON_CANONICAL_ACTIONS as readonly string[]).includes(token)) return token as DaemonAction;
+	return DAEMON_ACTION_ALIASES[token];
+}
+
+/** Exit codes for `gjc daemon`. Backward compatible: success 0, any failure 1. */
+export const DAEMON_EXIT = { ok: 0, failure: 1 } as const;
+
+/** Human-facing headline when a spawn/reload is refused by a live foreign identity. */
+export const OWNERSHIP_MISMATCH_MESSAGE =
+	"refused: a live Telegram daemon with a different bot token or chat already owns this workspace";
+
+/** Structured, actionable recovery for a token/chat ownership mismatch. */
+export function ownershipMismatchRecovery(): DaemonRecovery {
+	return {
+		reason: "ownership_mismatch",
+		summary: "A live Telegram daemon owned by a different bot token or chat already holds this workspace.",
+		steps: [
+			"Confirm the intended bot token and chat with `gjc notify` (or edit notifications.telegram in your config).",
+			"If the running daemon is stale or unwanted, stop it with `gjc daemon stop --force`, then rerun `gjc daemon restart`.",
+			"If it is the correct daemon, no action is needed — this workspace attaches automatically once the identities match.",
+		],
+	};
+}
+
+function timestamp(ms: number | undefined): string | undefined {
+	if (ms === undefined) return undefined;
+	const date = new Date(ms);
+	return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+
+/**
+ * Render one daemon status. Concise by default (single head line + any
+ * actionable warning); `--verbose` adds runtime detail and the full roots list.
+ */
+export function formatDaemonStatus(status: DaemonStatus, opts: { verbose?: boolean } = {}): string {
+	const lines: string[] = [];
+	if (!status.configured) {
+		lines.push(`${status.kind}: not configured`);
+		if (status.runtime.warning) lines.push(`  warning: ${status.runtime.warning}`);
+		return lines.join("\n");
+	}
+
+	const meta: string[] = [];
+	if (status.pid !== undefined) meta.push(`pid ${status.pid}`);
+	if (status.ownerId) meta.push(`owner ${status.ownerId}`);
+	const rootCount = status.rootCount ?? status.roots?.length ?? 0;
+	if (rootCount > 0) meta.push(`${rootCount} root${rootCount === 1 ? "" : "s"}`);
+
+	let head = `${status.kind}: ${status.health}`;
+	if (meta.length > 0) head += ` (${meta.join(", ")})`;
+	if (status.detail) head += ` — ${status.detail}`;
+	lines.push(head);
+	if (status.runtime.warning) lines.push(`  warning: ${status.runtime.warning}`);
+
+	if (opts.verbose) {
+		lines.push(`  runtime: ${status.runtime.mode} (${status.runtime.execPath})`);
+		const started = timestamp(status.startedAt);
+		if (started) lines.push(`  started: ${started}`);
+		const heartbeat = timestamp(status.heartbeatAt);
+		if (heartbeat) lines.push(`  heartbeat: ${heartbeat}`);
+		const roots = status.roots ?? [];
+		lines.push(`  roots: ${rootCount}`);
+		for (const root of roots) lines.push(`    - ${root}`);
+	}
+
+	return lines.join("\n");
+}
+
+/**
+ * Render one operation result. Keeps the stable `<kind> <action>: ok|failed —
+ * <message>` head line, then any warnings, then actionable recovery steps.
+ */
+export function formatDaemonResult(result: DaemonOperationResult): string {
+	const lines = [`${result.kind} ${result.action}: ${result.ok ? "ok" : "failed"} — ${result.message}`];
+	for (const warning of result.warnings) lines.push(`  warning: ${warning}`);
+	if (result.recovery) {
+		lines.push(`  ${result.recovery.summary}`);
+		lines.push("  to recover:");
+		result.recovery.steps.forEach((step, i) => {
+			lines.push(`    ${i + 1}. ${step}`);
+		});
+	}
+	return lines.join("\n");
+}

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

@@ -1,4 +1,15 @@
-import { type Component, Container, Markdown, Spacer, Text } from "@gajae-code/tui";
+import {
+	type Component,
+	Container,
+	isViewportAnchorSourceRenderer,
+	Markdown,
+	Spacer,
+	Text,
+	type ViewportAnchorProvider,
+	type ViewportAnchorRender,
+	type ViewportAnchorSource,
+	type ViewportAnchorSourceRenderer,
+} from "@gajae-code/tui";
 import { getMarkdownTheme, type Theme } from "../modes/theme/theme";
 
 interface RoundQuestionModel {
@@ -48,6 +59,60 @@ interface ThresholdModel {
 
 type DeepInterviewModel = RoundQuestionModel | TopologyQuestionModel | ProgressModel | ThresholdModel;
 
+class DeepInterviewSemanticContainer extends Container implements ViewportAnchorProvider, ViewportAnchorSourceRenderer {
+	#nextSource = 0;
+
+	override addChild(component: Component): void {
+		super.addChild(component);
+		if (isViewportAnchorSourceRenderer(component)) {
+			this.setViewportAnchorSource(component, { id: `deep-interview-part:${this.#nextSource++}` });
+		}
+	}
+
+	override renderWithViewportAnchors(width: number): ViewportAnchorRender {
+		const lines = super.renderWithViewportAnchors(width).lines;
+		return { lines, anchors: lines.map(() => null) };
+	}
+
+	renderWithViewportAnchorSource(width: number, source: ViewportAnchorSource): ViewportAnchorRender {
+		const rendered = super.renderWithViewportAnchors(width);
+		const extents = new Map<string, { graphemeEnd: number; cellEnd: number }>();
+		for (const anchor of rendered.anchors) {
+			if (anchor === null) continue;
+			const extent = extents.get(anchor.id);
+			if (extent) {
+				extent.graphemeEnd = Math.max(extent.graphemeEnd, anchor.graphemeEnd);
+				extent.cellEnd = Math.max(extent.cellEnd, anchor.cellEnd);
+			} else {
+				extents.set(anchor.id, { graphemeEnd: anchor.graphemeEnd, cellEnd: anchor.cellEnd });
+			}
+		}
+		const offsets = new Map<string, { grapheme: number; cell: number }>();
+		let grapheme = 0;
+		let cell = 0;
+		for (const [id, extent] of extents) {
+			offsets.set(id, { grapheme, cell });
+			grapheme += extent.graphemeEnd;
+			cell += extent.cellEnd;
+		}
+		return {
+			lines: rendered.lines,
+			anchors: rendered.anchors.map(anchor => {
+				if (anchor === null) return null;
+				const offset = offsets.get(anchor.id);
+				if (!offset) throw new Error(`Missing deep-interview anchor offset for ${anchor.id}`);
+				return {
+					id: source.id,
+					graphemeStart: offset.grapheme + anchor.graphemeStart,
+					graphemeEnd: offset.grapheme + anchor.graphemeEnd,
+					cellStart: offset.cell + anchor.cellStart,
+					cellEnd: offset.cell + anchor.cellEnd,
+				};
+			}),
+		};
+	}
+}
+
 function normalizeText(text: string): string {
 	if (typeof text !== "string") return "";
 	return text.trim().replaceAll("\r\n", "\n");
@@ -258,7 +323,7 @@ function renderPipeSummary(title: string, value: string | undefined): string | u
 }
 
 function renderModel(model: DeepInterviewModel, uiTheme: Theme): Component {
-	const container = new Container();
+	const container = new DeepInterviewSemanticContainer();
 	if (model.kind === "round-question") {
 		const meta = [
 			`Round ${model.round}`,

package/src/defaults/gjc/extensions/grok-cli-vendor/src/models/catalog.ts

@@ -1,12 +1,14 @@
 /**
  * Model definitions for Grok CLI's API.
  */
+import { Effort } from '@gajae-code/ai/model-thinking';
 
 // ─── Cost constants ($/M tokens) ──────────────────────────────────────────────
 
 const COST_BUILD = { input: 1, output: 2, cacheRead: 0.2, cacheWrite: 0.2 };
 const COST_COMPOSER_FAST = { input: 3, output: 15, cacheRead: 0.5, cacheWrite: 0 };
 const COST_43 = { input: 1.25, output: 2.5, cacheRead: 0.2, cacheWrite: 0 };
+const COST_45 = { input: 2, output: 6, cacheRead: 0.5, cacheWrite: 0 };
 const COST_420 = { input: 2, output: 6, cacheRead: 0.2, cacheWrite: 0 };
 
 // ─── Model type ───────────────────────────────────────────────────────────────
@@ -24,6 +26,8 @@ export interface GrokCliModelConfig {
   };
   contextWindow: number;
   maxTokens: number;
+  /** Highest reasoning effort supported by this model. */
+  maxReasoningEffort?: Effort;
   /** Models that don't support reasoning.effort get a thinkingLevelMap. */
   thinkingLevelMap?: Record<string, string | null>;
 }
@@ -69,6 +73,18 @@ const FALLBACK_MODELS: GrokCliModelConfig[] = [
     contextWindow: 1_000_000,
     maxTokens: 30_000,
   },
+  {
+    // Official metadata and pricing: https://docs.x.ai/developers/models/grok-4.5
+    id: 'grok-4.5',
+    name: 'Grok 4.5',
+    reasoning: true,
+    input: ['text', 'image'],
+    cost: COST_45,
+    contextWindow: 500_000,
+    maxTokens: 30_000,
+    // https://docs.x.ai/developers/model-capabilities/text/reasoning caps Grok 4.5 at high.
+    maxReasoningEffort: Effort.High,
+  },
   {
     id: 'grok-4.20-0309-reasoning',
     name: 'Grok 4.20 Reasoning',
@@ -106,15 +122,37 @@ const FALLBACK_MODELS: GrokCliModelConfig[] = [
   },
 ];
 
-const EFFORT_CAPABLE_PREFIXES = ['grok-3-mini', 'grok-4.20-multi-agent', 'grok-4.3'];
+// Official aliases: https://docs.x.ai/developers/models/grok-4.5
+const MODEL_ALIASES: Readonly<Record<string, string>> = {
+  'grok-4.5-latest': 'grok-4.5',
+  'grok-build-latest': 'grok-4.5',
+};
 
-export function supportsReasoningEffort(modelId: string): boolean {
+function getModelName(modelId: string): string {
   const parts = modelId.split('/');
-  const name = (parts.at(-1) ?? modelId).toLowerCase();
+  return (parts.at(-1) ?? modelId).toLowerCase();
+}
+
+function getCanonicalModelName(modelId: string): string {
+  const name = getModelName(modelId);
+  return MODEL_ALIASES[name] ?? name;
+}
+
+export function getMaxReasoningEffort(modelId: string): Effort | undefined {
+  const name = getCanonicalModelName(modelId);
+  return FALLBACK_MODELS.find(
+    (model) => name === model.id.toLowerCase() || name.startsWith(`${model.id.toLowerCase()}-`),
+  )?.maxReasoningEffort;
+}
+
+const EFFORT_CAPABLE_PREFIXES = ['grok-3-mini', 'grok-4.20-multi-agent', 'grok-4.3', 'grok-4.5'];
+
+export function supportsReasoningEffort(modelId: string): boolean {
+  const name = getCanonicalModelName(modelId);
   if (!EFFORT_CAPABLE_PREFIXES.some((prefix) => name.startsWith(prefix))) {
     return false;
   }
-  const model = resolveModels().find((entry) => entry.id.toLowerCase() === name);
+  const model = resolveModels().find((entry) => getCanonicalModelName(entry.id) === name);
   if (model) {
     if (!model.reasoning) return false;
     if (!model.thinkingLevelMap) return true;
@@ -139,17 +177,19 @@ export function resolveModels(): GrokCliModelConfig[] {
     .filter(Boolean);
   if (env.length === 0) return FALLBACK_MODELS;
 
-  const byId = new Map(FALLBACK_MODELS.map((m) => [m.id, m]));
-  return env.map(
-    (id) =>
-      byId.get(id) ?? {
-        id,
-        name: id,
-        reasoning: true,
-        input: ['text'] as ('text' | 'image')[],
-        cost: COST_BUILD,
-        contextWindow: 1_000_000,
-        maxTokens: 30_000,
-      },
-  );
+  const byId = new Map(FALLBACK_MODELS.map((model) => [model.id.toLowerCase(), model]));
+  return env.map((id) => {
+    const model = byId.get(getCanonicalModelName(id));
+    if (model) return model.id === id ? model : { ...model, id };
+
+    return {
+      id,
+      name: id,
+      reasoning: true,
+      input: ['text'] as ('text' | 'image')[],
+      cost: COST_BUILD,
+      contextWindow: 1_000_000,
+      maxTokens: 30_000,
+    };
+  });
 }

package/src/defaults/gjc/extensions/grok-cli-vendor/src/payload/sanitize.ts

@@ -22,7 +22,8 @@
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { extname, isAbsolute, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { supportsReasoningEffort } from '../models/catalog.js';
+import { Effort, THINKING_EFFORTS } from '@gajae-code/ai/model-thinking';
+import { getMaxReasoningEffort, supportsReasoningEffort } from '../models/catalog.js';
 
 // ─── Content text extraction ─────────────────────────────────────────────────
 
@@ -266,6 +267,18 @@ function stripUnsupportedTopLevelFields(next: Record<string, unknown>): void {
   delete next.truncation;
 }
 
+function normalizeReasoningEffort(modelId: string, value: unknown): unknown {
+  const effort = value === Effort.Minimal ? Effort.Low : value;
+  if (typeof effort !== 'string') return effort;
+
+  const maxEffort = getMaxReasoningEffort(modelId);
+  if (maxEffort === undefined) return effort;
+
+  const effortIndex = THINKING_EFFORTS.indexOf(effort as Effort);
+  const maxEffortIndex = THINKING_EFFORTS.indexOf(maxEffort);
+  return effortIndex > maxEffortIndex ? maxEffort : effort;
+}
+
 // ─── Main sanitization ────────────────────────────────────────────────────────
 
 /**
@@ -334,7 +347,7 @@ export function sanitizePayload(
   if (supportsReasoningEffort(modelId)) {
     const reasoning = next.reasoning as Record<string, unknown> | undefined;
     if (reasoning) {
-      const effort = reasoning.effort === 'minimal' ? 'low' : reasoning.effort;
+      const effort = normalizeReasoningEffort(modelId, reasoning.effort);
       next.reasoning = reasoning.summary !== undefined ? { effort } : { ...reasoning, effort };
     }
   } else {

package/src/defaults/gjc/extensions/grok-cli-vendor/src/provider/register.ts

@@ -36,7 +36,11 @@ export default function registerGrokCli(api: ExtensionAPI) {
       name: m.name,
       reasoning: m.reasoning,
       thinking: m.reasoning
-        ? { minLevel: Effort.Low, maxLevel: Effort.XHigh, mode: 'effort' }
+        ? {
+            minLevel: Effort.Low,
+            maxLevel: m.maxReasoningEffort ?? Effort.XHigh,
+            mode: 'effort',
+          }
         : undefined,
       input: m.input,
       cost: m.cost,