@gajae-code/coding-agent 0.11.11 → 0.12.0

package/src/commands/deep-interview.ts

@@ -2,8 +2,22 @@ import { Command, Flags } from "@gajae-code/utils/cli";
 import { runNativeDeepInterviewCommand } from "../gjc-runtime/deep-interview-runtime";
 
 export default class DeepInterview extends Command {
-	static description =
-		"Run native GJC deep-interview workflow. Use `draft` for editable CLI-owned mutation inputs; JSON repair verbs are compatibility-only.";
+	static description = `Run native GJC deep-interview workflow.
+
+All deep-interview state operations go through this command — no gjc state needed:
+  read                Print the persisted envelope, revision, content sha, and any pending draft
+  write               One-shot incremental JSON merge into state (--reset replaces; the locked
+                      intent contract survives a reset)
+  stage               Stage one JSON transition draft (--for <transition> --input '<json>'|@file)
+  check               Dry-run the staged draft against current state (same merge apply performs)
+  apply               Commit the staged draft with runtime-owned revision+sha CAS
+  discard             Remove the pending draft
+  clear               Clear deep-interview state for the session (lifecycle passthrough)
+  handoff             Hand off to the next workflow skill (lifecycle passthrough)
+
+Ambiguity is runtime-owned: apply/write derive current_ambiguity from the latest valid scored
+round and clamp it to the deterministic floor. Sessions resolve from --session-id, payload
+session_id, or GJC_SESSION_ID.`;
 	static strict = false;
 	static flags = {
 		quick: Flags.boolean({ description: "Seed a quick deep-interview run" }),
@@ -15,6 +29,11 @@ export default class DeepInterview extends Command {
 		"session-id": Flags.string({
 			description: "Route state/spec handoff through a session-scoped .gjc/_session-{sessionid} directory",
 		}),
+		input: Flags.string({ description: "JSON payload (or @file) for the write/stage verbs" }),
+		for: Flags.string({
+			description: "Transition for stage: initialize-context | record-round | update-facts | merge-state",
+		}),
+		reset: Flags.boolean({ description: "With write: replace state instead of incremental merge" }),
 		write: Flags.boolean({ description: "Persist a final deep-interview spec through the sanctioned GJC CLI/API" }),
 		stage: Flags.string({ description: 'Spec stage for --write (currently "final")' }),
 		slug: Flags.string({ description: "Safe slug for .gjc/_session-{sessionid}/specs/deep-interview-<slug>.md" }),
@@ -27,13 +46,14 @@ export default class DeepInterview extends Command {
 		json: Flags.boolean({ description: "Output JSON" }),
 	};
 	static examples = [
-		'$ gjc deep-interview --trace --standard "<idea>" --json',
-		"$ gjc deep-interview draft create --for initialize-context --session-id <id> --json",
-		"$ gjc deep-interview draft edit --draft-id <id> --expected-draft-revision 1 --op set --path /type --value greenfield --json",
-		"$ gjc deep-interview draft check --draft-id <id> --json",
-		"$ gjc deep-interview initialize-context --draft-id <id> --expected-draft-revision <n> --json",
-		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md --json",
-		"$ gjc deep-interview inspect --session-id <id> --selector summary --json",
+		'$ gjc deep-interview --trace --standard "<idea>"',
+		"$ gjc deep-interview read --json",
+		'$ gjc deep-interview write --input \'{"state":{"threshold":0.05}}\' --json',
+		'$ gjc deep-interview stage --for record-round --input \'{"state":{"rounds":[{"round":1,"round_key":"r1"}]}}\' --json',
+		"$ gjc deep-interview check --json",
+		"$ gjc deep-interview apply --json",
+		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md",
+		"$ gjc deep-interview --write --stage final --slug my-feature --spec ./final-spec.md --deliberate",
 	];
 
 	async run(): Promise<void> {

package/src/commands/harness.ts

@@ -14,6 +14,7 @@ import { existsSync, readFileSync } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { Args, Command, Flags } from "@gajae-code/utils/cli";
+import { $credentialEnv } from "@gajae-code/utils/env";
 import {
 	GJC_TMUX_OWNER_GENERATION_ENV,
 	GJC_TMUX_OWNER_SERVER_KEY_ENV,
@@ -565,20 +566,42 @@ function ownerIsolationPlatform(): NodeJS.Platform {
 		: "linux";
 }
 
+/**
+ * Operator override for the process-start probe command, resolved from trusted
+ * environment sources only.
+ *
+ * The result is spawned, so whatever can set it chooses which binary runs.
+ * `$env` merges the caller's `cwd/.env` into `process.env`, so reading it there
+ * would let repository content pick the command; resolve it the same way
+ * provider credentials are (launching shell plus GJC/user-owned `.env` files,
+ * never the project `.env`). A malformed override stays fatal rather than
+ * silently falling back to `ps`, matching the previous behavior.
+ */
+type ProcessStartCommandOverride = { kind: "none" } | { kind: "invalid" } | { kind: "command"; command: string[] };
+
+function processStartCommandOverride(): ProcessStartCommandOverride {
+	const configured = $credentialEnv("GJC_HARNESS_PROCESS_START_COMMAND");
+	if (!configured) return { kind: "none" };
+	try {
+		const parsed = JSON.parse(configured) as unknown;
+		if (!Array.isArray(parsed) || parsed.length === 0 || parsed.some(value => typeof value !== "string" || !value))
+			return { kind: "invalid" };
+		return { kind: "command", command: parsed as string[] };
+	} catch {
+		return { kind: "invalid" };
+	}
+}
+
+/** Test seam: the process-start command override as resolved from trusted env. */
+export function processStartCommandOverrideForTest(): ProcessStartCommandOverride {
+	return processStartCommandOverride();
+}
+
 function portableProcessStartTime(pid: number): string | null {
 	if (process.platform === "linux") return null;
-	const configured = process.env.GJC_HARNESS_PROCESS_START_COMMAND;
-	let command: string[] = ["ps", "-o", "lstart=", "-p"];
-	if (configured) {
-		try {
-			const parsed = JSON.parse(configured) as unknown;
-			if (!Array.isArray(parsed) || parsed.length === 0 || parsed.some(value => typeof value !== "string" || !value))
-				return null;
-			command = parsed;
-		} catch {
-			return null;
-		}
-	}
+	const override = processStartCommandOverride();
+	if (override.kind === "invalid") return null;
+	const command: string[] = override.kind === "command" ? override.command : ["ps", "-o", "lstart=", "-p"];
 	const result = Bun.spawnSync([...command, String(pid)], {
 		stdout: "pipe",
 		stderr: "ignore",

package/src/commands/read.ts

@@ -1,7 +1,7 @@
 /**
  * Show what the read tool will return for a given path.
  */
-import { Args, Command } from "@gajae-code/utils/cli";
+import { Args, Command, Flags } from "@gajae-code/utils/cli";
 import { type ReadCommandArgs, runReadCommand } from "../cli/read-cli";
 import { initTheme } from "../modes/theme/theme";
 
@@ -15,8 +15,16 @@ export default class Read extends Command {
 		}),
 	};
 
+	static flags = {
+		truncation: Flags.string({
+			options: ["head", "last", "both"],
+			description: "Which end of an over-budget result to keep",
+		}),
+	};
+
 	static examples = [
 		"gjc read src/foo.ts",
+		"gjc read src/foo.ts --truncation head",
 		"gjc read src/foo.ts:50-100",
 		"gjc read src/foo.ts:raw",
 		"gjc read https://example.com",
@@ -25,9 +33,10 @@ export default class Read extends Command {
 	];
 
 	async run(): Promise<void> {
-		const { args } = await this.parse(Read);
+		const { args, flags } = await this.parse(Read);
 		const cmd: ReadCommandArgs = {
 			path: args.path ?? "",
+			truncation: flags.truncation as ReadCommandArgs["truncation"],
 		};
 		await initTheme();
 		await runReadCommand(cmd);

package/src/commands/team.ts

@@ -173,7 +173,7 @@ 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 update-worker-status read-worker-heartbeat recover-stale-claims update-worker-heartbeat write-worker-inbox write-worker-identity",
+					"read-config read-manifest read-worker-status update-worker-status read-worker-heartbeat recover-stale-claims update-worker-heartbeat read-worker-memory-guard update-worker-memory-guard apply-worker-memory-guard 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',

package/src/config/model-registry.ts

@@ -34,7 +34,7 @@ const DEFAULT_LOCAL_TOKEN = "lm-studio-local";
 
 import { registerOAuthProvider, unregisterOAuthProviders } from "@gajae-code/ai/utils/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@gajae-code/ai/utils/oauth/types";
-import { $pickenv, isRecord, logger } from "@gajae-code/utils";
+import { $pickCredentialEnv, isRecord, logger } from "@gajae-code/utils";
 import { parseModelString, resolveProviderModelReference } from "../config/model-resolver";
 import { isValidThemeColor, type ThemeColor } from "../modes/theme/theme";
 import type { AuthStorage, OAuthCredential } from "../session/auth-storage";
@@ -450,8 +450,20 @@ function getProviderBaseUrlEnvKeys(provider: string): string[] {
 	return keys;
 }
 
+/**
+ * Provider base URL from the environment, trusted sources only.
+ *
+ * The result is baked into the provider override and reaches `model.baseUrl`,
+ * which the provider resolvers use as the request endpoint that carries the
+ * provider credential. `$env` (and therefore `$pickenv`) merges the caller's
+ * `cwd/.env`, so reading it there would let repository content redirect
+ * authenticated traffic for any provider — including re-admitting a redirect
+ * that the provider-level resolvers already reject. Resolve it the same way
+ * provider credentials are: launching shell plus GJC/user-owned `.env` files,
+ * never the project `.env`.
+ */
 function resolveProviderBaseUrlFromEnv(provider: string): string | undefined {
-	return $pickenv(...getProviderBaseUrlEnvKeys(provider));
+	return $pickCredentialEnv(...getProviderBaseUrlEnvKeys(provider));
 }
 
 function normalizeLocalOpenAICompatBaseUrl(baseUrl: string): string {
@@ -2507,6 +2519,13 @@ export class ModelRegistry {
 		return this.#keylessProviders.has(model.provider) || this.authStorage.hasAuth(model.provider);
 	}
 
+	/**
+	 * Check whether auth is configured for a provider.
+	 */
+	hasConfiguredProviderAuth(provider: string): boolean {
+		return this.#keylessProviders.has(provider) || this.authStorage.hasAuth(provider);
+	}
+
 	getDiscoverableProviders(): string[] {
 		const disabledProviders = getDisabledProviderIdsFromSettings();
 		return this.#discoveryManager.providers

package/src/config/provider-auth-health.ts

@@ -0,0 +1,42 @@
+import type { AuthStorage } from "@gajae-code/ai/auth-storage";
+
+/**
+ * Most recent OAuth validation outcome per provider, used only as an ordering
+ * hint so `/model` can rank a provider whose stored credentials failed
+ * validation below one that is healthy, without re-running validation itself.
+ *
+ * Entries are scoped to the `AuthStorage` that produced them and to its
+ * credential generation, so any login, logout, import, or deletion discards the
+ * stale result instead of overriding current auth state.
+ */
+export type ProviderAuthHealth = "valid" | "invalid";
+
+interface HealthEntry {
+	generation: number;
+	health: ProviderAuthHealth;
+}
+
+const healthByStorage = new WeakMap<AuthStorage, Map<string, HealthEntry>>();
+
+export function recordProviderAuthHealth(
+	authStorage: AuthStorage,
+	providerId: string,
+	health: ProviderAuthHealth,
+): void {
+	let entries = healthByStorage.get(authStorage);
+	if (!entries) {
+		entries = new Map();
+		healthByStorage.set(authStorage, entries);
+	}
+	entries.set(providerId, { generation: authStorage.getGeneration(), health });
+}
+
+export function getProviderAuthHealth(authStorage: AuthStorage, providerId: string): ProviderAuthHealth | undefined {
+	const entry = healthByStorage.get(authStorage)?.get(providerId);
+	if (!entry || entry.generation !== authStorage.getGeneration()) return undefined;
+	return entry.health;
+}
+
+export function clearProviderAuthHealth(authStorage: AuthStorage): void {
+	healthByStorage.delete(authStorage);
+}

package/src/config/provider-ranking.ts

@@ -0,0 +1,119 @@
+/**
+ * Shared provider ordering used by every provider-facing selector (`/login`,
+ * `/model`, `/provider`).
+ *
+ * Providers the user already has come first, then a curated list of well-known
+ * providers, then everything else alphabetically. This is the single source of
+ * truth for that order — surfaces must not keep their own famous-provider list.
+ */
+
+/**
+ * Auth/config state of a provider as seen by the calling surface.
+ *
+ * - `valid` — stored credentials that validated successfully.
+ * - `checking` — stored credentials whose async validation is still in flight.
+ *   Ranked with `valid` so rows do not reflow when validation resolves.
+ * - `configured` — no OAuth record, but the provider is present in the model
+ *   registry with a working API key (custom/API-compatible providers).
+ * - `invalid` — stored credentials that failed validation (problematic login).
+ * - `none` — nothing stored and nothing configured.
+ */
+export type ProviderAuthState = "valid" | "checking" | "configured" | "invalid" | "none";
+
+export const PROVIDER_RANK_TIER = {
+	existing: 0,
+	problematic: 1,
+	famous: 2,
+	other: 3,
+} as const;
+
+export type ProviderRankTier = (typeof PROVIDER_RANK_TIER)[keyof typeof PROVIDER_RANK_TIER];
+
+/**
+ * Curated provider order for the famous tier. Regional and device variants sit
+ * immediately behind their primary so related entries stay grouped.
+ */
+export const FAMOUS_PROVIDER_ORDER: readonly string[] = [
+	"openai-codex",
+	"openai-codex-device",
+	"anthropic",
+	"xai",
+	"opencode-go",
+	"zai",
+	"glm-zcode",
+	"alibaba-token-plan",
+	"qwen-portal",
+	"kimi-code",
+	"moonshot",
+	"minimax-code",
+	"minimax-code-cn",
+	"xiaomi",
+	"xiaomi-token-plan-sgp",
+	"xiaomi-token-plan-ams",
+	"xiaomi-token-plan-cn",
+	"opengateway",
+	"bizrouter",
+	"github-copilot",
+	"cursor",
+];
+
+const FAMOUS_PROVIDER_INDEX = new Map(FAMOUS_PROVIDER_ORDER.map((id, index) => [id, index]));
+
+/** A provider as ranked by a surface. `label` is what the user sees. */
+export interface RankableProvider {
+	id: string;
+	label: string;
+	authState: ProviderAuthState;
+}
+
+/** A provider's position in the ordering: its tier plus its rank inside that tier. */
+export interface ProviderRank {
+	tier: ProviderRankTier;
+	intraTierRank: number;
+}
+
+/**
+ * The single ranking result for a provider. `intraTierRank` is the curated
+ * famous-list position, or `Number.MAX_SAFE_INTEGER` for providers that are not
+ * on the list and therefore order by display label.
+ */
+export function rankProvider(provider: RankableProvider): ProviderRank {
+	return {
+		tier: providerRankTier(provider.authState, provider.id),
+		intraTierRank: FAMOUS_PROVIDER_INDEX.get(provider.id) ?? Number.MAX_SAFE_INTEGER,
+	};
+}
+
+export function providerRankTier(authState: ProviderAuthState, id: string): ProviderRankTier {
+	if (authState === "valid" || authState === "checking" || authState === "configured") {
+		return PROVIDER_RANK_TIER.existing;
+	}
+	if (authState === "invalid") return PROVIDER_RANK_TIER.problematic;
+	return FAMOUS_PROVIDER_INDEX.has(id) ? PROVIDER_RANK_TIER.famous : PROVIDER_RANK_TIER.other;
+}
+
+/** Position within the famous list, or `undefined` for providers not on it. */
+export function famousProviderIndex(id: string): number | undefined {
+	return FAMOUS_PROVIDER_INDEX.get(id);
+}
+
+/**
+ * Total order over providers: tier, then famous-list position, then display
+ * label, then id. The trailing id comparison guarantees no ties.
+ */
+export function compareRankedProviders(left: RankableProvider, right: RankableProvider): number {
+	const leftRank = rankProvider(left);
+	const rightRank = rankProvider(right);
+	if (leftRank.tier !== rightRank.tier) return leftRank.tier - rightRank.tier;
+	if (leftRank.intraTierRank !== rightRank.intraTierRank) return leftRank.intraTierRank - rightRank.intraTierRank;
+
+	const label = left.label.localeCompare(right.label);
+	if (label !== 0) return label;
+
+	return left.id.localeCompare(right.id);
+}
+
+/** Convenience wrapper returning a new array in ranked order. */
+export function sortRankedProviders<T extends RankableProvider>(providers: readonly T[]): T[] {
+	return [...providers].sort(compareRankedProviders);
+}

package/src/config/settings-schema.ts

@@ -506,6 +506,11 @@ export const SETTINGS_SCHEMA = {
 		default: 5,
 		validate: (value: number) => Number.isInteger(value) && value >= 1 && value <= 20,
 	},
+	"gjc.ralplan.maxReviewPassesPerLane": {
+		type: "number",
+		default: 1,
+		validate: (value: number) => Number.isInteger(value) && value >= 1 && value <= 10,
+	},
 
 	// ────────────────────────────────────────────────────────────────────────
 	// Appearance
@@ -2054,7 +2059,8 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "editing",
 			label: "Default Read Limit",
-			description: "Default number of lines returned when agent calls read without a limit",
+			description:
+				"Default collection/selection limit for read operations; bare local receipts use the separate 50-line / 10 KiB receipt budgets",
 			options: [
 				{ value: "200", label: "200 lines" },
 				{ value: "300", label: "300 lines" },
@@ -2094,6 +2100,22 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"read.truncation": {
+		type: "enum",
+		values: ["head", "last", "both"] as const,
+		default: "last",
+		ui: {
+			tab: "editing",
+			label: "Read Truncation",
+			description:
+				"Configured default direction for routes that support directional truncation; bare local and archive reads use this value (factory default: last), while explicit truncation always wins",
+			options: [
+				{ value: "head", label: "Head", description: "Keep the first N lines" },
+				{ value: "last", label: "Last", description: "Keep the last N lines (default)" },
+				{ value: "both", label: "Both", description: "Keep the start and the end, elide the middle" },
+			],
+		},
+	},
 	"read.summaryMaxBytes": {
 		type: "number",
 		default: 20,