@gajae-code/coding-agent 0.5.0 → 0.5.1

package/src/async/job-manager.ts

@@ -13,6 +13,14 @@ export interface AsyncJob {
 	type: "bash" | "task";
 	status: "running" | "completed" | "failed" | "cancelled" | "paused";
 	startTime: number;
+
+	/**
+	 * Wall-clock ms when the job left the `running` state (completed, failed,
+	 * cancelled, or paused). Undefined while running. Frozen on the first
+	 * terminal/pause transition so elapsed-time renderers stop counting once a
+	 * job is no longer active instead of growing forever against `Date.now()`.
+	 */
+	endTime?: number;
 	label: string;
 	abortController: AbortController;
 	promise: Promise<void>;
@@ -28,6 +36,16 @@ export interface AsyncJob {
 	ownerId?: string;
 }
 
+/**
+ * Elapsed wall-clock ms for a job, frozen once it stops running. While the job
+ * is active (`endTime` undefined) this counts against `now`; after it stops it
+ * returns the fixed `endTime - startTime` span so status renderers do not keep
+ * incrementing a completed job's timer.
+ */
+export function jobElapsedMs(job: Pick<AsyncJob, "startTime" | "endTime">, now: number = Date.now()): number {
+	return Math.max(0, (job.endTime ?? now) - job.startTime);
+}
+
 export interface AsyncJobMetadata {
 	subagent?: {
 		id: string;
@@ -80,6 +98,12 @@ export interface SubagentRecord {
 	/** False for ephemeral sessions (no persistent artifacts dir). */
 	resumable: boolean;
 	queued?: { ownerId?: string; seq: number; message?: string; createdAt: number };
+	/** Resolved model the subagent was asked to use, e.g. "openai-codex/gpt-5.5". */
+	requestedModel?: string;
+	/** Model actually used after auth fallback (#985); equals requestedModel when no fallback. */
+	effectiveModel?: string;
+	/** True when the requested model lacked credentials and the subagent fell back to the parent model. */
+	modelFellBack?: boolean;
 }
 
 /** Lightweight, manager-owned resume payload. The async layer treats `data` as opaque. */
@@ -368,6 +392,7 @@ export class AsyncJobManager {
 					// delivery and no eviction scheduling: a paused subagent stays
 					// listed and resumable from its sessionFile.
 					job.status = "paused";
+					this.#freezeEndTime(job);
 					if (outcome.note) job.resultText = outcome.note;
 					this.#markRecordPaused(id);
 					this.#drainResumeQueue();
@@ -375,6 +400,7 @@ export class AsyncJobManager {
 				}
 
 				job.status = "completed";
+				this.#freezeEndTime(job);
 				job.resultText = outcome.text;
 				this.#enqueueDelivery(id, outcome.text);
 				this.#runLifecycle(id, "terminal");
@@ -393,6 +419,7 @@ export class AsyncJobManager {
 				this.#runLifecycle(id, "terminal");
 				const errorText = error instanceof Error ? error.message : String(error);
 				job.status = "failed";
+				this.#freezeEndTime(job);
 				job.errorText = errorText;
 				this.#enqueueDelivery(id, errorText);
 				this.#scheduleEviction(id);
@@ -428,10 +455,22 @@ export class AsyncJobManager {
 		if (job.status !== "running") return false;
 		this.#runLifecycle(id, "cancel");
 		job.status = "cancelled";
+		this.#freezeEndTime(job);
 		job.abortController.abort();
 		return true;
 	}
 
+	/**
+	 * Freeze the wall-clock instant a job stopped running. Idempotent: the
+	 * first stop (completed/failed/cancelled/paused) wins so elapsed-time
+	 * renderers report a stable duration instead of counting against
+	 * `Date.now()` forever. A resumed subagent registers a brand-new job with
+	 * its own `startTime`, so a paused job's frozen `endTime` is never reused.
+	 */
+	#freezeEndTime(job: AsyncJob): void {
+		job.endTime ??= Date.now();
+	}
+
 	#runLifecycle(jobId: string, phase: "cancel" | "terminal" | "evict"): void {
 		const fired = this.#lifecyclePhases.get(jobId) ?? new Set<"cancel" | "terminal" | "evict">();
 		if (fired.has(phase)) return;
@@ -503,6 +542,18 @@ export class AsyncJobManager {
 		this.#subagentRecords.set(record.subagentId, record);
 	}
 
+	/** Patch model metadata onto an existing subagent record (best-effort; no-op if unknown). */
+	updateSubagentModel(
+		subagentId: string,
+		model: { requestedModel?: string; effectiveModel?: string; modelFellBack?: boolean },
+	): void {
+		const record = this.#subagentRecords.get(subagentId);
+		if (!record) return;
+		record.requestedModel = model.requestedModel;
+		record.effectiveModel = model.effectiveModel;
+		record.modelFellBack = model.modelFellBack;
+	}
+
 	getSubagentRecord(subagentId: string, filter?: AsyncJobFilter): SubagentRecord | undefined {
 		const rec = this.#subagentRecords.get(subagentId.trim());
 		if (!rec) return undefined;
@@ -978,6 +1029,7 @@ export class AsyncJobManager {
 		for (const job of this.getRunningJobs(filter)) {
 			this.#runLifecycle(job.id, "cancel");
 			job.status = "cancelled";
+			this.#freezeEndTime(job);
 			job.abortController.abort();
 			this.#scheduleEviction(job.id);
 		}

package/src/cli/args.ts

@@ -30,6 +30,7 @@ export interface Args {
 	mode?: Mode;
 	noSession?: boolean;
 	sessionDir?: string;
+	rpcListen?: string;
 	providerSessionId?: string;
 	fork?: string;
 	models?: string[];
@@ -145,6 +146,8 @@ export function parseArgs(args: string[]): Args {
 			result.noSession = true;
 		} else if (arg === "--session-dir" && i + 1 < args.length) {
 			result.sessionDir = args[++i];
+		} else if (arg === "--listen" && i + 1 < args.length) {
+			result.rpcListen = args[++i];
 		} else if (arg === "--models" && i + 1 < args.length) {
 			result.models = args[++i].split(",").map(s => s.trim());
 		} else if (arg === "--no-tools") {

package/src/cli/auth-broker-cli.ts

@@ -70,6 +70,7 @@ const CALLBACK_PORTS: Record<string, number> = {
 	"google-antigravity": 51121,
 	"gitlab-duo": 8080,
 	xai: 56121,
+	"grok-build": 56121,
 };
 
 function getTokenFilePath(): string {

package/src/cli/list-models.ts

@@ -5,7 +5,12 @@ import { type Api, getSupportedEfforts, type Model } from "@gajae-code/ai";
 import { fuzzyFilter } from "@gajae-code/tui";
 import { formatNumber } from "@gajae-code/utils";
 import type { ModelRegistry } from "../config/model-registry";
-import { discoverAndLoadExtensions, loadExtensions } from "../extensibility/extensions";
+import {
+	discoverAndLoadExtensions,
+	type ExtensionFactory,
+	loadExtensionFromFactory,
+	loadExtensions,
+} from "../extensibility/extensions";
 import { EventBus } from "../utils/event-bus";
 
 interface ProviderRow {
@@ -137,6 +142,8 @@ export interface RunListModelsOptions {
 	cwd: string;
 	/** CLI-supplied extension paths (e.g. from `-e <path>`). */
 	additionalExtensionPaths?: string[];
+	/** In-process extension factories to load without filesystem discovery. */
+	extensionFactories?: Array<{ factory: ExtensionFactory; name: string }>;
 	/** Extension paths configured under `extensions:` in user settings. */
 	settingsExtensions?: string[];
 	/** Disabled extension ids from settings (`disabledExtensions`). */
@@ -159,6 +166,7 @@ export async function runListModelsCommand(options: RunListModelsOptions): Promi
 		modelRegistry,
 		cwd,
 		additionalExtensionPaths = [],
+		extensionFactories = [],
 		settingsExtensions = [],
 		disabledExtensionIds = [],
 		disableExtensionDiscovery = false,
@@ -174,6 +182,10 @@ export async function runListModelsCommand(options: RunListModelsOptions): Promi
 				eventBus,
 				disabledExtensionIds,
 			);
+	for (const { factory, name } of extensionFactories) {
+		const extension = await loadExtensionFromFactory(factory, cwd, eventBus, extensionsResult.runtime, name);
+		extensionsResult.extensions.push(extension);
+	}
 
 	for (const { path: extPath, error } of extensionsResult.errors) {
 		process.stderr.write(`Failed to load extension: ${extPath}: ${error}\n`);

package/src/cli.ts

@@ -32,6 +32,7 @@ const commands: CommandEntry[] = [
 	{ name: "coordinator", load: () => import("./commands/coordinator").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: "gc", load: () => import("./commands/gc").then(m => m.default) },
 	{ name: "ralplan", load: () => import("./commands/ralplan").then(m => m.default) },
 	{ name: "config", load: () => import("./commands/config").then(m => m.default) },
 	{ name: "mcp-serve", load: () => import("./commands/mcp-serve").then(m => m.default) },

package/src/commands/gc.ts

@@ -0,0 +1,22 @@
+import { Command, Flags } from "@gajae-code/utils/cli";
+import { runGjcGcCommand } from "../gjc-runtime/gc-runtime";
+
+export default class Gc extends Command {
+	static description = "Garbage-collect stale GJC session/PID records (dry-run by default)";
+	static strict = false;
+	static flags = {
+		json: Flags.boolean({ char: "j", description: "Emit machine-readable JSON", default: false }),
+		prune: Flags.boolean({ description: "Remove stale records (default: report only)", default: false }),
+		force: Flags.boolean({ description: "Alias for --prune (eligible records only)", default: false }),
+		"dry-run": Flags.boolean({ description: "Force report-only mode", default: false }),
+	};
+
+	static examples = ["gjc gc", "gjc gc --json", "gjc gc --prune", "gjc gc --prune --json"];
+
+	async run(): Promise<void> {
+		const result = await runGjcGcCommand(this.argv, process.cwd(), process.env);
+		if (result.stdout) process.stdout.write(result.stdout);
+		if (result.stderr) process.stderr.write(result.stderr);
+		process.exitCode = result.status;
+	}
+}

package/src/commands/harness.ts

@@ -16,7 +16,7 @@ import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { resolveGjcTmuxCommand, sanitizeTmuxToken } from "../gjc-runtime/tmux-common";
 import { classifyRecovery } from "../harness-control-plane/classifier";
 import { callEndpoint, EndpointUnreachableError } from "../harness-control-plane/control-endpoint";
-import { type ResolvedOwner, RuntimeOwner, resolveOwner } from "../harness-control-plane/owner";
+import { type ResolvedOwner, RuntimeOwner, resolveOwner, resolveOwnerLive } from "../harness-control-plane/owner";
 import { preserveDirtyWorktree } from "../harness-control-plane/preserve";
 import { RECEIPT_SPOOL_DIR_ENV } from "../harness-control-plane/receipt-spool";
 import { buildReceipt, requiresVanishBeforeAction, type VanishEvidence } from "../harness-control-plane/receipts";
@@ -948,10 +948,14 @@ export default class Harness extends Command {
 		let observation = input.observation as Partial<Observation> | undefined;
 		let stateView: SessionState | null = null;
 		const sessionId = flagSession ?? (typeof input.sessionId === "string" ? input.sessionId : undefined);
+		// Session-backed classify derives owner liveness from the same lease/socket probe observe
+		// uses for routing, so a live (e.g. manual) owner is never misread as vanished/restart-clean.
+		let ownerLive = false;
 		if (sessionId) {
 			stateView = await loadState(root, sessionId);
+			ownerLive = await resolveOwnerLive(root, sessionId);
 			if (!observation) {
-				const built = await buildObservation(root, stateView, ownerLiveFor(stateView));
+				const built = await buildObservation(root, stateView, ownerLive);
 				observation = built.observation;
 				stateView = await markVanishedOwnerBlocked(
 					root,
@@ -975,7 +979,7 @@ export default class Harness extends Command {
 		const decision = classifyRecovery({ observation: full, retryBudget: budget });
 		if (stateView) {
 			writeJson(
-				buildResponse(stateView, ownerLiveFor(stateView), {
+				buildResponse(stateView, ownerLive, {
 					decision,
 					observation: { ...full, lifecycle: stateView.lifecycle },
 				}),

package/src/config/file-lock-gc.ts

@@ -0,0 +1,181 @@
+/**
+ * GC adapter for config file-locks (`<file>.lock` dirs holding `{pid, timestamp}`).
+ */
+
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getAgentDir, getConfigRootDir, isEnoent } from "@gajae-code/utils";
+import type {
+	GcCollectResult,
+	GcContext,
+	GcError,
+	GcPruneOutcome,
+	GcRecord,
+	GcStoreAdapter,
+} from "../gjc-runtime/gc-runtime";
+import { gcPidStatusLabel } from "../gjc-runtime/gc-runtime";
+import { resolveReceiptSpoolDir } from "../harness-control-plane/receipt-spool";
+import { readFileLockInfoForGc, removeFileLockDirForGc } from "./file-lock";
+
+const MAX_WALK_DEPTH = 6;
+const MAX_WALK_ENTRIES = 20_000;
+
+// High-cardinality, lock-free subtrees we never descend into. `.lock` dirs are
+// created next to config files, never inside these.
+const PRUNED_DIR_NAMES = new Set(["sessions", "node_modules", ".git", "blobs", "artifacts", "receipts", "events"]);
+
+interface WalkState {
+	entries: number;
+	truncated: boolean;
+}
+
+// Global, env-aware GJC lock roots. Per the approved scope this covers the
+// user config root, the agent dir (honors GJC_CODING_AGENT_DIR), and the
+// configured receipt-spool dir — NOT the invocation cwd's project `.gjc`.
+function knownFileLockRoots(ctx: GcContext): string[] {
+	const roots = [getConfigRootDir(), getAgentDir()];
+	const spoolDir = resolveReceiptSpoolDir(ctx.env);
+	if (spoolDir) roots.push(spoolDir);
+	return Array.from(new Set(roots.map(root => path.resolve(root))));
+}
+
+function errorMessage(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+function keptMalformedRecord(lockDir: string): GcRecord {
+	return {
+		store: "file_locks",
+		id: lockDir,
+		path: lockDir,
+		pid_status: "none",
+		status: "malformed",
+		stale: false,
+		removable: false,
+		action: "none",
+		reason: "missing_or_malformed_file_lock_info",
+	};
+}
+
+async function collectLockRecord(lockDir: string, ctx: GcContext): Promise<GcRecord> {
+	const info = await readFileLockInfoForGc(lockDir);
+	if (!info) return keptMalformedRecord(lockDir);
+
+	const probeResult = ctx.probe(info.pid);
+	const pidStatus = gcPidStatusLabel(probeResult);
+	const removable = probeResult.status === "dead";
+
+	return {
+		store: "file_locks",
+		id: lockDir,
+		path: lockDir,
+		pid: info.pid,
+		pid_status: pidStatus,
+		status: pidStatus,
+		stale: removable,
+		removable,
+		action: "none",
+		reason: removable ? "file_lock_owner_pid_dead" : `file_lock_owner_pid_${pidStatus}`,
+		detail: `timestamp=${info.timestamp}`,
+	};
+}
+
+async function walkForLockDirs(
+	dir: string,
+	depth: number,
+	state: WalkState,
+	lockDirs: Set<string>,
+	errors: GcError[],
+): Promise<void> {
+	if (state.entries >= MAX_WALK_ENTRIES) {
+		state.truncated = true;
+		return;
+	}
+
+	let stat: Awaited<ReturnType<typeof fs.lstat>>;
+	try {
+		stat = await fs.lstat(dir);
+	} catch (error) {
+		if (isEnoent(error)) return;
+		errors.push({ store: "file_locks", scope: dir, message: errorMessage(error) });
+		return;
+	}
+
+	state.entries++;
+	if (!stat.isDirectory() || stat.isSymbolicLink()) return;
+
+	if (path.basename(dir).endsWith(".lock")) {
+		lockDirs.add(dir);
+		return;
+	}
+
+	if (depth >= MAX_WALK_DEPTH) return;
+
+	let entries: string[];
+	try {
+		entries = await fs.readdir(dir);
+	} catch (error) {
+		if (isEnoent(error)) return;
+		errors.push({ store: "file_locks", scope: dir, message: errorMessage(error) });
+		return;
+	}
+
+	for (const entry of entries) {
+		if (state.entries >= MAX_WALK_ENTRIES) {
+			state.truncated = true;
+			return;
+		}
+		if (PRUNED_DIR_NAMES.has(entry)) continue;
+		await walkForLockDirs(path.join(dir, entry), depth + 1, state, lockDirs, errors);
+	}
+}
+
+export const fileLocksGcAdapter: GcStoreAdapter = {
+	store: "file_locks",
+	async collect(ctx: GcContext): Promise<GcCollectResult> {
+		const records: GcRecord[] = [];
+		const errors: GcError[] = [];
+		const lockDirs = new Set<string>();
+		const state: WalkState = { entries: 0, truncated: false };
+
+		for (const root of knownFileLockRoots(ctx)) {
+			await walkForLockDirs(root, 0, state, lockDirs, errors);
+			if (state.truncated) break;
+		}
+
+		if (state.truncated) {
+			errors.push({
+				store: "file_locks",
+				scope: "discovery",
+				message: `file lock discovery capped at ${MAX_WALK_ENTRIES} entries`,
+			});
+		}
+
+		for (const lockDir of lockDirs) {
+			try {
+				records.push(await collectLockRecord(lockDir, ctx));
+			} catch (error) {
+				errors.push({ store: "file_locks", scope: lockDir, message: errorMessage(error) });
+			}
+		}
+
+		return { records, errors };
+	},
+	async prune(record: GcRecord, ctx: GcContext): Promise<GcPruneOutcome> {
+		const lockDir = record.path ?? record.id;
+		const info = await readFileLockInfoForGc(lockDir);
+		if (!info) return { removed: false, skipped: "lock_no_longer_dead_or_missing" };
+
+		const probeResult = ctx.probe(info.pid);
+		if (probeResult.status !== "dead") {
+			return { removed: false, skipped: "lock_no_longer_dead_or_missing" };
+		}
+
+		try {
+			await removeFileLockDirForGc(lockDir);
+			return { removed: true };
+		} catch (error) {
+			return { removed: false, error: errorMessage(error) };
+		}
+	},
+};

package/src/config/file-lock.ts

@@ -36,6 +36,20 @@ async function readLockInfo(lockPath: string): Promise<LockInfo | null> {
 	}
 }
 
+/** @internal */
+export async function readFileLockInfoForGc(lockDir: string): Promise<{ pid: number; timestamp: number } | null> {
+	const info = await readLockInfo(lockDir);
+	if (!info) return null;
+	if (!Number.isFinite(info.pid) || info.pid <= 0) return null;
+	if (!Number.isFinite(info.timestamp)) return null;
+	return info;
+}
+
+/** @internal */
+export async function removeFileLockDirForGc(lockDir: string): Promise<void> {
+	await fs.rm(lockDir, { recursive: true, force: true });
+}
+
 function isProcessAlive(pid: number): boolean {
 	try {
 		process.kill(pid, 0);

package/src/config/model-profiles.ts

@@ -90,25 +90,25 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		architect: "anthropic/claude-opus-4-8:xhigh",
 	}),
 	profile("glm-eco", ["zai"], {
-		default: "zai/glm-5.1:low",
-		executor: "zai/glm-5.1:minimal",
-		planner: "zai/glm-5.1:low",
-		critic: "zai/glm-5.1:medium",
-		architect: "zai/glm-5.1:high",
+		default: "zai/glm-5.2:low",
+		executor: "zai/glm-5.2:minimal",
+		planner: "zai/glm-5.2:low",
+		critic: "zai/glm-5.2:medium",
+		architect: "zai/glm-5.2:high",
 	}),
 	profile("glm-medium", ["zai"], {
-		default: "zai/glm-5.1:medium",
-		executor: "zai/glm-5.1:low",
-		planner: "zai/glm-5.1:medium",
-		critic: "zai/glm-5.1:high",
-		architect: "zai/glm-5.1:xhigh",
+		default: "zai/glm-5.2:medium",
+		executor: "zai/glm-5.2:low",
+		planner: "zai/glm-5.2:medium",
+		critic: "zai/glm-5.2:high",
+		architect: "zai/glm-5.2:xhigh",
 	}),
 	profile("glm-pro", ["zai"], {
-		default: "zai/glm-5.1:xhigh",
-		executor: "zai/glm-5.1:medium",
-		planner: "zai/glm-5.1:high",
-		critic: "zai/glm-5.1:xhigh",
-		architect: "zai/glm-5.1:xhigh",
+		default: "zai/glm-5.2:xhigh",
+		executor: "zai/glm-5.2:medium",
+		planner: "zai/glm-5.2:high",
+		critic: "zai/glm-5.2:xhigh",
+		architect: "zai/glm-5.2:xhigh",
 	}),
 	profile("kimi-coding-plan-eco", ["kimi-code"], {
 		default: "kimi-code/kimi-k2.7-code:low",
@@ -173,6 +173,13 @@ export const BUILTIN_MODEL_PROFILES: readonly ModelProfileDefinition[] = [
 		critic: "xai/grok-4.3:xhigh",
 		architect: "xai/grok-4.3:xhigh",
 	}),
+	profile("grok-build-pro", ["grok-build"], {
+		default: "grok-build/grok-composer-2.5-fast",
+		executor: "grok-build/grok-build",
+		planner: "grok-build/grok-composer-2.5-fast",
+		critic: "grok-build/grok-composer-2.5-fast",
+		architect: "grok-build/grok-build",
+	}),
 	profile("cursor-eco", ["cursor"], {
 		default: "cursor/composer-1.5:low",
 		executor: "cursor/composer-1.5:minimal",
@@ -254,6 +261,7 @@ const PROFILE_PRESENTATION: Record<string, ModelProfilePresentation> = {
 	"grok-eco": { displayName: "Grok Eco", providerGroup: "GROK" },
 	"grok-medium": { displayName: "Grok Medium", providerGroup: "GROK" },
 	"grok-pro": { displayName: "Grok Pro", providerGroup: "GROK" },
+	"grok-build-pro": { displayName: "Grok Build Pro", providerGroup: "GROK" },
 	"cursor-eco": { displayName: "Cursor Eco", providerGroup: "CURSOR" },
 	"cursor-medium": { displayName: "Cursor Medium", providerGroup: "CURSOR" },
 	"cursor-pro": { displayName: "Cursor Pro", providerGroup: "CURSOR" },
@@ -285,6 +293,7 @@ const PROFILE_RECOMMENDATIONS: Record<string, string> = {
 	"kimi-code": "kimi-coding-plan-medium",
 	xiaomi: "mimo-medium",
 	xai: "grok-medium",
+	"grok-build": "grok-build-pro",
 	cursor: "cursor-medium",
 	"minimax-code": "minimax-medium",
 };

package/src/coordinator/contract.ts

@@ -9,6 +9,7 @@ export const COORDINATOR_MCP_TOOL_NAMES = [
 	"gjc_coordinator_list_artifacts",
 	"gjc_coordinator_read_artifact",
 	"gjc_coordinator_read_coordination_status",
+	"gjc_coordinator_watch_events",
 	"gjc_coordinator_register_session",
 	"gjc_coordinator_start_session",
 	"gjc_coordinator_send_prompt",